tethys.backend/app/models/person.ts

import { column, SnakeCaseNamingStrategy, computed, manyToMany, afterFetch, afterFind } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Dataset from './dataset.js';
import BaseModel from './base_model.js';
import type { ManyToMany } from '@adonisjs/lucid/types/relations';

export default class Person extends BaseModel {
    public static namingStrategy = new SnakeCaseNamingStrategy();
    public static primaryKey = 'id';
    public static table = 'persons';
    public static selfAssignPrimaryKey = false;
    // only the academic_title, email, first_name, identifier_orcid, last_name  and name_type attributes are allowed to be mass assigned.
    public static fillable: string[] = ['academic_title', 'email', 'first_name', 'identifier_orcid', 'last_name', 'name_type'];

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

    @column({ columnName: 'academic_title' })
    public academicTitle: string;

    @column()
    public email: string;

    @column({})
    public firstName: string;

    @column({})
    public lastName: string;

    @column({})
    public identifierOrcid: string;

    @column({})
    public status: boolean;

    @column({})
    public nameType: string;

    @column.dateTime({
        serialize: (value: Date | null) => {
            return value ? dayjs(value).format('MMMM D YYYY HH:mm a') : value;
        },
        autoCreate: true,
    })
    public createdAt: DateTime;

    @computed({
        serializeAs: 'name',
    })
    public get fullName() {
        return [this.firstName, this.lastName].filter(Boolean).join(' ');
    }

    // @computed()
    // public get progress(): number {
    // 	return 50;
    // }

    // @computed()
    // public get created_at() {
    // 	return '2023-03-21 08:45:00';
    // }

    @computed({
        serializeAs: 'dataset_count',
    })
    public get datasetCount() {
        const stock = this.$extras.datasets_count; //my pivot column name was "stock"
        return Number(stock);
    }

    @computed()
    public get pivot_contributor_type() {
        const contributor_type = this.$extras.pivot_contributor_type; //my pivot column name was "stock"
        return contributor_type;
    }

    @computed({ serializeAs: 'allow_email_contact' })
    public get allowEmailContact() {
        // If the datasets relation is missing or empty, return false instead of null.
        if (!this.datasets || this.datasets.length === 0) {
            return false;
        }
        // Otherwise return the pivot attribute from the first related dataset.
        return this.datasets[0].$extras?.pivot_allow_email_contact;
    }

    @manyToMany(() => Dataset, {
        pivotForeignKey: 'person_id',
        pivotRelatedForeignKey: 'document_id',
        pivotTable: 'link_documents_persons',
        pivotColumns: ['role', 'sort_order', 'allow_email_contact'],
    })
    public datasets: ManyToMany<typeof Dataset>;

    // public toJSON() {
    //     const json = super.toJSON();

    //     // Check if this person is loaded through a pivot relationship with sensitive roles
    //     const pivotRole = this.$extras?.pivot_role;
    //     if (pivotRole === 'author' || pivotRole === 'contributor') {
    //         // Remove sensitive information for public-facing roles
    //         delete json.email;
    //         // delete json.identifierOrcid;
    //     }

    //     return json;
    // }
     @afterFind()
    public static async afterFindHook(person: Person) {
        if (person.$extras?.pivot_role === 'author' || person.$extras?.pivot_role === 'contributor') {
            person.email = undefined as any;
        }
    }

    @afterFetch()
    public static async afterFetchHook(persons: Person[]) {
        persons.forEach(person => {
            if (person.$extras?.pivot_role === 'author' || person.$extras?.pivot_role === 'contributor') {
                person.email = undefined as any;
            }
        });
    }
}