Polymorphic Relations

[golinmarq]

is there a way to handle this relations?

[thetutlage]

Nope, not right now. I will develop this feature soon. Keep the task open.

[golinmarq]

Is this will be available for 4.0?

[RomainLanz]

There's a plugin for that https://github.com/enniel/adonis-lucid-polymorphic

[thetutlage]

I have personally never felt the use of Polymorphic relationships and they have so many issues in performance and general database design.

Now bad practices is a subjective term and I do not use it to justify my point, but Polymorphic is really something that should be avoided to have a cleaner database schema.

SQL databases has no issues with the number of table one can have, so it's always better to create a separate table that anyone can see and tell that what it does, over checking all the type columns to see that.

Also JOINS on varchar table is the worst thing you can do to SQL. So I have no plans to add it to the core.

Also doing a quick google search on Why polymorphic relations are bad will answer a lot of questions

[rdunk]

Seems like this is being discussed again on Discord given the enniel/adonis-lucid-polymorphic package doesn't seem to be maintained/compatible with 4.x. Has there been a decision made to add polymorphic relationships to the core?

[golinmarq]

@rdunk I think @thetutlage was clear with the decision. I used to like polymorphic relationships but after meditating really well, I think We don't need it

[saumya04]

@thetutlage
I do not fully agree with your reason for "Why Polymorphic relations are bad".
Actually polymorphic relationships are used for some defined cases, to minimize the use of multiple tables for allocating same type of data.

Just for the sake of an example, there is a case as defined in Laravel Docs:

If there is a table structure like this:

posts
    id - integer
    title - string
    body - text

videos
    id - integer
    title - string
    url - string

comments
    id - integer
    body - text
    commentable_id - integer
    commentable_type - string

Two important columns to note are the commentable_id and commentable_type columns on the comments table. The commentable_id column will contain the ID value of the post or video, while the commentable_type column will contain the class name of the owning model. The commentable_type column is how the ORM determines which "type" of owning model to return when accessing the commentable relation.

I think in the above example polymorphic relationship plays a major role in minimizimg tables & their structure.

[ericsonweah]

@thetutlage @saumya04
From my experience "Polymorphic Relations" are very powerfull ! I have not seen anything bad about them, at least so far and so far my projects and experience go. In fact sometimes, actually most of the time, not only they are more powerful than many to "many to many relationships", they are also easier to deal with. They are also far much more future-proof! Just plan or design your database (data structure) very well.

[danjdewhurst]

Any update on this?

[MohammedElattar]

AdonisJS Morph One and Morph Many Relations Workarounds

This is a solution to implement polymorphic morphOne and morphMany relationships in AdonisJS using the Lucid ORM. It allows you to handle polymorphic relationships similar to Laravel's Eloquent ORM, enabling flexibility in associating a model with multiple other models.

Installation

If you want to use this solution in your project, simply copy the following code into your project files.

Code Overview

Final Implementation

import CustomModel from '#models/utils/custom_model'

export function getMorphableTypeValue(model: typeof CustomModel) {
    return model.table
}

import { hasOne, hasMany } from '@adonisjs/lucid/orm'
import { LucidModel } from '@adonisjs/lucid/types/model'
import { HasOne, HasMany, ModelRelations } from '@adonisjs/lucid/types/relations'
import { getMorphableTypeValue } from '../../../../app/utils/morph.js'

export type MorphOneRelationType<T extends LucidModel> = HasOne<T>
export type MorphManyRelationType<T extends LucidModel> = HasMany<T>

export type MorphRelationOptions<
    RelatedModel extends LucidModel,
    ParentModel extends LucidModel,
    Related extends ModelRelations<RelatedModel, ParentModel>,
> = {
    type?: string
    id?: string
    localKey?: string
    serializeAs?: string | null
    onQuery?(query: Related['builder'] | Related['subQuery']): void
    meta?: any
}

export const generateMorphable = (morphable: string) => {
    return {
        dbType: `${morphable}_type`,
        type: `${morphable}Type`,
        dbId: `${morphable}_id`,
        id: `${morphable}Id`,
    }
}

const getMorphOptions = (
    morphableColumns: ReturnType<typeof generateMorphable>,
    morphableTypeValue: string,
    options?: MorphRelationOptions<LucidModel, LucidModel, any>
) => {
    const morphableType = options?.type ?? morphableColumns.dbType

    return {
        foreignKey: options?.id ?? morphableColumns.id,
        localKey: options?.localKey,
        meta: options?.meta,
        serializeAs: options?.serializeAs,
        onQuery(query: any) {
            query.where(morphableType, morphableTypeValue)

            if (options?.onQuery) {
                return options.onQuery(query)
            }

            return query
        },
    }
}

const morphRelation = (
    relationType: 'morphOne' | 'morphMany',
    model: LucidModel,
    morphable: string,
    options?: MorphRelationOptions<LucidModel, LucidModel, any>
) => {
    return function (target: any, propertyKey: string) {
        const morphableColumns = generateMorphable(morphable)
        const relationOptions = getMorphOptions(
            morphableColumns,
            getMorphableTypeValue(target.constructor),
            options
        )

        const relationMethod = relationType === 'morphOne' ? hasOne : hasMany

        return relationMethod(() => model, relationOptions)(target, propertyKey)
    }
}

export function morphOne<Model extends LucidModel>(
    model: Model,
    morphable: string,
    options?: MorphRelationOptions<Model, LucidModel, HasOne<Model, LucidModel>>
) {
    return morphRelation('morphOne', model, morphable, options)
}

export function morphMany<Model extends LucidModel>(
    model: Model,
    morphable: string,
    options?: MorphRelationOptions<Model, LucidModel, HasMany<Model, LucidModel>>
) {
    return morphRelation('morphMany', model, morphable, options)
}

Usage

Morph One

To define a polymorphic morphOne relation:

@morphOne(Media, 'model')
declare avatar: MorphOneRelationType<typeof Media>

Morph Many

To define a polymorphic morphMany relation:

@morphMany(Media, 'model')
declare images: MorphManyRelationType<typeof Media>

Key Concepts:

• Polymorphic Relations: This solution allows you to associate a model with multiple other models using a single foreign key, which is common in polymorphic relationships.

• morphOne: This sets up a one-to-one polymorphic relationship.

• morphMany: This sets up a one-to-many polymorphic relationship.

• generateMorphable: This helper function generates the required column names for the polymorphic relationship.

• getMorphOptions: This function builds the options required for the relationship based on the morphable and additional parameters.

Benefits

• Reduced Redundancy: Common logic for morph relations is shared between morphOne and morphMany.

• Flexibility: You can customize queries using the onQuery option to filter the results as needed.

Conclusion

This solution provides an elegant way to implement polymorphic morphOne and morphMany relationships in AdonisJS. It simplifies code and ensures better maintainability.

---

[holoyan]

Hi all, I just published an AdonisJs Polymorphic package with full support for polymorphic relationships in Lucid ORM, including morphOne,
morphMany, and morphTo. Feel free to give me feedback!

[thetutlage]

@holoyan Great work. I think it will be worth sharing in our Discord as well, I am sure many will find it useful 💪