@shohaghinfo/aerojs 0.1.0

package/dist/database/model.js

@@ -0,0 +1,960 @@
+import { TenancyContext } from '../tenancy/tenant.js';
+/**
+ * @file model.ts
+ * @description Lucid-inspired Active Record ORM for AeroJS. Completely rebuilt with:
+ *
+ *  ✅ EXISTING: hasOne, hasMany, belongsTo, softDelete, eager loading
+ *  🆕 NEW: manyToMany (pivot table), hasManyThrough
+ *  🆕 NEW: Static Lifecycle Hooks (@beforeSave, @afterCreate, etc.)
+ *  🆕 NEW: Query Scopes (Model.query().active().byBranch(1))
+ *  🆕 NEW: Computed Properties ($get prefix)
+ *  🆕 NEW: $dirty tracking (know exactly what changed)
+ *  🆕 NEW: $original + isDirty(field) helpers
+ *
+ * Hospital uses:
+ *   - Doctor ↔ Specialization (manyToMany via doctor_specializations)
+ *   - Hospital → Wards → Beds (hasManyThrough)
+ *   - Patient.query().active().opd().byBranch(1).paginate(1, 20)
+ *   - @beforeCreate() → generate MRN
+ *   - @beforeDelete() → block hard-delete on medical records
+ */
+import { Database } from './connection.js';
+import { QueryBuilder } from './query-builder.js';
+import { NotFoundError } from '../core/errors.js';
+import { getHookRegistry } from './model-hooks.js';
+// ─── Relation Class ───────────────────────────────────────────────────────────
+export class Relation {
+    type;
+    RelatedModel;
+    foreignKey;
+    localKey;
+    parentInstance;
+    pivotTable;
+    pivotForeignKey;
+    pivotRelatedKey;
+    pivotColumns;
+    ThroughModel;
+    throughForeignKey;
+    throughLocalKey;
+    constructor(def) {
+        this.type = def.type;
+        this.RelatedModel = def.RelatedModel;
+        this.foreignKey = def.foreignKey;
+        this.localKey = def.localKey;
+        this.parentInstance = def.parentInstance;
+        this.pivotTable = def.pivotTable;
+        this.pivotForeignKey = def.pivotForeignKey;
+        this.pivotRelatedKey = def.pivotRelatedKey;
+        this.pivotColumns = def.pivotColumns;
+        this.ThroughModel = def.ThroughModel;
+        this.throughForeignKey = def.throughForeignKey;
+        this.throughLocalKey = def.throughLocalKey;
+    }
+    async then(onfulfilled, onrejected) {
+        try {
+            const result = await this._resolve();
+            return onfulfilled ? onfulfilled(result) : result;
+        }
+        catch (err) {
+            if (onrejected)
+                return onrejected(err);
+            throw err;
+        }
+    }
+    async _resolve() {
+        const qb = this.RelatedModel.query();
+        switch (this.type) {
+            case 'belongsTo': {
+                const foreignVal = this.parentInstance.get(this.foreignKey);
+                if (foreignVal === undefined || foreignVal === null)
+                    return null;
+                return qb.where(this.localKey, foreignVal).first();
+            }
+            case 'hasOne': {
+                const localVal = this.parentInstance.get(this.localKey);
+                if (localVal === undefined || localVal === null)
+                    return null;
+                return qb.where(this.foreignKey, localVal).first();
+            }
+            case 'hasMany': {
+                const localVal = this.parentInstance.get(this.localKey);
+                if (localVal === undefined || localVal === null)
+                    return [];
+                return qb.where(this.foreignKey, localVal).get();
+            }
+            case 'manyToMany': {
+                return this._resolveManyToMany();
+            }
+            case 'hasManyThrough': {
+                return this._resolveHasManyThrough();
+            }
+            default:
+                return null;
+        }
+    }
+    async _resolveManyToMany() {
+        const localVal = this.parentInstance.get(this.localKey);
+        if (localVal === undefined || localVal === null)
+            return [];
+        const pivotTable = this.pivotTable;
+        const pivotFK = this.pivotForeignKey;
+        const pivotRK = this.pivotRelatedKey;
+        const relatedTable = this.RelatedModel.getTable();
+        const relatedPK = this.RelatedModel.primaryKey;
+        const pivotExtra = this.pivotColumns ?? [];
+        // SELECT related.*, pivot.col1, pivot.col2 FROM related
+        // INNER JOIN pivot ON related.id = pivot.pivot_related_key
+        // WHERE pivot.pivot_foreign_key = localVal
+        const selectCols = [
+            `${relatedTable}.*`,
+            ...pivotExtra.map((c) => `${pivotTable}.${c} as pivot_${c}`),
+        ];
+        const rows = await Database.table(relatedTable)
+            .select(...selectCols)
+            .join(pivotTable, `${relatedTable}.${relatedPK}`, '=', `${pivotTable}.${pivotRK}`)
+            .where(`${pivotTable}.${pivotFK}`, localVal)
+            .get();
+        return rows.map((r) => {
+            const inst = new this.RelatedModel(r);
+            inst._exists = true;
+            inst._original = { ...r };
+            // Attach pivot data
+            if (pivotExtra.length > 0) {
+                const pivot = {};
+                for (const c of pivotExtra) {
+                    pivot[c] = r[`pivot_${c}`];
+                    delete inst._attributes[`pivot_${c}`];
+                }
+                inst._relations['$pivot'] = pivot;
+            }
+            return inst;
+        });
+    }
+    async _resolveHasManyThrough() {
+        const localVal = this.parentInstance.get(this.localKey);
+        if (localVal === undefined || localVal === null)
+            return [];
+        const throughTable = this.ThroughModel.getTable();
+        const throughFK = this.throughForeignKey; // FK on through model → parent
+        const throughLK = this.throughLocalKey; // FK on related model → through
+        const relatedTable = this.RelatedModel.getTable();
+        const relatedPK = this.RelatedModel.primaryKey;
+        // SELECT related.* FROM related
+        // INNER JOIN through ON related.through_fk = through.id
+        // WHERE through.parent_fk = localVal
+        const rows = await Database.table(relatedTable)
+            .select(`${relatedTable}.*`)
+            .join(throughTable, `${relatedTable}.${throughLK}`, '=', `${throughTable}.${this.ThroughModel.primaryKey}`)
+            .where(`${throughTable}.${throughFK}`, localVal)
+            .get();
+        return rows.map((r) => {
+            const inst = new this.RelatedModel(r);
+            inst._exists = true;
+            inst._original = { ...r };
+            return inst;
+        });
+    }
+}
+// ─── Computed Property Decorator ──────────────────────────────────────────────
+/**
+ * Marks a getter as a "computed property" — included in toJSON() output.
+ * Computed properties are derived from other attributes (not stored in DB).
+ *
+ * @example
+ * class Patient extends Model {
+ *   @computed()
+ *   get age(): number {
+ *     const dob = new Date(this.date_of_birth);
+ *     return Math.floor((Date.now() - dob.getTime()) / (365.25 * 24 * 3600 * 1000));
+ *   }
+ *
+ *   @computed()
+ *   get fullName(): string {
+ *     return `${this.first_name} ${this.last_name}`;
+ *   }
+ * }
+ */
+export function computed() {
+    return function (target, propertyKey) {
+        const ModelProto = target;
+        if (!ModelProto._computedProperties) {
+            ModelProto._computedProperties = [];
+        }
+        ModelProto._computedProperties.push(String(propertyKey));
+    };
+}
+// ─── Model Base Class ─────────────────────────────────────────────────────────
+export class Model {
+    // ── Static Configuration ────────────────────────────────────────────────────
+    static table = '';
+    static primaryKey = 'id';
+    static hidden = [];
+    static fillable = [];
+    static tenanted = false;
+    static tenantColumn = 'tenant_id';
+    static softDeletes = false;
+    static timestamps = true;
+    static connection = 'default';
+    /**
+     * Global query scopes automatically applied to every query.
+     *
+     * @example
+     * class Patient extends Model {
+     *   public static override globalScopes = [BranchScope, ActiveScope];
+     * }
+     */
+    static globalScopes = [];
+    // ── Instance State ──────────────────────────────────────────────────────────
+    _attributes;
+    _original;
+    _dirty;
+    _exists = false;
+    _relations = {};
+    constructor(attributes = {}) {
+        this._attributes = {};
+        this._original = {};
+        this._dirty = {};
+        this._exists = false;
+        this._relations = {};
+        this.fill(attributes);
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (typeof prop === 'symbol')
+                    return Reflect.get(target, prop, receiver);
+                if (target._relations && prop in target._relations)
+                    return target._relations[prop];
+                if (prop in target) {
+                    const val = Reflect.get(target, prop, receiver);
+                    if (typeof val === 'function' && prop !== 'constructor')
+                        return val.bind(target);
+                    return val;
+                }
+                return target.get(String(prop));
+            },
+            set(target, prop, value, receiver) {
+                if (typeof prop === 'symbol')
+                    return Reflect.set(target, prop, value, receiver);
+                if (prop in target &&
+                    !['_attributes', '_original', '_dirty', '_relations', '_exists'].includes(String(prop))) {
+                    const desc = Object.getOwnPropertyDescriptor(target, prop) ||
+                        Object.getOwnPropertyDescriptor(Object.getPrototypeOf(target), prop);
+                    if (desc && (desc.get || desc.set))
+                        return Reflect.set(target, prop, value, receiver);
+                }
+                target.set(String(prop), value);
+                return true;
+            },
+        });
+    }
+    fill(attributes) {
+        const raw = attributes instanceof Model ? attributes.getAttributes() : attributes;
+        const Ctor = this.constructor;
+        for (const [key, value] of Object.entries(raw)) {
+            if (Ctor.fillable.length === 0 || Ctor.fillable.includes(key)) {
+                this._attributes[key] = value;
+            }
+        }
+        return this;
+    }
+    get(key) {
+        return this._attributes[key] !== undefined ? this._attributes[key] : null;
+    }
+    set(key, value) {
+        if (this._exists && this._original[key] !== value) {
+            this._dirty[key] = true;
+        }
+        this._attributes[key] = value;
+        return this;
+    }
+    /** Returns true if the given field has changed since last save. */
+    isDirty(field) {
+        if (field)
+            return !!this._dirty[field];
+        return Object.keys(this._dirty).length > 0;
+    }
+    /** Returns all changed attributes since last save. */
+    getDirty() {
+        const result = {};
+        for (const key of Object.keys(this._dirty)) {
+            result[key] = this._attributes[key];
+        }
+        return result;
+    }
+    getAttributes() {
+        return { ...this._attributes };
+    }
+    get attributes() {
+        return this.getAttributes();
+    }
+    static getTable() {
+        if (this.table)
+            return this.table;
+        const name = this.name || 'Model';
+        const snake = name.replace(/([A-Z])/g, (m, p1, offset) => offset > 0 ? '_' + p1.toLowerCase() : p1.toLowerCase());
+        return snake.endsWith('s') ? snake : `${snake}s`;
+    }
+    // ─── Relationships ──────────────────────────────────────────────────────────
+    hasMany(RelatedModel, foreignKey, localKey) {
+        return new Relation({
+            type: 'hasMany',
+            RelatedModel,
+            foreignKey: foreignKey || `${this.constructor.name.toLowerCase()}_id`,
+            localKey: localKey || this.constructor.primaryKey,
+            parentInstance: this,
+        });
+    }
+    hasOne(RelatedModel, foreignKey, localKey) {
+        return new Relation({
+            type: 'hasOne',
+            RelatedModel,
+            foreignKey: foreignKey || `${this.constructor.name.toLowerCase()}_id`,
+            localKey: localKey || this.constructor.primaryKey,
+            parentInstance: this,
+        });
+    }
+    belongsTo(RelatedModel, foreignKey, ownerKey) {
+        return new Relation({
+            type: 'belongsTo',
+            RelatedModel,
+            foreignKey: foreignKey || `${RelatedModel.name.toLowerCase()}_id`,
+            localKey: ownerKey || RelatedModel.primaryKey,
+            parentInstance: this,
+        });
+    }
+    /**
+     * ManyToMany Relationship via a pivot table.
+     *
+     * @example
+     * // Doctor ↔ Specialization (pivot: doctor_specializations)
+     * public specializations() {
+     *   return this.manyToMany(Specialization, {
+     *     pivotTable: 'doctor_specializations',
+     *     pivotForeignKey: 'doctor_id',
+     *     pivotRelatedKey: 'specialization_id',
+     *     pivotColumns: ['certified_at'], // extra pivot columns
+     *   });
+     * }
+     *
+     * // Patient ↔ ICD-11 Diagnosis (pivot: patient_diagnoses)
+     * public diagnoses() {
+     *   return this.manyToMany(Diagnosis, {
+     *     pivotTable: 'patient_diagnoses',
+     *     pivotForeignKey: 'patient_id',
+     *     pivotRelatedKey: 'diagnosis_code',
+     *   });
+     * }
+     *
+     * // OT Surgery ↔ Surgeon team (pivot: ot_surgery_doctors)
+     * public surgeons() {
+     *   return this.manyToMany(Doctor, {
+     *     pivotTable: 'ot_surgery_doctors',
+     *     pivotForeignKey: 'surgery_id',
+     *     pivotRelatedKey: 'doctor_id',
+     *     pivotColumns: ['role'], // primary_surgeon, assistant, anesthesiologist
+     *   });
+     * }
+     */
+    manyToMany(RelatedModel, options = {}) {
+        const Ctor = this.constructor;
+        const thisName = Ctor.name.toLowerCase();
+        const relatedName = RelatedModel.name.toLowerCase();
+        const pivotTable = options.pivotTable ??
+            [thisName, relatedName].sort().join('_') + 's';
+        return new Relation({
+            type: 'manyToMany',
+            RelatedModel,
+            foreignKey: options.localKey || Ctor.primaryKey,
+            localKey: options.localKey || Ctor.primaryKey,
+            parentInstance: this,
+            pivotTable,
+            pivotForeignKey: options.pivotForeignKey ?? `${thisName}_id`,
+            pivotRelatedKey: options.pivotRelatedKey ?? `${relatedName}_id`,
+            pivotColumns: options.pivotColumns ?? [],
+        });
+    }
+    /**
+     * HasManyThrough Relationship.
+     *
+     * @example
+     * // Hospital has many Beds through Wards
+     * public beds() {
+     *   return this.hasManyThrough(Bed, Ward, {
+     *     foreignKey: 'hospital_id',       // FK on Ward pointing to Hospital
+     *     throughForeignKey: 'ward_id',    // FK on Bed pointing to Ward
+     *   });
+     * }
+     *
+     * // Country has many Patients through Hospitals
+     * public patients() {
+     *   return this.hasManyThrough(Patient, Hospital, {
+     *     foreignKey: 'country_id',
+     *     throughForeignKey: 'hospital_id',
+     *   });
+     * }
+     */
+    hasManyThrough(RelatedModel, ThroughModel, options = {}) {
+        const Ctor = this.constructor;
+        const throughName = ThroughModel.name.toLowerCase();
+        const relatedName = RelatedModel.name.toLowerCase();
+        return new Relation({
+            type: 'hasManyThrough',
+            RelatedModel,
+            ThroughModel,
+            foreignKey: options.foreignKey ?? `${Ctor.name.toLowerCase()}_id`,
+            localKey: options.localKey ?? Ctor.primaryKey,
+            parentInstance: this,
+            throughForeignKey: options.foreignKey ?? `${Ctor.name.toLowerCase()}_id`,
+            throughLocalKey: options.throughForeignKey ?? `${throughName}_id`,
+        });
+    }
+    // ─── ManyToMany Pivot Helpers ───────────────────────────────────────────────
+    /**
+     * Attach related records to the ManyToMany pivot table.
+     *
+     * @example
+     * // Attach specializations to doctor
+     * await doctor.attach('specializations', [1, 3, 5]);
+     *
+     * // Attach with pivot data (e.g. certified_at date)
+     * await doctor.attach('specializations', { 1: { certified_at: '2024-01-01' } });
+     */
+    async attach(relationName, idsOrMap, connectionOrAdapter) {
+        const rel = this[relationName]();
+        if (rel.type !== 'manyToMany')
+            throw new Error(`attach() only works on manyToMany relations`);
+        const Ctor = this.constructor;
+        const localVal = this.get(Ctor.primaryKey);
+        const conn = connectionOrAdapter || Ctor.connection;
+        const table = rel.pivotTable;
+        const rows = [];
+        if (Array.isArray(idsOrMap)) {
+            for (const relatedId of idsOrMap) {
+                rows.push({ [rel.pivotForeignKey]: localVal, [rel.pivotRelatedKey]: relatedId });
+            }
+        }
+        else {
+            for (const [relatedId, pivotData] of Object.entries(idsOrMap)) {
+                rows.push({ [rel.pivotForeignKey]: localVal, [rel.pivotRelatedKey]: relatedId, ...pivotData });
+            }
+        }
+        for (const row of rows) {
+            await Database.table(table, conn).insert(row);
+        }
+    }
+    /**
+     * Detach related records from the ManyToMany pivot table.
+     *
+     * @example
+     * await doctor.detach('specializations', [3]); // detach specific
+     * await doctor.detach('specializations');       // detach all
+     */
+    async detach(relationName, ids, connectionOrAdapter) {
+        const rel = this[relationName]();
+        if (rel.type !== 'manyToMany')
+            throw new Error(`detach() only works on manyToMany relations`);
+        const Ctor = this.constructor;
+        const localVal = this.get(Ctor.primaryKey);
+        const conn = connectionOrAdapter || Ctor.connection;
+        let qb = Database.table(rel.pivotTable, conn).where(rel.pivotForeignKey, localVal);
+        if (ids && ids.length > 0) {
+            qb = qb.whereIn(rel.pivotRelatedKey, ids);
+        }
+        await qb.delete();
+    }
+    /**
+     * Sync pivot table — detach all then re-attach.
+     *
+     * @example
+     * // Sync a doctor's specializations (replaces all existing)
+     * await doctor.sync('specializations', [1, 3, 5]);
+     */
+    async sync(relationName, idsOrMap, connectionOrAdapter) {
+        await this.detach(relationName, undefined, connectionOrAdapter);
+        await this.attach(relationName, idsOrMap, connectionOrAdapter);
+    }
+    // ─── Static Query Builder ───────────────────────────────────────────────────
+    /**
+     * Starts a model-level QueryBuilder with full support for:
+     * - Eager loading (.with())
+     * - Soft deletes (.withTrashed(), .onlyTrashed())
+     * - Query scopes (.active(), .byBranch(), etc.)
+     * - Global scopes (auto-applied)
+     */
+    static query(connectionOrAdapter) {
+        const table = this.getTable();
+        const qb = Database.table(table, connectionOrAdapter || this.connection);
+        const ModelClass = this;
+        // Apply multi-tenancy auto-scope
+        if (this.tenanted) {
+            const tenantId = TenancyContext.getStore();
+            if (tenantId !== undefined) {
+                qb.where(this.tenantColumn, tenantId);
+            }
+        }
+        qb._eagerLoads = [];
+        qb._withTrashed = false;
+        qb._onlyTrashed = false;
+        qb.with = (...relations) => {
+            qb._eagerLoads.push(...relations);
+            return qb;
+        };
+        qb.preload = (...relations) => qb.with(...relations);
+        qb.withTrashed = () => { qb._withTrashed = true; return qb; };
+        qb.onlyTrashed = () => { qb._onlyTrashed = true; return qb; };
+        // ── Query Scope Binding ─────────────────────────────────────────────────
+        // Auto-bind static scope methods: Model.scopeActive() → qb.active()
+        const proto = ModelClass;
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            if (key.startsWith('scope') && typeof proto[key] === 'function') {
+                const scopeName = key.charAt(5).toLowerCase() + key.slice(6); // scopeActive → active
+                qb[scopeName] = (...args) => {
+                    proto[key](qb, ...args);
+                    return qb;
+                };
+            }
+        }
+        // ── Apply global scopes ─────────────────────────────────────────────────
+        for (const scope of ModelClass.globalScopes) {
+            scope(qb);
+        }
+        const applySoftDeleteFilter = () => {
+            if (ModelClass.softDeletes) {
+                if (qb._onlyTrashed) {
+                    qb.whereNotNull('deleted_at');
+                }
+                else if (!qb._withTrashed) {
+                    qb.whereNull('deleted_at');
+                }
+            }
+        };
+        const hydrateRow = (r) => {
+            const inst = new ModelClass(r);
+            inst._exists = true;
+            inst._original = { ...r };
+            inst._dirty = {};
+            return inst;
+        };
+        const originalGet = qb.get.bind(qb);
+        const originalFirst = qb.first.bind(qb);
+        qb.get = async () => {
+            applySoftDeleteFilter();
+            // beforeFetch hook
+            const registry = getHookRegistry(ModelClass);
+            await registry.execute('beforeFetch', qb);
+            const rows = await originalGet();
+            const instances = rows.map(hydrateRow);
+            // afterFetch hook
+            await registry.execute('afterFetch', instances);
+            // Eager Load
+            if (qb._eagerLoads.length > 0 && instances.length > 0) {
+                for (const relationName of qb._eagerLoads) {
+                    await ModelClass.eagerLoadRelation(instances, relationName);
+                }
+            }
+            return instances;
+        };
+        qb.first = async () => {
+            const prevLimit = qb.limitCount;
+            qb.limitCount = 1;
+            const rows = await qb.get();
+            qb.limitCount = prevLimit;
+            const inst = rows[0] || null;
+            if (inst) {
+                const registry = getHookRegistry(ModelClass);
+                await registry.execute('afterFind', inst);
+            }
+            return inst;
+        };
+        qb.firstOrFail = async () => {
+            const inst = await qb.first();
+            if (!inst)
+                throw new NotFoundError(`${ModelClass.name} not found`);
+            return inst;
+        };
+        return qb;
+    }
+    // ─── Eager Loading ──────────────────────────────────────────────────────────
+    static async eagerLoadRelation(instances, relationName) {
+        if (instances.length === 0)
+            return;
+        const sample = instances[0];
+        if (typeof sample[relationName] !== 'function')
+            return;
+        const relation = sample[relationName]();
+        if (relation.type === 'manyToMany') {
+            await this._eagerLoadManyToMany(instances, relationName, relation);
+            return;
+        }
+        if (relation.type === 'hasManyThrough') {
+            await this._eagerLoadHasManyThrough(instances, relationName, relation);
+            return;
+        }
+        if (relation.type === 'belongsTo') {
+            const foreignKeys = instances
+                .map((i) => i.get(relation.foreignKey))
+                .filter((k) => k !== null && k !== undefined);
+            if (foreignKeys.length === 0) {
+                for (const inst of instances)
+                    inst._relations[relationName] = null;
+                return;
+            }
+            const relatedRows = await relation.RelatedModel.query()
+                .whereIn(relation.localKey, foreignKeys)
+                .get();
+            for (const inst of instances) {
+                const fv = inst.get(relation.foreignKey);
+                inst._relations[relationName] =
+                    relatedRows.find((r) => r.get(relation.localKey) === fv) || null;
+            }
+        }
+        else {
+            const parentKeys = instances
+                .map((i) => i.get(relation.localKey))
+                .filter((k) => k !== null && k !== undefined);
+            if (parentKeys.length === 0) {
+                for (const inst of instances) {
+                    inst._relations[relationName] = relation.type === 'hasMany' ? [] : null;
+                }
+                return;
+            }
+            const relatedRows = await relation.RelatedModel.query()
+                .whereIn(relation.foreignKey, parentKeys)
+                .get();
+            for (const inst of instances) {
+                const pv = inst.get(relation.localKey);
+                if (relation.type === 'hasMany') {
+                    inst._relations[relationName] = relatedRows.filter((r) => r.get(relation.foreignKey) === pv);
+                }
+                else {
+                    inst._relations[relationName] =
+                        relatedRows.find((r) => r.get(relation.foreignKey) === pv) || null;
+                }
+            }
+        }
+    }
+    static async _eagerLoadManyToMany(instances, relationName, rel) {
+        const localKey = rel.localKey;
+        const parentKeys = instances.map((i) => i.get(localKey)).filter((k) => k != null);
+        if (parentKeys.length === 0) {
+            for (const inst of instances)
+                inst._relations[relationName] = [];
+            return;
+        }
+        const relatedTable = rel.RelatedModel.getTable();
+        const relatedPK = rel.RelatedModel.primaryKey;
+        const pivotExtra = rel.pivotColumns ?? [];
+        const selectCols = [
+            `${relatedTable}.*`,
+            `${rel.pivotTable}.${rel.pivotForeignKey} as __pivot_fk`,
+            ...pivotExtra.map((c) => `${rel.pivotTable}.${c} as pivot_${c}`),
+        ];
+        const rows = await Database.table(relatedTable)
+            .select(...selectCols)
+            .join(rel.pivotTable, `${relatedTable}.${relatedPK}`, '=', `${rel.pivotTable}.${rel.pivotRelatedKey}`)
+            .whereIn(`${rel.pivotTable}.${rel.pivotForeignKey}`, parentKeys)
+            .get();
+        const map = new Map();
+        for (const inst of instances) {
+            map.set(inst.get(localKey), []);
+        }
+        for (const row of rows) {
+            const parentKey = row.__pivot_fk;
+            const inst = new rel.RelatedModel(row);
+            inst._exists = true;
+            inst._original = { ...row };
+            delete inst._attributes['__pivot_fk'];
+            if (pivotExtra.length > 0) {
+                const pivot = {};
+                for (const c of pivotExtra) {
+                    pivot[c] = row[`pivot_${c}`];
+                    delete inst._attributes[`pivot_${c}`];
+                }
+                inst._relations['$pivot'] = pivot;
+            }
+            const list = map.get(parentKey);
+            if (list)
+                list.push(inst);
+        }
+        for (const inst of instances) {
+            inst._relations[relationName] = map.get(inst.get(localKey)) ?? [];
+        }
+    }
+    static async _eagerLoadHasManyThrough(instances, relationName, rel) {
+        const parentKeys = instances.map((i) => i.get(rel.localKey)).filter((k) => k != null);
+        if (parentKeys.length === 0) {
+            for (const inst of instances)
+                inst._relations[relationName] = [];
+            return;
+        }
+        const relatedTable = rel.RelatedModel.getTable();
+        const throughTable = rel.ThroughModel.getTable();
+        const rows = await Database.table(relatedTable)
+            .select(`${relatedTable}.*`, `${throughTable}.${rel.throughForeignKey} as __through_fk`)
+            .join(throughTable, `${relatedTable}.${rel.throughLocalKey}`, '=', `${throughTable}.${rel.ThroughModel.primaryKey}`)
+            .whereIn(`${throughTable}.${rel.throughForeignKey}`, parentKeys)
+            .get();
+        const map = new Map();
+        for (const inst of instances)
+            map.set(inst.get(rel.localKey), []);
+        for (const row of rows) {
+            const parentKey = row.__through_fk;
+            const inst = new rel.RelatedModel(row);
+            inst._exists = true;
+            inst._original = { ...row };
+            delete inst._attributes['__through_fk'];
+            const list = map.get(parentKey);
+            if (list)
+                list.push(inst);
+        }
+        for (const inst of instances) {
+            inst._relations[relationName] = map.get(inst.get(rel.localKey)) ?? [];
+        }
+    }
+    // ─── Static Finders ─────────────────────────────────────────────────────────
+    static async find(id) {
+        return this.query().where(this.primaryKey, id).first();
+    }
+    static async findOrFail(id) {
+        const inst = await this.find(id);
+        if (!inst)
+            throw new NotFoundError(`${this.name} with id ${id} not found`);
+        return inst;
+    }
+    static async findBy(column, value) {
+        return this.query().where(column, value).first();
+    }
+    static async all() {
+        return this.query().get();
+    }
+    static where(column, operatorOrValue, value) {
+        return this.query().where(column, operatorOrValue, value);
+    }
+    static whereIn(column, values) {
+        return this.query().whereIn(column, values);
+    }
+    static whereNotIn(column, values) {
+        return this.query().whereNotIn(column, values);
+    }
+    static whereBetween(column, range) {
+        return this.query().whereBetween(column, range);
+    }
+    static whereNotBetween(column, range) {
+        return this.query().whereNotBetween(column, range);
+    }
+    static whereLike(column, pattern) {
+        return this.query().whereLike(column, pattern);
+    }
+    static whereNull(column) {
+        return this.query().whereNull(column);
+    }
+    static whereNotNull(column) {
+        return this.query().whereNotNull(column);
+    }
+    static whereRaw(sql, bindings = []) {
+        return this.query().whereRaw(sql, bindings);
+    }
+    static orderBy(column, direction = 'ASC') {
+        return this.query().orderBy(column, direction);
+    }
+    static limit(count) {
+        return this.query().limit(count);
+    }
+    static async paginate(page = 1, perPage = 15) {
+        return this.query().paginate(page, perPage);
+    }
+    static with(...relations) {
+        return this.query().with(...relations);
+    }
+    static preload(...relations) {
+        return this.query().preload(...relations);
+    }
+    static async count(column = '*') {
+        return this.query().count(column);
+    }
+    static async sum(column) {
+        return this.query().sum(column);
+    }
+    static async avg(column) {
+        return this.query().avg(column);
+    }
+    static async create(attributes, connectionOrAdapter) {
+        const instance = new this(attributes);
+        await instance.save(connectionOrAdapter);
+        return instance;
+    }
+    static async firstOrCreate(search, attributes = {}, connectionOrAdapter) {
+        let q = this.query(connectionOrAdapter);
+        for (const [k, v] of Object.entries(search)) {
+            q = q.where(k, v);
+        }
+        const found = await q.first();
+        if (found)
+            return found;
+        return this.create({ ...search, ...attributes }, connectionOrAdapter);
+    }
+    /**
+     * Update or create a record.
+     *
+     * @example
+     * await Patient.updateOrCreate(
+     *   { mrn: 'AKMMCH-2024-0001' },
+     *   { name: 'Rahim', phone: '01700000000' }
+     * );
+     */
+    static async updateOrCreate(search, attributes, connectionOrAdapter) {
+        let q = this.query(connectionOrAdapter);
+        for (const [k, v] of Object.entries(search))
+            q = q.where(k, v);
+        const found = await q.first();
+        if (found) {
+            found.fill(attributes);
+            await found.save(connectionOrAdapter);
+            return found;
+        }
+        return this.create({ ...search, ...attributes }, connectionOrAdapter);
+    }
+    // ─── Save / Delete ──────────────────────────────────────────────────────────
+    async save(connectionOrAdapter) {
+        const Ctor = this.constructor;
+        const pk = Ctor.primaryKey;
+        const table = Ctor.getTable();
+        const conn = connectionOrAdapter || Ctor.connection;
+        const registry = getHookRegistry(Ctor);
+        await registry.execute('beforeSave', this);
+        const formatSqlDate = () => new Date().toISOString().slice(0, 19).replace('T', ' ');
+        if (!this._exists) {
+            await registry.execute('beforeCreate', this);
+            const createdCol = typeof Ctor.timestamps === 'object'
+                ? (Ctor.timestamps.createdAt || null)
+                : (Ctor.timestamps ? 'created_at' : null);
+            const updatedCol = typeof Ctor.timestamps === 'object'
+                ? (Ctor.timestamps.updatedAt || null)
+                : (Ctor.timestamps ? 'updated_at' : null);
+            if (createdCol && !this._attributes[createdCol])
+                this._attributes[createdCol] = formatSqlDate();
+            if (updatedCol && !this._attributes[updatedCol])
+                this._attributes[updatedCol] = formatSqlDate();
+            const res = await Database.table(table, conn).insert(this._attributes);
+            if (res.insertId && !this._attributes[pk])
+                this._attributes[pk] = res.insertId;
+            this._exists = true;
+            this._original = { ...this._attributes };
+            this._dirty = {};
+            await registry.execute('afterCreate', this);
+        }
+        else {
+            await registry.execute('beforeUpdate', this);
+            const updatedCol = typeof Ctor.timestamps === 'object'
+                ? (Ctor.timestamps.updatedAt || null)
+                : (Ctor.timestamps ? 'updated_at' : null);
+            if (updatedCol)
+                this._attributes[updatedCol] = formatSqlDate();
+            const id = this._attributes[pk];
+            await Database.table(table, conn).where(pk, id).update(this._attributes);
+            this._original = { ...this._attributes };
+            this._dirty = {};
+            await registry.execute('afterUpdate', this);
+        }
+        await registry.execute('afterSave', this);
+        return this;
+    }
+    async delete(connectionOrAdapter) {
+        if (!this._exists)
+            return false;
+        const Ctor = this.constructor;
+        const pk = Ctor.primaryKey;
+        const id = this._attributes[pk];
+        const conn = connectionOrAdapter || Ctor.connection;
+        const registry = getHookRegistry(Ctor);
+        await registry.execute('beforeDelete', this);
+        if (Ctor.softDeletes) {
+            const now = new Date().toISOString().slice(0, 19).replace('T', ' ');
+            this.set('deleted_at', now);
+            await Database.table(Ctor.getTable(), conn).where(pk, id).update({ deleted_at: now });
+        }
+        else {
+            await Database.table(Ctor.getTable(), conn).where(pk, id).delete();
+            this._exists = false;
+        }
+        await registry.execute('afterDelete', this);
+        return true;
+    }
+    async restore(connectionOrAdapter) {
+        const Ctor = this.constructor;
+        if (!Ctor.softDeletes || !this._exists)
+            return false;
+        const pk = Ctor.primaryKey;
+        const id = this._attributes[pk];
+        const conn = connectionOrAdapter || Ctor.connection;
+        this.set('deleted_at', null);
+        await Database.table(Ctor.getTable(), conn).where(pk, id).update({ deleted_at: null });
+        return true;
+    }
+    async forceDelete(connectionOrAdapter) {
+        if (!this._exists)
+            return false;
+        const Ctor = this.constructor;
+        const pk = Ctor.primaryKey;
+        const id = this._attributes[pk];
+        const conn = connectionOrAdapter || Ctor.connection;
+        await Database.table(Ctor.getTable(), conn).where(pk, id).delete();
+        this._exists = false;
+        return true;
+    }
+    // ─── Serialization ──────────────────────────────────────────────────────────
+    /**
+     * Converts the model to a plain JSON object.
+     * Hidden attributes are excluded. Relations and computed properties are included.
+     */
+    toJSON() {
+        const Ctor = this.constructor;
+        const json = {};
+        for (const [key, val] of Object.entries(this._attributes)) {
+            if (!Ctor.hidden.includes(key))
+                json[key] = val;
+        }
+        // Include eager-loaded relations
+        for (const [rel, val] of Object.entries(this._relations)) {
+            if (rel === '$pivot')
+                continue; // handled separately
+            if (Array.isArray(val)) {
+                json[rel] = val.map((item) => (item?.toJSON ? item.toJSON() : item));
+            }
+            else if (val?.toJSON) {
+                json[rel] = val.toJSON();
+            }
+            else {
+                json[rel] = val;
+            }
+        }
+        // Include computed properties (registered via @computed decorator)
+        const computedProps = Object.getPrototypeOf(this)._computedProperties ?? [];
+        for (const prop of computedProps) {
+            try {
+                const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), prop);
+                if (descriptor?.get) {
+                    json[prop] = descriptor.get.call(this);
+                }
+            }
+            catch {
+                // Computed property threw — skip silently
+            }
+        }
+        return json;
+    }
+    // ─── Instance Lifecycle Hooks (override-style, kept for backward compat) ────
+    /** @deprecated Use @beforeSave() decorator or registerHook() instead */
+    async beforeCreate() { }
+    /** @deprecated Use @afterCreate() decorator or registerHook() instead */
+    async afterCreate() { }
+    /** @deprecated Use @beforeSave() decorator or registerHook() instead */
+    async beforeSave() { }
+    /** @deprecated Use @afterSave() decorator or registerHook() instead */
+    async afterSave() { }
+    /** @deprecated Use @beforeDelete() decorator or registerHook() instead */
+    async beforeDelete() { }
+    /** @deprecated Use @afterDelete() decorator or registerHook() instead */
+    async afterDelete() { }
+}
+export default Model;
+//# sourceMappingURL=model.js.map