override model function and call base implementation

[michaelxh]

I'm having difficult overriding model functions and calling the base implementation.

Here is an example using sequelize-typescript

  @Table({ tableName: 'test' })
  class TestModel extends Model {
    @Column(STRING)
    public name!: string;
    
    public static override async findOne<M extends Model>(
      options: NonNullFindOptions<Attributes<M>>
    ): Promise<M> {
      return super.findOne(options); 
    }
  }

Here are the typecheck errors I get ...

TS2322: Type 'Model<{}, {}>' is not assignable to type 'M'.  
'Model<{}, {}>' is assignable to the constraint of type 'M', but 'M' could be instantiated with a different subtype of constraint 'Model<any, any>'.

TS2769: No overload matches this call.  
Overload 1 of 2, '(this: ModelStatic<Model<{}, {}>>, options: NonNullFindOptions<{}>): Promise<Model<{}, {}>>', gave the following error.     
The 'this' context of type 'typeof Model' is not assignable to method's 'this' of type 'ModelStatic<Model<{}, {}>>'.       
Type 'typeof Model' is not assignable to type 'new () => Model<{}, {}>'.         
Cannot assign an abstract constructor type to a non-abstract constructor type.  
Overload 2 of 2, '(this: ModelStatic<Model<{}, {}>>, options?: FindOptions<{}> | undefined): Promise<Model<{}, {}> | null>', gave the following error.     
The 'this' context of type 'typeof Model' is not assignable to method's 'this' of type 'ModelStatic<Model<{}, {}>>'.

Given the current usage of ModelStatic on the typings of Model methods, I'm not sure there is a way to override model functions as super will never have a constructor defined that returns the inheriting class M.

Have others found a way to override sequelize static methods? This is especially useful for methods that do not have hooks, such as aggregate.

[ephys]

Specify the generic when you call the parent method:

  public static override async findOne<M extends Model>(
    this: ModelStatic<M>,
    options: NonNullFindOptions<Attributes<M>>
  ): Promise<M> {
    return super.findOne<M>(options);
  }

[michaelxh]

Good call. Unfortunately, although the original error is gone, I still see a type error.

The 'this' context of type 'typeof Model' is not assignable to method's 'this' of type 'ModelStatic<M>'.

[michaelxh]

I ended up using Proxy to do this.

const overrideHandler: ProxyHandler<typeof OverrideModel> = {
    get: (target, prop, receiver) => {
      if (prop === 'aggregate') {
        return function aggregateWrapper(
          this: ModelStatic<OverrideModel>,
          field: keyof Attributes<OverrideModel>,
          aggregateFunction: string,
          options?: AggregateOptions<OverrideModel>
        ) {
          // do some override behavior

          // Reflect.get(..) is like like super (calls 'target's implementation, sequelize.Model.aggregate)
          // we .bind it to the receiver the output Proxy Model that will be initialized by sequelize-typescript
          return Reflect.get(target, prop, receiver).bind(
            this,
            field,
            aggregateFunction,
            updatedOptions
          )();
        };
      }

      return Reflect.get(target, prop, receiver);
    },
  };

  // sequelize-typescript decorators rely on Reflect.getMetadata to set up hooks. But there is an open issue that
  // Reflect.getMetadata does not work across proxies. https://github.com/rbuckton/reflect-metadata/issues/106
  // So if we Proxy OverrideModel directly, our hooks do not work. The metadata written by sequelize-typescript on OverrideModel
  // is effectively erased.
  // Reflect.getMetadata, however, does continue to work for a proxy object's parent classes as Proxy seemingly does not
  // affect a target's parent classes. So we create a shim class that inherits from OverrideModel and Proxy the shim.
  // sequelize-typescript hooks will work as long as the metadata is somewhere along the Model's inheritance chain.
  class ProxyShim extends OverrideModel {};
  return new Proxy<typeof ProxyShim>(ProxyShim, overrideHandler);