Adonis 5: Best way to implement traits?

[timboozle]

What would be the best way to implement traits in v5?

I have a model Feed that has some relatively complex operations I used to use traits for in v4.
For example Feed.download() and Feed.parse()

[LeCoupa]

Create a class that extends BaseModel and inherit this new class?

[thetutlage]

It's not only about AdonisJS. Its about any code written in Typescript. When using traits or mixins, you have to make sure that the new properties are also picked up by the type system.

[hsharma1996]

@thetutlage any solution form your side, any suggestion on sharing common function between models ? The extend class method does not work. Is there any other way we can achieve it ?

[thetutlage]

Shared #3188

[RosarioDeveloper]

Does someone already solve this problem?

I have got the same problem and I would like it if someone has already solved this problema.

[RomainLanz]

You can have a look at @thetutlage answer above yours.

[alexandreguertin]

@timboozle

I'm not familiar with Typescript. All feedback will be taken into account and greatly valued.

Thanks to Adonis Notifications mixins for the inspiration, here's a working example of a "Trait" that adds translation to a model.

// App/Models/Mixins/TranslationMixin.ts

import { NormalizeConstructor } from '@ioc:Adonis/Core/Helpers'
import { BaseModel, column, HasMany, hasMany } from '@ioc:Adonis/Lucid/Orm'

/**
 * Generates the translation model used in the relation. (e.g. ConditionTranslation)
 */
function TranslationModelFactory (tableName: string, columnNames: string[]) {
  class TranslationModel extends BaseModel {
    public static table = tableName

    @column({ isPrimary: true })
    public id: number

    @column()
    public language: string
  }

  /**
   * Adds decorator "column" to the defined columns and foreign key.
   */
  for (const columnName of columnNames) {
    TranslationModel.prototype[columnName] = null
    column()(TranslationModel.prototype, columnName)
  }

  return TranslationModel
}

export default function (modelName: string, columnNames: string[], options?: {
  tableName?: string,
  localKey?: string,
  foreignKey?: string,
}) {
  return function<T extends NormalizeConstructor<typeof BaseModel>> (Base: T) {
    const opts = {
      tableName: `${modelName.toLowerCase()}_translations`,
      localKey: 'id',
      foreignKey: `${modelName.toLocaleLowerCase()}_id`,
      ...options,
    }

    const TranslationModel = TranslationModelFactory(opts.tableName, [opts.foreignKey, ...columnNames])

    /**
     * The actual "Trait".
     */
    class TranslationMixin extends Base {
      /**
       * Because the relationship requires it, we're duplicating the column declaration here.
       */
      @column({ isPrimary: true })
      public id: any

      @hasMany(() => TranslationModel, {
        localKey: opts.localKey,
        foreignKey: opts.foreignKey,
      })
      public translations: HasMany<typeof TranslationModel>
    }

    return TranslationMixin
  }
}

// App/Models/Condition.ts

import { DateTime } from 'luxon'
import { compose } from '@ioc:Adonis/Core/Helpers'
import { BaseModel, column } from '@ioc:Adonis/Lucid/Orm'

import TranslationMixin from './Mixins/TranslationMixin'

export default class Condition extends compose(
  BaseModel,
  TranslationMixin('Condition', ['title'])
) {
  @column({ isPrimary: true })
  public id: number

  @column.dateTime({ autoCreate: true })
  public createdAt: DateTime

  @column.dateTime({ autoCreate: true, autoUpdate: true })
  public updatedAt: DateTime
}