@spinajs/orm 2.0.180 → 2.0.181

package/lib/mjs/model.js

@@ -1,801 +1,801 @@
-/* eslint-disable prettier/prettier */
-import { SortOrder } from './enums.js';
-import { MODEL_DESCTRIPTION_SYMBOL } from './decorators.js';
-import { RelationType, InsertBehaviour, ModelToSqlConverter, ObjectToSqlConverter } from './interfaces.js';
-import { UpdateQueryBuilder, TruncateTableQueryBuilder, SelectQueryBuilder, DeleteQueryBuilder, InsertQueryBuilder } from './builders.js';
-import { DI, isConstructor } from '@spinajs/di';
-import { Orm } from './orm.js';
-import { ModelHydrator } from './hydrators.js';
-import _ from 'lodash';
-import { v4 as uuidv4 } from 'uuid';
-import { OrmException } from './exceptions.js';
-import { StandardModelDehydrator, StandardModelWithRelationsDehydrator } from './dehydrators.js';
-import { DateTime } from 'luxon';
-import { ManyToManyRelationList, OneToManyRelationList, SingleRelation } from './relation-objects.js';
-import { DiscriminationMapMiddleware } from './middlewares.js';
-export function extractModelDescriptor(targetOrForward) {
-    const target = !isConstructor(targetOrForward) && targetOrForward ? targetOrForward() : targetOrForward;
-    if (!target) {
-        return null;
-    }
-    let descriptor = null;
-    _reduce(target);
-    return descriptor;
-    function _reduce(t) {
-        if (!t) {
-            return;
-        }
-        if (t[MODEL_DESCTRIPTION_SYMBOL]) {
-            descriptor = descriptor ?? {};
-            _.mergeWith(descriptor, t[MODEL_DESCTRIPTION_SYMBOL], (a, b) => {
-                if (!a) {
-                    return b;
-                }
-                if (Array.isArray(a)) {
-                    return a.concat(b);
-                }
-                return a;
-            });
-        }
-        _reduce(t.prototype);
-        _reduce(t.__proto__);
-    }
-}
-export class ModelBase {
-    /**
-     * Gets descriptor for this model. It contains information about relations, orm driver, connection properties,
-     * db table attached, column information and others.
-     */
-    get ModelDescriptor() {
-        return extractModelDescriptor(this.constructor);
-    }
-    /**
-     * Gets di container associated with this model ( via connection object  eg. different drivers have their own implementation of things)
-     */
-    get Container() {
-        if (!this._container) {
-            const orm = DI.get(Orm);
-            const driver = orm.Connections.get(this.ModelDescriptor.Connection);
-            if (!driver) {
-                throw new Error(`model ${this.constructor.name} have invalid connection ${this.ModelDescriptor.Connection}, please check your db config file or model connection name`);
-            }
-            this._container = driver.Container;
-        }
-        return this._container;
-    }
-    get PrimaryKeyName() {
-        return this.ModelDescriptor.PrimaryKey;
-    }
-    get PrimaryKeyValue() {
-        return this[this.PrimaryKeyName];
-    }
-    set PrimaryKeyValue(newVal) {
-        this[this.PrimaryKeyName] = newVal;
-        this.ModelDescriptor.Relations.forEach((r) => {
-            const rel = this[r.Name];
-            if (!rel)
-                return;
-            switch (r.Type) {
-                case RelationType.One:
-                    rel[r.ForeignKey] = newVal;
-                    break;
-                case RelationType.Many:
-                    rel.forEach((rVal) => (rVal[r.ForeignKey] = newVal));
-                    break;
-                case RelationType.ManyToMany:
-                    // TODO: rethink this
-                    break;
-            }
-        });
-    }
-    valueOf() {
-        return this.PrimaryKeyValue;
-    }
-    driver() {
-        const orm = DI.get(Orm);
-        const driver = orm.Connections.get(this.ModelDescriptor.Connection);
-        return driver;
-    }
-    /**
-     * Recursivelly takes all relation data and returns as single array
-     */
-    getFlattenRelationModels(recursive) {
-        const reduceRelations = function (m) {
-            const relations = [...m.ModelDescriptor.Relations.values()];
-            const models = _.flatMap(relations, (r) => {
-                if (r.Type === RelationType.Many || r.Type === RelationType.ManyToMany) {
-                    return m[r.Name];
-                }
-                if (m[r.Name].Value) {
-                    return [m[r.Name].Value];
-                }
-            }).filter((x) => x !== undefined);
-            if (recursive) {
-                return [...models, ..._.flatMap(models, reduceRelations)];
-            }
-            return models;
-        };
-        return reduceRelations(this);
-    }
-    static getModelDescriptor() {
-        throw new Error('Not implemented');
-    }
-    static getRelationDescriptor(_relation) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Clears all data in table
-     */
-    static truncate() {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Get all data from db
-     */
-    static all(_page, _perPage) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Inserts data to DB.
-     *
-     * @param _data - data to insert
-     */
-    static insert(_data, _insertBehaviour = InsertBehaviour.None) {
-        throw new Error('Not implemented');
-    }
-    static where(_column, _operator, _value) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Updates single or multiple records at once with provided value based on condition
-     *
-     * @param _data - data to set
-     */
-    static update(_data) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Tries to find all models with given primary keys
-     */
-    static find(_pks) {
-        throw new Error('Not implemented');
-    }
-    static first() {
-        throw new Error('Not implemented');
-    }
-    static last() {
-        throw new Error('Not implemented');
-    }
-    static newest() {
-        throw new Error('Not implemented');
-    }
-    static oldest() {
-        throw new Error('Not implemented');
-    }
-    static count() {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Tries to find all models in db. If not all exists, throws exception
-     */
-    static findOrFail(_pks) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * gets model by specified pk, if not exists, returns null
-     *
-     */
-    static get(_pk) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Finds model by specified pk. If model not exists in db throws exception
-     *
-     */
-    static getOrFail(_pk) {
-        throw new Error('Not implemented');
-    }
-    /**
-     *
-     * Checks if model with pk key or unique fields exists and if not creates one AND NOT save in db
-     * NOTE: it checks for unique fields constraint
-     */
-    static getOrNew(_pk, _data) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Creates query on this model. used for quering db for partial data, to perform some kind of operations
-     * that dont need full ORM model to involve, or other non standard operations eg. joins or raw data queries based on this model
-     */
-    static query() {
-        throw new Error('Not implemented');
-    }
-    /**
-     *
-     * Checks if model with pk key / unique fields exists and if not creates one and saves to db
-     * NOTE: it checks for unique fields too.
-     *
-     * @param data - model width data to check
-     */
-    static getOrCreate(_pk, _data) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Creates new model & saves is to db
-     *
-     * @param  data - initial model data
-     */
-    static create(_data) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Deletes model from db
-     *
-     * @param pk - primary key
-     */
-    static destroy(_pk) {
-        throw new Error('Not implemented');
-    }
-    /**
-     * Checks if model exists in db
-     */
-    static exists() {
-        throw new Error('Not implemented');
-    }
-    constructor(data) {
-        /**
-         * List of hidden properties from JSON / dehydrations
-         * eg. password field of user
-         */
-        this._hidden = [];
-        this.setDefaults();
-        if (data) {
-            this.hydrate(data);
-        }
-    }
-    /**
-     * Fills model with data. It only fills properties that exists in database
-     *
-     * @param data - data to fill
-     */
-    hydrate(data) {
-        this.Container.resolve(Array.ofType(ModelHydrator)).forEach((h) => h.hydrate(this, data));
-    }
-    /**
-     *
-     * Attachess model to proper relation an sets foreign key
-     *
-     * @param data - model to attach
-     */
-    attach(data) {
-        // TODO: refactor this, to not check every time for relation
-        // do this as map or smth
-        for (const [_, v] of this.ModelDescriptor.Relations.entries()) {
-            if (v.TargetModel.name === data.constructor.name) {
-                // TODO: refactor this, so we dont update foreign key
-                // instead we must use belongsTo relation on data model to update
-                data[v.ForeignKey] = this.PrimaryKeyValue;
-                switch (v.Type) {
-                    case RelationType.One:
-                        this[v.Name].attach(data);
-                        break;
-                    case RelationType.Many:
-                    case RelationType.ManyToMany:
-                        this[v.Name].push(data);
-                        break;
-                }
-            }
-        }
-    }
-    /**
-     * Extracts all data from model. It takes only properties that exists in DB
-     */
-    dehydrate(omit) {
-        return this.Container.resolve(StandardModelDehydrator).dehydrate(this, [...(omit ?? []), ...this._hidden]);
-    }
-    /**
-     *
-     * Extracts all data from model with relation data. Relation data are dehydrated recursively.
-     *
-     * @param omit - fields to omit
-     */
-    dehydrateWithRelations(omit) {
-        return this.Container.resolve(StandardModelWithRelationsDehydrator).dehydrate(this, [...(omit ?? []), ...this._hidden]);
-    }
-    toSql() {
-        return this.Container.resolve(ModelToSqlConverter).toSql(this);
-    }
-    /**
-     * deletes enitt from db. If model have SoftDelete decorator, model is marked as deleted
-     */
-    async destroy() {
-        if (!this.PrimaryKeyValue) {
-            return;
-        }
-        await this.constructor.destroy(this.PrimaryKeyValue);
-    }
-    /**
-     * If model can be in achived state - sets archived at date and saves it to db
-     */
-    async archive() {
-        if (this.ModelDescriptor.Archived) {
-            this[this.ModelDescriptor.Archived.ArchivedAt] = DateTime.now();
-        }
-        else {
-            throw new OrmException('archived at column not exists in model');
-        }
-        const { query } = this.createUpdateQuery();
-        await query.update(this.toSql()).where(this.PrimaryKeyName, this.PrimaryKeyValue);
-    }
-    async update() {
-        const { query } = this.createUpdateQuery();
-        if (this.ModelDescriptor.Timestamps.UpdatedAt) {
-            this[this.ModelDescriptor.Timestamps.UpdatedAt] = DateTime.now();
-        }
-        await query.update(this.toSql()).where(this.PrimaryKeyName, this.PrimaryKeyValue);
-    }
-    /**
-     * Save all changes to db. It creates new entry id db or updates existing one if
-     * primary key exists
-     */
-    async insert(insertBehaviour = InsertBehaviour.None) {
-        const { query, description } = this.createInsertQuery();
-        switch (insertBehaviour) {
-            case InsertBehaviour.InsertOrIgnore:
-                query.orIgnore();
-                break;
-            case InsertBehaviour.InsertOrUpdate:
-                query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
-                break;
-            case InsertBehaviour.InsertOrReplace:
-                query.orReplace();
-                break;
-        }
-        const iMidleware = {
-            afterQuery: (data) => {
-                this.PrimaryKeyValue = this.PrimaryKeyValue ?? data.LastInsertId;
-                return data;
-            },
-            modelCreation: () => null,
-            afterHydration: () => null,
-        };
-        query.middleware(iMidleware);
-        return query.values(this.toSql());
-    }
-    /**
-     *
-     * Shorthand for inserting model when no primary key exists, or update
-     * its value in db if primary key is set
-     *
-     * @param insertBehaviour - insert mode
-     */
-    async insertOrUpdate(insertBehaviour = InsertBehaviour.None) {
-        if (this.PrimaryKeyValue) {
-            await this.update();
-        }
-        else {
-            await this.insert(insertBehaviour);
-        }
-    }
-    /**
-     * Gets model data from database and returns as fresh instance.
-     *
-     * If primary key is not fetched, tries to load by columns with unique constraint.
-     * If there is no unique columns or primary key, throws error
-     */
-    async fresh() {
-        const { query, description } = this.createSelectQuery();
-        query.select('*');
-        _preparePkWhere(description, query, this);
-        _prepareOrderBy(description, query);
-        // TODO: rethink all cast of this type?
-        return (await query.firstOrFail());
-    }
-    /**
-     * Refresh model from database.
-     *
-     * If no primary key is set, tries to fetch data base on columns
-     * with unique constraints. If none exists, throws exception
-     */
-    async refresh() {
-        let model = null;
-        model = await this.fresh();
-        for (const c of this.ModelDescriptor.Columns) {
-            this[c.Name] = model[c.Name];
-        }
-    }
-    toJSON() {
-        return this.dehydrate();
-    }
-    /**
-     * sets default values for model. values are taken from DB default column prop
-     */
-    setDefaults() {
-        this.ModelDescriptor.Columns?.forEach((c) => {
-            if (c.Uuid) {
-                this[c.Name] = uuidv4();
-            }
-            else {
-                this[c.Name] = c.DefaultValue;
-            }
-        });
-        if (this.ModelDescriptor.Timestamps.CreatedAt) {
-            this[this.ModelDescriptor.Timestamps.CreatedAt] = DateTime.now();
-        }
-        for (const [, rel] of this.ModelDescriptor.Relations) {
-            if (rel.Factory) {
-                this[rel.Name] = rel.Factory(this, rel, this.Container);
-            }
-            else if (rel.RelationClass) {
-                this[rel.Name] = this.Container.resolve(rel.RelationClass, [this, rel.TargetModel, rel, []]);
-            }
-            else if (rel.Type === RelationType.Many) {
-                this[rel.Name] = new OneToManyRelationList(this, rel.TargetModel, rel, []);
-            }
-            else if (rel.Type === RelationType.ManyToMany) {
-                this[rel.Name] = new ManyToManyRelationList(this, rel.TargetModel, rel, []);
-            }
-            else {
-                this[rel.Name] = new SingleRelation(this, rel.TargetModel, rel, null);
-            }
-        }
-    }
-    createSelectQuery() {
-        return createQuery(this.constructor, SelectQueryBuilder);
-    }
-    createUpdateQuery() {
-        return createQuery(this.constructor, UpdateQueryBuilder);
-    }
-    createInsertQuery() {
-        return createQuery(this.constructor, InsertQueryBuilder);
-    }
-}
-function _descriptor(model) {
-    return model[MODEL_DESCTRIPTION_SYMBOL];
-}
-function _preparePkWhere(description, query, model) {
-    if (description.PrimaryKey) {
-        query.where(description.PrimaryKey, model.PrimaryKeyValue);
-    }
-    else {
-        const unique = description.Columns.filter((x) => x.Unique);
-        if (unique.length !== 0) {
-            for (const c of unique) {
-                query.where(c.Name, '=', model[c.Name]);
-            }
-        }
-        else {
-            throw new OrmException('Model dont have primary key set or columns with unique constraint, cannot fetch model from database');
-        }
-    }
-}
-function _prepareOrderBy(description, query, order) {
-    if (description.PrimaryKey) {
-        query.order(description.PrimaryKey, order ?? SortOrder.DESC);
-    }
-    else {
-        const unique = description.Columns.filter((c) => c.Unique);
-        if (unique.length !== 0) {
-            unique.forEach((c) => query.order(c.Name, order ?? SortOrder.DESC));
-        }
-        else if (description.Timestamps?.CreatedAt) {
-            query.order(description.Timestamps.CreatedAt, order ?? SortOrder.DESC);
-        }
-        else if (description.Timestamps?.UpdatedAt) {
-            query.order(description.Timestamps.UpdatedAt, order ?? SortOrder.DESC);
-        }
-    }
-}
-export class HistoricalModel {
-}
-/**
- * Helper function to create query based on model
- *
- * @param model - source model for query
- * @param query - query class
- * @param injectModel - should inject model information into query, if not, query will return raw data
- *
- * @returns
- */
-export function createQuery(model, query, injectModel = true) {
-    const dsc = _descriptor(model);
-    if (!dsc) {
-        throw new Error(`model ${model.name} does not have model descriptor. Use @model decorator on class`);
-    }
-    const orm = DI.get(Orm);
-    const driver = orm.Connections.get(dsc.Connection);
-    if (!driver) {
-        throw new Error(`model ${model.name} have invalid connection ${dsc.Connection}, please check your db config file or model connection name`);
-    }
-    const cnt = driver.Container;
-    const qr = cnt.resolve(query, [driver, injectModel ? orm.Models.find((x) => x.name === model.name).type : null]);
-    if (qr instanceof SelectQueryBuilder) {
-        const scope = model._queryScopes;
-        if (scope) {
-            Object.getOwnPropertyNames(scope.__proto__)
-                .filter((x) => x !== 'constructor')
-                .forEach(function (property) {
-                if (typeof scope[property] === 'function') {
-                    qr[property] = scope[property].bind(qr);
-                }
-            });
-        }
-    }
-    qr.middleware(new DiscriminationMapMiddleware(dsc));
-    qr.setTable(dsc.TableName);
-    if (driver.Options.Database) {
-        qr.database(driver.Options.Database);
-    }
-    return {
-        query: qr,
-        description: dsc,
-        model,
-        container: driver.Container,
-    };
-}
-export const MODEL_STATIC_MIXINS = {
-    getModelDescriptor() {
-        const dsc = _descriptor(this);
-        if (!dsc) {
-            throw new OrmException(`Model ${this.constructor.name} has no descriptor`);
-        }
-        return dsc;
-    },
-    getRelationDescriptor(relation) {
-        const descriptor = this.getModelDescriptor();
-        let rDescriptor = null;
-        for (const [key, value] of descriptor.Relations) {
-            if (key.toLowerCase() === relation.toLowerCase().trim()) {
-                rDescriptor = value;
-                break;
-            }
-        }
-        if (!rDescriptor) {
-            throw new OrmException(`Model ${this.constructor.name} has no relation ${relation}`);
-        }
-        return rDescriptor;
-    },
-    truncate() {
-        const { query } = createQuery(this, TruncateTableQueryBuilder, false);
-        return query;
-    },
-    driver() {
-        const dsc = this.getModelDescriptor();
-        const orm = DI.get(Orm);
-        const driver = orm.Connections.get(dsc.Connection);
-        if (!driver) {
-            throw new Error(`model ${this.name} have invalid connection ${dsc.Connection}, please check your db config file or model connection name`);
-        }
-        return driver;
-    },
-    query() {
-        const { query } = createQuery(this, SelectQueryBuilder);
-        return query;
-    },
-    where(column, operator, value) {
-        const { query } = createQuery(this, SelectQueryBuilder);
-        query.select('*');
-        return query.where(column, operator, value);
-    },
-    update(data) {
-        const { query } = createQuery(this, UpdateQueryBuilder);
-        return query.update(data);
-    },
-    all(page, perPage) {
-        const { query } = createQuery(this, SelectQueryBuilder);
-        query.select('*');
-        if (page >= 0 && perPage > 0) {
-            query.take(perPage).skip(page * perPage);
-        }
-        return query;
-    },
-    /**
-     * Try to insert new value
-     */
-    async insert(data, insertBehaviour = InsertBehaviour.None) {
-        const { query, description, container } = createQuery(this, InsertQueryBuilder);
-        const converter = container.resolve(ObjectToSqlConverter);
-        if (Array.isArray(data)) {
-            if (insertBehaviour !== InsertBehaviour.None) {
-                throw new OrmException(`insert behaviour is not supported with arrays`);
-            }
-            query.values(data.map((d) => {
-                if (d instanceof ModelBase) {
-                    return d.toSql();
-                }
-                return converter.toSql(d);
-            }));
-        }
-        else {
-            switch (insertBehaviour) {
-                case InsertBehaviour.InsertOrIgnore:
-                    query.orIgnore();
-                    break;
-                case InsertBehaviour.InsertOrUpdate:
-                    query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
-                    break;
-                case InsertBehaviour.InsertOrReplace:
-                    query.orReplace();
-                    break;
-            }
-            if (data instanceof ModelBase) {
-                query.values(data.toSql());
-            }
-            else {
-                query.values(converter.toSql(data));
-            }
-        }
-        const iMidleware = {
-            afterQuery: (result) => {
-                if (Array.isArray(data)) {
-                    data.forEach((v, idx) => {
-                        if (v instanceof ModelBase) {
-                            v.PrimaryKeyValue = v.PrimaryKeyValue ?? result.LastInsertId - data.length + idx + 1;
-                        }
-                    });
-                }
-                else if (data instanceof ModelBase) {
-                    data.PrimaryKeyValue = data.PrimaryKeyValue ?? result.LastInsertId;
-                }
-                return result;
-            },
-            modelCreation: () => null,
-            afterHydration: () => null,
-        };
-        query.middleware(iMidleware);
-        return query;
-    },
-    async find(pks) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        const pkey = description.PrimaryKey;
-        query.select('*');
-        query.whereIn(pkey, pks);
-        return await query;
-    },
-    async findOrFail(pks) {
-        const { query, description, model } = createQuery(this, SelectQueryBuilder);
-        const pkey = description.PrimaryKey;
-        query.select('*');
-        query.whereIn(pkey, pks);
-        const result = await query;
-        if (result.length !== pks.length) {
-            throw new Error(`could not find all results for model ${model.name}`);
-        }
-        return result;
-    },
-    async get(pk) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        const pkey = description.PrimaryKey;
-        query.select('*');
-        query.where(pkey, pk);
-        _prepareOrderBy(description, query);
-        return (await query.first());
-    },
-    async getOrFail(pk) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        const pkey = description.PrimaryKey;
-        query.select('*');
-        query.where(pkey, pk);
-        _prepareOrderBy(description, query);
-        return (await query.firstOrFail());
-    },
-    destroy(pks) {
-        const description = _descriptor(this);
-        const data = Array.isArray(pks) ? pks : [pks];
-        const { query } = description.SoftDelete?.DeletedAt ? createQuery(this, UpdateQueryBuilder) : createQuery(this, DeleteQueryBuilder);
-        if (description.SoftDelete?.DeletedAt) {
-            query.update({
-                [description.SoftDelete.DeletedAt]: DateTime.now(),
-            });
-        }
-        if (pks) {
-            query.whereIn(description.PrimaryKey, data);
-        }
-        return query;
-    },
-    async create(data) {
-        const entity = new (Function.prototype.bind.apply(this))(data);
-        await entity.insert();
-        return entity;
-    },
-    async getOrCreate(pk, data) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        // pk constrain
-        if (description.PrimaryKey && pk !== null) {
-            query.where(description.PrimaryKey, pk);
-        }
-        // check for all unique columns ( unique constrain )
-        description.Columns.filter((c) => c.Unique).forEach((c) => {
-            query.andWhere(c, data[c.Name]);
-        });
-        _prepareOrderBy(description, query);
-        let entity = (await query.first());
-        if (!entity) {
-            entity = new (Function.prototype.bind.apply(this))(data);
-            await entity.insert();
-            return entity;
-        }
-        return entity;
-    },
-    async getOrNew(pk, data) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        // pk constrain
-        if (description.PrimaryKey) {
-            query.where(description.PrimaryKey, pk);
-        }
-        // check for all unique columns ( unique constrain )
-        description.Columns.filter((c) => c.Unique).forEach((c) => {
-            query.andWhere(c, data[c.Name]);
-        });
-        _prepareOrderBy(description, query);
-        let entity = (await query.first());
-        if (!entity) {
-            entity = new (Function.prototype.bind.apply(this))(data);
-            return entity;
-        }
-        return entity;
-    },
-    async exists(pk) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        // pk constrain
-        if (description.PrimaryKey && pk !== null) {
-            query.where(description.PrimaryKey, pk);
-        }
-        const result = await query.clearColumns().select(description.PrimaryKey).first();
-        if (result) {
-            return true;
-        }
-        return false;
-    },
-    async first(callback) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        _prepareOrderBy(description, query, SortOrder.ASC);
-        if (callback) {
-            callback(query);
-        }
-        return (await query.first());
-    },
-    async last(callback) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        _prepareOrderBy(description, query, SortOrder.DESC);
-        if (callback) {
-            callback(query);
-        }
-        return (await query.first());
-    },
-    async newest(callback) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        if (description.Timestamps?.CreatedAt) {
-            query.order(description.Timestamps.CreatedAt, SortOrder.DESC);
-        }
-        else {
-            throw new OrmException('cannot fetch newest entity - CreateAt column not exists in model/db');
-        }
-        if (callback) {
-            callback(query);
-        }
-        return (await query.first());
-    },
-    async oldest(callback) {
-        const { query, description } = createQuery(this, SelectQueryBuilder);
-        if (description.Timestamps?.CreatedAt) {
-            query.order(description.Timestamps.CreatedAt, SortOrder.ASC);
-        }
-        else {
-            throw new OrmException('cannot fetch oldest entity - CreateAt column not exists in model/db');
-        }
-        if (callback) {
-            callback(query);
-        }
-        return (await query.first());
-    },
-    async count(callback) {
-        const { query } = createQuery(this, SelectQueryBuilder);
-        query.count('*', 'count');
-        if (callback) {
-            callback(query);
-        }
-        return await (await query.asRaw()).count;
-    },
-};
+/* eslint-disable prettier/prettier */
+import { SortOrder } from './enums.js';
+import { MODEL_DESCTRIPTION_SYMBOL } from './decorators.js';
+import { RelationType, InsertBehaviour, ModelToSqlConverter, ObjectToSqlConverter } from './interfaces.js';
+import { UpdateQueryBuilder, TruncateTableQueryBuilder, SelectQueryBuilder, DeleteQueryBuilder, InsertQueryBuilder } from './builders.js';
+import { DI, isConstructor } from '@spinajs/di';
+import { Orm } from './orm.js';
+import { ModelHydrator } from './hydrators.js';
+import _ from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+import { OrmException } from './exceptions.js';
+import { StandardModelDehydrator, StandardModelWithRelationsDehydrator } from './dehydrators.js';
+import { DateTime } from 'luxon';
+import { ManyToManyRelationList, OneToManyRelationList, SingleRelation } from './relation-objects.js';
+import { DiscriminationMapMiddleware } from './middlewares.js';
+export function extractModelDescriptor(targetOrForward) {
+    const target = !isConstructor(targetOrForward) && targetOrForward ? targetOrForward() : targetOrForward;
+    if (!target) {
+        return null;
+    }
+    let descriptor = null;
+    _reduce(target);
+    return descriptor;
+    function _reduce(t) {
+        if (!t) {
+            return;
+        }
+        if (t[MODEL_DESCTRIPTION_SYMBOL]) {
+            descriptor = descriptor ?? {};
+            _.mergeWith(descriptor, t[MODEL_DESCTRIPTION_SYMBOL], (a, b) => {
+                if (!a) {
+                    return b;
+                }
+                if (Array.isArray(a)) {
+                    return a.concat(b);
+                }
+                return a;
+            });
+        }
+        _reduce(t.prototype);
+        _reduce(t.__proto__);
+    }
+}
+export class ModelBase {
+    /**
+     * Gets descriptor for this model. It contains information about relations, orm driver, connection properties,
+     * db table attached, column information and others.
+     */
+    get ModelDescriptor() {
+        return extractModelDescriptor(this.constructor);
+    }
+    /**
+     * Gets di container associated with this model ( via connection object  eg. different drivers have their own implementation of things)
+     */
+    get Container() {
+        if (!this._container) {
+            const orm = DI.get(Orm);
+            const driver = orm.Connections.get(this.ModelDescriptor.Connection);
+            if (!driver) {
+                throw new Error(`model ${this.constructor.name} have invalid connection ${this.ModelDescriptor.Connection}, please check your db config file or model connection name`);
+            }
+            this._container = driver.Container;
+        }
+        return this._container;
+    }
+    get PrimaryKeyName() {
+        return this.ModelDescriptor.PrimaryKey;
+    }
+    get PrimaryKeyValue() {
+        return this[this.PrimaryKeyName];
+    }
+    set PrimaryKeyValue(newVal) {
+        this[this.PrimaryKeyName] = newVal;
+        this.ModelDescriptor.Relations.forEach((r) => {
+            const rel = this[r.Name];
+            if (!rel)
+                return;
+            switch (r.Type) {
+                case RelationType.One:
+                    rel[r.ForeignKey] = newVal;
+                    break;
+                case RelationType.Many:
+                    rel.forEach((rVal) => (rVal[r.ForeignKey] = newVal));
+                    break;
+                case RelationType.ManyToMany:
+                    // TODO: rethink this
+                    break;
+            }
+        });
+    }
+    valueOf() {
+        return this.PrimaryKeyValue;
+    }
+    driver() {
+        const orm = DI.get(Orm);
+        const driver = orm.Connections.get(this.ModelDescriptor.Connection);
+        return driver;
+    }
+    /**
+     * Recursivelly takes all relation data and returns as single array
+     */
+    getFlattenRelationModels(recursive) {
+        const reduceRelations = function (m) {
+            const relations = [...m.ModelDescriptor.Relations.values()];
+            const models = _.flatMap(relations, (r) => {
+                if (r.Type === RelationType.Many || r.Type === RelationType.ManyToMany) {
+                    return m[r.Name];
+                }
+                if (m[r.Name].Value) {
+                    return [m[r.Name].Value];
+                }
+            }).filter((x) => x !== undefined);
+            if (recursive) {
+                return [...models, ..._.flatMap(models, reduceRelations)];
+            }
+            return models;
+        };
+        return reduceRelations(this);
+    }
+    static getModelDescriptor() {
+        throw new Error('Not implemented');
+    }
+    static getRelationDescriptor(_relation) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Clears all data in table
+     */
+    static truncate() {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Get all data from db
+     */
+    static all(_page, _perPage) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Inserts data to DB.
+     *
+     * @param _data - data to insert
+     */
+    static insert(_data, _insertBehaviour = InsertBehaviour.None) {
+        throw new Error('Not implemented');
+    }
+    static where(_column, _operator, _value) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Updates single or multiple records at once with provided value based on condition
+     *
+     * @param _data - data to set
+     */
+    static update(_data) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Tries to find all models with given primary keys
+     */
+    static find(_pks) {
+        throw new Error('Not implemented');
+    }
+    static first() {
+        throw new Error('Not implemented');
+    }
+    static last() {
+        throw new Error('Not implemented');
+    }
+    static newest() {
+        throw new Error('Not implemented');
+    }
+    static oldest() {
+        throw new Error('Not implemented');
+    }
+    static count() {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Tries to find all models in db. If not all exists, throws exception
+     */
+    static findOrFail(_pks) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * gets model by specified pk, if not exists, returns null
+     *
+     */
+    static get(_pk) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Finds model by specified pk. If model not exists in db throws exception
+     *
+     */
+    static getOrFail(_pk) {
+        throw new Error('Not implemented');
+    }
+    /**
+     *
+     * Checks if model with pk key or unique fields exists and if not creates one AND NOT save in db
+     * NOTE: it checks for unique fields constraint
+     */
+    static getOrNew(_pk, _data) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Creates query on this model. used for quering db for partial data, to perform some kind of operations
+     * that dont need full ORM model to involve, or other non standard operations eg. joins or raw data queries based on this model
+     */
+    static query() {
+        throw new Error('Not implemented');
+    }
+    /**
+     *
+     * Checks if model with pk key / unique fields exists and if not creates one and saves to db
+     * NOTE: it checks for unique fields too.
+     *
+     * @param data - model width data to check
+     */
+    static getOrCreate(_pk, _data) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Creates new model & saves is to db
+     *
+     * @param  data - initial model data
+     */
+    static create(_data) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Deletes model from db
+     *
+     * @param pk - primary key
+     */
+    static destroy(_pk) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * Checks if model exists in db
+     */
+    static exists() {
+        throw new Error('Not implemented');
+    }
+    constructor(data) {
+        /**
+         * List of hidden properties from JSON / dehydrations
+         * eg. password field of user
+         */
+        this._hidden = [];
+        this.setDefaults();
+        if (data) {
+            this.hydrate(data);
+        }
+    }
+    /**
+     * Fills model with data. It only fills properties that exists in database
+     *
+     * @param data - data to fill
+     */
+    hydrate(data) {
+        this.Container.resolve(Array.ofType(ModelHydrator)).forEach((h) => h.hydrate(this, data));
+    }
+    /**
+     *
+     * Attachess model to proper relation an sets foreign key
+     *
+     * @param data - model to attach
+     */
+    attach(data) {
+        // TODO: refactor this, to not check every time for relation
+        // do this as map or smth
+        for (const [_, v] of this.ModelDescriptor.Relations.entries()) {
+            if (v.TargetModel.name === data.constructor.name) {
+                // TODO: refactor this, so we dont update foreign key
+                // instead we must use belongsTo relation on data model to update
+                data[v.ForeignKey] = this.PrimaryKeyValue;
+                switch (v.Type) {
+                    case RelationType.One:
+                        this[v.Name].attach(data);
+                        break;
+                    case RelationType.Many:
+                    case RelationType.ManyToMany:
+                        this[v.Name].push(data);
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * Extracts all data from model. It takes only properties that exists in DB
+     */
+    dehydrate(omit) {
+        return this.Container.resolve(StandardModelDehydrator).dehydrate(this, [...(omit ?? []), ...this._hidden]);
+    }
+    /**
+     *
+     * Extracts all data from model with relation data. Relation data are dehydrated recursively.
+     *
+     * @param omit - fields to omit
+     */
+    dehydrateWithRelations(omit) {
+        return this.Container.resolve(StandardModelWithRelationsDehydrator).dehydrate(this, [...(omit ?? []), ...this._hidden]);
+    }
+    toSql() {
+        return this.Container.resolve(ModelToSqlConverter).toSql(this);
+    }
+    /**
+     * deletes enitt from db. If model have SoftDelete decorator, model is marked as deleted
+     */
+    async destroy() {
+        if (!this.PrimaryKeyValue) {
+            return;
+        }
+        await this.constructor.destroy(this.PrimaryKeyValue);
+    }
+    /**
+     * If model can be in achived state - sets archived at date and saves it to db
+     */
+    async archive() {
+        if (this.ModelDescriptor.Archived) {
+            this[this.ModelDescriptor.Archived.ArchivedAt] = DateTime.now();
+        }
+        else {
+            throw new OrmException('archived at column not exists in model');
+        }
+        const { query } = this.createUpdateQuery();
+        await query.update(this.toSql()).where(this.PrimaryKeyName, this.PrimaryKeyValue);
+    }
+    async update() {
+        const { query } = this.createUpdateQuery();
+        if (this.ModelDescriptor.Timestamps.UpdatedAt) {
+            this[this.ModelDescriptor.Timestamps.UpdatedAt] = DateTime.now();
+        }
+        await query.update(this.toSql()).where(this.PrimaryKeyName, this.PrimaryKeyValue);
+    }
+    /**
+     * Save all changes to db. It creates new entry id db or updates existing one if
+     * primary key exists
+     */
+    async insert(insertBehaviour = InsertBehaviour.None) {
+        const { query, description } = this.createInsertQuery();
+        switch (insertBehaviour) {
+            case InsertBehaviour.InsertOrIgnore:
+                query.orIgnore();
+                break;
+            case InsertBehaviour.InsertOrUpdate:
+                query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
+                break;
+            case InsertBehaviour.InsertOrReplace:
+                query.orReplace();
+                break;
+        }
+        const iMidleware = {
+            afterQuery: (data) => {
+                this.PrimaryKeyValue = this.PrimaryKeyValue ?? data.LastInsertId;
+                return data;
+            },
+            modelCreation: () => null,
+            afterHydration: () => null,
+        };
+        query.middleware(iMidleware);
+        return query.values(this.toSql());
+    }
+    /**
+     *
+     * Shorthand for inserting model when no primary key exists, or update
+     * its value in db if primary key is set
+     *
+     * @param insertBehaviour - insert mode
+     */
+    async insertOrUpdate(insertBehaviour = InsertBehaviour.None) {
+        if (this.PrimaryKeyValue) {
+            await this.update();
+        }
+        else {
+            await this.insert(insertBehaviour);
+        }
+    }
+    /**
+     * Gets model data from database and returns as fresh instance.
+     *
+     * If primary key is not fetched, tries to load by columns with unique constraint.
+     * If there is no unique columns or primary key, throws error
+     */
+    async fresh() {
+        const { query, description } = this.createSelectQuery();
+        query.select('*');
+        _preparePkWhere(description, query, this);
+        _prepareOrderBy(description, query);
+        // TODO: rethink all cast of this type?
+        return (await query.firstOrFail());
+    }
+    /**
+     * Refresh model from database.
+     *
+     * If no primary key is set, tries to fetch data base on columns
+     * with unique constraints. If none exists, throws exception
+     */
+    async refresh() {
+        let model = null;
+        model = await this.fresh();
+        for (const c of this.ModelDescriptor.Columns) {
+            this[c.Name] = model[c.Name];
+        }
+    }
+    toJSON() {
+        return this.dehydrate();
+    }
+    /**
+     * sets default values for model. values are taken from DB default column prop
+     */
+    setDefaults() {
+        this.ModelDescriptor.Columns?.forEach((c) => {
+            if (c.Uuid) {
+                this[c.Name] = uuidv4();
+            }
+            else {
+                this[c.Name] = c.DefaultValue;
+            }
+        });
+        if (this.ModelDescriptor.Timestamps.CreatedAt) {
+            this[this.ModelDescriptor.Timestamps.CreatedAt] = DateTime.now();
+        }
+        for (const [, rel] of this.ModelDescriptor.Relations) {
+            if (rel.Factory) {
+                this[rel.Name] = rel.Factory(this, rel, this.Container);
+            }
+            else if (rel.RelationClass) {
+                this[rel.Name] = this.Container.resolve(rel.RelationClass, [this, rel.TargetModel, rel, []]);
+            }
+            else if (rel.Type === RelationType.Many) {
+                this[rel.Name] = new OneToManyRelationList(this, rel.TargetModel, rel, []);
+            }
+            else if (rel.Type === RelationType.ManyToMany) {
+                this[rel.Name] = new ManyToManyRelationList(this, rel.TargetModel, rel, []);
+            }
+            else {
+                this[rel.Name] = new SingleRelation(this, rel.TargetModel, rel, null);
+            }
+        }
+    }
+    createSelectQuery() {
+        return createQuery(this.constructor, SelectQueryBuilder);
+    }
+    createUpdateQuery() {
+        return createQuery(this.constructor, UpdateQueryBuilder);
+    }
+    createInsertQuery() {
+        return createQuery(this.constructor, InsertQueryBuilder);
+    }
+}
+function _descriptor(model) {
+    return model[MODEL_DESCTRIPTION_SYMBOL];
+}
+function _preparePkWhere(description, query, model) {
+    if (description.PrimaryKey) {
+        query.where(description.PrimaryKey, model.PrimaryKeyValue);
+    }
+    else {
+        const unique = description.Columns.filter((x) => x.Unique);
+        if (unique.length !== 0) {
+            for (const c of unique) {
+                query.where(c.Name, '=', model[c.Name]);
+            }
+        }
+        else {
+            throw new OrmException('Model dont have primary key set or columns with unique constraint, cannot fetch model from database');
+        }
+    }
+}
+function _prepareOrderBy(description, query, order) {
+    if (description.PrimaryKey) {
+        query.order(description.PrimaryKey, order ?? SortOrder.DESC);
+    }
+    else {
+        const unique = description.Columns.filter((c) => c.Unique);
+        if (unique.length !== 0) {
+            unique.forEach((c) => query.order(c.Name, order ?? SortOrder.DESC));
+        }
+        else if (description.Timestamps?.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, order ?? SortOrder.DESC);
+        }
+        else if (description.Timestamps?.UpdatedAt) {
+            query.order(description.Timestamps.UpdatedAt, order ?? SortOrder.DESC);
+        }
+    }
+}
+export class HistoricalModel {
+}
+/**
+ * Helper function to create query based on model
+ *
+ * @param model - source model for query
+ * @param query - query class
+ * @param injectModel - should inject model information into query, if not, query will return raw data
+ *
+ * @returns
+ */
+export function createQuery(model, query, injectModel = true) {
+    const dsc = _descriptor(model);
+    if (!dsc) {
+        throw new Error(`model ${model.name} does not have model descriptor. Use @model decorator on class`);
+    }
+    const orm = DI.get(Orm);
+    const driver = orm.Connections.get(dsc.Connection);
+    if (!driver) {
+        throw new Error(`model ${model.name} have invalid connection ${dsc.Connection}, please check your db config file or model connection name`);
+    }
+    const cnt = driver.Container;
+    const qr = cnt.resolve(query, [driver, injectModel ? orm.Models.find((x) => x.name === model.name).type : null]);
+    if (qr instanceof SelectQueryBuilder) {
+        const scope = model._queryScopes;
+        if (scope) {
+            Object.getOwnPropertyNames(scope.__proto__)
+                .filter((x) => x !== 'constructor')
+                .forEach(function (property) {
+                if (typeof scope[property] === 'function') {
+                    qr[property] = scope[property].bind(qr);
+                }
+            });
+        }
+    }
+    qr.middleware(new DiscriminationMapMiddleware(dsc));
+    qr.setTable(dsc.TableName);
+    if (driver.Options.Database) {
+        qr.database(driver.Options.Database);
+    }
+    return {
+        query: qr,
+        description: dsc,
+        model,
+        container: driver.Container,
+    };
+}
+export const MODEL_STATIC_MIXINS = {
+    getModelDescriptor() {
+        const dsc = _descriptor(this);
+        if (!dsc) {
+            throw new OrmException(`Model ${this.constructor.name} has no descriptor`);
+        }
+        return dsc;
+    },
+    getRelationDescriptor(relation) {
+        const descriptor = this.getModelDescriptor();
+        let rDescriptor = null;
+        for (const [key, value] of descriptor.Relations) {
+            if (key.toLowerCase() === relation.toLowerCase().trim()) {
+                rDescriptor = value;
+                break;
+            }
+        }
+        if (!rDescriptor) {
+            throw new OrmException(`Model ${this.constructor.name} has no relation ${relation}`);
+        }
+        return rDescriptor;
+    },
+    truncate() {
+        const { query } = createQuery(this, TruncateTableQueryBuilder, false);
+        return query;
+    },
+    driver() {
+        const dsc = this.getModelDescriptor();
+        const orm = DI.get(Orm);
+        const driver = orm.Connections.get(dsc.Connection);
+        if (!driver) {
+            throw new Error(`model ${this.name} have invalid connection ${dsc.Connection}, please check your db config file or model connection name`);
+        }
+        return driver;
+    },
+    query() {
+        const { query } = createQuery(this, SelectQueryBuilder);
+        return query;
+    },
+    where(column, operator, value) {
+        const { query } = createQuery(this, SelectQueryBuilder);
+        query.select('*');
+        return query.where(column, operator, value);
+    },
+    update(data) {
+        const { query } = createQuery(this, UpdateQueryBuilder);
+        return query.update(data);
+    },
+    all(page, perPage) {
+        const { query } = createQuery(this, SelectQueryBuilder);
+        query.select('*');
+        if (page >= 0 && perPage > 0) {
+            query.take(perPage).skip(page * perPage);
+        }
+        return query;
+    },
+    /**
+     * Try to insert new value
+     */
+    async insert(data, insertBehaviour = InsertBehaviour.None) {
+        const { query, description, container } = createQuery(this, InsertQueryBuilder);
+        const converter = container.resolve(ObjectToSqlConverter);
+        if (Array.isArray(data)) {
+            if (insertBehaviour !== InsertBehaviour.None) {
+                throw new OrmException(`insert behaviour is not supported with arrays`);
+            }
+            query.values(data.map((d) => {
+                if (d instanceof ModelBase) {
+                    return d.toSql();
+                }
+                return converter.toSql(d);
+            }));
+        }
+        else {
+            switch (insertBehaviour) {
+                case InsertBehaviour.InsertOrIgnore:
+                    query.orIgnore();
+                    break;
+                case InsertBehaviour.InsertOrUpdate:
+                    query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
+                    break;
+                case InsertBehaviour.InsertOrReplace:
+                    query.orReplace();
+                    break;
+            }
+            if (data instanceof ModelBase) {
+                query.values(data.toSql());
+            }
+            else {
+                query.values(converter.toSql(data));
+            }
+        }
+        const iMidleware = {
+            afterQuery: (result) => {
+                if (Array.isArray(data)) {
+                    data.forEach((v, idx) => {
+                        if (v instanceof ModelBase) {
+                            v.PrimaryKeyValue = v.PrimaryKeyValue ?? result.LastInsertId - data.length + idx + 1;
+                        }
+                    });
+                }
+                else if (data instanceof ModelBase) {
+                    data.PrimaryKeyValue = data.PrimaryKeyValue ?? result.LastInsertId;
+                }
+                return result;
+            },
+            modelCreation: () => null,
+            afterHydration: () => null,
+        };
+        query.middleware(iMidleware);
+        return query;
+    },
+    async find(pks) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.whereIn(pkey, pks);
+        return await query;
+    },
+    async findOrFail(pks) {
+        const { query, description, model } = createQuery(this, SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.whereIn(pkey, pks);
+        const result = await query;
+        if (result.length !== pks.length) {
+            throw new Error(`could not find all results for model ${model.name}`);
+        }
+        return result;
+    },
+    async get(pk) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.where(pkey, pk);
+        _prepareOrderBy(description, query);
+        return (await query.first());
+    },
+    async getOrFail(pk) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.where(pkey, pk);
+        _prepareOrderBy(description, query);
+        return (await query.firstOrFail());
+    },
+    destroy(pks) {
+        const description = _descriptor(this);
+        const data = Array.isArray(pks) ? pks : [pks];
+        const { query } = description.SoftDelete?.DeletedAt ? createQuery(this, UpdateQueryBuilder) : createQuery(this, DeleteQueryBuilder);
+        if (description.SoftDelete?.DeletedAt) {
+            query.update({
+                [description.SoftDelete.DeletedAt]: DateTime.now(),
+            });
+        }
+        if (pks) {
+            query.whereIn(description.PrimaryKey, data);
+        }
+        return query;
+    },
+    async create(data) {
+        const entity = new (Function.prototype.bind.apply(this))(data);
+        await entity.insert();
+        return entity;
+    },
+    async getOrCreate(pk, data) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        // pk constrain
+        if (description.PrimaryKey && pk !== null) {
+            query.where(description.PrimaryKey, pk);
+        }
+        // check for all unique columns ( unique constrain )
+        description.Columns.filter((c) => c.Unique).forEach((c) => {
+            query.andWhere(c, data[c.Name]);
+        });
+        _prepareOrderBy(description, query);
+        let entity = (await query.first());
+        if (!entity) {
+            entity = new (Function.prototype.bind.apply(this))(data);
+            await entity.insert();
+            return entity;
+        }
+        return entity;
+    },
+    async getOrNew(pk, data) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        // pk constrain
+        if (description.PrimaryKey) {
+            query.where(description.PrimaryKey, pk);
+        }
+        // check for all unique columns ( unique constrain )
+        description.Columns.filter((c) => c.Unique).forEach((c) => {
+            query.andWhere(c, data[c.Name]);
+        });
+        _prepareOrderBy(description, query);
+        let entity = (await query.first());
+        if (!entity) {
+            entity = new (Function.prototype.bind.apply(this))(data);
+            return entity;
+        }
+        return entity;
+    },
+    async exists(pk) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        // pk constrain
+        if (description.PrimaryKey && pk !== null) {
+            query.where(description.PrimaryKey, pk);
+        }
+        const result = await query.clearColumns().select(description.PrimaryKey).first();
+        if (result) {
+            return true;
+        }
+        return false;
+    },
+    async first(callback) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        _prepareOrderBy(description, query, SortOrder.ASC);
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async last(callback) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        _prepareOrderBy(description, query, SortOrder.DESC);
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async newest(callback) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        if (description.Timestamps?.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, SortOrder.DESC);
+        }
+        else {
+            throw new OrmException('cannot fetch newest entity - CreateAt column not exists in model/db');
+        }
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async oldest(callback) {
+        const { query, description } = createQuery(this, SelectQueryBuilder);
+        if (description.Timestamps?.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, SortOrder.ASC);
+        }
+        else {
+            throw new OrmException('cannot fetch oldest entity - CreateAt column not exists in model/db');
+        }
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async count(callback) {
+        const { query } = createQuery(this, SelectQueryBuilder);
+        query.count('*', 'count');
+        if (callback) {
+            callback(query);
+        }
+        return await (await query.asRaw()).count;
+    },
+};
 //# sourceMappingURL=model.js.map