@spinajs/orm-sql 2.0.38 → 2.0.39

package/lib/orm/src/model.js

@@ -0,0 +1,779 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_STATIC_MIXINS = exports.createQuery = exports.HistoricalModel = exports.ModelBase = exports.extractModelDescriptor = void 0;
+/* eslint-disable prettier/prettier */
+const relations_1 = require("./relations");
+const enums_1 = require("./enums");
+const decorators_1 = require("./decorators");
+const interfaces_1 = require("./interfaces");
+const builders_1 = require("./builders");
+const di_1 = require("@spinajs/di");
+const orm_1 = require("./orm");
+const hydrators_1 = require("./hydrators");
+const _ = __importStar(require("lodash"));
+const uuid_1 = require("uuid");
+const exceptions_1 = require("./exceptions");
+const dehydrators_1 = require("./dehydrators");
+const luxon_1 = require("luxon");
+function extractModelDescriptor(targetOrForward) {
+    const target = !(0, di_1.isConstructor)(targetOrForward) && targetOrForward ? targetOrForward() : targetOrForward;
+    if (!target) {
+        return null;
+    }
+    let descriptor = null;
+    _reduce(target);
+    return descriptor;
+    function _reduce(t) {
+        if (!t) {
+            return;
+        }
+        if (t[decorators_1.MODEL_DESCTRIPTION_SYMBOL]) {
+            descriptor = descriptor !== null && descriptor !== void 0 ? descriptor : {};
+            _.mergeWith(descriptor, t[decorators_1.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__);
+    }
+}
+exports.extractModelDescriptor = extractModelDescriptor;
+class ModelBase {
+    constructor(data) {
+        /**
+         * List of hidden properties from JSON / dehydrations
+         * eg. password field of user
+         */
+        this._hidden = [];
+        this.setDefaults();
+        if (data) {
+            this.hydrate(data);
+        }
+    }
+    /**
+     * 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_1.DI.get(orm_1.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 interfaces_1.RelationType.One:
+                    rel[r.ForeignKey] = newVal;
+                    break;
+                case interfaces_1.RelationType.Many:
+                    rel.forEach((rVal) => (rVal[r.ForeignKey] = newVal));
+                    break;
+                case interfaces_1.RelationType.ManyToMany:
+                    // TODO: rethink this
+                    break;
+            }
+        });
+    }
+    driver() {
+        const orm = di_1.DI.get(orm_1.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 === interfaces_1.RelationType.Many || r.Type === interfaces_1.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);
+    }
+    /**
+     * 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 = interfaces_1.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');
+    }
+    /**
+     * Fills model with data. It only fills properties that exists in database
+     *
+     * @param data - data to fill
+     */
+    hydrate(data) {
+        this.Container.resolve(Array.ofType(hydrators_1.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) {
+                data[v.ForeignKey] = this.PrimaryKeyValue;
+                switch (v.Type) {
+                    case interfaces_1.RelationType.One:
+                        this[v.Name].attach(data);
+                        break;
+                    case interfaces_1.RelationType.Many:
+                    case interfaces_1.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(dehydrators_1.ModelDehydrator).dehydrate(this, [...(omit !== null && omit !== void 0 ? omit : []), ...this._hidden]);
+    }
+    toSql() {
+        var _a;
+        const obj = {};
+        const relArr = [...this.ModelDescriptor.Relations.values()];
+        (_a = this.ModelDescriptor.Columns) === null || _a === void 0 ? void 0 : _a.forEach((c) => {
+            const val = this[c.Name];
+            if (!c.PrimaryKey && !c.Nullable && (val === null || val === undefined || val === '')) {
+                throw new exceptions_1.OrmException(`Field ${c.Name} cannot be null`);
+            }
+            obj[c.Name] = c.Converter ? c.Converter.toDB(val, this, this.ModelDescriptor.Converters.get(c.Name).Options) : val;
+        });
+        for (const val of relArr) {
+            if (val.Type === interfaces_1.RelationType.One) {
+                if (this[val.Name].Value) {
+                    obj[val.ForeignKey] = this[val.Name].Value.PrimaryKeyValue;
+                }
+            }
+        }
+        return obj;
+    }
+    /**
+     * 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() {
+        const { query } = this.createUpdateQuery();
+        if (this.ModelDescriptor.Archived) {
+            this[this.ModelDescriptor.Archived.ArchivedAt] = luxon_1.DateTime.now();
+        }
+        else {
+            throw new exceptions_1.OrmException('archived at column not exists in model');
+        }
+        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] = luxon_1.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 = interfaces_1.InsertBehaviour.None) {
+        const { query, description } = this.createInsertQuery();
+        switch (insertBehaviour) {
+            case interfaces_1.InsertBehaviour.InsertOrIgnore:
+                query.orIgnore();
+                break;
+            case interfaces_1.InsertBehaviour.InsertOrUpdate:
+                query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
+                break;
+            case interfaces_1.InsertBehaviour.InsertOrReplace:
+                query.orReplace();
+                break;
+        }
+        const iMidleware = {
+            afterQuery: (data) => {
+                var _a;
+                this.PrimaryKeyValue = (_a = this.PrimaryKeyValue) !== null && _a !== void 0 ? _a : data.LastInsertId;
+                return data;
+            },
+            modelCreation: () => null,
+            afterHydration: () => null,
+        };
+        query.middleware(iMidleware);
+        return query.values(this.toSql());
+    }
+    /**
+     * 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() {
+        var _a;
+        (_a = this.ModelDescriptor.Columns) === null || _a === void 0 ? void 0 : _a.forEach((c) => {
+            if (c.Uuid) {
+                this[c.Name] = (0, uuid_1.v4)();
+            }
+            else {
+                this[c.Name] = c.DefaultValue;
+            }
+        });
+        if (this.ModelDescriptor.Timestamps.CreatedAt) {
+            this[this.ModelDescriptor.Timestamps.CreatedAt] = luxon_1.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 === interfaces_1.RelationType.Many) {
+                this[rel.Name] = new relations_1.OneToManyRelationList(this, rel.TargetModel, rel, []);
+            }
+            else if (rel.Type === interfaces_1.RelationType.ManyToMany) {
+                this[rel.Name] = new relations_1.ManyToManyRelationList(this, rel.TargetModel, rel, []);
+            }
+            else {
+                this[rel.Name] = new relations_1.SingleRelation(this, rel.TargetModel, rel, null);
+            }
+        }
+    }
+    createSelectQuery() {
+        return createQuery(this.constructor, builders_1.SelectQueryBuilder);
+    }
+    createUpdateQuery() {
+        return createQuery(this.constructor, builders_1.UpdateQueryBuilder);
+    }
+    createInsertQuery() {
+        return createQuery(this.constructor, builders_1.InsertQueryBuilder);
+    }
+}
+exports.ModelBase = ModelBase;
+function _descriptor(model) {
+    return model[decorators_1.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 exceptions_1.OrmException('Model dont have primary key set or columns with unique constraint, cannot fetch model from database');
+        }
+    }
+}
+function _prepareOrderBy(description, query, order) {
+    var _a, _b;
+    if (description.PrimaryKey) {
+        query.order(description.PrimaryKey, order !== null && order !== void 0 ? order : enums_1.SordOrder.DESC);
+    }
+    else {
+        const unique = description.Columns.filter((c) => c.Unique);
+        if (unique.length !== 0) {
+            unique.forEach((c) => query.order(c.Name, order !== null && order !== void 0 ? order : enums_1.SordOrder.DESC));
+        }
+        else if ((_a = description.Timestamps) === null || _a === void 0 ? void 0 : _a.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, order !== null && order !== void 0 ? order : enums_1.SordOrder.DESC);
+        }
+        else if ((_b = description.Timestamps) === null || _b === void 0 ? void 0 : _b.UpdatedAt) {
+            query.order(description.Timestamps.UpdatedAt, order !== null && order !== void 0 ? order : enums_1.SordOrder.DESC);
+        }
+    }
+}
+class HistoricalModel {
+}
+exports.HistoricalModel = 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
+ */
+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_1.DI.get(orm_1.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 builders_1.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 relations_1.DiscriminationMapMiddleware(dsc));
+    qr.setTable(dsc.TableName);
+    if (driver.Options.Database) {
+        qr.database(driver.Options.Database);
+    }
+    return {
+        query: qr,
+        description: dsc,
+        model,
+    };
+}
+exports.createQuery = createQuery;
+exports.MODEL_STATIC_MIXINS = {
+    truncate() {
+        const { query } = createQuery(this, builders_1.TruncateTableQueryBuilder, false);
+        return query;
+    },
+    driver() {
+        const dsc = _descriptor(this);
+        const orm = di_1.DI.get(orm_1.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, builders_1.SelectQueryBuilder);
+        return query;
+    },
+    where(column, operator, value) {
+        const { query } = createQuery(this, builders_1.SelectQueryBuilder);
+        query.select('*');
+        return query.where(column, operator, value);
+    },
+    update(data) {
+        const { query } = createQuery(this, builders_1.UpdateQueryBuilder);
+        return query.update(data);
+    },
+    all(page, perPage) {
+        const { query } = createQuery(this, builders_1.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 = interfaces_1.InsertBehaviour.None) {
+        const { query, description } = createQuery(this, builders_1.InsertQueryBuilder);
+        if (Array.isArray(data)) {
+            if (insertBehaviour !== interfaces_1.InsertBehaviour.None) {
+                throw new exceptions_1.OrmException(`insert behaviour is not supported with arrays`);
+            }
+            query.values(data.map((d) => {
+                if (d instanceof ModelBase) {
+                    return d.toSql();
+                }
+                return d;
+            }));
+        }
+        else {
+            switch (insertBehaviour) {
+                case interfaces_1.InsertBehaviour.InsertOrIgnore:
+                    query.orIgnore();
+                    break;
+                case interfaces_1.InsertBehaviour.InsertOrUpdate:
+                    query.onDuplicate().update(description.Columns.filter((c) => !c.PrimaryKey).map((c) => c.Name));
+                    break;
+                case interfaces_1.InsertBehaviour.InsertOrReplace:
+                    query.orReplace();
+                    break;
+            }
+            if (data instanceof ModelBase) {
+                query.values(data.toSql());
+            }
+            else {
+                query.values(data);
+            }
+        }
+        const iMidleware = {
+            afterQuery: (result) => {
+                var _a;
+                if (Array.isArray(data)) {
+                    data.forEach((v, idx) => {
+                        var _a;
+                        if (v instanceof ModelBase) {
+                            v.PrimaryKeyValue = (_a = v.PrimaryKeyValue) !== null && _a !== void 0 ? _a : result.LastInsertId - data.length + idx;
+                        }
+                    });
+                }
+                else if (data instanceof ModelBase) {
+                    data.PrimaryKeyValue = (_a = data.PrimaryKeyValue) !== null && _a !== void 0 ? _a : result.LastInsertId;
+                }
+                return result;
+            },
+            modelCreation: () => null,
+            afterHydration: () => null,
+        };
+        query.middleware(iMidleware);
+        return query;
+    },
+    async find(pks) {
+        const { query, description } = createQuery(this, builders_1.SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.whereIn(pkey, pks);
+        return await query;
+    },
+    async findOrFail(pks) {
+        const { query, description, model } = createQuery(this, builders_1.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, builders_1.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, builders_1.SelectQueryBuilder);
+        const pkey = description.PrimaryKey;
+        query.select('*');
+        query.where(pkey, pk);
+        _prepareOrderBy(description, query);
+        return (await query.firstOrFail());
+    },
+    destroy(pks) {
+        var _a, _b;
+        const description = _descriptor(this);
+        const data = Array.isArray(pks) ? pks : [pks];
+        const { query } = ((_a = description.SoftDelete) === null || _a === void 0 ? void 0 : _a.DeletedAt) ? createQuery(this, builders_1.UpdateQueryBuilder) : createQuery(this, builders_1.DeleteQueryBuilder);
+        if ((_b = description.SoftDelete) === null || _b === void 0 ? void 0 : _b.DeletedAt) {
+            query.update({
+                [description.SoftDelete.DeletedAt]: luxon_1.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, builders_1.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, builders_1.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 first(callback) {
+        const { query, description } = createQuery(this, builders_1.SelectQueryBuilder);
+        _prepareOrderBy(description, query, enums_1.SordOrder.ASC);
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async last(callback) {
+        const { query, description } = createQuery(this, builders_1.SelectQueryBuilder);
+        _prepareOrderBy(description, query, enums_1.SordOrder.DESC);
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async newest(callback) {
+        var _a;
+        const { query, description } = createQuery(this, builders_1.SelectQueryBuilder);
+        if ((_a = description.Timestamps) === null || _a === void 0 ? void 0 : _a.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, enums_1.SordOrder.DESC);
+        }
+        else {
+            throw new exceptions_1.OrmException('cannot fetch newest entity - CreateAt column not exists in model/db');
+        }
+        if (callback) {
+            callback(query);
+        }
+        return (await query.first());
+    },
+    async oldest(callback) {
+        var _a;
+        const { query, description } = createQuery(this, builders_1.SelectQueryBuilder);
+        if ((_a = description.Timestamps) === null || _a === void 0 ? void 0 : _a.CreatedAt) {
+            query.order(description.Timestamps.CreatedAt, enums_1.SordOrder.ASC);
+        }
+        else {
+            throw new exceptions_1.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, builders_1.SelectQueryBuilder);
+        query.count('*', 'count');
+        if (callback) {
+            callback(query);
+        }
+        return await (await query.asRaw()).count;
+    },
+};
+//# sourceMappingURL=model.js.map