@kava/kava-api-core 1.0.0

package/dist/model.util.js

@@ -0,0 +1,1495 @@
+import { status } from 'elysia';
+import { conversion, db } from '@utils';
+// ==========================
+// ## Decorator Type
+// ==========================
+export const PRIMARY_KEY_META = Symbol('primary-key-meta');
+export const FIELD_META = Symbol('field-meta');
+export const RELATION_META = Symbol('relation-meta');
+export const SOFT_DELETE_META = Symbol('soft-delete');
+export const ATTRIBUTE_META = Symbol('attribute-meta');
+export const FORMATTER_META = Symbol('formatter-meta');
+export const SCOPE_META = Symbol('scope-meta');
+const Casts = {
+    string: {
+        fromDB: (v) => v == null ? v : String(v),
+        toDB: (v) => v,
+    },
+    number: {
+        fromDB: (v) => v == null ? v : Number(v),
+        toDB: (v) => v,
+    },
+    boolean: {
+        fromDB: (v) => Boolean(v),
+        toDB: (v) => v ? 1 : 0,
+    },
+    date: {
+        fromDB: (v) => v ? new Date(v) : null,
+        toDB: (v) => v instanceof Date ? v.toISOString() : v,
+    },
+    json: {
+        fromDB: (v) => {
+            if (typeof v !== 'string')
+                return v;
+            try {
+                return JSON.parse(v);
+            }
+            catch {
+                return null;
+            }
+        },
+        toDB: (v) => JSON.stringify(v),
+    },
+};
+export class Model {
+    // ==========================
+    // ## Constructor model
+    // ==========================
+    constructor(data = {}) {
+        this._original = {};
+        this._exists = false;
+        this._trx = undefined;
+        this._instanceHooks = {};
+        this._disabledHooks = new Set();
+        Object.assign(this, data);
+        if (this[this.constructor.primaryKey])
+            this._exists = true;
+    }
+    static newInstance() {
+        return new this();
+    }
+    static getDefaultFields() {
+        const pk = this[PRIMARY_KEY_META] ?? this.primaryKey ?? 'id';
+        return {
+            [pk]: {
+                cast: 'number',
+                selectable: true,
+            },
+            created_at: { cast: 'date' },
+            updated_at: { cast: 'date' },
+            deleted_at: { cast: 'date' },
+        };
+    }
+    static get fields() {
+        const defaults = this.getDefaultFields?.() ?? {};
+        return { ...defaults, ...(this[FIELD_META] ?? {}) };
+    }
+    static get fillable() {
+        return Object.entries(this.fields).filter(([, v]) => v.fillable).map(([k]) => k);
+    }
+    static get selectable() {
+        return Object.entries(this.fields).filter(([, v]) => v.selectable).map(([k]) => k);
+    }
+    static get searchable() {
+        return Object.entries(this.fields).filter(([, v]) => v.searchable).map(([k]) => k);
+    }
+    // ==========================
+    // ## Table
+    // ==========================
+    static getTable() {
+        if (this.table)
+            return this.table;
+        return conversion.strPlural(conversion.strSnake(this.name));
+    }
+    // ==========================
+    // ## Primary key
+    // ==========================
+    static getPrimaryKey() {
+        return this[PRIMARY_KEY_META] ?? this.primaryKey ?? 'id';
+    }
+    static get relations() {
+        return this[RELATION_META] ?? {};
+    }
+    // ==========================
+    // ## Attribute
+    // ==========================
+    static get attributes() {
+        return this[ATTRIBUTE_META] ?? {};
+    }
+    // ==========================
+    // ## Formatter
+    // ==========================
+    static get formatters() {
+        return this[FORMATTER_META] ?? {};
+    }
+    // ==========================
+    // ## Scope
+    // ==========================
+    static get scopes() {
+        return this[SCOPE_META] ?? {};
+    }
+    // ==========================
+    // ## Getter attribute
+    // ==========================
+    getOriginal(key) {
+        if (!key)
+            return { ...this._original };
+        return this._original[key];
+    }
+    getChanges() {
+        const changes = {};
+        for (const key in this._original) {
+            if (this[key] != this._original[key]) {
+                changes[key] = this[key];
+            }
+        }
+        return changes;
+    }
+    getPrevious() {
+        const prev = {};
+        for (const key in this._original) {
+            if (this[key] != this._original[key]) {
+                prev[key] = this._original[key];
+            }
+        }
+        return prev;
+    }
+    // ==========================
+    // ## Query builder
+    // ==========================
+    static query(trx) {
+        const qb = (trx ?? db)(this.getTable());
+        return extendModelQuery(qb, this);
+    }
+    // ==========================
+    // ## Casting
+    // ==========================
+    castFromDB(row) {
+        const ctor = this.constructor;
+        const fields = ctor.fields;
+        for (const [key, value] of Object.entries(row)) {
+            if (!fields[key])
+                continue;
+            const meta = fields[key];
+            this[key] = meta.cast ? Casts[meta.cast].fromDB(value) : value;
+        }
+        this._original = {};
+        for (const key of Object.keys(fields)) {
+            this._original[key] = this[key];
+        }
+        const attrs = ctor.attributes;
+        for (const [name, fn] of Object.entries(attrs)) {
+            Object.defineProperty(this, name, {
+                get: () => fn.call(this),
+                enumerable: true,
+            });
+        }
+        this._exists = true;
+        return this;
+    }
+    castToDB() {
+        const fields = this.constructor.fields;
+        const data = {};
+        for (const [key, meta] of Object.entries(fields)) {
+            if (!meta.fillable)
+                continue;
+            const val = this[key];
+            if (val === undefined)
+                continue;
+            data[key] = meta.cast ? Casts[meta.cast].toDB(val) : val;
+        }
+        return data;
+    }
+    // ==========================
+    // ## Dirty Field
+    // ==========================
+    getDirty() {
+        const dirty = {};
+        for (const key in this._original) {
+            if (Object.is(this[key], this._original[key]))
+                continue;
+            dirty[key] = this[key];
+        }
+        return dirty;
+    }
+    // ==========================
+    // ## Hydration
+    // ==========================
+    static hydrate(rows) {
+        if (!rows || !Array.isArray(rows))
+            return [];
+        return rows.map(row => {
+            if (row instanceof this)
+                return row;
+            const instance = this.newInstance();
+            return instance.castFromDB(row);
+        });
+    }
+    // ==========================
+    // ## Fill model from payload
+    // ==========================
+    fill(payload) {
+        const ctor = this.constructor;
+        const fields = ctor.fields;
+        for (const [key, value] of Object.entries(payload)) {
+            const meta = fields[key];
+            if (!meta || !meta.fillable)
+                continue;
+            this[key] = value;
+        }
+        return this;
+    }
+    // ==========================
+    // ## Create from fillable
+    // ==========================
+    static async create(payload, trx) {
+        const instance = this.newInstance();
+        instance.fill(payload);
+        const data = instance.castToDB();
+        await instance.runHook('before-create', { model: instance, trx });
+        const conn = trx ?? db;
+        const [row] = await conn(this.getTable()).insert(data).returning('*');
+        await instance.runHook('after-create', { model: instance, trx });
+        return instance.castFromDB(row);
+    }
+    // ==========================
+    // ## update from fillable
+    // ==========================
+    static async update(payload, uniqueKeys, trx) {
+        if (!uniqueKeys.length) {
+            throw new Error('updateByUnique requires uniqueKeys');
+        }
+        const instance = this.newInstance();
+        instance.fill(payload);
+        const data = instance.castToDB();
+        const where = {};
+        for (const key of uniqueKeys) {
+            if (payload[key] === undefined) {
+                throw new Error(`Missing unique key: ${key}`);
+            }
+            where[key] = payload[key];
+        }
+        const conn = trx ?? db;
+        const [row] = await conn(this.getTable()).where(where).update(data).returning('*');
+        if (!row)
+            throw status(404, { message: 'Record not found' });
+        return instance.castFromDB(row);
+    }
+    // ==========================
+    // ## Update or insert from fillable
+    // ==========================
+    static async upsert(payload, uniqueKeys, trx) {
+        if (uniqueKeys.length === 0) {
+            throw new Error('Upsert requires uniqueKeys');
+        }
+        const constraints = {};
+        for (const key of uniqueKeys) {
+            if (payload[key] === undefined) {
+                throw new Error(`Missing unique key: ${key}`);
+            }
+            constraints[key] = payload[key];
+        }
+        let row = await this.query().where(constraints).first();
+        if (!row) {
+            const instance = this.newInstance();
+            instance.fill(payload);
+            const data = instance.castToDB();
+            const conn = trx ?? db;
+            const [row] = await conn(this.getTable()).insert(data).returning('*');
+            return instance.castFromDB(row);
+        }
+        else {
+            const instance = this.newInstance();
+            instance.fill(payload);
+            const data = instance.castToDB();
+            const conn = trx ?? db;
+            const [row] = await conn(this.getTable()).where(constraints).update(data).returning('*');
+            return instance.castFromDB(row);
+        }
+    }
+    // ==========================
+    // ## Save (insert / update)
+    // ==========================
+    async save() {
+        const model = this.constructor;
+        const table = model.getTable();
+        const pk = model.primaryKey;
+        const conn = this._trx ?? db;
+        const hookCtx = { model: this, trx: this._trx };
+        if (!this._exists) {
+            const data = this.castToDB();
+            await this.runHook(`before-create`, hookCtx);
+            const [row] = await conn(table).insert(data).returning('*');
+            this.castFromDB(row);
+            await this.runHook(`after-create`, hookCtx);
+            return this;
+        }
+        const dirty = this.getDirty();
+        if (Object.keys(dirty).length === 0)
+            return this;
+        await this.runHook(`before-update`, hookCtx);
+        const fields = model.fields;
+        const updateData = {};
+        for (const [key, meta] of Object.entries(fields)) {
+            if (!meta.fillable)
+                continue;
+            if (!(key in dirty))
+                continue;
+            const val = dirty[key];
+            updateData[key] = meta.cast ? Casts[meta.cast].toDB(val) : val;
+        }
+        if (Object.keys(updateData).length === 0)
+            return this;
+        await conn(table).where(pk, this[pk]).update(updateData);
+        Object.assign(this._original, dirty);
+        await this.runHook(`after-update`, hookCtx);
+        return this;
+    }
+    // ==========================
+    // ## Save with relation
+    // ==========================
+    async pump(payload, options = {}) {
+        const isRoot = !options.trx;
+        const trx = options.trx ?? await db.transaction();
+        try {
+            // Handle Array (Bulk)
+            if (Array.isArray(payload)) {
+                const Ctor = this.constructor;
+                const pkName = Ctor.primaryKey ?? 'id';
+                const results = [];
+                for (const item of payload) {
+                    let instance = null;
+                    const pkValue = item[pkName];
+                    if (pkValue) {
+                        const row = await Ctor.query(trx).where(pkName, pkValue).first();
+                        if (row) {
+                            instance = Ctor.hydrate([row])[0];
+                        }
+                    }
+                    if (!instance) {
+                        instance = Ctor.newInstance();
+                    }
+                    await instance.pump(item, { trx });
+                    results.push(instance);
+                }
+                if (isRoot)
+                    await trx.commit();
+                return results;
+            }
+            const ctor = this.constructor;
+            const fields = ctor.fields;
+            const relations = ctor.relations ?? {};
+            const flat = {};
+            const nested = {};
+            for (const key of Object.keys(payload)) {
+                const value = payload[key];
+                if (fields[key]?.fillable) {
+                    flat[key] = value;
+                }
+                else if (relations[key] && value !== null) {
+                    nested[key] = value;
+                }
+            }
+            this.fill(flat);
+            await this.useTransaction(trx).save();
+            for (const [name, value] of Object.entries(nested)) {
+                const relDef = relations[name];
+                if (!relDef)
+                    continue;
+                const desc = relDef();
+                const Related = desc.model();
+                // ===== hasMany / belongsToMany =====
+                if (Array.isArray(value)) {
+                    const existing = await Related.query(trx).where(desc.foreignKey, this[desc.localKey]).get();
+                    const existingIds = existing.map((r) => r[Related.primaryKey]);
+                    const incomingIds = [];
+                    for (const item of value) {
+                        if (item[Related.primaryKey]) {
+                            const child = await Related.query(trx).where(Related.primaryKey, item[Related.primaryKey]).getFirst();
+                            if (child) {
+                                await child.pump(item, { trx });
+                                incomingIds.push(child[Related.primaryKey]);
+                            }
+                        }
+                        else {
+                            const child = Related.newInstance();
+                            child[desc.foreignKey] = this[desc.localKey];
+                            await child.pump(item, { trx });
+                            incomingIds.push(child[Related.primaryKey]);
+                        }
+                    }
+                    const toDelete = existingIds.filter((id) => !incomingIds.includes(id));
+                    if (toDelete.length) {
+                        await Related.query(trx).whereIn(Related.primaryKey, toDelete).delete();
+                    }
+                    continue;
+                }
+                const child = Related.newInstance();
+                if (desc.type !== 'belongsTo') {
+                    ;
+                    child[desc.foreignKey] = this[desc.localKey];
+                }
+                await child.pump(value, { trx });
+            }
+            if (isRoot)
+                await trx.commit();
+            return this;
+        }
+        catch (err) {
+            if (isRoot)
+                await trx.rollback();
+            throw err;
+        }
+    }
+    // ==========================
+    // ## Soft Delete
+    // ==========================
+    static getSoftDeleteConfig() {
+        return this[SOFT_DELETE_META] ?? null;
+    }
+    static isSoftDelete() {
+        return !!this.getSoftDeleteConfig();
+    }
+    static getDeletedAtColumn() {
+        return this.getSoftDeleteConfig()?.column ?? null;
+    }
+    // ==========================
+    // ## Delete (with or without soft delete)
+    // ==========================
+    async delete() {
+        const model = this.constructor;
+        const soft = model.getSoftDeleteConfig?.();
+        if (!this._exists)
+            return null;
+        if (!soft)
+            return await this.forceDelete();
+        const trx = this._trx ?? await db.transaction();
+        try {
+            await this.runHook(`before-delete`, { model: this, trx });
+            await trx(model.getTable()).where(model.primaryKey, this[model.primaryKey]).update({ [soft.column]: new Date() });
+            await this.runHook(`after-delete`, { model: this, trx });
+            if (!this._trx)
+                await trx.commit();
+            const snapshot = await (this._trx ?? db)(model.getTable()).where(model.primaryKey, this[model.primaryKey]).first();
+            this._exists = false;
+            return snapshot;
+        }
+        catch (err) {
+            if (!this._trx)
+                await trx.rollback();
+            throw err;
+        }
+    }
+    // ==========================
+    // ## Delete without soft delete
+    // ==========================
+    async forceDelete() {
+        const model = this.constructor;
+        const pk = model.primaryKey;
+        if (!this._exists)
+            return;
+        const snapshot = await (this._trx ?? db)(model.getTable()).where(pk, this[pk]).first();
+        if (!snapshot)
+            return null;
+        await (this._trx ?? db)(model.getTable()).where(pk, this[pk]).delete();
+        this._exists = false;
+        return snapshot;
+    }
+    async restore() {
+        const model = this.constructor;
+        const soft = model.getSoftDeleteConfig?.();
+        if (!soft)
+            return this;
+        await this.runHook(`before-update`, { model: this, trx: this._trx });
+        await (this._trx ?? db)(model.getTable()).where(model.primaryKey, this[model.primaryKey]).update({ [soft.column]: null });
+        await this.runHook(`after-update`, { model: this, trx: this._trx });
+        this._exists = true;
+        return this;
+    }
+    // ==========================
+    // ## Model Hook
+    // ==========================
+    on(event, fn) {
+        if (!this._instanceHooks[event])
+            this._instanceHooks[event] = [];
+        this._instanceHooks[event].push(fn);
+        return this;
+    }
+    off(event) {
+        this._disabledHooks.add(event);
+        return this;
+    }
+    async runHook(event, ctx) {
+        if (this._disabledHooks.has(event))
+            return;
+        const ctor = this.constructor;
+        const globals = ctor._hooks?.[event] ?? [];
+        for (const fn of globals)
+            await fn(ctx);
+        const locals = this._instanceHooks[event] ?? [];
+        for (const fn of locals)
+            await fn(ctx);
+    }
+    // ==========================
+    // ## To response data 
+    // ==========================
+    toJSON() {
+        const data = {};
+        const ctor = this.constructor;
+        const fields = ctor.fields ?? {};
+        const relations = ctor.relations ?? {};
+        const attributes = ctor.attributes ?? {};
+        for (const key of Object.keys(fields)) {
+            if (fields[key]?.hidden)
+                continue;
+            data[key] = this[key];
+        }
+        const expanded = this.__expandedAttributes ?? [];
+        for (const key of expanded) {
+            if (attributes[key]) {
+                data[key] = this[key];
+            }
+        }
+        for (const key of Object.keys(relations)) {
+            if (this[key] !== undefined) {
+                data[key] = this[key];
+            }
+        }
+        return data;
+    }
+    // ==========================
+    // ## Transaction binding
+    // ==========================
+    useTransaction(trx) {
+        this._trx = trx;
+        return this;
+    }
+}
+Model.table = "";
+Model.primaryKey = 'id';
+Model.softDelete = false;
+Model.deletedAtColumn = 'deleted_at';
+Model._hooks = {};
+// ==========================
+// ## Model query builder (extend from knex query builder)
+// ==========================
+export function extendModelQuery(query, Model) {
+    ;
+    query.$model = Model;
+    query._withTree = {};
+    query._softDeleteScope = 'default' //? default | with | only
+    ;
+    query._formatter = null;
+    query._disabledScopes = new Set();
+    query.withTrashed = function () {
+        this._softDeleteScope = 'with';
+        return this;
+    };
+    query.onlyTrashed = function () {
+        this._softDeleteScope = 'only';
+        return this;
+    };
+    // ==========================
+    // ## find or not found 
+    // ==========================
+    if (!query.findOrNotFound) {
+        ;
+        query.findOrNotFound = async function (id) {
+            applyGlobalScopes(this);
+            const pk = Model.primaryKey ?? 'id';
+            const row = await this.where(pk, id).first();
+            if (!row)
+                throw status(404, { message: "Error: Record not found!" });
+            return Model.hydrate([row])[0];
+        };
+    }
+    // ==========================
+    // ## first or not found 
+    // ==========================
+    if (!query.firstOrNotFound) {
+        ;
+        query.firstOrNotFound = async function () {
+            applyGlobalScopes(this);
+            const row = await this.first();
+            if (!row)
+                throw status(404, { message: "Error: Record not found!" });
+            return Model.hydrate([row])[0];
+        };
+    }
+    // ==========================
+    // ## find
+    // ==========================
+    if (!query.find) {
+        ;
+        query.find = async function (id) {
+            applyGlobalScopes(this);
+            const pk = Model.primaryKey ?? 'id';
+            const row = await this.where(pk, id).first();
+            if (!row)
+                return null;
+            return Model.hydrate([row])[0];
+        };
+    }
+    // ==========================
+    // ## Search query
+    // ==========================
+    if (!query.search) {
+        ;
+        query.search = function (keyword, { includes = [], searchable = [] } = {}) {
+            const model = this.$model;
+            if (!model)
+                return this;
+            const defaultSearchable = Model.searchable || [];
+            const mergedSearchable = searchable?.length ? searchable : [...defaultSearchable, ...includes];
+            if (!keyword || !mergedSearchable.length)
+                return this;
+            this.where((q) => {
+                mergedSearchable.forEach((column) => {
+                    if (column.includes(".")) {
+                        const [relation, col] = column.split(".");
+                        q.orWhereHas(relation, (rel) => rel.where(col, "ILIKE", `%${keyword}%`));
+                    }
+                    else {
+                        q.orWhere(column, "ILIKE", `%${keyword}%`);
+                    }
+                });
+            });
+            return this;
+        };
+    }
+    // ==========================
+    // ## Filer query
+    // ==========================
+    if (!query.filter) {
+        ;
+        query.filter = function (filters) {
+            if (!filters)
+                return this;
+            for (const [field, filter] of Object.entries(filters)) {
+                const [type, value] = filter.split(":");
+                if (!type || value === undefined)
+                    continue;
+                const applyWhere = (q, col) => {
+                    switch (type) {
+                        case "li":
+                            q.where(col, "ILIKE", `%${value}%`);
+                            break;
+                        case "eq":
+                            q.where(col, value);
+                            break;
+                        case "ne":
+                            q.where(col, "!=", value);
+                            break;
+                        case "in":
+                            q.whereIn(col, value.split(","));
+                            break;
+                        case "ni":
+                            q.whereNotIn(col, value.split(","));
+                            break;
+                        case "bw": {
+                            const [min, max] = value.split(",");
+                            q.whereBetween(col, [min, max]);
+                            break;
+                        }
+                    }
+                };
+                if (field.includes(".")) {
+                    const [relation, col] = field.split(".");
+                    this.whereHas(relation, (q) => applyWhere(q, col));
+                }
+                else {
+                    applyWhere(this, field);
+                }
+            }
+            return this;
+        };
+    }
+    // ==========================
+    // ## Select query
+    // ==========================
+    if (!query.selects) {
+        ;
+        query.selects = function ({ includes = [], selectable = [] } = {}) {
+            const model = this.$model;
+            if (!model)
+                return this;
+            const defaultSelectable = Model.selectable || ["*"];
+            this.select(selectable?.length ? selectable : [...defaultSelectable, ...includes]);
+            return this;
+        };
+    }
+    // ==========================
+    // ## Sort query
+    // ==========================
+    if (!query.sorts) {
+        ;
+        query.sorts = function (sorts) {
+            if (!Array.isArray(sorts) || sorts.length === 0)
+                return this;
+            sorts.forEach((sortExpr) => {
+                if (typeof sortExpr !== "string")
+                    return;
+                const parts = sortExpr.trim().split(/\s+/);
+                const column = parts[0];
+                const direction = (parts[1] || "asc").toLowerCase();
+                if (!["asc", "desc"].includes(direction)) {
+                    this.orderBy(column, "asc");
+                }
+                else {
+                    this.orderBy(column, direction);
+                }
+            });
+            return this;
+        };
+    }
+    // ==========================
+    // ## Get query
+    // ==========================
+    ;
+    query.get = async function () {
+        applyGlobalScopes(this);
+        applyWithAggregates(this);
+        applyOrderByAggregates(this);
+        const rows = await this;
+        let result = this.$model.hydrate(rows);
+        if (this._withTree && Object.keys(this._withTree).length) {
+            await loadRelations(result, this.$model, this._withTree);
+        }
+        result.forEach((item) => {
+            item.__expandedAttributes = Object.keys(this._withTree || {})
+                .filter(k => this._withTree[k]?.__attribute);
+        });
+        if (this._formatter) {
+            result = result.map(this._formatter);
+        }
+        return result;
+    };
+    query.getFirst = async function () {
+        applyGlobalScopes(this);
+        applyWithAggregates(this);
+        applyOrderByAggregates(this);
+        const rows = await this.limit(1);
+        let result = this.$model.hydrate(rows);
+        if (this._withTree && Object.keys(this._withTree).length) {
+            await loadRelations(result, this.$model, this._withTree);
+        }
+        if (!result.at(0))
+            return null;
+        result.at(0).__expandedAttributes = Object.keys(this._withTree || {}).filter(k => this._withTree[k]?.__attribute);
+        if (this._formatter) {
+            result = result.map(this._formatter).at(0);
+        }
+        return result.at(0);
+    };
+    // ==========================
+    // ## Paginate query
+    // ==========================
+    if (!query.paginate) {
+        ;
+        query.paginate = async function (page = 1, limit = 10) {
+            applyGlobalScopes(this);
+            applyWithAggregates(this);
+            applyOrderByAggregates(this);
+            const offset = (page - 1) * limit;
+            const raw = await this.clone().limit(limit).offset(offset);
+            let data = Model.hydrate(raw);
+            const [{ count }] = await this.clone().clearSelect().clearOrder().count('* as count');
+            const total = Number(count);
+            if (!total)
+                return { data: [], total: 0 };
+            if (this._withTree && Object.keys(this._withTree).length) {
+                await loadRelations(data, this.$model, this._withTree);
+            }
+            data.forEach((item) => {
+                item.__expandedAttributes = Object.keys(this._withTree || {})
+                    .filter(k => this._withTree[k]?.__attribute);
+            });
+            if (this._formatter) {
+                data = data.map(this._formatter);
+            }
+            return { data, total };
+        };
+    }
+    // =================================>
+    // ## Expand query (Eager loading)
+    // =================================>
+    ;
+    query.expand = function (entries = []) {
+        if (!Array.isArray(entries) || !entries.length)
+            return this;
+        if (!this._withTree)
+            this._withTree = {};
+        const applyPath = (path, callback) => {
+            const parts = path.split('.');
+            let cur = this._withTree;
+            let node;
+            for (const part of parts) {
+                cur[part] ??= { __children: {} };
+                node = cur[part];
+                cur = node.__children;
+            }
+            if (callback && node) {
+                node.__callback = callback;
+            }
+        };
+        for (const entry of entries) {
+            if (typeof entry === 'string') {
+                applyPath(entry);
+                continue;
+            }
+            if (typeof entry === 'object') {
+                for (const [path, cb] of Object.entries(entry)) {
+                    applyPath(path, cb);
+                }
+            }
+        }
+        return this;
+    };
+    // ==========================
+    // ## Where has query
+    // ==========================
+    if (!query.whereHas) {
+        ;
+        query.whereHas = function (path, callback) {
+            const Model = this.$model;
+            if (!Model)
+                return this;
+            const relations = path.split('.');
+            whereHasSubquery(this, Model, relations, callback, false);
+            return this;
+        };
+    }
+    // ==========================
+    // ## Or where has query
+    // ==========================
+    if (!query.orWhereHas) {
+        ;
+        query.orWhereHas = function (path, callback) {
+            const Model = this.$model;
+            if (!Model)
+                return this;
+            this.orWhere(() => {
+                const relations = path.split('.');
+                whereHasSubquery(this, Model, relations, callback, false);
+            });
+            return this;
+        };
+    }
+    // ==========================
+    // ## Where doesn't have has query
+    // ==========================
+    if (!query.whereDoesntHave) {
+        ;
+        query.whereDoesntHave = function (path, callback) {
+            const Model = this.$model;
+            if (!Model)
+                return this;
+            const relations = path.split('.');
+            whereHasSubquery(this, Model, relations, callback, true);
+            return this;
+        };
+    }
+    // ==========================
+    // ## Or where doesn't have has query
+    // ==========================
+    if (!query.orWhereDoesntHave) {
+        ;
+        query.orWhereDoesntHave = function (path, callback) {
+            const Model = this.$model;
+            if (!Model)
+                return this;
+            this.orWhere(() => {
+                const relations = path.split('.');
+                whereHasSubquery(this, Model, relations, callback, true);
+            });
+            return this;
+        };
+    }
+    // ==========================
+    // ## Scope query
+    // =========================
+    if (!query.scope) {
+        ;
+        query.scope = function (name, ...args) {
+            const Model = this.$model;
+            if (!Model)
+                return this;
+            const meta = Model.scopes?.[name];
+            if (!meta) {
+                throw new Error(`Scope "${name}" not found`);
+            }
+            if (meta.mode !== 'internal') {
+                throw new Error(`Scope "${name}" is global and cannot be called manually`);
+            }
+            meta.fn.apply(this, args);
+            return this;
+        };
+    }
+    if (!query.withoutScope) {
+        ;
+        query.withoutScope = function (...names) {
+            for (const name of names) {
+                this._disabledScopes.add(name);
+            }
+            return this;
+        };
+    }
+    // ==========================
+    // ## with aggregate query
+    // ==========================
+    if (!query.withAggregate) {
+        ;
+        query.withAggregate = function (expr, fn, column = '*', callback) {
+            if (!this._withAggregates)
+                this._withAggregates = [];
+            const [rel, aliasRaw] = expr.split(/\s+as\s+/i);
+            this._withAggregates.push({
+                relation: rel.trim(),
+                alias: aliasRaw?.trim() || `${rel}_${fn}`,
+                fn,
+                column,
+                callback,
+            });
+            return this;
+        };
+    }
+    // ==========================
+    // ## Order by aggregate query
+    // ==========================
+    if (!query.orderByAggregate) {
+        ;
+        query.orderByAggregate = function (expr, fn, column = '*', direction = 'asc', callback) {
+            if (!this._orderByAggregates)
+                this._orderByAggregates = [];
+            const [rel, aliasRaw] = expr.split(/\s+as\s+/i);
+            this._orderByAggregates.push({
+                relation: rel.trim(),
+                alias: aliasRaw?.trim(),
+                fn,
+                column,
+                direction,
+                callback,
+            });
+            return this;
+        };
+    }
+    // =================================>
+    // ## Get option query
+    // =================================>
+    if (!query.option) {
+        ;
+        query.option = async function (selectableOption) {
+            applyGlobalScopes(this);
+            const model = this.$model;
+            const q = this.clone();
+            let defaultSelectable = [];
+            if (model) {
+                defaultSelectable = model.selectable || [];
+            }
+            let processedCols = [];
+            if (!Array.isArray(selectableOption) || selectableOption.length === 0) {
+                const valueCol = defaultSelectable.length > 0 ? defaultSelectable[0] : model.primaryKey;
+                const labelCol = defaultSelectable.length > 0 ? defaultSelectable[1] : defaultSelectable[0] ?? model.primaryKey;
+                processedCols = [`${valueCol} as value`, `${labelCol} as label`];
+            }
+            else {
+                processedCols = selectableOption.map((col, index) => {
+                    const hasAlias = /\s+as\s+/i.test(col);
+                    if (!hasAlias) {
+                        if (index === 0)
+                            return `${col} as value`;
+                        if (index === 1)
+                            return `${col} as label`;
+                    }
+                    return col;
+                });
+            }
+            q.clearSelect().select(processedCols);
+            return await q;
+        };
+    }
+    // ==========================
+    // ## Paginate or option query
+    // ==========================
+    if (!query.paginateOrOption) {
+        ;
+        query.paginateOrOption = async function (page = 1, limit = 10, option, selectableOption) {
+            const isOption = ["true", "1", "yes"].includes(String(option).toLowerCase());
+            if (isOption) {
+                const data = await this.option(selectableOption);
+                return { data, total: data.length };
+            }
+            const result = await this.paginate(page, limit);
+            return result;
+        };
+    }
+    // ==========================
+    // ## Resolve query
+    // ==========================
+    if (!query.resolve) {
+        ;
+        query.resolve = async function (input = {}) {
+            const gq = input?.getQuery ? input.getQuery : input;
+            const isOption = input?.headers?.["x-option"] || gq?.isOption || false;
+            this.
+                expand?.(gq.expand).
+                search?.(gq.search, {
+                includes: [],
+                searchable: gq.searchable
+            }).
+                filter?.(gq.filter).
+                selects?.({
+                includes: [],
+                selectable: gq.selectable
+            }).
+                sorts?.(gq.sort);
+            if (isOption || gq.paginate)
+                return await this.paginateOrOption?.(gq.page, gq.paginate, isOption, gq.selectableOption);
+            const data = await this.query().get();
+            return { data, total: data.length };
+        };
+    }
+    // ==========================
+    // ## format result query
+    // ==========================
+    if (!query.format) {
+        ;
+        query.format = function (formatter) {
+            const Model = this.$model;
+            if (typeof formatter === 'string') {
+                const fn = Model?.formatters?.[formatter];
+                if (!fn)
+                    throw new Error(`Formatter "${formatter}" not found on model ${Model?.name}`);
+                this._formatter = fn;
+                return this;
+            }
+            if (typeof formatter === 'function') {
+                this._formatter = formatter;
+                return this;
+            }
+            throw new Error('format() only accepts string or function');
+        };
+    }
+    return query;
+}
+// ?? Public model helpers
+// =================================>
+// ## Primary key decorator model helpers
+// =================================>
+export function PrimaryKey() {
+    return function (target, key) {
+        const ctor = target.constructor;
+        ctor.primaryKey = key;
+        if (!ctor[FIELD_META])
+            ctor[FIELD_META] = {};
+        ctor[FIELD_META][key] = {
+            cast: 'number',
+            selectable: true,
+        };
+        ctor[PRIMARY_KEY_META] = key;
+    };
+}
+// =================================>
+// ## Field decorator model helpers
+// =================================>
+export function Field(defs) {
+    return function (target, key) {
+        const ctor = target.constructor;
+        if (!ctor[FIELD_META])
+            ctor[FIELD_META] = {};
+        const meta = {};
+        const [first, ...rest] = defs;
+        if (['string', 'number', 'boolean', 'date', 'json'].includes(first)) {
+            meta.cast = first;
+        }
+        else {
+            rest.unshift(first);
+        }
+        for (const flag of rest) {
+            if (flag === 'fillable')
+                meta.fillable = true;
+            if (flag === 'selectable')
+                meta.selectable = true;
+            if (flag === 'searchable')
+                meta.searchable = true;
+        }
+        ctor[FIELD_META][key] = meta;
+    };
+}
+// =================================>
+// ## Relation decorator model helpers
+// =================================>
+export function HasMany(model, options) {
+    return (target, key) => {
+        const parent = target.constructor;
+        const parentKey = options?.localKey ?? 'id';
+        const foreignKey = options?.foreignKey ?? `${conversion.strSnake(parent.name)}_id`;
+        pushRelation(target, key, { type: 'hasMany', model, foreignKey, localKey: parentKey, callback: options?.callback });
+    };
+}
+export function HasOne(model, options) {
+    return (target, key) => {
+        const parent = target.constructor;
+        const parentKey = options?.localKey ?? 'id';
+        const foreignKey = options?.foreignKey ?? `${conversion.strSnake(parent.name)}_id`;
+        pushRelation(target, key, { type: 'hasOne', model, foreignKey, localKey: parentKey, callback: options?.callback });
+    };
+}
+export function BelongsTo(model, options) {
+    return (target, key) => {
+        const ctor = target.constructor;
+        const foreignKey = options?.foreignKey ?? `${conversion.strSnake(key)}_id`;
+        const ownerKey = options?.ownerKey ?? 'id';
+        pushRelation(target, key, { type: 'belongsTo', model, foreignKey, localKey: ownerKey, callback: options?.callback });
+        if (!ctor[FIELD_META])
+            ctor[FIELD_META] = {};
+        if (!ctor[FIELD_META][foreignKey]) {
+            ctor[FIELD_META][foreignKey] = {
+                cast: 'number',
+                fillable: true,
+                selectable: true,
+            };
+        }
+    };
+}
+// export function BelongsToMany(
+//   model     :  () => typeof Model,
+//   options  ?:  {
+//     pivotTable    ?:  string
+//     pivotLocal    ?:  string
+//     pivotForeign  ?:  string
+//     localKey      ?:  string
+//     callback      ?:  (q: any) => void
+//   }
+// ) {
+//   return (target: any, key: string) => {
+//     const parent        =  target.constructor
+//     const parentName    =  conversion.strSnake(parent.name)
+//     const relatedName   =  conversion.strSnake(model().name)
+//     const pivotTable    =  options?.pivotTable ?? conversion.strPlural(`${parentName}_${relatedName}`)
+//     const localKey      =  options?.localKey ?? 'id'
+//     const pivotLocal    =  options?.pivotLocal ?? `${parentName}_id`
+//     const pivotForeign  =  options?.pivotForeign ?? `${relatedName}_id`
+//     pushRelation(target, key, { type: 'belongsToMany', model, localKey, foreignKey: localKey, pivotTable, pivotLocal, pivotForeign, callback: options?.callback })
+//   }
+// }
+export function BelongsToMany(model, options) {
+    return (target, key) => {
+        const localKey = options?.localKey ?? 'id';
+        pushRelation(target, key, {
+            type: 'belongsToMany',
+            model,
+            localKey,
+            foreignKey: localKey,
+            pivotTable: options?.pivotTable,
+            pivotLocal: options?.pivotLocal,
+            pivotForeign: options?.pivotForeign,
+            callback: options?.callback,
+        });
+    };
+}
+// =================================>
+// ## Soft delete decorator model helpers
+// =================================>
+export function SoftDelete() {
+    return function (target, propertyKey) {
+        const ctor = target.constructor;
+        ctor[SOFT_DELETE_META] = { enabled: true, column: propertyKey };
+    };
+}
+// =================================>
+// ## Attribute decorator model helpers
+// =================================>
+export function Attribute() {
+    return function (target, key, descriptor) {
+        const ctor = target.constructor;
+        if (!ctor[ATTRIBUTE_META])
+            ctor[ATTRIBUTE_META] = {};
+        ctor[ATTRIBUTE_META][key] = descriptor.value;
+    };
+}
+// =================================>
+// ## Formatter decorator model helpers
+// =================================>
+export function Formatter() {
+    return function (target, propertyKey, descriptor) {
+        const ctor = target;
+        if (!ctor[FORMATTER_META]) {
+            ctor[FORMATTER_META] = {};
+        }
+        ctor[FORMATTER_META][propertyKey] = descriptor.value;
+    };
+}
+// =================================>
+// ## Scope decorator model helpers
+// =================================>
+export function Scope(mode = 'internal') {
+    return function (target, propertyKey, descriptor) {
+        const ctor = target.constructor;
+        if (!ctor[SCOPE_META])
+            ctor[SCOPE_META] = {};
+        ctor[SCOPE_META][propertyKey] = {
+            fn: descriptor.value,
+            mode,
+        };
+    };
+}
+// =================================>
+// ## Hook
+// =================================>
+export function On(event) {
+    return function (target, propertyKey, descriptor) {
+        const ctor = target.constructor;
+        if (!ctor._hooks) {
+            ctor._hooks = {};
+        }
+        if (!ctor._hooks[event]) {
+            ctor._hooks[event] = [];
+        }
+        ctor._hooks[event].push(async ({ model, trx }) => {
+            return descriptor.value.call(model, { trx });
+        });
+    };
+}
+// ?? Private model helpers
+// =================================>
+// ## Global scope model helpers
+// =================================>
+function applyGlobalScopes(query) {
+    const Model = query.$model;
+    if (!Model)
+        return;
+    applyScopes(query);
+    if (Model.isSoftDelete?.()) {
+        const col = Model.getDeletedAtColumn();
+        const mode = query._softDeleteScope ?? 'default';
+        if (mode === 'with')
+            return;
+        if (mode === 'default')
+            query.whereNull(col);
+        if (mode === 'only')
+            query.whereNotNull(col);
+    }
+}
+// =================================>
+// ## Load relation model helpers
+// =================================>
+async function loadRelations(rows, Model, tree) {
+    if (!rows.length)
+        return;
+    for (const [name, node] of Object.entries(tree)) {
+        const rel = Model.relations[name];
+        if (!rel)
+            continue;
+        const desc = rel();
+        let related = [];
+        if (desc.type === 'belongsTo') {
+            related = await loadBelongsTo(rows, desc, name, node.__callback);
+        }
+        if (desc.type === 'belongsToMany') {
+            related = await loadBelongsToMany(rows, desc, name, node.__callback);
+        }
+        if (desc.type === 'hasMany') {
+            related = await loadHasMany(rows, desc, name, node.__callback);
+        }
+        if (desc.type === 'hasOne') {
+            related = await loadHasOne(rows, desc, name, node.__callback);
+        }
+        if (node.__children &&
+            Object.keys(node.__children).length &&
+            related.length) {
+            await loadRelations(related, desc.model(), node.__children);
+        }
+    }
+}
+async function loadBelongsTo(rows, rel, name, callback) {
+    const ids = [...new Set(rows.map(r => r[rel.foreignKey]).filter(Boolean))];
+    if (!ids.length) {
+        rows.forEach(r => (r[name] = null));
+        return [];
+    }
+    const q = rel.model().query().whereIn(rel.localKey, ids);
+    rel.callback?.(q);
+    callback?.(q);
+    const related = rel.model().hydrate(await q);
+    const map = new Map(related.map((r) => [String(r[rel.localKey]), r]));
+    rows.forEach(r => (r[name] = map.get(String(r[rel.foreignKey])) ?? null));
+    return related;
+}
+async function loadBelongsToMany(rows, rel, name, callback) {
+    const ids = rows.map(r => r[rel.localKey]);
+    if (!ids.length) {
+        rows.forEach(r => (r[name] = []));
+        return [];
+    }
+    const Parent = rows[0].constructor;
+    const Related = rel.model();
+    const parentName = conversion.strSnake(Parent.name);
+    const relatedName = conversion.strSnake(Related.name);
+    const pivotTable = rel.pivotTable ?? conversion.strPlural(`${parentName}_${relatedName}`);
+    const pivotLocal = rel.pivotLocal ?? `${parentName}_id`;
+    const pivotForeign = rel.pivotForeign ?? `${relatedName}_id`;
+    const relatedTable = Related.getTable();
+    const q = Related.query().join(pivotTable, `${relatedTable}.${Related.primaryKey}`, '=', `${pivotTable}.${pivotForeign}`).whereIn(`${pivotTable}.${pivotLocal}`, ids);
+    rel.callback?.(q);
+    callback?.(q);
+    const related = Related.hydrate(await q);
+    const grouped = {};
+    for (const r of related) {
+        const pivotValue = r[pivotLocal];
+        (grouped[pivotValue] ??= []).push(r);
+    }
+    rows.forEach(r => { r[name] = grouped[r[rel.localKey]] ?? []; });
+    return related;
+}
+async function loadHasMany(rows, rel, name, callback) {
+    const ids = rows.map(r => r[rel.localKey]);
+    if (!ids.length) {
+        rows.forEach(r => (r[name] = []));
+        return [];
+    }
+    const q = rel.model().query().whereIn(rel.foreignKey, ids);
+    rel.callback?.(q);
+    callback?.(q);
+    const related = rel.model().hydrate(await q);
+    const grouped = {};
+    for (const r of related) {
+        ;
+        (grouped[String(r[rel.foreignKey])] ??= []).push(r);
+    }
+    rows.forEach(r => (r[name] = grouped[String(r[rel.localKey])] ?? []));
+    return related;
+}
+async function loadHasOne(rows, rel, name, callback) {
+    const ids = rows.map(r => r[rel.localKey]);
+    if (!ids.length) {
+        rows.forEach(r => (r[name] = null));
+        return [];
+    }
+    const q = rel.model().query().whereIn(rel.foreignKey, ids);
+    rel.callback?.(q);
+    callback?.(q);
+    const related = rel.model().hydrate(await q);
+    const map = new Map(related.map((r) => [String(r[rel.foreignKey]), r]));
+    rows.forEach(r => r[name] = map.get(String(r[rel.localKey])) ?? null);
+    return related;
+}
+// =================================>
+// ## Add relation model helpers
+// =================================>
+function pushRelation(target, key, desc) {
+    const ctor = target.constructor;
+    if (!ctor[RELATION_META])
+        ctor[RELATION_META] = {};
+    ctor[RELATION_META][key] = () => desc;
+}
+// =================================>
+// ## Where has model helpers
+// =================================>
+function whereHasSubquery(parentQuery, Model, relations, callback, negate = false) {
+    const relation = relations[0];
+    const relDef = Model.relations?.[relation];
+    if (!relDef)
+        return;
+    const desc = relDef();
+    const Related = desc.model();
+    const parentTable = Model.getTable();
+    const relatedTable = Related.getTable();
+    const method = negate ? 'whereNotExists' : 'whereExists';
+    parentQuery[method](function () {
+        this.select(1).from(relatedTable);
+        if (desc.type === 'hasMany' || desc.type === 'hasOne') {
+            this.whereRaw(`${relatedTable}.${desc.foreignKey} = ${parentTable}.${desc.localKey}`);
+        }
+        if (desc.type === 'belongsTo') {
+            this.whereRaw(`${relatedTable}.${desc.localKey} = ${parentTable}.${desc.foreignKey}`);
+        }
+        if (desc.type === 'belongsToMany') {
+            const pivot = desc.pivotTable;
+            this.join(pivot, `${pivot}.${desc.pivotForeign}`, '=', `${relatedTable}.${Related.primaryKey}`);
+            this.whereRaw(`${pivot}.${desc.pivotLocal} = ${parentTable}.${desc.localKey}`);
+        }
+        if (relations.length > 1) {
+            whereHasSubquery(this, Related, relations.slice(1), callback, negate);
+            return;
+        }
+        if (callback) {
+            const qb = Related.query().from(relatedTable);
+            desc.callback?.(qb);
+            callback(qb);
+            this.whereExists(qb);
+        }
+    });
+}
+// =================================>
+// ## Add aggregate model helpers
+// =================================>
+function applyWithAggregates(query) {
+    const Model = query.$model;
+    if (!Model || !query._withAggregates?.length)
+        return;
+    const parentTable = Model.getTable();
+    for (const item of query._withAggregates) {
+        const relDef = Model.relations?.[item.relation];
+        if (!relDef)
+            continue;
+        const desc = relDef();
+        const Related = desc.model();
+        const relatedTable = Related.getTable();
+        const fn = item.fn;
+        const sub = db(Related.getTable())[fn](item.column);
+        if (desc.type === 'hasMany' || desc.type === 'hasOne') {
+            sub.whereRaw(`${relatedTable}.${desc.foreignKey} = ${parentTable}.${desc.localKey}`);
+        }
+        if (desc.type === 'belongsTo') {
+            sub.whereRaw(`${relatedTable}.${desc.localKey} = ${parentTable}.${desc.foreignKey}`);
+        }
+        if (desc.type === 'belongsToMany') {
+            const pivot = desc.pivotTable;
+            sub.join(pivot, `${pivot}.${desc.pivotForeign}`, '=', `${relatedTable}.${Related.primaryKey}`);
+            sub.whereRaw(`${pivot}.${desc.pivotLocal} = ${parentTable}.${desc.localKey}`);
+        }
+        desc.callback?.(sub);
+        item.callback?.(sub);
+        query.select(query.client.raw(`(${sub.toQuery()}) as ${item.alias}`));
+    }
+}
+// =================================>
+// ## Add order by aggregate model helpers
+// =================================>
+function applyOrderByAggregates(query) {
+    const Model = query.$model;
+    if (!Model || !query._orderByAggregates?.length)
+        return;
+    const parentTable = Model.getTable();
+    for (const item of query._orderByAggregates) {
+        const relDef = Model.relations?.[item.relation];
+        if (!relDef)
+            continue;
+        const desc = relDef();
+        const Related = desc.model();
+        const relatedTable = Related.getTable();
+        const fn = item.fn;
+        const sub = db(Related.getTable())[fn](item.column);
+        if (desc.type === 'hasMany') {
+            sub.whereRaw(`${relatedTable}.${desc.foreignKey} = ${parentTable}.${desc.localKey}`);
+        }
+        if (desc.type === 'belongsTo') {
+            sub.whereRaw(`${relatedTable}.${desc.localKey} = ${parentTable}.${desc.foreignKey}`);
+        }
+        if (Related.isSoftDelete?.()) {
+            sub.whereNull(Related.getDeletedAtColumn());
+        }
+        desc.callback?.(sub);
+        item.callback?.(sub);
+        query.orderByRaw(`(${sub.toQuery()}) ${item.direction}`);
+    }
+}
+// =================================>
+// ## Add scope model helpers
+// =================================>
+function applyScopes(query) {
+    const Model = query.$model;
+    if (!Model)
+        return;
+    const scopes = Model.scopes ?? {};
+    const disabled = query._disabledScopes ?? new Set();
+    for (const [name, meta] of Object.entries(scopes)) {
+        if (meta.mode !== 'global')
+            continue;
+        if (disabled.has(name))
+            continue;
+        meta.fn.call(Model, query);
+    }
+}
+//# sourceMappingURL=model.util.js.map