$add method interface

[connected-pjeri]

On the $add method interface its return value is Promise<this> but this isn't the case for m:n eg:

[ [ SourceContentItem {
     dataValues: { id: null, contentItemId: 1045, sourceId: 4 },
    _previousDataValues: { contentItemId: undefined, sourceId: undefined },
    _changed: { contentItemId: true, sourceId: true },
    _modelOptions: [Object],
    _options: { isNewRecord: true, _schema: null, _schemaDelimiter: '', includeNames: [] },
    hasPrimaryKeys: true,
    __eagerlyLoadedAssociations: [],
    isNewRecord: false } ] ]

If the source was already set, it returns [].

Monkey patch is to set that interface to return Promise<any> but better solution would just be to create an interface for it.

(L419 Model.d.ts) Eg: $add<R extends Model<R>>(propertyKey: string, instances: R|R[], options?: IAssociationActionOptions): Promise<any>;

Cred to @connected-jlovelock for finding this.

[RobinBuschmann]

So it should look rather like that: $add<R extends Model<R>>(propertyKey: string, instances: R|R[], options?: IAssociationActionOptions): Promise<this>|[];?

Can you provide an example? So in which exact case it is []? Thank you :)

[connected-pjeri]

Assume you have m:n models defined with their joint table defined as a model (in order to be able to access hooks on those joins) . Then attempt to $add the association.

Examples below:

Models

export class ContentItem extends Model<ContentItem> {
  @BelongsToMany(
    () => Source,
    () => SourceContentItem,
    "contentItemId",
    "sourceId",
  )
  sources: Source[];
}

export class Source extends Model<Source> {
  @BelongsToMany(
    () => ContentItem,
    () => SourceContentItem,
    "sourceId",
    "contentItemId",
  )
  contentItems: ContentItem[];
}

export class SourceContentItem extends Model<SourceContentItem> {
  @ForeignKey(() => ContentItem)
  @AllowNull(false)
  @Column
  contentItemId: number;

  @ForeignKey(() => Source)
  @AllowNull(false)
  @Column
  sourceId: number;

  @BelongsTo(
    () => ContentItem,
    "contentItemId",
  )
  contentItem: ContentItem;

  @BelongsTo(
    () => Source,
    "sourceId",
  )
  source: Source;
}

  static addSourceToContentItem(contentItem: ContentItem, source: Source): Promise<boolean> {
    return Promise.resolve(
      contentItem.$add("Source", source).then((res) => {
        return !!res.length;
      }),
    );
  }

If you log the return value on a successful $add you get the example shown above, otherwise if you try again but the source has already been added then you get [].

[RobinBuschmann]

Since $add is a function from sequelize-typescript I would suggest a more consistent way here. Which means, let's ensure that a Promise is always returned, in any case.

@connected-pjeri What do you think about it?

[Patrax]

Much like findOrCreate I think it should return a Promise([this, boolean] ) to know if its a new add.

[RobinBuschmann]

@Patrax Thanks for your input. Sounds like the best solution to me :)

[RobinBuschmann]

Since sequelize returns inconsistent values (arrays of through table instances or the instance where these methods are called on or undefined) for $add and $set, I've decided to use Promise<unknown> for @1.0.0. and Promise<any> for @0.6.X.

The other return types will be:
$has - Promise<boolean>
$remove - Promise<any>
$get<T> - Promise<T|T[]>
$create<T> - Promise<T>