[V5] Add relations in mixins

[Melchyore]

@adonis/core 5.4.2
@adonisjs/lucid 16.3.2

Hello!

I'm facing a strange problem and I hope you could help me.

I'm trying to create a package for Adonis, it consists of a set of mixins that can be inherited by models.

I apologize because it will be a little long.

I have the main mixin file called Notifiable:

import type * as OrmContract from '@ioc:Adonis/Lucid/Orm'
import type * as Helpers from '@ioc:Adonis/Core/Helpers'

import { DatabaseNotification as DatabaseNotificationContract } from '@ioc:Adonis/Addons/Notifications'

import HasDatabaseNotifications from './HasDatabaseNotifications'
import RouteNotifications from './RouteNotifications'

export default function Notifiable (
  { compose }: typeof Helpers, Orm: typeof OrmContract,
  DatabaseNotification: DatabaseNotificationContract
) {
  return class _Notifiable extends compose(Orm.BaseModel, HasDatabaseNotifications(Orm, DatabaseNotification), RouteNotifications) {}
}

The above mixin extends from 2 other mixins:

1. HasDatabaseNotifications

import { NormalizeConstructor } from '@ioc:Adonis/Core/Helpers'

import type * as Orm from '@ioc:Adonis/Lucid/Orm'

import { DatabaseNotification as DatabaseNotificationContract } from '@ioc:Adonis/Addons/Notifications'

/**
 * @NOTICE Exporting a function instead of the class itslef allows us to use the decorators inside the mixin class.
 */
export default function ({ hasMany }: typeof Orm, DatabaseNotification: DatabaseNotificationContract) {
  return function HasDatabaseNotifications<T extends NormalizeConstructor<Orm.LucidModel>>(
      Superclass: T
    ) {
    class _HasDatabaseNotifications extends Superclass {
      @hasMany(() => DatabaseNotification)
      public notifications: Orm.HasMany<typeof DatabaseNotification>

      async readNotifications () {
        const self = this as Orm.LucidRow
        
        return await self.load('notifications', (query) => {
          query.whereNotNull('read_at')
        })
      }

      async unreadNotifications () {
        const self = this as Orm.LucidRow

        return await self.load('notifications', (query) => {
          query.whereNull('read_at')
        })
      }
    }

    return _HasDatabaseNotifications
  }
}

2. RouteNotifications

import { NormalizeConstructor } from '@ioc:Adonis/Core/Helpers'
import { LucidModel } from '@ioc:Adonis/Lucid/Orm'
import { Notification } from '@ioc:Adonis/Addons/Notifications'

const RouteNotifications = <T extends NormalizeConstructor<LucidModel>>(Superclass: T) => {
  return class extends Superclass {
    public notify (notification?: Notification) {
      console.log('test')
    }

    public routeNotificationFor (driver: string, notification = null) {
      // @TODO: capitalize `driver`
      const method = `routeNotificationFor${driver}`

      if (typeof this[method] === 'function') {
        this[method](notification)
      }

      const values = {
        database: this.notifications,
        mail: this.email
      }

      return values[driver] ?? null
    }
  }
}

export default RouteNotifications

The HasDatabaseNotifications mixin defines a hasMany relation with the DatabaseNotification model:

import type * as Orm from '@ioc:Adonis/Lucid/Orm'

import { DateTime } from 'luxon'

export default function createModel ({ BaseModel, column, beforeSave, afterFetch, afterFind }: typeof Orm): any {
  class DatabaseNotification extends BaseModel {
    @column({ isPrimary: true })
    public id: number
  
    @column()
    public data: string | Record<string, any>
  
    @column.dateTime()
    public readAt: DateTime

    public get read () {
      return this.readAt !== null
    }
  
    public get unread () {
      return this.readAt === null
    }
  
    @beforeSave()
    public static stringify (databaseNotification: DatabaseNotification) {
      if (databaseNotification.$dirty.data) {
        databaseNotification.data = JSON.stringify(databaseNotification.data)
      }
    }
  
    @afterFind()
    public static parse (databaseNotification: DatabaseNotification) {
      databaseNotification.data = DatabaseNotification._parse(databaseNotification.data as string)
    }
  
    @afterFetch()
    public static parseAll (databaseNotifications: Array<DatabaseNotification>) {
      databaseNotifications.forEach((databaseNotification: DatabaseNotification) => {
        databaseNotification.data = DatabaseNotification._parse(databaseNotification.data as string)
      })
    }
  
    static _parse (data: string) {
      return JSON.parse(data)
    }
  }

  return DatabaseNotification
}

I register all of that within this provider:

import { ApplicationContract } from '@ioc:Adonis/Core/Application'

import { DatabaseNotification as DatabaseNotificationContract } from '@ioc:Adonis/Addons/Notifications'

export default class AppProvider {
  public static needsApplication = true

  constructor (protected app: ApplicationContract) {}

  public register () {
    this.app.container.singleton('Adonis/Addons/Notifications', () => {
      const Notification = require('../src/Notification')

      return new Notification()
    })

    this.app.container.bind('Adonis/Addons/Notifications/Models/DatabaseNotification', async () => {
      const Orm = this.app.container.use('Adonis/Lucid/Orm')

      const { default: createModel } = await import('../src/Models/DatabaseNotification')

      return createModel(Orm)
    })

    this.app.container.singleton('Adonis/Addons/Notifications/Mixins/Notifiable', async () => {
      const Helpers = this.app.container.use('Adonis/Core/Helpers')
      const Orm = this.app.container.use('Adonis/Lucid/Orm')
      const DatabaseNotification = await this.app.container.useAsync('Adonis/Addons/Notifications/Models/DatabaseNotification') as DatabaseNotificationContract

      const Notifiable = require('../src/Mixins/Notifiable').default

      return Notifiable(Helpers, Orm, DatabaseNotification)
    })
  }

  public async boot () {}

  public async ready () {}

  public async shutdown () {}
}

Now I want to run some tests, so I created a mixin.spec.ts file and setup the application with database and providers. I have created a little function to generate my user model for test:

async function getUserModel (app: ApplicationContract) {
  const { column } = app.container.use('Adonis/Lucid/Orm')
  const Notifiable = await app.container.useAsync('Adonis/Addons/Notifications/Mixins/Notifiable') as Notifiable

  class User extends Notifiable {
    @column({ isPrimary: true })
    public id: number

    @column()
    public username: string

    @column()
    public password: string

    @column()
    public email: string

    @column()
    public rememberMeToken: string
  }

  User.boot()
  User.$getRelation('notifications')!.boot()

  return User
}

Now comes the problem, when I want to run the test, I get the following error:
E_MISSING_MODEL_ATTRIBUTE: "User.notifications" expects "id" to exist on "User" model, but is missing

As you can see, the User model has the id attribute but the error says that it doesn't. It's weird, right?
If I remove the hasMany relationship everything works fine.

If I add the id attribute to the mixin HasDatabaseNotifications, it also works... but I don't want that, the id must be used in the final model, not in the top level model because if someone wants to use uuid or whatever else instead of simple numeric id, I won't force him...

Can you help me, please?