@decaf-ts/core 0.3.38 → 0.4.1

package/dist/core.cjs

@@ -0,0 +1,2361 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/db-decorators'), require('@decaf-ts/injectable-decorators'), require('@decaf-ts/reflection'), require('@decaf-ts/decorator-validation')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/db-decorators', '@decaf-ts/injectable-decorators', '@decaf-ts/reflection', '@decaf-ts/decorator-validation'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.core = {}, global.dbDecorators, global.injectableDecorators, global.reflection, global.decoratorValidation));
+})(this, (function (exports, dbDecorators, injectableDecorators, reflection, decoratorValidation) { 'use strict';
+
+    /**
+     * @summary defines order directions when sorting
+     *
+     * @constant OrderDirection
+     *
+     * @category Query
+     */
+    exports.OrderDirection = void 0;
+    (function (OrderDirection) {
+        /**
+         * @summary Defines the sort order as ascending
+         * @prop ASC
+         */
+        OrderDirection["ASC"] = "asc";
+        /**
+         * @summary Defines the sort order as descending
+         * @property {string} DSC
+         */
+        OrderDirection["DSC"] = "desc";
+    })(exports.OrderDirection || (exports.OrderDirection = {}));
+    exports.Cascade = void 0;
+    (function (Cascade) {
+        Cascade["CASCADE"] = "cascade";
+        Cascade["NONE"] = "none";
+    })(exports.Cascade || (exports.Cascade = {}));
+    const DefaultCascade = {
+        update: exports.Cascade.CASCADE,
+        delete: exports.Cascade.NONE,
+    };
+
+    class Context extends dbDecorators.Context {
+        constructor(operation, model, parent) {
+            super(operation, model, parent);
+        }
+        get timestamp() {
+            if (!this._timestamp)
+                this._timestamp = new Date();
+            return this._timestamp;
+        }
+    }
+
+    exports.PersistenceKeys = void 0;
+    (function (PersistenceKeys) {
+        PersistenceKeys["INDEX"] = "index";
+        PersistenceKeys["UNIQUE"] = "unique";
+        PersistenceKeys["ADAPTER"] = "adapter";
+        PersistenceKeys["INJECTABLE"] = "decaf_{0}_adapter_for_{1}";
+        PersistenceKeys["TABLE"] = "table";
+        PersistenceKeys["COLUMN"] = "column";
+        PersistenceKeys["METADATA"] = "__metadata";
+        PersistenceKeys["RELATIONS"] = "__relations";
+        PersistenceKeys["CLAUSE_SEQUENCE"] = "clause-sequence";
+        // Ownership
+        PersistenceKeys["CREATED_BY"] = "ownership.created-by";
+        PersistenceKeys["UPDATED_BY"] = "ownership.updated-by";
+        // Relations
+        PersistenceKeys["ONE_TO_ONE"] = "relations.one-to-one";
+        PersistenceKeys["ONE_TO_MANY"] = "relations.one-to-many";
+        PersistenceKeys["MANY_TO_ONE"] = "relations.many-to-one";
+        PersistenceKeys["POPULATE"] = "populate";
+    })(exports.PersistenceKeys || (exports.PersistenceKeys = {}));
+    exports.Roles = void 0;
+    (function (Roles) {
+        Roles["ADMIN"] = "admin";
+        Roles["WRITER"] = "writer";
+        Roles["READER"] = "reader";
+    })(exports.Roles || (exports.Roles = {}));
+
+    exports.Operator = void 0;
+    (function (Operator) {
+        Operator["EQUAL"] = "EQUAL";
+        Operator["DIFFERENT"] = "DIFFERENT";
+        Operator["BIGGER"] = "BIGGER";
+        Operator["BIGGER_EQ"] = "BIGGER_EQ";
+        Operator["SMALLER"] = "SMALLER";
+        Operator["SMALLER_EQ"] = "SMALLER_EQ";
+        // BETWEEN = "BETWEEN",
+        Operator["NOT"] = "NOT";
+        Operator["IN"] = "IN";
+        // IS = "IS",
+        Operator["REGEXP"] = "REGEXP";
+    })(exports.Operator || (exports.Operator = {}));
+    exports.GroupOperator = void 0;
+    (function (GroupOperator) {
+        GroupOperator["AND"] = "AND";
+        GroupOperator["OR"] = "OR";
+    })(exports.GroupOperator || (exports.GroupOperator = {}));
+    exports.Const = void 0;
+    (function (Const) {
+        Const["NULL"] = "NULL";
+        Const["FULL_RECORD"] = "*";
+    })(exports.Const || (exports.Const = {}));
+    /**
+     * @summary Defines execution order of Clauses in statements as defined in SQL.
+     *
+     * @description sub priorities where defined to better organize clauses within statements, eg From and Join Clauses
+     *
+     * @const Priority
+     *
+     * @category Clauses
+     * @subcategory Constants
+     */
+    exports.Priority = void 0;
+    (function (Priority) {
+        /**
+         * @summary Defines the priority for the FROM Clause
+         * @description From Clause in SELECT Statements.
+         * Values Clause in INSERT Statements
+         *
+         * @prop FROM
+         */
+        Priority[Priority["FROM"] = 1] = "FROM";
+        /**
+         * @summary Defines the priority for the JOIN Clause
+         *
+         * @property {number} JOIN
+         */
+        Priority[Priority["JOIN"] = 1.1] = "JOIN";
+        /**
+         * Where Clause
+         */
+        Priority[Priority["WHERE"] = 2] = "WHERE";
+        /**
+         * Group By Clause
+         */
+        Priority[Priority["GROUP_BY"] = 3] = "GROUP_BY";
+        /**
+         * Having Clause
+         */
+        Priority[Priority["HAVING"] = 4] = "HAVING";
+        /**
+         * Select Clause in SELECT Statements
+         * Insert Clause in INSERT Statements
+         */
+        Priority[Priority["SELECT"] = 5] = "SELECT";
+        /**
+         * Order By Clause
+         */
+        Priority[Priority["ORDER_BY"] = 6] = "ORDER_BY";
+        /**
+         * Limit Clause
+         */
+        Priority[Priority["LIMIT"] = 7] = "LIMIT";
+        /**
+         * Offset Clause
+         */
+        Priority[Priority["OFFSET"] = 7.1] = "OFFSET";
+    })(exports.Priority || (exports.Priority = {}));
+    const MandatoryPriorities = [exports.Priority.FROM, exports.Priority.SELECT];
+    exports.StatementType = void 0;
+    (function (StatementType) {
+        StatementType["QUERY"] = "query";
+        StatementType["TRANSACTION"] = "transaction";
+    })(exports.StatementType || (exports.StatementType = {}));
+
+    /**
+     * @summary Helper Class to build queries
+     *
+     * @param {Database} db
+     *
+     * @class Query
+     *
+     * @category Query
+     */
+    class Query {
+        constructor(adapter) {
+            this.adapter = adapter;
+        }
+        /**
+         * @summary Creates a Select Clause
+         * @param {SelectSelector} [selector]
+         */
+        select(selector = exports.Const.FULL_RECORD) {
+            return this.adapter.Clauses.select(selector);
+        }
+        /**
+         * @summary Creates a Min Clause
+         * @param {SelectSelector} selector
+         */
+        min(selector) {
+            return this.select().min(selector);
+        }
+        /**
+         * @summary Creates a Max Clause
+         * @param {SelectSelector} selector
+         */
+        max(selector) {
+            return this.select().max(selector);
+        }
+        /**
+         * @summary Creates a Distinct Clause
+         * @param {SelectSelector} selector
+         */
+        distinct(selector) {
+            return this.select().distinct(selector);
+        }
+        /**
+         * @summary Creates a Count Clause
+         * @param {SelectSelector} selector
+         */
+        count(selector) {
+            return this.select().count(selector);
+        }
+        insert() {
+            return this.adapter.Clauses.insert();
+        }
+    }
+
+    class ConnectionError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(ConnectionError.name, msg);
+        }
+    }
+    class UnsupportedError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(UnsupportedError.name, msg);
+        }
+    }
+
+    /**
+     * @summary Abstract Decaf-ts Persistence Adapter Class
+     * @description Offers the base implementation for all Adapter Classes
+     * and manages them various registered {@link Adapter}s
+     *
+     * @typedef Y the underlying persistence object type
+     * @typedef Q The query object the adapter uses
+     *
+     * @param {Y} native the underlying persistence object
+     * @param {string} flavour the under witch the persistence adapter should be stored
+     *
+     * @class Adapter
+     * @implements RawExecutor
+     * @implements Observable
+     */
+    class Adapter {
+        static { this._cache = {}; }
+        get native() {
+            return this._native;
+        }
+        repository() {
+            return Repository;
+        }
+        constructor(native, flavour) {
+            this.flavour = flavour;
+            this._observers = [];
+            if (this.flavour in Adapter._cache)
+                throw new dbDecorators.InternalError(`Persistence adapter flavour ${this.flavour} already registered`);
+            this._native = native;
+            Adapter._cache[this.flavour] = this;
+        }
+        Query() {
+            return new Query(this);
+        }
+        isReserved(attr) {
+            return !attr;
+        }
+        async context(operation, model) {
+            let user;
+            try {
+                user = await this.user();
+            }
+            catch (e) {
+                if (!(e instanceof UnsupportedError))
+                    throw e;
+            }
+            const c = new (class extends Context {
+                constructor(operation, model, parent) {
+                    super(operation, model, parent);
+                }
+                get user() {
+                    if (!user)
+                        throw new UnsupportedError("Adapter does not support user identification");
+                    return user;
+                }
+            })(operation, model);
+            return c;
+        }
+        prepare(model, pk) {
+            const result = Object.entries(model).reduce((accum, [key, val]) => {
+                // if (key === pk) return accum;
+                const mappedProp = Repository.column(model, key);
+                if (this.isReserved(mappedProp))
+                    throw new dbDecorators.InternalError(`Property name ${mappedProp} is reserved`);
+                accum[mappedProp] = val;
+                return accum;
+            }, {});
+            if (model[exports.PersistenceKeys.METADATA])
+                Object.defineProperty(result, exports.PersistenceKeys.METADATA, {
+                    enumerable: false,
+                    writable: false,
+                    configurable: true,
+                    value: model[exports.PersistenceKeys.METADATA],
+                });
+            return {
+                record: result,
+                id: model[pk],
+            };
+        }
+        revert(obj, clazz, pk, id) {
+            const ob = {};
+            ob[pk] = id;
+            const m = (typeof clazz === "string" ? decoratorValidation.Model.build(ob, clazz) : new clazz(ob));
+            const metadata = obj[exports.PersistenceKeys.METADATA];
+            const result = Object.keys(m).reduce((accum, key) => {
+                if (key === pk)
+                    return accum;
+                accum[key] = obj[Repository.column(accum, key)];
+                return accum;
+            }, m);
+            if (metadata)
+                Object.defineProperty(result, exports.PersistenceKeys.METADATA, {
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                    value: metadata,
+                });
+            return result;
+        }
+        async createAll(tableName, id, model, ...args) {
+            if (id.length !== model.length)
+                throw new dbDecorators.InternalError("Ids and models must have the same length");
+            return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...args)));
+        }
+        async readAll(tableName, id, ...args) {
+            return Promise.all(id.map((i) => this.read(tableName, i, ...args)));
+        }
+        async updateAll(tableName, id, model, ...args) {
+            if (id.length !== model.length)
+                throw new dbDecorators.InternalError("Ids and models must have the same length");
+            return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...args)));
+        }
+        async deleteAll(tableName, id, ...args) {
+            return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));
+        }
+        /**
+         * @summary Registers an {@link Observer}
+         * @param {Observer} observer
+         *
+         * @see {Observable#observe}
+         */
+        observe(observer) {
+            const index = this._observers.indexOf(observer);
+            if (index !== -1)
+                throw new dbDecorators.InternalError("Observer already registered");
+            this._observers.push(observer);
+        }
+        /**
+         * @summary Unregisters an {@link Observer}
+         * @param {Observer} observer
+         *
+         * @see {Observable#unObserve}
+         */
+        unObserve(observer) {
+            const index = this._observers.indexOf(observer);
+            if (index === -1)
+                throw new dbDecorators.InternalError("Failed to find Observer");
+            this._observers.splice(index, 1);
+        }
+        /**
+         * @summary calls all registered {@link Observer}s to update themselves
+         * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
+         */
+        async updateObservers(...args) {
+            const results = await Promise.allSettled(this._observers.map((o) => o.refresh(...args)));
+            results.forEach((result, i) => {
+                if (result.status === "rejected")
+                    console.warn(`Failed to update observable ${this._observers[i]}: ${result.reason}`);
+            });
+        }
+        static get current() {
+            return this._current;
+        }
+        static get(flavour) {
+            if (flavour in this._cache)
+                return this._cache[flavour];
+            throw new dbDecorators.InternalError(`No Adapter registered under ${flavour}.`);
+        }
+        static setCurrent(flavour) {
+            const adapter = Adapter.get(flavour);
+            if (!adapter)
+                throw new dbDecorators.NotFoundError(`No persistence flavour ${flavour} registered`);
+            this._current = adapter;
+        }
+        static key(key) {
+            return Repository.key(key);
+        }
+        static models(flavour) {
+            try {
+                const registry = decoratorValidation.Model.getRegistry();
+                const cache = registry.cache;
+                const managedModels = Object.values(cache)
+                    .map((m) => {
+                    let f = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), m);
+                    if (f && f === flavour)
+                        return m;
+                    if (!f) {
+                        const repo = Reflect.getMetadata(Repository.key(dbDecorators.DBKeys.REPOSITORY), m);
+                        if (!repo)
+                            return;
+                        const repository = Repository.forModel(m);
+                        f = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), repository);
+                        return f;
+                    }
+                })
+                    .filter((m) => !!m);
+                return managedModels;
+            }
+            catch (e) {
+                throw new dbDecorators.InternalError(e);
+            }
+        }
+    }
+
+    function getTableName(model) {
+        const metadata = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.TABLE), model instanceof decoratorValidation.Model ? model.constructor : model);
+        if (metadata) {
+            return metadata;
+        }
+        if (model instanceof decoratorValidation.Model) {
+            return model.constructor.name;
+        }
+        return model.name;
+    }
+    function sequenceNameForModel(model, ...args) {
+        return [getTableName(model), ...args].join("_");
+    }
+
+    class Sequence {
+        constructor(options) {
+            this.options = options;
+        }
+        static pk(model) {
+            return sequenceNameForModel(model, "pk");
+        }
+    }
+
+    function uses(flavour) {
+        return reflection.apply(reflection.metadata(Adapter.key(exports.PersistenceKeys.ADAPTER), flavour));
+    }
+
+    class Repository extends dbDecorators.Repository {
+        static { this._cache = {}; }
+        get adapter() {
+            if (!this._adapter)
+                throw new dbDecorators.InternalError(`No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?`);
+            return this._adapter;
+        }
+        get tableName() {
+            if (!this._tableName)
+                this._tableName = Repository.table(this.class);
+            return this._tableName;
+        }
+        constructor(adapter, clazz) {
+            super(clazz);
+            this.observers = [];
+            if (adapter)
+                this._adapter = adapter;
+            if (clazz) {
+                Repository.register(clazz, this);
+                if (adapter) {
+                    const flavour = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), clazz);
+                    if (flavour && flavour !== adapter.flavour)
+                        throw new dbDecorators.InternalError("Incompatible flavours");
+                    uses(adapter.flavour)(clazz);
+                }
+            }
+            [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach((m) => {
+                const name = m.name;
+                dbDecorators.wrapMethodWithContext(this, this[name + "Prefix"], m, this[name + "Suffix"]);
+            });
+        }
+        async createPrefix(model, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.CREATE, this.class, args, this.adapter);
+            model = new this.class(model);
+            await dbDecorators.enforceDBDecorators(this, contextArgs.context, model, dbDecorators.OperationKeys.CREATE, dbDecorators.OperationKeys.ON);
+            const errors = model.hasErrors();
+            if (errors)
+                throw new dbDecorators.ValidationError(errors.toString());
+            return [model, ...contextArgs.args];
+        }
+        async create(model, ...args) {
+            // eslint-disable-next-line prefer-const
+            let { record, id } = this.adapter.prepare(model, this.pk);
+            record = await this.adapter.create(this.tableName, id, record, ...args);
+            return this.adapter.revert(record, this.class, this.pk, id);
+        }
+        async createAll(models, ...args) {
+            if (!models.length)
+                return models;
+            const prepared = models.map((m) => this.adapter.prepare(m, this.pk));
+            const ids = prepared.map((p) => p.id);
+            let records = prepared.map((p) => p.record);
+            records = await this.adapter.createAll(this.tableName, ids, records, ...args);
+            return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i]));
+        }
+        async createAllPrefix(models, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.CREATE, this.class, args, this.adapter);
+            if (!models.length)
+                return [models, ...contextArgs.args];
+            const opts = Repository.getSequenceOptions(models[0]);
+            let ids = [];
+            if (opts.type) {
+                if (!opts.name)
+                    opts.name = Sequence.pk(models[0]);
+                ids = await (await this.adapter.Sequence(opts)).range(models.length);
+            }
+            models = await Promise.all(models.map(async (m, i) => {
+                m = new this.class(m);
+                m[this.pk] = ids[i];
+                await dbDecorators.enforceDBDecorators(this, contextArgs.context, m, dbDecorators.OperationKeys.CREATE, dbDecorators.OperationKeys.ON);
+                return m;
+            }));
+            const errors = models
+                .map((m) => m.hasErrors())
+                .reduce((accum, e, i) => {
+                if (e)
+                    accum =
+                        typeof accum === "string"
+                            ? accum + `\n - ${i}: ${e.toString()}`
+                            : ` - ${i}: ${e.toString()}`;
+                return accum;
+            }, undefined);
+            if (errors)
+                throw new dbDecorators.ValidationError(errors);
+            return [models, ...contextArgs.args];
+        }
+        async readPrefix(key, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.READ, this.class, args, this.adapter);
+            const model = new this.class();
+            model[this.pk] = key;
+            await dbDecorators.enforceDBDecorators(this, contextArgs.context, model, dbDecorators.OperationKeys.READ, dbDecorators.OperationKeys.ON);
+            return [key, ...contextArgs.args];
+        }
+        async read(id, ...args) {
+            const m = await this.adapter.read(this.tableName, id, ...args);
+            return this.adapter.revert(m, this.class, this.pk, id);
+        }
+        async readAllPrefix(keys, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.READ, this.class, args, this.adapter);
+            await Promise.all(keys.map(async (k) => {
+                const m = new this.class();
+                m[this.pk] = k;
+                return dbDecorators.enforceDBDecorators(this, contextArgs.context, m, dbDecorators.OperationKeys.READ, dbDecorators.OperationKeys.ON);
+            }));
+            return [keys, ...contextArgs.args];
+        }
+        async readAll(keys, ...args) {
+            const records = await this.adapter.readAll(this.tableName, keys, ...args);
+            return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+        }
+        async update(model, ...args) {
+            // eslint-disable-next-line prefer-const
+            let { record, id } = this.adapter.prepare(model, this.pk);
+            record = await this.adapter.update(this.tableName, id, record, ...args);
+            return this.adapter.revert(record, this.class, this.pk, id);
+        }
+        async updatePrefix(model, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.UPDATE, this.class, args, this.adapter);
+            const pk = model[this.pk];
+            if (!pk)
+                throw new dbDecorators.InternalError(`No value for the Id is defined under the property ${this.pk}`);
+            const oldModel = await this.read(pk, ...contextArgs.args);
+            model = this.merge(oldModel, model);
+            await dbDecorators.enforceDBDecorators(this, contextArgs.context, model, dbDecorators.OperationKeys.UPDATE, dbDecorators.OperationKeys.ON, oldModel);
+            const errors = model.hasErrors(oldModel, ...Repository.relations(this.class));
+            if (errors)
+                throw new dbDecorators.ValidationError(errors.toString());
+            if (Repository.getMetadata(oldModel)) {
+                if (!Repository.getMetadata(model))
+                    Repository.setMetadata(model, Repository.getMetadata(oldModel));
+            }
+            return [model, ...contextArgs.args];
+        }
+        async updateAll(models, ...args) {
+            const records = models.map((m) => this.adapter.prepare(m, this.pk));
+            const updated = await this.adapter.updateAll(this.tableName, records.map((r) => r.id), records.map((r) => r.record), ...args);
+            return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id));
+        }
+        async updateAllPrefix(models, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.UPDATE, this.class, args, this.adapter);
+            const ids = models.map((m) => {
+                const id = m[this.pk];
+                if (!id)
+                    throw new dbDecorators.InternalError("missing id on update operation");
+                return id;
+            });
+            const oldModels = await this.readAll(ids, ...contextArgs.args);
+            models = models.map((m, i) => {
+                m = this.merge(oldModels[i], m);
+                if (Repository.getMetadata(oldModels[i])) {
+                    if (!Repository.getMetadata(m))
+                        Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));
+                }
+                return m;
+            });
+            await Promise.all(models.map((m, i) => dbDecorators.enforceDBDecorators(this, contextArgs.context, m, dbDecorators.OperationKeys.UPDATE, dbDecorators.OperationKeys.ON, oldModels[i])));
+            const errors = models
+                .map((m, i) => m.hasErrors(oldModels[i], m))
+                .reduce((accum, e, i) => {
+                if (e)
+                    accum =
+                        typeof accum === "string"
+                            ? accum + `\n - ${i}: ${e.toString()}`
+                            : ` - ${i}: ${e.toString()}`;
+                return accum;
+            }, undefined);
+            if (errors)
+                throw new dbDecorators.ValidationError(errors);
+            models.forEach((m, i) => {
+                if (Repository.getMetadata(oldModels[i])) {
+                    if (!Repository.getMetadata(m))
+                        Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));
+                }
+            });
+            return [models, ...contextArgs.args];
+        }
+        async deletePrefix(key, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.DELETE, this.class, args, this.adapter);
+            const model = await this.read(key, ...contextArgs.args);
+            await dbDecorators.enforceDBDecorators(this, contextArgs.context, model, dbDecorators.OperationKeys.DELETE, dbDecorators.OperationKeys.ON);
+            return [key, ...contextArgs.args];
+        }
+        async delete(id, ...args) {
+            const m = await this.adapter.delete(this.tableName, id, ...args);
+            return this.adapter.revert(m, this.class, this.pk, id);
+        }
+        async deleteAllPrefix(keys, ...args) {
+            const contextArgs = await Context.args(dbDecorators.OperationKeys.DELETE, this.class, args, this.adapter);
+            const models = await this.readAll(keys, ...contextArgs.args);
+            await Promise.all(models.map(async (m) => {
+                return dbDecorators.enforceDBDecorators(this, contextArgs.context, m, dbDecorators.OperationKeys.DELETE, dbDecorators.OperationKeys.ON);
+            }));
+            return [keys, ...contextArgs.args];
+        }
+        async deleteAll(keys, ...args) {
+            const results = await this.adapter.deleteAll(this.tableName, keys, ...args);
+            return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+        }
+        select(selector) {
+            return new Query(this.adapter).select(selector).from(this.class);
+        }
+        async query(condition, orderBy, order = exports.OrderDirection.ASC, limit, skip) {
+            const sort = [orderBy, order];
+            const query = this.select().where(condition).orderBy(sort);
+            if (limit)
+                query.limit(limit);
+            if (skip)
+                query.offset(skip);
+            return query.execute();
+        }
+        /**
+         * @summary Registers an {@link Observer}
+         * @param {Observer} observer
+         *
+         * @see {Observable#observe}
+         */
+        observe(observer) {
+            const index = this.observers.indexOf(observer);
+            if (index !== -1)
+                throw new dbDecorators.InternalError("Observer already registered");
+            this.observers.push(observer);
+        }
+        /**
+         * @summary Unregisters an {@link Observer}
+         * @param {Observer} observer
+         *
+         * @see {Observable#unObserve}
+         */
+        unObserve(observer) {
+            const index = this.observers.indexOf(observer);
+            if (index === -1)
+                throw new dbDecorators.InternalError("Failed to find Observer");
+            this.observers.splice(index, 1);
+        }
+        /**
+         * @summary calls all registered {@link Observer}s to update themselves
+         * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method
+         */
+        async updateObservers(...args) {
+            const results = await Promise.allSettled(this.observers.map((o) => o.refresh(...args)));
+            results.forEach((result, i) => {
+                if (result.status === "rejected")
+                    console.warn(`Failed to update observable ${this.observers[i]}: ${result.reason}`);
+            });
+        }
+        static forModel(model, defaultFlavour) {
+            let repo;
+            try {
+                repo = this.get(model);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                repo = undefined;
+            }
+            if (repo instanceof Repository)
+                return repo;
+            const flavour = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), model) ||
+                (repo &&
+                    Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), repo)) ||
+                defaultFlavour;
+            const adapter = flavour
+                ? Adapter.get(flavour)
+                : undefined;
+            if (!adapter)
+                throw new dbDecorators.InternalError(`No registered persistence adapter found flavour ${flavour}`);
+            repo = repo || adapter.repository();
+            return new repo(adapter, model);
+        }
+        static get(model) {
+            const name = Repository.table(model);
+            if (name in this._cache)
+                return this._cache[name];
+            throw new dbDecorators.InternalError(`Could not find repository registered under ${name}`);
+        }
+        static register(model, repo) {
+            const name = Repository.table(model);
+            if (name in this._cache)
+                throw new dbDecorators.InternalError(`${name} already registered as a repository`);
+            this._cache[name] = repo;
+        }
+        static setMetadata(model, metadata) {
+            Object.defineProperty(model, exports.PersistenceKeys.METADATA, {
+                enumerable: false,
+                configurable: true,
+                writable: false,
+                value: metadata,
+            });
+        }
+        static getMetadata(model) {
+            const descriptor = Object.getOwnPropertyDescriptor(model, exports.PersistenceKeys.METADATA);
+            return descriptor ? descriptor.value : undefined;
+        }
+        static removeMetadata(model) {
+            const descriptor = Object.getOwnPropertyDescriptor(model, exports.PersistenceKeys.METADATA);
+            if (descriptor)
+                delete model[exports.PersistenceKeys.METADATA];
+        }
+        static getSequenceOptions(model) {
+            const pk = dbDecorators.findPrimaryKey(model).id;
+            const metadata = Reflect.getMetadata(Repository.key(dbDecorators.DBKeys.ID), model, pk);
+            if (!metadata)
+                throw new dbDecorators.InternalError("No sequence options defined for model. did you use the @pk decorator?");
+            return metadata;
+        }
+        static indexes(model) {
+            const indexDecorators = reflection.Reflection.getAllPropertyDecorators(model instanceof decoratorValidation.Model ? model : new model(), dbDecorators.DBKeys.REFLECT);
+            return Object.entries(indexDecorators || {}).reduce((accum, [k, val]) => {
+                const decs = val.filter((v) => v.key.startsWith(exports.PersistenceKeys.INDEX));
+                if (decs && decs.length) {
+                    for (const dec of decs) {
+                        const { key, props } = dec;
+                        accum[k] = accum[k] || {};
+                        accum[k][key] = props;
+                    }
+                }
+                return accum;
+            }, {});
+        }
+        static relations(model) {
+            const result = [];
+            let prototype = model instanceof decoratorValidation.Model
+                ? Object.getPrototypeOf(model)
+                : model.prototype;
+            while (prototype != null) {
+                const props = prototype[exports.PersistenceKeys.RELATIONS];
+                if (props) {
+                    result.push(...props);
+                }
+                prototype = Object.getPrototypeOf(prototype);
+            }
+            return result;
+        }
+        static table(model) {
+            return getTableName(model);
+        }
+        static column(model, attribute) {
+            const metadata = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.COLUMN), model, attribute);
+            return metadata ? metadata : attribute;
+        }
+    }
+
+    function repository(model, nameOverride) {
+        return ((original, propertyKey) => {
+            if (propertyKey) {
+                return injectableDecorators.inject(nameOverride || model.name)(original, propertyKey);
+            }
+            reflection.metadata(Repository.key(dbDecorators.DBKeys.REPOSITORY), nameOverride || original.name)(model);
+            Repository.register(model, original);
+            return injectableDecorators.injectable(nameOverride || original.name, true, (instance) => {
+                Object.defineProperty(instance, dbDecorators.DBKeys.CLASS, {
+                    enumerable: false,
+                    configurable: false,
+                    writable: false,
+                    value: model,
+                });
+            })(original);
+        });
+    }
+
+    /**
+     * @summary Represents a failure in observer communication
+     *
+     * @param {string} msg the error message
+     *
+     * @class ObserverError
+     * @extends BaseError
+     */
+    class ObserverError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(ObserverError.name, msg);
+        }
+    }
+
+    function generateInjectableNameForRepository(model, flavour) {
+        if (!flavour) {
+            const key = Adapter.key(exports.PersistenceKeys.ADAPTER);
+            flavour = Reflect.getMetadata(key, model instanceof decoratorValidation.Model ? model.constructor : model);
+            if (!flavour)
+                throw new dbDecorators.InternalError(`Could not retrieve flavour from model ${model instanceof decoratorValidation.Model ? model.constructor.name : model.name}`);
+        }
+        return decoratorValidation.sf(exports.PersistenceKeys.INJECTABLE, flavour, Repository.table(model));
+    }
+
+    class InjectablesRegistry extends injectableDecorators.InjectableRegistryImp {
+        constructor() {
+            super();
+        }
+        get(name) {
+            let injectable = super.get(name);
+            if (!injectable)
+                try {
+                    const m = decoratorValidation.Model.get(name);
+                    if (m)
+                        injectable = Repository.forModel(m);
+                    if (injectable) {
+                        if (injectable instanceof Repository)
+                            return injectable;
+                        const flavour = Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), injectable.constructor) ||
+                            Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), m);
+                        injectableDecorators.Injectables.register(injectable, generateInjectableNameForRepository(m, flavour));
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    return undefined;
+                }
+            return injectable;
+        }
+    }
+
+    const DefaultSequenceOptions = {
+        type: "Number",
+        startWith: 0,
+        incrementBy: 1,
+        cycle: false,
+    };
+    const NumericSequence = {
+        type: "Number",
+        startWith: 0,
+        incrementBy: 1,
+        cycle: false,
+    };
+    const BigIntSequence = {
+        type: "BigInt",
+        startWith: 0,
+        incrementBy: 1,
+        cycle: false,
+    };
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    class QueryError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(QueryError.name, msg);
+        }
+    }
+    class PagingError extends dbDecorators.BaseError {
+        constructor(msg) {
+            super(PagingError.name, msg);
+        }
+    }
+
+    /**
+     * @summary Condition Class
+     * @description Represents a logical condition
+     *
+     * @param {string | Condition} attr1
+     * @param {Operator | GroupOperator} operator
+     * @param {string | Condition} comparison
+     *
+     * @class Condition
+     * @implements Executor
+     *
+     * @category Query
+     * @subcategory Conditions
+     */
+    class Condition extends decoratorValidation.Model {
+        constructor(attr1, operator, comparison) {
+            super();
+            this.attr1 = undefined;
+            this.operator = undefined;
+            this.comparison = undefined;
+            this.attr1 = attr1;
+            this.operator = operator;
+            this.comparison = comparison;
+        }
+        /**
+         * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+         * @param {Condition} condition
+         */
+        and(condition) {
+            return Condition.and(this, condition);
+        }
+        /**
+         * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+         * @param {Condition} condition
+         */
+        or(condition) {
+            return Condition.or(this, condition);
+        }
+        /**
+         * @summary excludes a valut from the result
+         * @param val
+         */
+        not(val) {
+            return new Condition(this, exports.Operator.NOT, val);
+        }
+        /**
+         * @inheritDoc
+         */
+        hasErrors(...exceptions) {
+            const errors = super.hasErrors(...exceptions);
+            if (errors)
+                return errors;
+            if (typeof this.attr1 === "string") {
+                if (this.comparison instanceof Condition)
+                    return {
+                        comparison: {
+                            condition: "Both sides of the comparison must be of the same type",
+                        },
+                    };
+                if (Object.values(exports.Operator).indexOf(this.operator) === -1)
+                    return {
+                        operator: {
+                            condition: decoratorValidation.sf("Invalid operator {0}", this.operator),
+                        },
+                    };
+            }
+            if (this.attr1 instanceof Condition) {
+                if (!(this.comparison instanceof Condition) &&
+                    this.operator !== exports.Operator.NOT)
+                    return {
+                        comparison: {
+                            condition: decoratorValidation.sf("Invalid operator {0}", this.operator),
+                        },
+                    };
+                if (Object.values(exports.GroupOperator).indexOf(this.operator) ===
+                    -1 &&
+                    this.operator !== exports.Operator.NOT)
+                    return {
+                        operator: {
+                            condition: decoratorValidation.sf("Invalid operator {0}", this.operator),
+                        },
+                    };
+                // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== "string")
+                //     return {
+                //         attr1: {
+                //             condition: stringFormat("Parent condition attribute must be a string")
+                //         }
+                //     } as ModelErrorDefinition
+            }
+        }
+        /**
+         * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+         * @param {Condition} condition1
+         * @param {Condition} condition2
+         */
+        static and(condition1, condition2) {
+            return Condition.group(condition1, exports.GroupOperator.AND, condition2);
+        }
+        /**
+         * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+         * @param {Condition} condition1
+         * @param {Condition} condition2
+         */
+        static or(condition1, condition2) {
+            return Condition.group(condition1, exports.GroupOperator.OR, condition2);
+        }
+        /**
+         * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
+         * @param {Condition} condition1
+         * @param {GroupOperator} operator
+         * @param {Condition} condition2
+         */
+        static group(condition1, operator, condition2) {
+            return new Condition(condition1, operator, condition2);
+        }
+        static attribute(attr) {
+            return new Condition.Builder().attribute(attr);
+        }
+        /**
+         * @summary Condition Builder Class
+         * @description provides a simple API to build {@link Condition}s
+         *
+         * @class ConditionBuilder
+         * @implements Builder
+         * @implements AttributeOption
+         *
+         * @category Query
+         * @subcategory Conditions
+         */
+        static { this.Builder = class ConditionBuilder {
+            constructor() {
+                this.attr1 = undefined;
+                this.operator = undefined;
+                this.comparison = undefined;
+            }
+            /**
+             * @inheritDoc
+             */
+            attribute(attr) {
+                this.attr1 = attr;
+                return this;
+            }
+            /**
+             * @summary Creates an Equality Comparison
+             * @param {any} val
+             */
+            eq(val) {
+                return this.setOp(exports.Operator.EQUAL, val);
+            }
+            /**
+             * @summary Creates a Different Comparison
+             * @param {any} val
+             */
+            dif(val) {
+                return this.setOp(exports.Operator.DIFFERENT, val);
+            }
+            /**
+             * @summary Creates a Greater Than Comparison
+             * @param {any} val
+             */
+            gt(val) {
+                return this.setOp(exports.Operator.BIGGER, val);
+            }
+            /**
+             * @summary Creates a Lower Than Comparison
+             * @param {any} val
+             */
+            lt(val) {
+                return this.setOp(exports.Operator.SMALLER, val);
+            }
+            /**
+             * @summary Creates a Greater or Equal to Comparison
+             * @param {any} val
+             */
+            gte(val) {
+                return this.setOp(exports.Operator.BIGGER_EQ, val);
+            }
+            /**
+             * @summary Creates a Lower or Equal to Comparison
+             * @param {any} val
+             */
+            lte(val) {
+                return this.setOp(exports.Operator.SMALLER_EQ, val);
+            }
+            in(arr) {
+                return this.setOp(exports.Operator.IN, arr);
+            }
+            /**
+             * @summary Creates a Regexpo Comparison
+             * @param {any} val
+             */
+            regexp(val) {
+                return this.setOp(exports.Operator.REGEXP, new RegExp(val).source);
+            }
+            /**
+             * @summary Creates an {@link Operator} based Comparison
+             * @param {Operator} op
+             * @param {any} val
+             */
+            setOp(op, val) {
+                this.operator = op;
+                this.comparison = val;
+                return this.build();
+            }
+            /**
+             * @summary Builds the Database Object
+             * @throws {QueryError} if it fails to build the {@link Condition}
+             * @private
+             */
+            build() {
+                try {
+                    return new Condition(this.attr1, this.operator, this.comparison);
+                }
+                catch (e) {
+                    throw new QueryError(e);
+                }
+            }
+        }; }
+        static get builder() {
+            return new Condition.Builder();
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", Object)
+    ], Condition.prototype, "attr1", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", String)
+    ], Condition.prototype, "operator", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", Object)
+    ], Condition.prototype, "comparison", void 0);
+
+    async function createOrUpdate(model, context, repository) {
+        if (!repository) {
+            const constructor = decoratorValidation.Model.get(model.constructor.name);
+            if (!constructor)
+                throw new dbDecorators.InternalError(`Could not find model ${model.constructor.name}`);
+            repository = Repository.forModel(constructor);
+        }
+        if (typeof model[repository.pk] === "undefined")
+            return repository.create(model, context);
+        else {
+            try {
+                return repository.update(model, context);
+            }
+            catch (e) {
+                if (!(e instanceof dbDecorators.NotFoundError))
+                    throw e;
+                return repository.create(model, context);
+            }
+        }
+    }
+    async function oneToOneOnCreate(context, data, key, model) {
+        const propertyValue = model[key];
+        if (!propertyValue)
+            return;
+        if (typeof propertyValue !== "object") {
+            const innerRepo = repositoryFromTypeMetadata(model, key);
+            const read = await innerRepo.read(propertyValue);
+            await cacheModelForPopulate(context, model, key, propertyValue, read);
+            model[key] = propertyValue;
+            return;
+        }
+        const constructor = decoratorValidation.Model.get(data.class);
+        if (!constructor)
+            throw new dbDecorators.InternalError(`Could not find model ${data.class}`);
+        const repo = Repository.forModel(constructor);
+        const created = await repo.create(propertyValue);
+        const pk = dbDecorators.findPrimaryKey(created).id;
+        await cacheModelForPopulate(context, model, key, created[pk], created);
+        model[key] = created[pk];
+    }
+    async function oneToOneOnUpdate(context, data, key, model) {
+        const propertyValue = model[key];
+        if (!propertyValue)
+            return;
+        if (data.cascade.update !== exports.Cascade.CASCADE)
+            return;
+        if (typeof propertyValue !== "object") {
+            const innerRepo = repositoryFromTypeMetadata(model, key);
+            const read = await innerRepo.read(propertyValue);
+            await cacheModelForPopulate(context, model, key, propertyValue, read);
+            model[key] = propertyValue;
+            return;
+        }
+        const updated = await createOrUpdate(model[key], context);
+        const pk = dbDecorators.findPrimaryKey(updated).id;
+        await cacheModelForPopulate(context, model, key, updated[pk], updated);
+        model[key] = updated[pk];
+    }
+    async function oneToOneOnDelete(context, data, key, model) {
+        const propertyValue = model[key];
+        if (!propertyValue)
+            return;
+        if (data.cascade.update !== exports.Cascade.CASCADE)
+            return;
+        const innerRepo = repositoryFromTypeMetadata(model, key);
+        let deleted;
+        if (!(propertyValue instanceof decoratorValidation.Model))
+            deleted = await innerRepo.delete(model[key], context);
+        else
+            deleted = await innerRepo.delete(model[key][innerRepo.pk], context);
+        await cacheModelForPopulate(context, model, key, deleted[innerRepo.pk], deleted);
+    }
+    async function oneToManyOnCreate(context, data, key, model) {
+        const propertyValues = model[key];
+        if (!propertyValues || !propertyValues.length)
+            return;
+        const arrayType = typeof propertyValues[0];
+        if (!propertyValues.every((item) => typeof item === arrayType))
+            throw new dbDecorators.InternalError(`Invalid operation. All elements of property ${key} must match the same type.`);
+        const uniqueValues = new Set([...propertyValues]);
+        if (arrayType !== "object") {
+            const repo = repositoryFromTypeMetadata(model, key);
+            for (const id of uniqueValues) {
+                const read = await repo.read(id);
+                await cacheModelForPopulate(context, model, key, id, read);
+            }
+            model[key] = [...uniqueValues];
+            return;
+        }
+        const pkName = dbDecorators.findPrimaryKey(propertyValues[0]).id;
+        const result = new Set();
+        for (const m of propertyValues) {
+            const record = await createOrUpdate(m, context);
+            await cacheModelForPopulate(context, model, key, record[pkName], record);
+            result.add(record[pkName]);
+        }
+        model[key] = [...result];
+    }
+    async function oneToManyOnUpdate(context, data, key, model) {
+        const { cascade } = data;
+        if (cascade.update !== exports.Cascade.CASCADE)
+            return;
+        return oneToManyOnCreate.call(this, context, data, key, model);
+    }
+    async function oneToManyOnDelete(context, data, key, model) {
+        if (data.cascade.delete !== exports.Cascade.CASCADE)
+            return;
+        const values = model[key];
+        if (!values || !values.length)
+            return;
+        const arrayType = typeof values[0];
+        const areAllSameType = values.every((item) => typeof item === arrayType);
+        if (!areAllSameType)
+            throw new dbDecorators.InternalError(`Invalid operation. All elements of property ${key} must match the same type.`);
+        const isInstantiated = arrayType === "object";
+        const repo = isInstantiated
+            ? Repository.forModel(values[0])
+            : repositoryFromTypeMetadata(model, key);
+        const uniqueValues = new Set([
+            ...(isInstantiated
+                ? values.map((v) => v[repo.pk])
+                : values),
+        ]);
+        for (const id of uniqueValues.values()) {
+            const deleted = await repo.delete(id, context);
+            await cacheModelForPopulate(context, model, key, id, deleted);
+        }
+        model[key] = [...uniqueValues];
+    }
+    function getPopulateKey(tableName, fieldName, id) {
+        return [exports.PersistenceKeys.POPULATE, tableName, fieldName, id].join(".");
+    }
+    async function cacheModelForPopulate(context, parentModel, propertyKey, pkValue, cacheValue) {
+        const cacheKey = getPopulateKey(parentModel.constructor.name, propertyKey, pkValue);
+        return context.put(cacheKey, cacheValue);
+    }
+    async function populate(context, data, key, model) {
+        if (!data.populate)
+            return;
+        const nested = model[key];
+        const isArr = Array.isArray(nested);
+        if (typeof nested === "undefined" || (isArr && nested.length === 0))
+            return;
+        async function fetchPopulateValues(c, model, propName, propKeyValues) {
+            let cacheKey;
+            let val;
+            const results = [];
+            for (const proKeyValue of propKeyValues) {
+                cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);
+                try {
+                    val = await c.get(cacheKey);
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    const repo = repositoryFromTypeMetadata(model, propName);
+                    if (!repo)
+                        throw new dbDecorators.InternalError("Could not find repo");
+                    val = await repo.read(proKeyValue);
+                }
+                results.push(val);
+            }
+            return results;
+        }
+        const res = await fetchPopulateValues(context, model, key, isArr ? nested : [nested]);
+        model[key] = isArr ? res : res[0];
+    }
+    const commomTypes = [
+        "array",
+        "string",
+        "number",
+        "boolean",
+        "symbol",
+        "function",
+        "object",
+        "undefined",
+        "null",
+        "bigint",
+    ];
+    function repositoryFromTypeMetadata(model, propertyKey) {
+        const types = Reflect.getMetadata(decoratorValidation.Validation.key(Array.isArray(model[propertyKey])
+            ? decoratorValidation.ValidationKeys.LIST
+            : decoratorValidation.ValidationKeys.TYPE), model, propertyKey);
+        const customTypes = Array.isArray(model[propertyKey])
+            ? types.clazz
+            : types.customTypes;
+        if (!types || !customTypes)
+            throw new dbDecorators.InternalError(`Failed to find types decorators for property ${propertyKey}`);
+        const allowedTypes = Array.isArray(customTypes)
+            ? [...customTypes]
+            : [customTypes];
+        const constructorName = allowedTypes.find((t) => !commomTypes.includes(`${t}`.toLowerCase()));
+        if (!constructorName)
+            throw new dbDecorators.InternalError(`Property key ${propertyKey} does not have a valid constructor type`);
+        const constructor = decoratorValidation.Model.get(constructorName);
+        if (!constructor)
+            throw new dbDecorators.InternalError(`No registered model found for ${constructorName}`);
+        return Repository.forModel(constructor);
+    }
+
+    function table(tableName) {
+        return reflection.metadata(Adapter.key(exports.PersistenceKeys.TABLE), tableName);
+    }
+    function column(columnName) {
+        return decoratorValidation.propMetadata(Adapter.key(exports.PersistenceKeys.COLUMN), columnName);
+    }
+    /**
+     * @summary Index Decorator
+     * @description properties decorated will the index in the
+     * DB for performance in queries
+     *
+     * @param {OrderDirection[]} [directions]
+     * @param {string[]} [compositions]
+     *
+     * @function index
+     */
+    function index(directions, compositions) {
+        return decoratorValidation.propMetadata(Repository.key(`${exports.PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(".")}` : ""}`), {
+            directions: directions,
+            compositions: compositions,
+        });
+    }
+    async function uniqueOnCreateUpdate(context, data, key, model) {
+        if (!model[key])
+            return;
+        const existing = await this.select()
+            .where(Condition.attribute(key).eq(model[key]))
+            .execute();
+        if (existing.length)
+            throw new dbDecorators.ConflictError(`model already exists with property ${key} equal to ${JSON.stringify(model[key], undefined, 2)}`);
+    }
+    /**
+     * @summary Unique Decorator
+     * @description Tags a property as unique.
+     *  No other elements in that table can have the same property value
+     *
+     * @function unique
+     *
+     * @memberOf module:wallet-db.Decorators
+     */
+    function unique() {
+        return reflection.apply(dbDecorators.onCreateUpdate(uniqueOnCreateUpdate), decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.UNIQUE), {}));
+    }
+    async function createdByOnCreateUpdate(context, data, key, model) {
+        const user = context.user;
+        if (!user)
+            throw new UnsupportedError("This adapter does not support user identification");
+        model[key] = user.id;
+    }
+    function createdBy() {
+        return reflection.apply(dbDecorators.onCreate(createdByOnCreateUpdate), decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.CREATED_BY), {}));
+    }
+    function updatedBy() {
+        return reflection.apply(dbDecorators.onCreateUpdate(createdByOnCreateUpdate), decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.CREATED_BY), {}));
+    }
+    /**
+     * @summary One To One relation Decorators
+     *
+     * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+     * @param {CascadeMetadata} [cascadeOptions]
+     * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
+     *
+     * @function onToOne
+     *
+     * @memberOf module:wallet-db.Decorators
+     *
+     * @see oneToMany
+     * @see manyToOne
+     */
+    function oneToOne(clazz, cascadeOptions = DefaultCascade, populate$1 = true) {
+        decoratorValidation.Model.register(clazz);
+        const metadata = {
+            class: clazz.name,
+            cascade: cascadeOptions,
+            populate: populate$1,
+        };
+        return reflection.apply(decoratorValidation.prop(exports.PersistenceKeys.RELATIONS), decoratorValidation.type([clazz.name, String.name, Number.name, BigInt.name]), dbDecorators.onCreate(oneToOneOnCreate, metadata), dbDecorators.onUpdate(oneToOneOnUpdate, metadata), dbDecorators.onDelete(oneToOneOnDelete, metadata), dbDecorators.afterAny(populate, metadata), decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.ONE_TO_ONE), metadata));
+    }
+    /**
+     * @summary One To Many relation Decorators
+     *
+     * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+     * @param {CascadeMetadata} [cascadeOptions]
+     *
+     * @function oneToMany
+     *
+     * @memberOf module:wallet-db.Decorators
+     *
+     * @see oneToOne
+     * @see manyToOne
+     */
+    function oneToMany(clazz, cascadeOptions = DefaultCascade, populate$1 = true) {
+        decoratorValidation.Model.register(clazz);
+        const metadata = {
+            class: clazz.name,
+            cascade: cascadeOptions,
+            populate: populate$1,
+        };
+        return reflection.apply(decoratorValidation.prop(exports.PersistenceKeys.RELATIONS), 
+        // @ts-expect-error purposeful override
+        decoratorValidation.list([clazz, String, Number, BigInt]), dbDecorators.onCreate(oneToManyOnCreate, metadata), dbDecorators.onUpdate(oneToManyOnUpdate, metadata), dbDecorators.onDelete(oneToManyOnDelete, metadata), dbDecorators.afterAny(populate, metadata), decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.ONE_TO_MANY), metadata));
+    }
+    /**
+     * @summary Many To One relation Decorators
+     *
+     * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
+     * @param {CascadeMetadata} [cascadeOptions]
+     *
+     * @function manyToOne
+     *
+     * @memberOf module:wallet-db.Decorators
+     *
+     * @see oneToMany
+     * @see oneToOne
+     */
+    function manyToOne(clazz, cascadeOptions = DefaultCascade, populate = true) {
+        decoratorValidation.Model.register(clazz);
+        const metadata = {
+            class: clazz.name,
+            cascade: cascadeOptions,
+            populate: populate,
+        };
+        return reflection.apply(decoratorValidation.prop(exports.PersistenceKeys.RELATIONS), decoratorValidation.type([clazz.name, String.name, Number.name, BigInt.name]), 
+        // onCreate(oneToManyOnCreate, metadata),
+        // onUpdate(oneToManyOnUpdate, metadata),
+        // onDelete(oneToManyOnDelete, metadata),
+        // afterAll(populate, metadata),
+        decoratorValidation.propMetadata(Repository.key(exports.PersistenceKeys.MANY_TO_ONE), metadata));
+    }
+
+    /**
+     * @summary Primary Key Decorator
+     * @description Marks the property as the {@link Model}s primary key.
+     *  Also marks the property as {@link unique} as {@required} and ensures the index is created properly according to the provided {@link Sequence}
+     *
+     *
+     *
+     * @function pk
+     *
+     * @memberOf module:wallet-db.Decorators
+     *
+     * @see unique
+     * @see required
+     * @see on
+     * @param data
+     * @param key
+     * @param model
+     */
+    async function pkOnCreate(context, data, key, model) {
+        if (!data.type || model[key]) {
+            return;
+        }
+        const setPrimaryKeyValue = function (target, propertyKey, value) {
+            Object.defineProperty(target, propertyKey, {
+                enumerable: true,
+                writable: false,
+                configurable: true,
+                value: value,
+            });
+        };
+        if (!data.name)
+            data.name = sequenceNameForModel(model, "pk");
+        let sequence;
+        try {
+            sequence = await this.adapter.Sequence(data);
+        }
+        catch (e) {
+            throw new dbDecorators.InternalError(`Failed to instantiate Sequence ${data.name}: ${e}`);
+        }
+        const next = await sequence.next();
+        setPrimaryKeyValue(model, key, next);
+    }
+    function pk(opts = DefaultSequenceOptions) {
+        opts = Object.assign({}, DefaultSequenceOptions, opts);
+        return reflection.apply(index([exports.OrderDirection.ASC, exports.OrderDirection.DSC]), decoratorValidation.required(), dbDecorators.readonly(), 
+        // type([String.name, Number.name, BigInt.name]),
+        decoratorValidation.propMetadata(Repository.key(dbDecorators.DBKeys.ID), opts), dbDecorators.onCreate(pkOnCreate, opts));
+    }
+
+    class BaseModel extends decoratorValidation.Model {
+        constructor(arg) {
+            super(arg);
+        }
+    }
+    __decorate([
+        dbDecorators.timestamp(dbDecorators.DBOperations.CREATE),
+        __metadata("design:type", Date)
+    ], BaseModel.prototype, "createdOn", void 0);
+    __decorate([
+        dbDecorators.timestamp(),
+        __metadata("design:type", Date)
+    ], BaseModel.prototype, "updatedOn", void 0);
+
+    exports.User = class User extends decoratorValidation.Model {
+        constructor(arg) {
+            super(arg);
+        }
+    };
+    __decorate([
+        pk(),
+        __metadata("design:type", String)
+    ], exports.User.prototype, "id", void 0);
+    __decorate([
+        decoratorValidation.list([String]),
+        __metadata("design:type", Array)
+    ], exports.User.prototype, "roles", void 0);
+    __decorate([
+        decoratorValidation.list([String]),
+        __metadata("design:type", Array)
+    ], exports.User.prototype, "affiliations", void 0);
+    exports.User = __decorate([
+        decoratorValidation.model(),
+        __metadata("design:paramtypes", [Object])
+    ], exports.User);
+
+    Object.defineProperty(decoratorValidation.DEFAULT_ERROR_MESSAGES, exports.PersistenceKeys.CLAUSE_SEQUENCE, {
+        value: "Invalid clause sequence: {0}",
+    });
+    Object.defineProperty(decoratorValidation.ValidationKeys, "CLAUSE_SEQUENCE", {
+        value: exports.PersistenceKeys.CLAUSE_SEQUENCE,
+    });
+    /**
+     *
+     * @param {string} [message]
+     *
+     * @function clauseSequence
+     *
+     * @category Decorators
+     * @subcategory Validation
+     */
+    function clauseSequence(message) {
+        return decoratorValidation.propMetadata(decoratorValidation.Validation.key(decoratorValidation.ValidationKeys.REQUIRED), {
+            message: message ||
+                decoratorValidation.DEFAULT_ERROR_MESSAGES[exports.PersistenceKeys.CLAUSE_SEQUENCE],
+        });
+    }
+
+    /**
+     * @summary Validates a {@link Sequence}'s {@link Clause}s
+     *
+     * @param {string} [message]
+     *
+     * @class ClauseSequenceValidator
+     * @extends Validator
+     *
+     * @category Validation
+     * @subcategory Validators
+     */
+    exports.ClauseSequenceValidator = class ClauseSequenceValidator extends decoratorValidation.Validator {
+        constructor(message = decoratorValidation.DEFAULT_ERROR_MESSAGES[exports.PersistenceKeys.CLAUSE_SEQUENCE]) {
+            super(message);
+        }
+        validateSequence(clauses, message) {
+            return MandatoryPriorities.every((p) => !!clauses.find((c) => c.getPriority() === p))
+                ? undefined
+                : this.getMessage(decoratorValidation.sf(message || this.message, "Missing required Clause Priorities"));
+        }
+        /**
+         * @summary Verifies the model for errors
+         * @param {string} value
+         * @param {ValidatorOptions} [options]
+         *
+         * @return Errors
+         *
+         * @override
+         *
+         * @see Validator
+         */
+        hasErrors(value, options) {
+            try {
+                if (!value ||
+                    !Array.isArray(value) ||
+                    !value.length ||
+                    !value.every((e) => e instanceof Clause))
+                    return this.getMessage(decoratorValidation.sf((options || {}).message || this.message, "No or invalid Clauses found"));
+                const clauses = value;
+                const clauseErrors = clauses.reduce((accum, c) => {
+                    const errs = c.hasErrors();
+                    if (errs)
+                        if (accum)
+                            accum += decoratorValidation.sf("\nClause {0}: {1}", c.constructor.name, errs.toString());
+                        else
+                            accum = decoratorValidation.sf("Clause {0}: {1}", c.constructor.name, errs.toString());
+                    return accum;
+                }, undefined);
+                if (clauseErrors)
+                    return this.getMessage(decoratorValidation.sf((options || {}).message || this.message, clauseErrors.toString()));
+                const verifyPriority = () => {
+                    const priorities = clauses.map((c) => c.getPriority());
+                    const allUnique = new Set(priorities).size === priorities.length;
+                    if (!allUnique)
+                        return "Not all clauses  have unique priorities";
+                    const sorted = priorities.sort((a, b) => {
+                        return b - a;
+                    });
+                    return reflection.isEqual(priorities, sorted)
+                        ? true
+                        : "Clauses  are not properly sorted";
+                };
+                const priorityCheck = verifyPriority();
+                if (priorityCheck !== true)
+                    return this.getMessage(decoratorValidation.sf((options || {}).message || this.message, "Invalid prioritization"));
+                const sequenceCheck = this.validateSequence(clauses, (options || {}).message);
+                if (sequenceCheck)
+                    return this.getMessage(decoratorValidation.sf((options || {}).message || this.message, "Invalid sequence"));
+            }
+            catch (e) {
+                throw new QueryError(decoratorValidation.sf("Failed to verify clause sequence {0}: {1}", value, e));
+            }
+        }
+    };
+    exports.ClauseSequenceValidator = __decorate([
+        decoratorValidation.validator(exports.PersistenceKeys.CLAUSE_SEQUENCE),
+        __metadata("design:paramtypes", [String])
+    ], exports.ClauseSequenceValidator);
+
+    /**
+     * @summary Statement Class
+     * @description holds all the clauses until they can be processed
+     *
+     * @param {ModelArg} [statement]
+     *
+     * @class Statement
+     * @extends Model
+     * @implements Executor
+     * @implements RawExecutor
+     *
+     * @category Query
+     */
+    class Statement extends decoratorValidation.Model {
+        constructor(db) {
+            super();
+            this.clauses = undefined;
+            this.target = undefined;
+            this.fullRecord = false;
+            this.type = undefined;
+            this.adapter = db;
+        }
+        build() {
+            if (!this.clauses)
+                throw new QueryError(decoratorValidation.sf("Failed to build Statement:\n{0}", "No Clauses"));
+            this.clauses.sort((c1, c2) => {
+                return c1.getPriority() - c2.getPriority();
+            });
+            const errors = this.hasErrors();
+            if (errors)
+                throw new QueryError(decoratorValidation.sf("Poorly built statement: {0}", errors.toString()));
+            let query;
+            try {
+                const iterator = function (clauses, previous = {}) {
+                    const c = clauses.shift();
+                    if (!c)
+                        return previous;
+                    const results = c.build(previous);
+                    return iterator(clauses, results);
+                };
+                query = iterator(new Array(...this.clauses));
+            }
+            catch (e) {
+                throw new QueryError(e);
+            }
+            return query;
+        }
+        /**
+         * @inheritDoc
+         */
+        async execute() {
+            try {
+                const query = this.build();
+                return this.raw(query);
+            }
+            catch (e) {
+                throw new dbDecorators.InternalError(e);
+            }
+        }
+        async raw(rawInput, ...args) {
+            const results = await this.adapter.raw(rawInput, true, ...args);
+            if (!this.fullRecord)
+                return results;
+            if (!this.target)
+                throw new dbDecorators.InternalError("No target defined in statement. should never happen");
+            const pkAttr = dbDecorators.findPrimaryKey(new this.target()).id;
+            const processor = function recordProcessor(r) {
+                const id = r[pkAttr];
+                return this.adapter.revert(r, this.target, pkAttr, id);
+            }.bind(this);
+            if (Array.isArray(results))
+                return results.map(processor);
+            return processor(results);
+        }
+        /**
+         * @inheritDoc
+         */
+        hasErrors(...exceptions) {
+            const errors = super.hasErrors(...exceptions);
+            if (errors)
+                return errors;
+            for (const i in this.clauses) {
+                const err = this.clauses[i].hasErrors();
+                if (err)
+                    return err;
+            }
+        }
+        /**
+         * @summary Adds a clause to the Statement
+         * @param {Clause} clause
+         */
+        addClause(clause) {
+            if (!this.clauses)
+                this.clauses = [];
+            const priority = clause.getPriority();
+            const currentPriority = this.clauses
+                .map((c, i) => ({ index: i, clause: c }))
+                .find((c) => c.clause.getPriority() === priority);
+            if (currentPriority) {
+                this.clauses[currentPriority.index] = clause;
+            }
+            this.clauses.push(clause);
+        }
+        getAdapter() {
+            return this.adapter;
+        }
+        /**
+         * @summary Defines the output class (when existing)
+         * @param {Constructor} clazz
+         */
+        setTarget(clazz) {
+            if (this.target)
+                throw new QueryError(decoratorValidation.sf("Output class already defined to {0}", this.target.name));
+            this.target = clazz;
+        }
+        getTarget() {
+            if (!this.target)
+                throw new dbDecorators.InternalError("No target defined for statement");
+            return this.target;
+        }
+        setFullRecord() {
+            this.fullRecord = true;
+        }
+        setMode(type) {
+            this.type = type;
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        decoratorValidation.minlength(MandatoryPriorities.length),
+        clauseSequence(),
+        __metadata("design:type", Array)
+    ], Statement.prototype, "clauses", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        decoratorValidation.type(["object"]),
+        __metadata("design:type", Adapter)
+    ], Statement.prototype, "adapter", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", Object)
+    ], Statement.prototype, "target", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", String)
+    ], Statement.prototype, "type", void 0);
+
+    /**
+     */
+    /**
+     * @summary Clause Class
+     * @description Represents a Clause in a {@link Statement}
+     *
+     * @typedef Q Represents que query object the persistence adapter uses
+     *
+     * @param {ModelArg<Clause<Q>>} [clause]
+     *
+     * @class Clause
+     * @extends Model
+     * @implements Executor
+     * @implements QueryBuilder
+     * @abstract
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class Clause extends decoratorValidation.Model {
+        constructor(clause) {
+            super();
+            this.priority = clause?.priority;
+            this.statement = clause?.statement;
+            if (!this.statement || !this.priority)
+                throw new QueryError("Missing statement or priority. Should be impossible");
+            this.statement.addClause(this);
+        }
+        get adapter() {
+            return this.statement.getAdapter();
+        }
+        get Clauses() {
+            return this.statement.getAdapter().Clauses;
+        }
+        /**
+         * @summary return the priority of the clause
+         * @see Priority
+         */
+        getPriority() {
+            return this.priority;
+        }
+        /**
+         * @inheritDoc
+         * @abstract
+         */
+        async execute() {
+            return this.statement.execute();
+        }
+        /**
+         * @inheritDoc
+         * @abstract
+         */
+        async paginate(size) {
+            return this.statement.paginate(size);
+        }
+        toString() {
+            return this.constructor.name;
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", Number)
+    ], Clause.prototype, "priority", void 0);
+    __decorate([
+        decoratorValidation.required(),
+        decoratorValidation.type("object"),
+        __metadata("design:type", Statement)
+    ], Clause.prototype, "statement", void 0);
+
+    /**
+     * @summary The base Selector based clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class SelectorBasedClause
+     * @extends Clause
+     * @abstract
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class SelectorBasedClause extends Clause {
+        constructor(clause) {
+            super(clause);
+            /**
+             * @summary Stores the selector
+             *
+             * @prop selector
+             * @protected
+             */
+            this.selector = undefined;
+            this.selector = clause.selector;
+        }
+        toString() {
+            return this.constructor.name + `[${this.selector}]`;
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", Object)
+    ], SelectorBasedClause.prototype, "selector", void 0);
+
+    /**
+     * @summary The FROM clause
+     *
+     * @param {ModelArg} [clause]
+     *
+     * @class FromClause
+     * @extends SelectorBasedClause
+     * @implements WhereOption
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class FromClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.FROM }));
+            this.selector =
+                typeof this.selector === "string"
+                    ? decoratorValidation.Model.get(this.selector)
+                    : this.selector;
+            if (!this.selector)
+                throw new QueryError(decoratorValidation.stringFormat("Could not find selector model: {0}"));
+            this.statement.setTarget(this.selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        where(condition) {
+            return this.Clauses.where(this.statement, condition);
+        }
+        /**
+         * @inheritDoc
+         */
+        orderBy(...selector) {
+            return this.Clauses.orderBy(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        groupBy(selector) {
+            return this.Clauses.groupBy(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        limit(selector) {
+            return this.Clauses.limit(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        offset(selector) {
+            return this.Clauses.offset(this.statement, selector);
+        }
+    }
+
+    /**
+     * @summary The GROUP BY clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class GroupByClause
+     * @extends SelectorBasedClause
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class GroupByClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.GROUP_BY }));
+        }
+    }
+
+    /**
+     * @summary The INSERT/INTO clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class FromClause
+     * @extends Clause
+     * @implements IntoOption
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class InsertClause extends Clause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.SELECT }));
+            this.table = undefined;
+        }
+        /**
+         * @inheritDoc
+         */
+        into(table) {
+            this.table = table.name; // TODO get mapped name
+            this.statement.setTarget(table);
+            return this;
+        }
+        /**
+         * @inheritDoc
+         */
+        values(...models) {
+            return this.Clauses.values(this.statement, models);
+        }
+        /**
+         * @inheritDoc
+         */
+        where(condition) {
+            return this.Clauses.where(this.statement, condition);
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        __metadata("design:type", String)
+    ], InsertClause.prototype, "table", void 0);
+
+    /**
+     * @summary Limit Clause
+     * @description Limits the results
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class LimitClause
+     * @extends SelectorBasedClause<T>
+     * @implements OffsetOption<T>
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class LimitClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.GROUP_BY }));
+        }
+        /**
+         * @inheritDoc
+         */
+        offset(selector) {
+            return this.Clauses.offset(this.statement, selector);
+        }
+    }
+
+    /**
+     * @summary The OFFSET clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class FromClause
+     * @extends SelectorBasedClause
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class OffsetClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.GROUP_BY }));
+        }
+    }
+
+    /**
+     * @summary The ORDER BY clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class OrderByClause
+     * @extends SelectorBasedClause
+     * @implements LimitOption
+     * @implements OffsetOption
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class OrderByClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.ORDER_BY }));
+        }
+        /**
+         * @inheritDoc
+         */
+        groupBy(selector) {
+            return this.Clauses.groupBy(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        limit(selector) {
+            return this.Clauses.limit(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        offset(selector) {
+            return this.Clauses.offset(this.statement, selector);
+        }
+    }
+
+    /**
+     * @summary The SELECT clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class SelectClause
+     * @extends SelectorBasedClause
+     * @implements SelectOption
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class SelectClause extends SelectorBasedClause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.SELECT }));
+            this.isDistinct = false;
+            this.isCount = false;
+            this.isMax = false;
+            this.isMin = false;
+            if (this.selector === exports.Const.FULL_RECORD)
+                this.statement.setFullRecord();
+            this.statement.setMode(exports.StatementType.QUERY);
+        }
+        /**
+         * @inheritDoc
+         */
+        distinct(selector) {
+            this.isDistinct = true;
+            this.selector = selector;
+            return this;
+        }
+        /**
+         * @inheritDoc
+         */
+        count(selector) {
+            this.selector = selector;
+            return this;
+        }
+        /**
+         * @inheritDoc
+         */
+        min(selector) {
+            this.selector = selector;
+            return this;
+        }
+        /**
+         * @inheritDoc
+         */
+        max(selector) {
+            this.selector = selector;
+            return this;
+        }
+        /**
+         * @inheritDoc
+         */
+        from(tableName) {
+            return this.Clauses.from(this.statement, tableName);
+        }
+    }
+
+    /**
+     * @summary The VALUES clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class ValuesClause
+     * @extends Clause
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class ValuesClause extends Clause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.FROM }));
+            this.models = undefined;
+            this.models = clause?.models;
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        decoratorValidation.type(Array.name),
+        __metadata("design:type", Array)
+    ], ValuesClause.prototype, "models", void 0);
+
+    /**
+     * @summary The WHERE clause
+     *
+     * @param {ClauseArg} [clause]
+     *
+     * @class WhereClause
+     * @extends Clause
+     * @implements OrderAndGroupOption
+     *
+     * @category Query
+     * @subcategory Clauses
+     */
+    class WhereClause extends Clause {
+        constructor(clause) {
+            super(Object.assign({}, clause, { priority: exports.Priority.WHERE }));
+            this.condition = undefined;
+            this.condition = clause?.condition;
+        }
+        /**
+         * @inheritDoc
+         */
+        orderBy(...selector) {
+            return this.Clauses.orderBy(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        groupBy(selector) {
+            return this.Clauses.groupBy(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        limit(selector) {
+            return this.Clauses.limit(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        offset(selector) {
+            return this.Clauses.offset(this.statement, selector);
+        }
+        /**
+         * @inheritDoc
+         */
+        hasErrors(...exceptions) {
+            const errors = super.hasErrors(...exceptions);
+            if (errors)
+                return errors;
+            return this.condition.hasErrors();
+        }
+    }
+    __decorate([
+        decoratorValidation.required(),
+        decoratorValidation.type("Condition"),
+        __metadata("design:type", Condition)
+    ], WhereClause.prototype, "condition", void 0);
+
+    class ClauseFactory {
+        constructor(adapter) {
+            this.adapter = adapter;
+        }
+    }
+
+    class Paginator {
+        get current() {
+            return this._currentPage;
+        }
+        get total() {
+            return this._totalPages;
+        }
+        get count() {
+            return this._recordCount;
+        }
+        get statement() {
+            if (!this._statement)
+                this._statement = this.prepare(this._rawStatement);
+            return this._statement;
+        }
+        get adapter() {
+            return this.stat.getAdapter();
+        }
+        constructor(stat, size, _rawStatement) {
+            this.stat = stat;
+            this.size = size;
+            this._rawStatement = _rawStatement;
+        }
+        async next() {
+            return this.page(this.current + 1);
+        }
+        async previous() {
+            return this.page(this.current - 1);
+        }
+        validatePage(page) {
+            if (page < 1 || !Number.isInteger(page))
+                throw new PagingError("page number cannot be under 1 and must be an integer");
+            if (page > this._totalPages)
+                throw new PagingError("page number cannot be under 1 and must be an integer");
+        }
+    }
+
+    injectableDecorators.Injectables.setRegistry(new InjectablesRegistry());
+    /**
+     * @summary stores the current package version
+     * @description this is how you should document a constant
+     * @const VERSION
+     * @memberOf module:ts-workspace
+     */
+    const VERSION = "0.4.1";
+
+    exports.Adapter = Adapter;
+    exports.BaseModel = BaseModel;
+    exports.BigIntSequence = BigIntSequence;
+    exports.Clause = Clause;
+    exports.ClauseFactory = ClauseFactory;
+    exports.Condition = Condition;
+    exports.ConnectionError = ConnectionError;
+    exports.Context = Context;
+    exports.DefaultCascade = DefaultCascade;
+    exports.DefaultSequenceOptions = DefaultSequenceOptions;
+    exports.FromClause = FromClause;
+    exports.GroupByClause = GroupByClause;
+    exports.InjectablesRegistry = InjectablesRegistry;
+    exports.InsertClause = InsertClause;
+    exports.LimitClause = LimitClause;
+    exports.MandatoryPriorities = MandatoryPriorities;
+    exports.NumericSequence = NumericSequence;
+    exports.ObserverError = ObserverError;
+    exports.OffsetClause = OffsetClause;
+    exports.OrderByClause = OrderByClause;
+    exports.Paginator = Paginator;
+    exports.PagingError = PagingError;
+    exports.Query = Query;
+    exports.QueryError = QueryError;
+    exports.Repository = Repository;
+    exports.SelectClause = SelectClause;
+    exports.SelectorBasedClause = SelectorBasedClause;
+    exports.Sequence = Sequence;
+    exports.Statement = Statement;
+    exports.UnsupportedError = UnsupportedError;
+    exports.VERSION = VERSION;
+    exports.ValuesClause = ValuesClause;
+    exports.WhereClause = WhereClause;
+    exports.clauseSequence = clauseSequence;
+    exports.column = column;
+    exports.createdBy = createdBy;
+    exports.createdByOnCreateUpdate = createdByOnCreateUpdate;
+    exports.generateInjectableNameForRepository = generateInjectableNameForRepository;
+    exports.getTableName = getTableName;
+    exports.index = index;
+    exports.manyToOne = manyToOne;
+    exports.oneToMany = oneToMany;
+    exports.oneToOne = oneToOne;
+    exports.pk = pk;
+    exports.pkOnCreate = pkOnCreate;
+    exports.repository = repository;
+    exports.sequenceNameForModel = sequenceNameForModel;
+    exports.table = table;
+    exports.unique = unique;
+    exports.uniqueOnCreateUpdate = uniqueOnCreateUpdate;
+    exports.updatedBy = updatedBy;
+    exports.uses = uses;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.cjs","sources":["../src/repository/constants.ts","../src/repository/Context.ts","../src/persistence/constants.ts","../src/query/constants.ts","../src/query/Query.ts","../src/persistence/errors.ts","../src/persistence/Adapter.ts","../src/identity/utils.ts","../src/persistence/Sequence.ts","../src/persistence/decorators.ts","../src/repository/Repository.ts","../src/repository/decorators.ts","../src/repository/errors.ts","../src/repository/utils.ts","../src/repository/injectables.ts","../src/interfaces/SequenceOptions.ts","../node_modules/tslib/tslib.es6.js","../src/query/errors.ts","../src/query/Condition.ts","../src/model/construction.ts","../src/model/decorators.ts","../src/identity/decorators.ts","../src/model/BaseModel.ts","../src/model/User.ts","../src/validators/decorators.ts","../src/validators/ClauseSequenceValidator.ts","../src/query/Statement.ts","../src/query/Clause.ts","../src/query/clauses/SelectorBasedClause.ts","../src/query/clauses/FromClause.ts","../src/query/clauses/GroupByClause.ts","../src/query/clauses/InsertClause.ts","../src/query/clauses/LimitClause.ts","../src/query/clauses/OffsetClause.ts","../src/query/clauses/OrderByClause.ts","../src/query/clauses/SelectClause.ts","../src/query/clauses/ValuesClause.ts","../src/query/clauses/WhereClause.ts","../src/query/ClauseFactory.ts","../src/query/Paginator.ts","../src/index.ts"],"sourcesContent":["import { CascadeMetadata } from \"./types\";\n\n/**\n * @summary defines order directions when sorting\n *\n * @constant OrderDirection\n *\n * @category Query\n */\nexport enum OrderDirection {\n  /**\n   * @summary Defines the sort order as ascending\n   * @prop ASC\n   */\n  ASC = \"asc\",\n  /**\n   * @summary Defines the sort order as descending\n   * @property {string} DSC\n   */\n  DSC = \"desc\",\n}\n\nexport enum Cascade {\n  CASCADE = \"cascade\",\n  NONE = \"none\",\n}\n\nexport const DefaultCascade: CascadeMetadata = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n};\n","import { Context as Ctx } from \"@decaf-ts/db-decorators\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { User } from \"../model\";\n\nexport abstract class Context<\n  M extends Model,\n  U extends User = User,\n> extends Ctx<M> {\n  protected _timestamp!: Date;\n\n  protected constructor(\n    operation: OperationKeys,\n    model?: Constructor<M>,\n    parent?: Context<any, any>\n  ) {\n    super(operation, model, parent);\n  }\n\n  override get timestamp() {\n    if (!this._timestamp) this._timestamp = new Date();\n    return this._timestamp;\n  }\n\n  abstract get user(): U | undefined;\n}\n","export enum PersistenceKeys {\n  INDEX = \"index\",\n  UNIQUE = \"unique\",\n  ADAPTER = \"adapter\",\n  INJECTABLE = \"decaf_{0}_adapter_for_{1}\",\n  TABLE = \"table\",\n  COLUMN = \"column\",\n  METADATA = \"__metadata\",\n  RELATIONS = \"__relations\",\n  CLAUSE_SEQUENCE = \"clause-sequence\",\n  // Ownership\n  CREATED_BY = \"ownership.created-by\",\n  UPDATED_BY = \"ownership.updated-by\",\n  // Relations\n  ONE_TO_ONE = \"relations.one-to-one\",\n  ONE_TO_MANY = \"relations.one-to-many\",\n  MANY_TO_ONE = \"relations.many-to-one\",\n  POPULATE = \"populate\",\n}\n\nexport enum Roles {\n  ADMIN = \"admin\",\n  WRITER = \"writer\",\n  READER = \"reader\",\n}\n","export enum Operator {\n  EQUAL = \"EQUAL\",\n  DIFFERENT = \"DIFFERENT\",\n  BIGGER = \"BIGGER\",\n  BIGGER_EQ = \"BIGGER_EQ\",\n  SMALLER = \"SMALLER\",\n  SMALLER_EQ = \"SMALLER_EQ\",\n  // BETWEEN = \"BETWEEN\",\n  NOT = \"NOT\",\n  IN = \"IN\",\n  // IS = \"IS\",\n  REGEXP = \"REGEXP\",\n}\n\nexport enum GroupOperator {\n  AND = \"AND\",\n  OR = \"OR\",\n}\n\nexport enum Const {\n  NULL = \"NULL\",\n  FULL_RECORD = \"*\",\n}\n\n/**\n * @summary Defines execution order of Clauses in statements as defined in SQL.\n *\n * @description sub priorities where defined to better organize clauses within statements, eg From and Join Clauses\n *\n * @const Priority\n *\n * @category Clauses\n * @subcategory Constants\n */\nexport enum Priority {\n  /**\n   * @summary Defines the priority for the FROM Clause\n   * @description From Clause in SELECT Statements.\n   * Values Clause in INSERT Statements\n   *\n   * @prop FROM\n   */\n  FROM = 1,\n  /**\n   * @summary Defines the priority for the JOIN Clause\n   *\n   * @property {number} JOIN\n   */\n  JOIN = 1.1,\n  /**\n   * Where Clause\n   */\n  WHERE = 2,\n  /**\n   * Group By Clause\n   */\n  GROUP_BY = 3,\n  /**\n   * Having Clause\n   */\n  HAVING = 4,\n  /**\n   * Select Clause in SELECT Statements\n   * Insert Clause in INSERT Statements\n   */\n  SELECT = 5,\n  /**\n   * Order By Clause\n   */\n  ORDER_BY = 6,\n  /**\n   * Limit Clause\n   */\n  LIMIT = 7,\n  /**\n   * Offset Clause\n   */\n  OFFSET = 7.1,\n}\n\nexport const MandatoryPriorities = [Priority.FROM, Priority.SELECT];\n\nexport enum StatementType {\n  QUERY = \"query\",\n  TRANSACTION = \"transaction\",\n}\n","import {\n  CountOption,\n  DistinctOption,\n  InsertOption,\n  MaxOption,\n  MinOption,\n  SelectOption,\n} from \"./options\";\nimport { SelectSelector } from \"./selectors\";\nimport { Adapter } from \"../persistence\";\nimport { Const } from \"./constants\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary Helper Class to build queries\n *\n * @param {Database} db\n *\n * @class Query\n *\n * @category Query\n */\nexport class Query<Q, M extends Model> {\n  constructor(private adapter: Adapter<any, Q>) {}\n\n  /**\n   * @summary Creates a Select Clause\n   * @param {SelectSelector} [selector]\n   */\n  select(selector: SelectSelector = Const.FULL_RECORD): SelectOption<M> {\n    return this.adapter.Clauses.select<M>(selector);\n  }\n  /**\n   * @summary Creates a Min Clause\n   * @param {SelectSelector} selector\n   */\n  min(selector: SelectSelector): MinOption<M> {\n    return this.select().min(selector);\n  }\n  /**\n   * @summary Creates a Max Clause\n   * @param {SelectSelector} selector\n   */\n  max(selector: SelectSelector): MaxOption<M> {\n    return this.select().max(selector);\n  }\n  /**\n   * @summary Creates a Distinct Clause\n   * @param {SelectSelector} selector\n   */\n  distinct(selector: SelectSelector): DistinctOption<M> {\n    return this.select().distinct(selector);\n  }\n  /**\n   * @summary Creates a Count Clause\n   * @param {SelectSelector} selector\n   */\n  count(selector?: SelectSelector): CountOption<M> {\n    return this.select().count(selector);\n  }\n\n  insert(): InsertOption<M> {\n    return this.adapter.Clauses.insert<M>();\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class ConnectionError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ConnectionError.name, msg);\n  }\n}\n\nexport class UnsupportedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(UnsupportedError.name, msg);\n  }\n}\n","import {\n  BaseError,\n  DBKeys,\n  InternalError,\n  NotFoundError,\n  Context,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Observer } from \"../interfaces/Observer\";\nimport {\n  Constructor,\n  Model,\n  ModelConstructor,\n  ModelRegistry,\n} from \"@decaf-ts/decorator-validation\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { RawExecutor } from \"../interfaces/RawExecutor\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Query } from \"../query/Query\";\nimport { Statement } from \"../query/Statement\";\nimport { ClauseFactory } from \"../query/ClauseFactory\";\nimport { Condition } from \"../query/Condition\";\nimport { Repository } from \"../repository/Repository\";\nimport { Sequence } from \"./Sequence\";\nimport { User } from \"../model/User\";\nimport { Context as Ctx } from \"../repository/Context\";\nimport { UnsupportedError } from \"./errors\";\n\n/**\n * @summary Abstract Decaf-ts Persistence Adapter Class\n * @description Offers the base implementation for all Adapter Classes\n * and manages them various registered {@link Adapter}s\n *\n * @typedef Y the underlying persistence object type\n * @typedef Q The query object the adapter uses\n *\n * @param {Y} native the underlying persistence object\n * @param {string} flavour the under witch the persistence adapter should be stored\n *\n * @class Adapter\n * @implements RawExecutor\n * @implements Observable\n */\nexport abstract class Adapter<Y, Q> implements RawExecutor<Q>, Observable {\n  private static _current: Adapter<any, any>;\n  private static _cache: Record<string, Adapter<any, any>> = {};\n\n  protected readonly _observers: Observer[] = [];\n  private readonly _native: Y;\n\n  get native() {\n    return this._native;\n  }\n\n  repository<M extends Model>(): Constructor<Repository<M, Q, Adapter<Y, Q>>> {\n    return Repository;\n  }\n\n  protected constructor(\n    native: Y,\n    readonly flavour: string\n  ) {\n    if (this.flavour in Adapter._cache)\n      throw new InternalError(\n        `Persistence adapter flavour ${this.flavour} already registered`\n      );\n    this._native = native;\n    Adapter._cache[this.flavour] = this;\n  }\n\n  Query<M extends Model>(): Query<Q, M> {\n    return new Query(this);\n  }\n\n  abstract parseCondition(condition: Condition): Q;\n\n  abstract get Statement(): Statement<Q>;\n\n  abstract get Clauses(): ClauseFactory<Y, Q>;\n\n  protected isReserved(attr: string) {\n    return !attr;\n  }\n\n  protected abstract parseError(err: Error): BaseError;\n\n  abstract initialize(...args: any[]): Promise<void>;\n\n  abstract Sequence(options: SequenceOptions): Promise<Sequence>;\n\n  protected abstract user(): Promise<User | undefined>;\n\n  async context<M extends Model, C extends Context<M>>(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    model: Constructor<M>\n  ): Promise<C> {\n    let user: User | undefined;\n    try {\n      user = await this.user();\n    } catch (e: any) {\n      if (!(e instanceof UnsupportedError)) throw e;\n    }\n\n    const c: C = new (class extends Ctx<M> {\n      constructor(\n        operation: OperationKeys,\n        model?: Constructor<M>,\n        parent?: Ctx<any, any>\n      ) {\n        super(operation, model, parent);\n      }\n\n      get user(): User | undefined {\n        if (!user)\n          throw new UnsupportedError(\n            \"Adapter does not support user identification\"\n          );\n        return user;\n      }\n    })(operation, model) as unknown as C;\n\n    return c;\n  }\n\n  prepare<M extends Model>(\n    model: M,\n    pk: string | number\n  ): {\n    record: Record<string, any>;\n    id: string;\n  } {\n    const result = Object.entries(model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        // if (key === pk) return accum;\n        const mappedProp = Repository.column(model, key);\n        if (this.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n    if ((model as any)[PersistenceKeys.METADATA])\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    return {\n      record: result,\n      id: (model as Record<string, any>)[pk],\n    };\n  }\n\n  revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: string,\n    id: string | number | bigint\n  ): M {\n    const ob: Record<string, any> = {};\n    ob[pk] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    const metadata = obj[PersistenceKeys.METADATA];\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      if (key === pk) return accum;\n      (accum as Record<string, any>)[key] = obj[Repository.column(accum, key)];\n      return accum;\n    }, m);\n    if (metadata)\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    return result;\n  }\n\n  abstract create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async createAll(\n    tableName: string,\n    id: (string | number)[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    return Promise.all(\n      id.map((i, count) => this.create(tableName, i, model[count], ...args))\n    );\n  }\n\n  abstract read(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async readAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    return Promise.all(id.map((i) => this.read(tableName, i, ...args)));\n  }\n\n  abstract update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async updateAll(\n    tableName: string,\n    id: string[] | number[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    return Promise.all(\n      id.map((i, count) => this.update(tableName, i, model[count], ...args))\n    );\n  }\n\n  abstract delete(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async deleteAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));\n  }\n\n  abstract raw<R>(rawInput: Q, process: boolean, ...args: any[]): Promise<R>;\n\n  /**\n   * @summary Registers an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#observe}\n   */\n  observe(observer: Observer): void {\n    const index = this._observers.indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this._observers.push(observer);\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  unObserve(observer: Observer): void {\n    const index = this._observers.indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this._observers.splice(index, 1);\n  }\n\n  /**\n   * @summary calls all registered {@link Observer}s to update themselves\n   * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method\n   */\n  async updateObservers(...args: any[]): Promise<void> {\n    const results = await Promise.allSettled(\n      this._observers.map((o) => o.refresh(...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        console.warn(\n          `Failed to update observable ${this._observers[i]}: ${result.reason}`\n        );\n    });\n  }\n\n  static get current() {\n    return this._current;\n  }\n\n  static get<Y, Q>(flavour: any): Adapter<Y, Q> | undefined {\n    if (flavour in this._cache) return this._cache[flavour];\n    throw new InternalError(`No Adapter registered under ${flavour}.`);\n  }\n\n  static setCurrent(flavour: string) {\n    const adapter = Adapter.get(flavour);\n    if (!adapter)\n      throw new NotFoundError(`No persistence flavour ${flavour} registered`);\n    this._current = adapter;\n  }\n\n  static key(key: string) {\n    return Repository.key(key);\n  }\n\n  static models<M extends Model>(flavour: string) {\n    try {\n      const registry = (Model as any).getRegistry() as ModelRegistry<any>;\n      const cache = (\n        registry as unknown as { cache: Record<string, ModelConstructor<any>> }\n      ).cache;\n      const managedModels: ModelConstructor<any>[] = Object.values(cache)\n        .map((m: ModelConstructor<M>) => {\n          let f = Reflect.getMetadata(\n            Adapter.key(PersistenceKeys.ADAPTER),\n            m as ModelConstructor<any>\n          );\n          if (f && f === flavour) return m;\n          if (!f) {\n            const repo = Reflect.getMetadata(\n              Repository.key(DBKeys.REPOSITORY),\n              m as ModelConstructor<any>\n            );\n            if (!repo) return;\n            const repository = Repository.forModel(m);\n\n            f = Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              repository\n            );\n            return f;\n          }\n        })\n        .filter((m) => !!m);\n      return managedModels;\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n}\n","import { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\n\nexport function getTableName<M extends Model>(model: M | Constructor<M>) {\n  const metadata = Reflect.getMetadata(\n    Adapter.key(PersistenceKeys.TABLE),\n    model instanceof Model ? model.constructor : model\n  );\n  if (metadata) {\n    return metadata;\n  }\n  if (model instanceof Model) {\n    return model.constructor.name;\n  }\n  return model.name;\n}\n\nexport function sequenceNameForModel<M extends Model>(\n  model: M | Constructor<M>,\n  ...args: string[]\n) {\n  return [getTableName(model), ...args].join(\"_\");\n}\n","/**\n * @summary Sequence\n *\n * @interface Sequence\n *\n * @category Sequences\n */\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { sequenceNameForModel } from \"../identity/utils\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\n\nexport abstract class Sequence {\n  protected constructor(protected readonly options: SequenceOptions) {}\n\n  /**\n   * @summary generates the next value in the sequence\n   *\n   * @method\n   */\n  abstract next(): Promise<string | number | bigint>;\n  abstract current(): Promise<string | number | bigint>;\n  abstract range(count: number): Promise<(number | string | bigint)[]>;\n\n  static pk<M extends Model>(model: M | Constructor<M>) {\n    return sequenceNameForModel(model, \"pk\");\n  }\n}\n","import { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Adapter } from \"./Adapter\";\n\nexport function uses(flavour: string) {\n  return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour));\n}\n","import {\n  DBKeys,\n  enforceDBDecorators,\n  findPrimaryKey,\n  InternalError,\n  IRepository,\n  OperationKeys,\n  Repository as Rep,\n  ValidationError,\n  wrapMethodWithContext,\n} from \"@decaf-ts/db-decorators\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { Observer } from \"../interfaces/Observer\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Query } from \"../query/Query\";\nimport { OrderDirection } from \"./constants\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { Queriable } from \"../interfaces/Queriable\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { IndexMetadata } from \"./types\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Condition } from \"../query/Condition\";\nimport { WhereOption } from \"../query/options\";\nimport { OrderBySelector, SelectSelector } from \"../query/selectors\";\nimport { getTableName } from \"../identity/utils\";\nimport { uses } from \"../persistence/decorators\";\nimport { Context } from \"./Context\";\n\nexport type Repo<\n  M extends Model,\n  Q = any,\n  A extends Adapter<any, Q> = Adapter<any, Q>,\n> = Repository<M, Q, A>;\n\nexport class Repository<M extends Model, Q, A extends Adapter<any, Q>>\n  extends Rep<M>\n  implements Observable, Queriable, IRepository<M>\n{\n  private static _cache: Record<\n    string,\n    Constructor<Repo<Model>> | Repo<Model>\n  > = {};\n\n  protected observers: Observer[] = [];\n\n  private readonly _adapter!: A;\n  private _tableName!: string;\n\n  protected get adapter(): A {\n    if (!this._adapter)\n      throw new InternalError(\n        `No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?`\n      );\n    return this._adapter;\n  }\n\n  protected get tableName() {\n    if (!this._tableName) this._tableName = Repository.table(this.class);\n    return this._tableName;\n  }\n\n  constructor(adapter?: A, clazz?: Constructor<M>) {\n    super(clazz);\n    if (adapter) this._adapter = adapter;\n    if (clazz) {\n      Repository.register(clazz, this);\n      if (adapter) {\n        const flavour = Reflect.getMetadata(\n          Adapter.key(PersistenceKeys.ADAPTER),\n          clazz\n        );\n        if (flavour && flavour !== adapter.flavour)\n          throw new InternalError(\"Incompatible flavours\");\n        uses(adapter.flavour)(clazz);\n      }\n    }\n    [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach(\n      (m) => {\n        const name = m.name;\n        wrapMethodWithContext(\n          this,\n          (this as any)[name + \"Prefix\"],\n          m,\n          (this as any)[name + \"Suffix\"]\n        );\n      }\n    );\n  }\n\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter\n    );\n    model = new this.class(model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n\n    const errors = model.hasErrors();\n    if (errors) throw new ValidationError(errors.toString());\n\n    return [model, ...contextArgs.args];\n  }\n\n  async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    return this.adapter.revert<M>(record, this.class, this.pk, id);\n  }\n\n  async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids as (string | number)[],\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  protected async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n    const opts = Repository.getSequenceOptions(models[0]);\n    let ids: (string | number | bigint | undefined)[] = [];\n    if (opts.type) {\n      if (!opts.name) opts.name = Sequence.pk(models[0]);\n      ids = await (await this.adapter.Sequence(opts)).range(models.length);\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        (m as Record<string, any>)[this.pk] = ids[i];\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) => m.hasErrors())\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  protected async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter\n    );\n    const model: M = new this.class();\n    (model as Record<string, any>)[this.pk] = key;\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  async read(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.read(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  protected async readAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter\n    );\n    await Promise.all(\n      keys.map(async (k) => {\n        const m = new this.class();\n        (m as Record<string, any>)[this.pk] = k;\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  async readAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const records = await this.adapter.readAll(this.tableName, keys, ...args);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert<M>(record, this.class, this.pk, id);\n  }\n\n  protected async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter\n    );\n    const pk = (model as Record<string, any>)[this.pk];\n    if (!pk)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk}`\n      );\n    const oldModel = await this.read(pk, ...contextArgs.args);\n    model = this.merge(oldModel, model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(\n      oldModel,\n      ...Repository.relations(this.class)\n    );\n    if (errors) throw new ValidationError(errors.toString());\n    if (Repository.getMetadata(oldModel)) {\n      if (!Repository.getMetadata(model))\n        Repository.setMetadata(model, Repository.getMetadata(oldModel));\n    }\n    return [model, ...contextArgs.args];\n  }\n\n  async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  protected async updateAllPrefix(models: M[], ...args: any[]): Promise<any[]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter\n    );\n    const ids = models.map((m) => {\n      const id = (m as Record<string, any>)[this.pk];\n      if (!id) throw new InternalError(\"missing id on update operation\");\n      return id;\n    });\n    const oldModels = await this.readAll(ids, ...contextArgs.args);\n    models = models.map((m, i) => {\n      m = this.merge(oldModels[i], m);\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n      return m;\n    });\n    await Promise.all(\n      models.map((m, i) =>\n        enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON,\n          oldModels[i]\n        )\n      )\n    );\n\n    const errors = models\n      .map((m, i) => m.hasErrors(oldModels[i], m))\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n\n    models.forEach((m, i) => {\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n    });\n    return [models, ...contextArgs.args];\n  }\n\n  protected async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter\n    );\n    const model = await this.read(key, ...contextArgs.args);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  async delete(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.delete(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  protected async deleteAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter\n    );\n    const models = await this.readAll(keys, ...contextArgs.args);\n    await Promise.all(\n      models.map(async (m) => {\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  async deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    const results = await this.adapter.deleteAll(this.tableName, keys, ...args);\n    return results.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  select(selector?: SelectSelector): WhereOption {\n    return new Query<Q, M>(this.adapter).select(selector).from(this.class);\n  }\n\n  async query<V>(\n    condition: Condition,\n    orderBy: string,\n    order: OrderDirection = OrderDirection.ASC,\n    limit?: number,\n    skip?: number\n  ): Promise<V> {\n    const sort: OrderBySelector = [orderBy as string, order as OrderDirection];\n    const query = this.select().where(condition).orderBy(sort);\n    if (limit) query.limit(limit);\n    if (skip) query.offset(skip);\n    return query.execute<V>();\n  }\n\n  /**\n   * @summary Registers an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#observe}\n   */\n  observe(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this.observers.push(observer);\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  unObserve(observer: Observer): void {\n    const index = this.observers.indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this.observers.splice(index, 1);\n  }\n\n  /**\n   * @summary calls all registered {@link Observer}s to update themselves\n   * @param {any[]} [args] optional arguments to be passed to the {@link Observer#refresh} method\n   */\n  async updateObservers(...args: any[]): Promise<void> {\n    const results = await Promise.allSettled(\n      this.observers.map((o) => o.refresh(...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        console.warn(\n          `Failed to update observable ${this.observers[i]}: ${result.reason}`\n        );\n    });\n  }\n\n  static forModel<M extends Model, R extends Repo<M>>(\n    model: Constructor<M>,\n    defaultFlavour?: string\n  ): R {\n    let repo: R | Constructor<R> | undefined;\n    try {\n      repo = this.get(model) as Constructor<R> | R;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      repo = undefined;\n    }\n\n    if (repo instanceof Repository) return repo as R;\n\n    const flavour: string | undefined =\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||\n      (repo &&\n        Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repo)) ||\n      defaultFlavour;\n    const adapter: Adapter<any, any> | undefined = flavour\n      ? Adapter.get(flavour)\n      : undefined;\n\n    if (!adapter)\n      throw new InternalError(\n        `No registered persistence adapter found flavour ${flavour}`\n      );\n\n    repo = repo || (adapter.repository() as Constructor<R>);\n    return new repo(adapter, model) as R;\n  }\n\n  private static get<M extends Model>(\n    model: Constructor<M>\n  ): Constructor<Repo<M>> | Repo<M> {\n    const name = Repository.table(model);\n    if (name in this._cache)\n      return this._cache[name] as Constructor<Repo<M>> | Repo<M>;\n    throw new InternalError(\n      `Could not find repository registered under ${name}`\n    );\n  }\n\n  static register<M extends Model>(\n    model: Constructor<M>,\n    repo: Constructor<Repo<M>> | Repo<M>\n  ) {\n    const name = Repository.table(model);\n    if (name in this._cache)\n      throw new InternalError(`${name} already registered as a repository`);\n    this._cache[name] = repo;\n  }\n\n  static setMetadata<M extends Model>(model: M, metadata: any) {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: true,\n      writable: false,\n      value: metadata,\n    });\n  }\n\n  static getMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    return descriptor ? descriptor.value : undefined;\n  }\n\n  static removeMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    if (descriptor) delete (model as any)[PersistenceKeys.METADATA];\n  }\n\n  static getSequenceOptions<M extends Model>(model: M) {\n    const pk = findPrimaryKey(model).id;\n    const metadata = Reflect.getMetadata(Repository.key(DBKeys.ID), model, pk);\n    if (!metadata)\n      throw new InternalError(\n        \"No sequence options defined for model. did you use the @pk decorator?\"\n      );\n    return metadata as SequenceOptions;\n  }\n\n  static indexes<M extends Model>(model: M | Constructor<M>) {\n    const indexDecorators = Reflection.getAllPropertyDecorators(\n      model instanceof Model ? model : new model(),\n      DBKeys.REFLECT\n    );\n    return Object.entries(indexDecorators || {}).reduce(\n      (accum: Record<string, Record<string, IndexMetadata>>, [k, val]) => {\n        const decs = val.filter((v) => v.key.startsWith(PersistenceKeys.INDEX));\n        if (decs && decs.length) {\n          for (const dec of decs) {\n            const { key, props } = dec;\n            accum[k] = accum[k] || {};\n            accum[k][key] = props as IndexMetadata;\n          }\n        }\n        return accum;\n      },\n      {}\n    );\n  }\n\n  static relations<M extends Model>(model: M | Constructor<M>) {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[PersistenceKeys.RELATIONS];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  static table<M extends Model>(model: M | Constructor<M>) {\n    return getTableName(model);\n  }\n\n  static column<M extends Model>(model: M, attribute: string) {\n    const metadata = Reflect.getMetadata(\n      Adapter.key(PersistenceKeys.COLUMN),\n      model,\n      attribute\n    );\n    return metadata ? metadata : attribute;\n  }\n}\n","import { inject, injectable } from \"@decaf-ts/injectable-decorators\";\nimport { DBKeys, IRepository } from \"@decaf-ts/db-decorators\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\nexport function repository<T extends Model>(\n  model: Constructor<T>,\n  nameOverride?: string\n): any {\n  return ((original: any, propertyKey?: any) => {\n    if (propertyKey) {\n      return inject(nameOverride || model.name)(original, propertyKey);\n    }\n\n    metadata(\n      Repository.key(DBKeys.REPOSITORY),\n      nameOverride || original.name\n    )(model);\n    Repository.register(model, original);\n    return injectable(\n      nameOverride || original.name,\n      true,\n      (instance: IRepository<T>) => {\n        Object.defineProperty(instance, DBKeys.CLASS, {\n          enumerable: false,\n          configurable: false,\n          writable: false,\n          value: model,\n        });\n      }\n    )(original);\n  }) as any;\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @summary Represents a failure in observer communication\n *\n * @param {string} msg the error message\n *\n * @class ObserverError\n * @extends BaseError\n */\nexport class ObserverError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ObserverError.name, msg);\n  }\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Constructor, sf } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\nexport function generateInjectableNameForRepository<T extends Model>(\n  model: Constructor<T> | T,\n  flavour?: string\n) {\n  if (!flavour) {\n    const key = Adapter.key(PersistenceKeys.ADAPTER);\n    flavour = Reflect.getMetadata(\n      key,\n      model instanceof Model ? model.constructor : model\n    );\n    if (!flavour)\n      throw new InternalError(\n        `Could not retrieve flavour from model ${model instanceof Model ? model.constructor.name : model.name}`\n      );\n  }\n  return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));\n}\n","import {\n  InjectableRegistryImp,\n  Injectables,\n} from \"@decaf-ts/injectable-decorators\";\nimport { Repository } from \"./Repository\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { generateInjectableNameForRepository } from \"./utils\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Adapter } from \"../persistence/Adapter\";\n\nexport class InjectablesRegistry extends InjectableRegistryImp {\n  constructor() {\n    super();\n  }\n\n  get<T>(name: string): T | undefined {\n    let injectable = super.get(name);\n    if (!injectable)\n      try {\n        const m = Model.get(name);\n        if (m) injectable = Repository.forModel(m);\n        if (injectable) {\n          if (injectable instanceof Repository) return injectable as T;\n          const flavour =\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              injectable.constructor\n            ) ||\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              m as ModelConstructor<any>\n            );\n          Injectables.register(\n            injectable,\n            generateInjectableNameForRepository(\n              m as ModelConstructor<any>,\n              flavour\n            )\n          );\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        return undefined;\n      }\n    return injectable as T | undefined;\n  }\n}\n","/**\n * @typedef SequenceOptions\n *\n * @prop {string | number} [startingValue] defines the starting value when sequence doest not exist\n *\n * @category Sequences\n */\nexport interface SequenceOptions {\n  name?: string;\n  type: \"Number\" | \"BigInt\" | undefined;\n  startWith: number;\n  incrementBy: number;\n  minValue?: number;\n  maxValue?: number;\n  cycle: boolean;\n}\n\nexport const DefaultSequenceOptions: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\nexport const NumericSequence: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\nexport const BigIntSequence: SequenceOptions = {\n  type: \"BigInt\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class QueryError extends BaseError {\n  constructor(msg: string | Error) {\n    super(QueryError.name, msg);\n  }\n}\n\nexport class PagingError extends BaseError {\n  constructor(msg: string | Error) {\n    super(PagingError.name, msg);\n  }\n}\n","import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @summary Condition Class\n * @description Represents a logical condition\n *\n * @param {string | Condition} attr1\n * @param {Operator | GroupOperator} operator\n * @param {string | Condition} comparison\n *\n * @class Condition\n * @implements Executor\n *\n * @category Query\n * @subcategory Conditions\n */\n\nexport class Condition extends Model {\n  @required()\n  protected attr1?: string | Condition = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition\n   */\n  and(condition: Condition): Condition {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition\n   */\n  or(condition: Condition): Condition {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @summary excludes a valut from the result\n   * @param val\n   */\n  not(val: any): Condition {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: sf(\"Invalid operator {0}\", this.operator as string),\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static and(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static or(condition1: Condition, condition2: Condition): Condition {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}\n   * @param {Condition} condition1\n   * @param {GroupOperator} operator\n   * @param {Condition} condition2\n   */\n  private static group(\n    condition1: Condition,\n    operator: GroupOperator,\n    condition2: Condition\n  ): Condition {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  static attribute(attr: string) {\n    return new Condition.Builder().attribute(attr);\n  }\n\n  /**\n   * @summary Condition Builder Class\n   * @description provides a simple API to build {@link Condition}s\n   *\n   * @class ConditionBuilder\n   * @implements Builder\n   * @implements AttributeOption\n   *\n   * @category Query\n   * @subcategory Conditions\n   */\n  private static Builder = class ConditionBuilder\n    implements ConditionBuilderOption, AttributeOption\n  {\n    attr1?: string | Condition = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @inheritDoc\n     */\n    attribute(attr: string): AttributeOption {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @summary Creates an Equality Comparison\n     * @param {any} val\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @summary Creates a Different Comparison\n     * @param {any} val\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @summary Creates a Greater Than Comparison\n     * @param {any} val\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @summary Creates a Lower Than Comparison\n     * @param {any} val\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @summary Creates a Greater or Equal to Comparison\n     * @param {any} val\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @summary Creates a Lower or Equal to Comparison\n     * @param {any} val\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @summary Creates a Regexpo Comparison\n     * @param {any} val\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @summary Creates an {@link Operator} based Comparison\n     * @param {Operator} op\n     * @param {any} val\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @summary Builds the Database Object\n     * @throws {QueryError} if it fails to build the {@link Condition}\n     * @private\n     */\n    private build(): Condition {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  static get builder(): ConditionBuilderOption {\n    return new Condition.Builder();\n  }\n}\n","import {\n  Constructor,\n  Model,\n  Validation,\n  ValidationKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Cascade } from \"../repository/constants\";\nimport { Context } from \"@decaf-ts/db-decorators\";\n\nexport async function createOrUpdate<M extends Model>(\n  model: M,\n  context: Context<M>,\n  repository?: Repo<M>\n): Promise<M> {\n  if (!repository) {\n    const constructor = Model.get(model.constructor.name);\n    if (!constructor)\n      throw new InternalError(`Could not find model ${model.constructor.name}`);\n    repository = Repository.forModel(constructor) as Repo<M>;\n  }\n  if (typeof (model as Record<string, any>)[repository.pk] === \"undefined\")\n    return repository.create(model, context);\n  else {\n    try {\n      return repository.update(model, context);\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      return repository.create(model, context);\n    }\n  }\n}\n\nexport async function oneToOneOnCreate<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const propertyValue: any = (model as Record<string, any>)[key];\n  if (!propertyValue) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as Record<string, any>)[key] = propertyValue;\n    return;\n  }\n\n  const constructor = Model.get(data.class);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor);\n  const created = await repo.create(propertyValue);\n  const pk = findPrimaryKey(created).id;\n  await cacheModelForPopulate(context, model, key, created[pk], created);\n  (model as any)[key] = created[pk];\n}\n\nexport async function oneToOneOnUpdate<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const propertyValue: any = (model as Record<string, any>)[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as Record<string, any>)[key] = propertyValue;\n    return;\n  }\n\n  const updated = await createOrUpdate(\n    (model as Record<string, any>)[key],\n    context\n  );\n  const pk = findPrimaryKey(updated).id;\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    (updated as Record<string, any>)[pk],\n    updated\n  );\n  (model as any)[key] = (updated as Record<string, any>)[pk];\n}\n\nexport async function oneToOneOnDelete<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const propertyValue: any = (model as Record<string, any>)[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n  const innerRepo: Repo<M> = repositoryFromTypeMetadata(model, key);\n  let deleted: M;\n  if (!(propertyValue instanceof Model))\n    deleted = await innerRepo.delete(\n      (model as Record<string, any>)[key],\n      context\n    );\n  else\n    deleted = await innerRepo.delete(\n      (model as Record<string, any>)[key][innerRepo.pk],\n      context\n    );\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    (deleted as Record<string, any>)[innerRepo.pk],\n    deleted\n  );\n}\n\nexport async function oneToManyOnCreate<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const propertyValues: any = (model as Record<string, any>)[key];\n  if (!propertyValues || !propertyValues.length) return;\n  const arrayType = typeof propertyValues[0];\n  if (!propertyValues.every((item: any) => typeof item === arrayType))\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key} must match the same type.`\n    );\n  const uniqueValues = new Set([...propertyValues]);\n  if (arrayType !== \"object\") {\n    const repo = repositoryFromTypeMetadata(model, key);\n    for (const id of uniqueValues) {\n      const read = await repo.read(id);\n      await cacheModelForPopulate(context, model, key, id, read);\n    }\n    (model as any)[key] = [...uniqueValues];\n    return;\n  }\n\n  const pkName = findPrimaryKey(propertyValues[0]).id;\n\n  const result: Set<string> = new Set();\n\n  for (const m of propertyValues) {\n    const record = await createOrUpdate(m, context);\n    await cacheModelForPopulate(context, model, key, record[pkName], record);\n    result.add(record[pkName]);\n  }\n\n  (model as any)[key] = [...result];\n}\n\nexport async function oneToManyOnUpdate<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const { cascade } = data;\n  if (cascade.update !== Cascade.CASCADE) return;\n  return oneToManyOnCreate.call(this, context, data, key, model);\n}\n\nexport async function oneToManyOnDelete<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  if (data.cascade.delete !== Cascade.CASCADE) return;\n  const values = (model as Record<string, any>)[key];\n  if (!values || !values.length) return;\n  const arrayType = typeof values[0];\n  const areAllSameType = values.every((item: any) => typeof item === arrayType);\n  if (!areAllSameType)\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key} must match the same type.`\n    );\n  const isInstantiated = arrayType === \"object\";\n  const repo = isInstantiated\n    ? Repository.forModel(values[0])\n    : repositoryFromTypeMetadata(model, key);\n\n  const uniqueValues = new Set([\n    ...(isInstantiated\n      ? values.map((v: Record<string, any>) => v[repo.pk])\n      : values),\n  ]);\n\n  for (const id of uniqueValues.values()) {\n    const deleted = await repo.delete(id, context);\n    await cacheModelForPopulate(context, model, key, id, deleted);\n  }\n  (model as any)[key] = [...uniqueValues];\n}\n\nexport function getPopulateKey(\n  tableName: string,\n  fieldName: string,\n  id: string | number\n) {\n  return [PersistenceKeys.POPULATE, tableName, fieldName, id].join(\".\");\n}\n\nexport async function cacheModelForPopulate<M extends Model>(\n  context: Context<M>,\n  parentModel: M,\n  propertyKey: string,\n  pkValue: string | number,\n  cacheValue: any\n) {\n  const cacheKey = getPopulateKey(\n    parentModel.constructor.name,\n    propertyKey,\n    pkValue\n  );\n  return context.put(cacheKey, cacheValue);\n}\n\nexport async function populate<\n  M extends Model,\n  R extends Repo<M>,\n  Y extends RelationsMetadata,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  if (!data.populate) return;\n  const nested: any = (model as Record<string, any>)[key];\n  const isArr = Array.isArray(nested);\n  if (typeof nested === \"undefined\" || (isArr && nested.length === 0)) return;\n\n  async function fetchPopulateValues(\n    c: Context<M>,\n    model: M,\n    propName: string,\n    propKeyValues: any[]\n  ) {\n    let cacheKey: string;\n    let val: any;\n    const results: M[] = [];\n    for (const proKeyValue of propKeyValues) {\n      cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);\n      try {\n        val = await c.get(cacheKey);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        const repo = repositoryFromTypeMetadata(model, propName);\n        if (!repo) throw new InternalError(\"Could not find repo\");\n        val = await repo.read(proKeyValue);\n      }\n      results.push(val);\n    }\n    return results;\n  }\n  const res = await fetchPopulateValues(\n    context,\n    model,\n    key,\n    isArr ? nested : [nested]\n  );\n  (model as Record<string, any>)[key] = isArr ? res : res[0];\n}\n\nconst commomTypes = [\n  \"array\",\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"symbol\",\n  \"function\",\n  \"object\",\n  \"undefined\",\n  \"null\",\n  \"bigint\",\n];\n\nexport function repositoryFromTypeMetadata<M extends Model>(\n  model: any,\n  propertyKey: string\n): Repo<M> {\n  const types = Reflect.getMetadata(\n    Validation.key(\n      Array.isArray(model[propertyKey])\n        ? ValidationKeys.LIST\n        : ValidationKeys.TYPE\n    ),\n    model,\n    propertyKey\n  );\n  const customTypes: any = Array.isArray(model[propertyKey])\n    ? types.clazz\n    : types.customTypes;\n  if (!types || !customTypes)\n    throw new InternalError(\n      `Failed to find types decorators for property ${propertyKey}`\n    );\n\n  const allowedTypes: string[] = Array.isArray(customTypes)\n    ? [...customTypes]\n    : [customTypes];\n  const constructorName = allowedTypes.find(\n    (t) => !commomTypes.includes(`${t}`.toLowerCase())\n  );\n  if (!constructorName)\n    throw new InternalError(\n      `Property key ${propertyKey} does not have a valid constructor type`\n    );\n  const constructor: Constructor<M> | undefined = Model.get(constructorName);\n  if (!constructor)\n    throw new InternalError(`No registered model found for ${constructorName}`);\n\n  return Repository.forModel(constructor);\n}\n","import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n} from \"@decaf-ts/db-decorators\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { CascadeMetadata, IndexMetadata } from \"../repository/types\";\nimport { DefaultCascade, OrderDirection } from \"../repository/constants\";\nimport {\n  Constructor,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { Condition } from \"../query/Condition\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToManyOnUpdate,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./construction\";\nimport { User } from \"./User\";\nimport { Context } from \"../repository/Context\";\nimport { UnsupportedError } from \"../persistence/errors\";\n\nexport function table(tableName: string) {\n  return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);\n}\n\nexport function column(columnName: string) {\n  return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);\n}\n\n/**\n * @summary Index Decorator\n * @description properties decorated will the index in the\n * DB for performance in queries\n *\n * @param {OrderDirection[]} [directions]\n * @param {string[]} [compositions]\n *\n * @function index\n */\nexport function index(directions?: OrderDirection[], compositions?: string[]) {\n  return propMetadata(\n    Repository.key(\n      `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n    ),\n    {\n      directions: directions,\n      compositions: compositions,\n    } as IndexMetadata\n  );\n}\n\nexport async function uniqueOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M>,\n  Y = any,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  if (!(model as any)[key]) return;\n  const existing = await this.select()\n    .where(Condition.attribute(key).eq((model as any)[key]))\n    .execute<M[]>();\n  if (existing.length)\n    throw new ConflictError(\n      `model already exists with property ${key} equal to ${JSON.stringify((model as any)[key], undefined, 2)}`\n    );\n}\n\n/**\n * @summary Unique Decorator\n * @description Tags a property as unique.\n *  No other elements in that table can have the same property value\n *\n * @function unique\n *\n * @memberOf module:wallet-db.Decorators\n */\nexport function unique() {\n  return apply(\n    onCreateUpdate(uniqueOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.UNIQUE), {})\n  );\n}\n\nexport async function createdByOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M>,\n  Y = any,\n>(this: R, context: Context<M>, data: Y, key: string, model: M): Promise<void> {\n  const user: User | undefined = context.user;\n  if (!user)\n    throw new UnsupportedError(\n      \"This adapter does not support user identification\"\n    );\n  (model as any)[key] = user.id;\n}\n\nexport function createdBy() {\n  return apply(\n    onCreate(createdByOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.CREATED_BY), {})\n  );\n}\n\nexport function updatedBy() {\n  return apply(\n    onCreateUpdate(createdByOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.CREATED_BY), {})\n  );\n}\n\n/**\n * @summary One To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database\n *\n * @function onToOne\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToMany\n * @see manyToOne\n */\nexport function oneToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  return apply(\n    prop(PersistenceKeys.RELATIONS),\n    type([clazz.name, String.name, Number.name, BigInt.name]),\n    onCreate(oneToOneOnCreate, metadata),\n    onUpdate(oneToOneOnUpdate, metadata),\n    onDelete(oneToOneOnDelete, metadata),\n    afterAny(pop, metadata),\n    propMetadata(Repository.key(PersistenceKeys.ONE_TO_ONE), metadata)\n  );\n}\n\n/**\n * @summary One To Many relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function oneToMany\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToOne\n * @see manyToOne\n */\nexport function oneToMany<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  return apply(\n    prop(PersistenceKeys.RELATIONS),\n    // @ts-expect-error purposeful override\n    list([clazz, String, Number, BigInt]),\n    onCreate(oneToManyOnCreate, metadata),\n    onUpdate(oneToManyOnUpdate, metadata),\n    onDelete(oneToManyOnDelete, metadata),\n    afterAny(pop, metadata),\n    propMetadata(Repository.key(PersistenceKeys.ONE_TO_MANY), metadata)\n  );\n}\n\n/**\n * @summary Many To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function manyToOne\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToMany\n * @see oneToOne\n */\nexport function manyToOne(\n  clazz: Constructor<any>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  return apply(\n    prop(PersistenceKeys.RELATIONS),\n    type([clazz.name, String.name, Number.name, BigInt.name]),\n    // onCreate(oneToManyOnCreate, metadata),\n    // onUpdate(oneToManyOnUpdate, metadata),\n    // onDelete(oneToManyOnDelete, metadata),\n    // afterAll(populate, metadata),\n    propMetadata(Repository.key(PersistenceKeys.MANY_TO_ONE), metadata)\n  );\n}\n","import { Model, propMetadata, required } from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  InternalError,\n  onCreate,\n  readonly,\n} from \"@decaf-ts/db-decorators\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\n\n/**\n * @summary Primary Key Decorator\n * @description Marks the property as the {@link Model}s primary key.\n *  Also marks the property as {@link unique} as {@required} and ensures the index is created properly according to the provided {@link Sequence}\n *\n *\n *\n * @function pk\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see unique\n * @see required\n * @see on\n * @param data\n * @param key\n * @param model\n */\nexport async function pkOnCreate<M extends Model, V extends Repo<M>>(\n  this: V,\n  context: Context<M>,\n  data: SequenceOptions,\n  key: string,\n  model: M\n): Promise<void> {\n  if (!data.type || (model as Record<string, any>)[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key, next);\n}\n\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts) as SequenceOptions;\n  return apply(\n    index([OrderDirection.ASC, OrderDirection.DSC]),\n    required(),\n    readonly(),\n    // type([String.name, Number.name, BigInt.name]),\n    propMetadata(Repository.key(DBKeys.ID), opts as SequenceOptions),\n    onCreate(pkOnCreate, opts as SequenceOptions)\n  );\n}\n","import { DBOperations, timestamp } from \"@decaf-ts/db-decorators\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\n\nexport abstract class BaseModel extends Model {\n  @timestamp(DBOperations.CREATE)\n  createdOn!: Date;\n  @timestamp()\n  updatedOn!: Date;\n\n  protected constructor(arg?: ModelArg<BaseModel>) {\n    super(arg);\n  }\n}\n","import { list, model, Model } from \"@decaf-ts/decorator-validation\";\nimport type { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { Roles } from \"../persistence/constants\";\nimport { pk } from \"../identity/decorators\";\n\n@model()\nexport class User extends Model {\n  @pk()\n  id!: string;\n\n  @list([String])\n  roles?: (string | Roles)[];\n\n  @list([String])\n  affiliations?: string[];\n\n  constructor(arg?: ModelArg<User>) {\n    super(arg);\n  }\n}\n","import {\n  DEFAULT_ERROR_MESSAGES,\n  propMetadata,\n  Validation,\n  ValidationKeys,\n  ValidationMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"../persistence\";\n\nObject.defineProperty(DEFAULT_ERROR_MESSAGES, PersistenceKeys.CLAUSE_SEQUENCE, {\n  value: \"Invalid clause sequence: {0}\",\n});\n\nObject.defineProperty(ValidationKeys, \"CLAUSE_SEQUENCE\", {\n  value: PersistenceKeys.CLAUSE_SEQUENCE,\n});\n\n/**\n *\n * @param {string} [message]\n *\n * @function clauseSequence\n *\n * @category Decorators\n * @subcategory Validation\n */\nexport function clauseSequence(message?: string) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.REQUIRED),\n    {\n      message:\n        message ||\n        ((DEFAULT_ERROR_MESSAGES as any)[\n          PersistenceKeys.CLAUSE_SEQUENCE as any\n        ] as string),\n    }\n  );\n}\n","import {\n  DEFAULT_ERROR_MESSAGES,\n  sf,\n  validator,\n  Validator,\n  ValidatorOptions,\n} from \"@decaf-ts/decorator-validation\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport { Clause } from \"../query/Clause\";\nimport { MandatoryPriorities } from \"../query/constants\";\nimport { QueryError } from \"../query/errors\";\nimport { PersistenceKeys } from \"../persistence/constants\";\n\n/**\n * @summary Validates a {@link Sequence}'s {@link Clause}s\n *\n * @param {string} [message]\n *\n * @class ClauseSequenceValidator\n * @extends Validator\n *\n * @category Validation\n * @subcategory Validators\n */\n@validator(PersistenceKeys.CLAUSE_SEQUENCE)\nexport class ClauseSequenceValidator extends Validator {\n  constructor(\n    message: string = DEFAULT_ERROR_MESSAGES[PersistenceKeys.CLAUSE_SEQUENCE]\n  ) {\n    super(message);\n  }\n\n  private validateSequence(\n    clauses: Clause<any>[],\n    message?: string\n  ): string | undefined {\n    return MandatoryPriorities.every(\n      (p) => !!clauses.find((c) => c.getPriority() === p)\n    )\n      ? undefined\n      : this.getMessage(\n          sf(message || this.message, \"Missing required Clause Priorities\")\n        );\n  }\n\n  /**\n   * @summary Verifies the model for errors\n   * @param {string} value\n   * @param {ValidatorOptions} [options]\n   *\n   * @return Errors\n   *\n   * @override\n   *\n   * @see Validator\n   */\n  public hasErrors(value: any, options?: ValidatorOptions): string | undefined {\n    try {\n      if (\n        !value ||\n        !Array.isArray(value) ||\n        !value.length ||\n        !value.every((e) => e instanceof Clause)\n      )\n        return this.getMessage(\n          sf(\n            (options || {}).message || this.message,\n            \"No or invalid Clauses found\"\n          )\n        );\n\n      const clauses: Clause<any>[] = value as Clause<any>[];\n\n      const clauseErrors = clauses.reduce(\n        (accum: string | undefined, c: Clause<any>) => {\n          const errs = c.hasErrors();\n          if (errs)\n            if (accum)\n              accum += sf(\n                \"\\nClause {0}: {1}\",\n                c.constructor.name,\n                errs.toString()\n              );\n            else\n              accum = sf(\n                \"Clause {0}: {1}\",\n                c.constructor.name,\n                errs.toString()\n              );\n          return accum;\n        },\n        undefined\n      );\n\n      if (clauseErrors)\n        return this.getMessage(\n          sf((options || {}).message || this.message, clauseErrors.toString())\n        );\n\n      const verifyPriority = () => {\n        const priorities = clauses.map((c) => c.getPriority());\n        const allUnique = new Set(priorities).size === priorities.length;\n        if (!allUnique) return \"Not all clauses  have unique priorities\";\n        const sorted = priorities.sort((a, b) => {\n          return b - a;\n        });\n\n        return isEqual(priorities, sorted)\n          ? true\n          : \"Clauses  are not properly sorted\";\n      };\n\n      const priorityCheck = verifyPriority();\n      if (priorityCheck !== true)\n        return this.getMessage(\n          sf((options || {}).message || this.message, \"Invalid prioritization\")\n        );\n\n      const sequenceCheck = this.validateSequence(\n        clauses,\n        (options || {}).message\n      );\n      if (sequenceCheck)\n        return this.getMessage(\n          sf((options || {}).message || this.message, \"Invalid sequence\")\n        );\n    } catch (e: any) {\n      throw new QueryError(\n        sf(\"Failed to verify clause sequence {0}: {1}\", value, e)\n      );\n    }\n  }\n}\n","import type { Constructor } from \"@decaf-ts/decorator-validation\";\nimport {\n  minlength,\n  Model,\n  ModelErrorDefinition,\n  required,\n  type,\n  sf,\n} from \"@decaf-ts/decorator-validation\";\nimport { Executor, RawExecutor } from \"../interfaces\";\nimport { MandatoryPriorities, StatementType } from \"./constants\";\nimport { QueryError } from \"./errors\";\nimport { Clause } from \"./Clause\";\nimport { clauseSequence } from \"../validators\";\nimport { Adapter } from \"../persistence\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { Paginator } from \"./Paginator\";\n\n/**\n * @summary Statement Class\n * @description holds all the clauses until they can be processed\n *\n * @param {ModelArg} [statement]\n *\n * @class Statement\n * @extends Model\n * @implements Executor\n * @implements RawExecutor\n *\n * @category Query\n */\nexport abstract class Statement<Q>\n  extends Model\n  implements Executor, RawExecutor<Q>\n{\n  @required()\n  @minlength(MandatoryPriorities.length)\n  @clauseSequence()\n  protected clauses?: Clause<any>[] = undefined;\n  @required()\n  @type([\"object\"])\n  protected adapter: Adapter<any, Q>;\n  @required()\n  protected target?: Constructor<any> = undefined;\n\n  protected fullRecord: boolean = false;\n\n  @required()\n  protected type?: string = undefined;\n\n  protected constructor(db: Adapter<any, Q>) {\n    super();\n    this.adapter = db;\n  }\n\n  protected build(): Q {\n    if (!this.clauses)\n      throw new QueryError(sf(\"Failed to build Statement:\\n{0}\", \"No Clauses\"));\n    this.clauses.sort((c1, c2) => {\n      return c1.getPriority() - c2.getPriority();\n    });\n\n    const errors = this.hasErrors();\n    if (errors)\n      throw new QueryError(\n        sf(\"Poorly built statement: {0}\", errors.toString())\n      );\n\n    let query: Q;\n    try {\n      const iterator = function (\n        clauses: Clause<any>[],\n        previous: any = {}\n      ): Q {\n        const c = clauses.shift();\n        if (!c) return previous as Q;\n        const results = c.build(previous);\n        return iterator(clauses, results as any);\n      };\n\n      query = iterator(new Array(...(this.clauses as Clause<Q>[]))) as Q;\n    } catch (e: any) {\n      throw new QueryError(e);\n    }\n\n    return query;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  async execute<Y>(): Promise<Y> {\n    try {\n      const query: Q = this.build();\n      return this.raw(query);\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  abstract paginate<Y>(size: number): Promise<Paginator<Y, Q>>;\n\n  async raw<R>(rawInput: Q, ...args: any[]): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput, true, ...args);\n    if (!this.fullRecord) return results;\n    if (!this.target)\n      throw new InternalError(\n        \"No target defined in statement. should never happen\"\n      );\n\n    const pkAttr = findPrimaryKey(new this.target() as any).id;\n\n    const processor = function recordProcessor(this: Statement<Q>, r: any) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.target as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    for (const i in this.clauses) {\n      const err = this.clauses[i as any].hasErrors();\n      if (err) return err;\n    }\n  }\n\n  /**\n   * @summary Adds a clause to the Statement\n   * @param {Clause} clause\n   */\n  addClause(clause: Clause<Q>) {\n    if (!this.clauses) this.clauses = [];\n\n    const priority = clause.getPriority();\n    const currentPriority = this.clauses\n      .map((c, i) => ({ index: i, clause: c }))\n      .find((c) => c.clause.getPriority() === priority);\n    if (currentPriority) {\n      this.clauses[currentPriority.index] = clause;\n    }\n    this.clauses.push(clause);\n  }\n\n  getAdapter(): Adapter<any, Q> {\n    return this.adapter;\n  }\n\n  /**\n   * @summary Defines the output class (when existing)\n   * @param {Constructor} clazz\n   */\n  setTarget(clazz: Constructor<any>) {\n    if (this.target)\n      throw new QueryError(\n        sf(\"Output class already defined to {0}\", this.target!.name)\n      );\n    this.target = clazz;\n  }\n\n  getTarget() {\n    if (!this.target)\n      throw new InternalError(\"No target defined for statement\");\n    return this.target;\n  }\n\n  setFullRecord() {\n    this.fullRecord = true;\n  }\n\n  setMode(type: StatementType) {\n    this.type = type;\n  }\n}\n","import { Executor } from \"../interfaces\";\nimport {\n  Model,\n  ModelArg,\n  required,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { QueryBuilder } from \"./options\";\nimport { QueryError } from \"./errors\";\nimport { Priority } from \"./constants\";\nimport { Statement } from \"./Statement\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\nimport { Paginator } from \"./Paginator\";\n\n/**\n */\n\n/**\n * @summary Clause Class\n * @description Represents a Clause in a {@link Statement}\n *\n * @typedef Q Represents que query object the persistence adapter uses\n *\n * @param {ModelArg<Clause<Q>>} [clause]\n *\n * @class Clause\n * @extends Model\n * @implements Executor\n * @implements QueryBuilder\n * @abstract\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class Clause<Q>\n  extends Model\n  implements Executor, Paginatable, QueryBuilder<Q>\n{\n  @required()\n  readonly priority!: Priority;\n\n  @required()\n  @type(\"object\")\n  readonly statement!: Statement<Q>;\n\n  protected constructor(clause?: ModelArg<Clause<Q>>) {\n    super();\n    this.priority = clause?.priority;\n    this.statement = clause?.statement;\n    if (!this.statement || !this.priority)\n      throw new QueryError(\n        \"Missing statement or priority. Should be impossible\"\n      );\n    this.statement.addClause(this);\n  }\n\n  protected get adapter() {\n    return this.statement.getAdapter();\n  }\n\n  protected get Clauses() {\n    return this.statement.getAdapter().Clauses;\n  }\n\n  /**\n   * @summary return the priority of the clause\n   * @see Priority\n   */\n  getPriority(): number {\n    return this.priority as number;\n  }\n\n  abstract build(previous: Q): Q;\n\n  /**\n   * @inheritDoc\n   * @abstract\n   */\n  async execute<R>(): Promise<R> {\n    return this.statement.execute();\n  }\n  /**\n   * @inheritDoc\n   * @abstract\n   */\n  async paginate<R>(size: number): Promise<Paginator<R, Q>> {\n    return this.statement.paginate(size);\n  }\n\n  toString() {\n    return this.constructor.name;\n  }\n\n  // /**\n  //  * @summary Factory method for {@link FromClause}\n  //  * @param {{priority: number, statement: Statement, getPriority: Function, build: Function, process: Function}} clause\n  //  */\n  // static isClause(clause: Partial<Clause<any>>) {\n  //   return clause instanceof Clause;\n  //   return (\n  //     clause.constructor &&\n  //     clause.constructor.name &&\n  //     clause.priority &&\n  //     clause.statement &&\n  //     clause.getPriority &&\n  //     clause.build &&\n  //     clause.execute\n  //   );\n  // }\n}\n","import { Clause } from \"../Clause\";\nimport { ModelArg, required } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary The base Selector based clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class SelectorBasedClause\n * @extends Clause\n * @abstract\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class SelectorBasedClause<Q, S> extends Clause<Q> {\n  /**\n   * @summary Stores the selector\n   *\n   * @prop selector\n   * @protected\n   */\n  @required()\n  protected selector?: S = undefined;\n\n  protected constructor(clause?: ModelArg<SelectorBasedClause<Q, S>>) {\n    super(clause);\n    this.selector = (clause as { selector: S }).selector;\n  }\n\n  toString() {\n    return this.constructor.name + `[${this.selector}]`;\n  }\n}\n","import { Priority } from \"../constants\";\nimport {\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n} from \"../selectors\";\nimport {\n  LimitOption,\n  OffsetOption,\n  OrderAndGroupOption,\n  WhereOption,\n} from \"../options\";\nimport { SelectorBasedClause } from \"./SelectorBasedClause\";\nimport { Executor } from \"../../interfaces\";\nimport { QueryError } from \"../errors\";\nimport { Condition } from \"../Condition\";\nimport {\n  Constructor,\n  Model,\n  ModelArg,\n  stringFormat,\n} from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary The FROM clause\n *\n * @param {ModelArg} [clause]\n *\n * @class FromClause\n * @extends SelectorBasedClause\n * @implements WhereOption\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class FromClause<Q, M extends Model>\n  extends SelectorBasedClause<Q, FromSelector<M>>\n  implements WhereOption\n{\n  protected constructor(clause?: ModelArg<FromClause<Q, M>>) {\n    super(Object.assign({}, clause, { priority: Priority.FROM }));\n    this.selector =\n      typeof this.selector === \"string\"\n        ? Model.get(this.selector)\n        : this.selector;\n    if (!this.selector)\n      throw new QueryError(stringFormat(\"Could not find selector model: {0}\"));\n    this.statement.setTarget(this.selector as Constructor<M>);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n\n  /**\n   * @inheritDoc\n   */\n  where(condition: Condition): OrderAndGroupOption {\n    return this.Clauses.where(this.statement, condition);\n  }\n  /**\n   * @inheritDoc\n   */\n  orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption {\n    return this.Clauses.orderBy(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  groupBy(selector: GroupBySelector): Executor {\n    return this.Clauses.groupBy(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  limit(selector: LimitSelector): OffsetOption {\n    return this.Clauses.limit(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  offset(selector: OffsetSelector): Executor {\n    return this.Clauses.offset(this.statement, selector);\n  }\n}\n","import { ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { GroupBySelector } from \"../selectors\";\nimport { Priority } from \"../constants\";\nimport { SelectorBasedClause } from \"./SelectorBasedClause\";\n\n/**\n * @summary The GROUP BY clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class GroupByClause\n * @extends SelectorBasedClause\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class GroupByClause<Q> extends SelectorBasedClause<\n  Q,\n  GroupBySelector\n> {\n  protected constructor(clause?: ModelArg<GroupByClause<Q>>) {\n    super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n}\n","import { Condition } from \"../Condition\";\nimport { InsertOption, IntoOption, OrderAndGroupOption } from \"../options\";\nimport { Priority } from \"../constants\";\nimport { Clause } from \"../Clause\";\nimport {\n  Constructor,\n  Model,\n  ModelArg,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { Executor } from \"../../interfaces\";\n\n/**\n * @summary The INSERT/INTO clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class FromClause\n * @extends Clause\n * @implements IntoOption\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class InsertClause<Q, M extends Model>\n  extends Clause<Q>\n  implements InsertOption<M>, IntoOption<M>\n{\n  @required()\n  protected table?: string = undefined;\n\n  protected constructor(clause?: ModelArg<InsertClause<Q, M>>) {\n    super(Object.assign({}, clause, { priority: Priority.SELECT }));\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n\n  /**\n   * @inheritDoc\n   */\n  into(table: Constructor<M>): IntoOption<M> {\n    this.table = table.name; // TODO get mapped name\n    this.statement.setTarget(table);\n    return this;\n  }\n  /**\n   * @inheritDoc\n   */\n  values(...models: M[]): Executor {\n    return this.Clauses.values(this.statement, models);\n  }\n  /**\n   * @inheritDoc\n   */\n  where(condition: Condition): OrderAndGroupOption {\n    return this.Clauses.where(this.statement, condition);\n  }\n}\n","import { SelectorBasedClause } from \"./SelectorBasedClause\";\nimport { OffsetOption } from \"../options\";\nimport { Executor } from \"../../interfaces\";\nimport { LimitSelector, OffsetSelector } from \"../selectors\";\nimport { Priority } from \"../constants\";\nimport { ModelArg } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary Limit Clause\n * @description Limits the results\n *\n * @param {ClauseArg} [clause]\n *\n * @class LimitClause\n * @extends SelectorBasedClause<T>\n * @implements OffsetOption<T>\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class LimitClause<Q>\n  extends SelectorBasedClause<Q, LimitSelector>\n  implements OffsetOption\n{\n  protected constructor(clause?: ModelArg<LimitClause<Q>>) {\n    super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n  /**\n   * @inheritDoc\n   */\n  offset(selector: OffsetSelector): Executor {\n    return this.Clauses.offset(this.statement, selector);\n  }\n}\n","import { SelectorBasedClause } from \"./SelectorBasedClause\";\nimport { OffsetSelector } from \"../selectors\";\nimport { Priority } from \"../constants\";\nimport { ModelArg } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary The OFFSET clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class FromClause\n * @extends SelectorBasedClause\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class OffsetClause<Q> extends SelectorBasedClause<\n  Q,\n  OffsetSelector\n> {\n  protected constructor(clause?: ModelArg<OffsetClause<Q>>) {\n    super(Object.assign({}, clause, { priority: Priority.GROUP_BY }));\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n}\n","import { SelectorBasedClause } from \"./SelectorBasedClause\";\nimport { Priority } from \"../constants\";\nimport {\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n} from \"../selectors\";\nimport { LimitOption, OffsetOption } from \"../options\";\nimport { Executor } from \"../../interfaces\";\nimport { ModelArg } from \"@decaf-ts/decorator-validation\";\n/**\n * @summary The ORDER BY clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class OrderByClause\n * @extends SelectorBasedClause\n * @implements LimitOption\n * @implements OffsetOption\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class OrderByClause<Q>\n  extends SelectorBasedClause<Q, OrderBySelector[]>\n  implements LimitOption, OffsetOption\n{\n  protected constructor(clause?: ModelArg<OrderByClause<Q>>) {\n    super(Object.assign({}, clause, { priority: Priority.ORDER_BY }));\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n  /**\n   * @inheritDoc\n   */\n  groupBy(selector: GroupBySelector): Executor {\n    return this.Clauses.groupBy(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  limit(selector: LimitSelector): OffsetOption {\n    return this.Clauses.limit(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  offset(selector: OffsetSelector): Executor {\n    return this.Clauses.offset(this.statement, selector);\n  }\n}\n","import { SelectorBasedClause } from \"./SelectorBasedClause\";\nimport {\n  CountOption,\n  DistinctOption,\n  MaxOption,\n  MinOption,\n  SelectOption,\n  WhereOption,\n} from \"../options\";\nimport { Const, Priority, StatementType } from \"../constants\";\nimport { Constructor, ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { SelectSelector } from \"../selectors\";\n\n/**\n * @summary The SELECT clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class SelectClause\n * @extends SelectorBasedClause\n * @implements SelectOption\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class SelectClause<Q, M extends Model>\n  extends SelectorBasedClause<Q, SelectSelector>\n  implements SelectOption<M>\n{\n  private isDistinct: boolean = false;\n  private isCount = false;\n  private isMax = false;\n  private isMin = false;\n\n  protected constructor(clause?: ModelArg<SelectClause<Q, M>>) {\n    super(Object.assign({}, clause, { priority: Priority.SELECT }));\n    if (this.selector === Const.FULL_RECORD) this.statement.setFullRecord();\n    this.statement.setMode(StatementType.QUERY);\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n  /**\n   * @inheritDoc\n   */\n  distinct(selector: SelectSelector): DistinctOption<M> {\n    this.isDistinct = true;\n    this.selector = selector;\n    return this;\n  }\n  /**\n   * @inheritDoc\n   */\n  count(selector: SelectSelector): CountOption<M> {\n    this.selector = selector;\n    return this;\n  }\n  /**\n   * @inheritDoc\n   */\n  min(selector: SelectSelector): MinOption<M> {\n    this.selector = selector;\n    return this;\n  }\n  /**\n   * @inheritDoc\n   */\n  max(selector: SelectSelector): MaxOption<M> {\n    this.selector = selector;\n    return this;\n  }\n  /**\n   * @inheritDoc\n   */\n  from(tableName: Constructor<M>): WhereOption {\n    return this.Clauses.from(this.statement, tableName);\n  }\n}\n","import { Clause } from \"../Clause\";\nimport { Priority } from \"../constants\";\nimport { ModelArg, required, type } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @summary The VALUES clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class ValuesClause\n * @extends Clause\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class ValuesClause<Q, M> extends Clause<Q> {\n  @required()\n  @type(Array.name)\n  models?: M[] = undefined;\n\n  protected constructor(clause?: ModelArg<ValuesClause<Q, M>>) {\n    super(Object.assign({}, clause, { priority: Priority.FROM }));\n    this.models = clause?.models;\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n}\n","import { Clause } from \"../Clause\";\nimport { Condition } from \"../Condition\";\nimport {\n  ModelArg,\n  ModelErrorDefinition,\n  required,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { LimitOption, OffsetOption, OrderAndGroupOption } from \"../options\";\nimport { Priority } from \"../constants\";\nimport {\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n} from \"../selectors\";\nimport { Executor } from \"../../interfaces\";\n/**\n * @summary The WHERE clause\n *\n * @param {ClauseArg} [clause]\n *\n * @class WhereClause\n * @extends Clause\n * @implements OrderAndGroupOption\n *\n * @category Query\n * @subcategory Clauses\n */\nexport abstract class WhereClause<Q>\n  extends Clause<Q>\n  implements OrderAndGroupOption\n{\n  @required()\n  @type(\"Condition\")\n  condition?: Condition = undefined;\n\n  protected constructor(clause?: ModelArg<WhereClause<Q>>) {\n    super(Object.assign({}, clause, { priority: Priority.WHERE }));\n    this.condition = clause?.condition;\n  }\n  /**\n   * @inheritDoc\n   */\n  abstract build(query: Q): Q;\n  /**\n   * @inheritDoc\n   */\n  orderBy(...selector: OrderBySelector[]): LimitOption & OffsetOption {\n    return this.Clauses.orderBy(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  groupBy(selector: GroupBySelector): Executor {\n    return this.Clauses.groupBy(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  limit(selector: LimitSelector): OffsetOption {\n    return this.Clauses.limit(this.statement, selector);\n  }\n  /**\n   * @inheritDoc\n   */\n  offset(selector: OffsetSelector): Executor {\n    return this.Clauses.offset(this.statement, selector);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n    return this.condition!.hasErrors();\n  }\n}\n","import { FromClause } from \"./clauses\";\nimport { GroupByClause } from \"./clauses/GroupByClause\";\nimport { InsertClause } from \"./clauses/InsertClause\";\nimport { LimitClause } from \"./clauses/LimitClause\";\nimport { OffsetClause } from \"./clauses/OffsetClause\";\nimport { OrderByClause } from \"./clauses/OrderByClause\";\nimport { SelectClause } from \"./clauses/SelectClause\";\nimport { ValuesClause } from \"./clauses/ValuesClause\";\nimport { WhereClause } from \"./clauses/WhereClause\";\nimport { Adapter } from \"../persistence\";\nimport { Condition } from \"./Condition\";\nimport {\n  FromSelector,\n  GroupBySelector,\n  LimitSelector,\n  OffsetSelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Statement } from \"./Statement\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\n\nexport abstract class ClauseFactory<Y, Q> {\n  /**\n   * @summary Factory method for {@link FromClause}\n   * @param {Statement} statement\n   * @param {FromSelector} selector\n   */\n  abstract from<M extends Model>(\n    statement: Statement<Q>,\n    selector: FromSelector<M>\n  ): FromClause<Q, M>;\n  /**\n   * @summary Factory method for {@link GroupByClause}\n   * @param {Statement} statement\n   * @param {GroupBySelector} selector\n   */\n  abstract groupBy(\n    statement: Statement<Q>,\n    selector: GroupBySelector\n  ): GroupByClause<Q>;\n  /**\n   * @summary Factory method for {@link InsertClause}\n   * @param {Statement} statement\n   */\n  abstract insert<M extends Model>(): InsertClause<Q, M>;\n  /**\n   * @summary Factory method for {@link LimitClause}\n   * @param {Statement} statement\n   * @param {LimitSelector} selector\n   */\n  abstract limit(\n    statement: Statement<Q>,\n    selector: LimitSelector\n  ): LimitClause<Q>;\n  /**\n   * @summary Factory method for {@link OffsetClause}\n   * @param {Statement} statement\n   * @param {OffsetSelector} selector\n   */\n  abstract offset(\n    statement: Statement<Q>,\n    selector: OffsetSelector\n  ): OffsetClause<Q>;\n  /**\n   * @summary Factory method for {@link OrderByClause}\n   * @param {Statement} statement\n   * @param {OrderBySelector} selector\n   */\n  abstract orderBy(\n    statement: Statement<Q>,\n    selector: OrderBySelector[]\n  ): OrderByClause<Q>;\n  /**\n   * @summary Factory method for {@link SelectClause}\n   * @param {Statement} statement\n   * @param {SelectSelector} [selector]\n   */\n  abstract select<M extends Model>(\n    selector?: SelectSelector\n  ): SelectClause<Q, M>;\n  /**\n   * @summary Factory method for {@link ValuesClause}\n   * @param {Statement} statement\n   * @param {M[]} values\n   */\n  abstract values<M extends Model>(\n    statement: Statement<Q>,\n    values: M[]\n  ): ValuesClause<Q, M>;\n  /**\n   * @summary Factory method for {@link WhereClause}\n   * @param {Statement} statement\n   * @param {Condition} condition\n   */\n  abstract where(statement: Statement<Q>, condition: Condition): WhereClause<Q>;\n\n  protected constructor(protected adapter: Adapter<Y, Q>) {}\n}\n","import { PagingError } from \"./errors\";\nimport { Statement } from \"./Statement\";\n\nexport abstract class Paginator<V, Q> {\n  protected _currentPage!: number;\n  protected _totalPages!: number;\n  protected _recordCount!: number;\n  protected limit!: number;\n\n  private _statement?: Q;\n\n  get current() {\n    return this._currentPage;\n  }\n\n  get total() {\n    return this._totalPages;\n  }\n\n  get count(): number {\n    return this._recordCount;\n  }\n\n  get statement() {\n    if (!this._statement) this._statement = this.prepare(this._rawStatement);\n    return this._statement;\n  }\n\n  protected get adapter() {\n    return this.stat.getAdapter();\n  }\n\n  protected constructor(\n    protected stat: Statement<Q>,\n    readonly size: number,\n    protected readonly _rawStatement: Q\n  ) {}\n\n  protected abstract prepare(rawStatement: Q): Q;\n\n  async next() {\n    return this.page(this.current + 1);\n  }\n\n  async previous() {\n    return this.page(this.current - 1);\n  }\n\n  protected validatePage(page: number) {\n    if (page < 1 || !Number.isInteger(page))\n      throw new PagingError(\n        \"page number cannot be under 1 and must be an integer\"\n      );\n    if (page > this._totalPages)\n      throw new PagingError(\n        \"page number cannot be under 1 and must be an integer\"\n      );\n  }\n\n  abstract page(page?: number, ...args: any[]): Promise<V[]>;\n}\n","import { InjectablesRegistry } from \"./repository\";\nimport { Injectables } from \"@decaf-ts/injectable-decorators\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module ts-workspace\n */\n\n/**\n * @summary Namespace summary\n * @description Namespace description\n * @namespace Namespace\n * @memberOf module:ts-workspace\n */\n\nexport * from \"./identity\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./persistence\";\nexport * from \"./query\";\nexport * from \"./repository\";\nexport * from \"./validators\";\n\nInjectables.setRegistry(new InjectablesRegistry());\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["OrderDirection","Cascade","Ctx","PersistenceKeys","Roles","Operator","GroupOperator","Const","Priority","StatementType","BaseError","InternalError","Model","NotFoundError","DBKeys","apply","metadata","Rep","wrapMethodWithContext","OperationKeys","enforceDBDecorators","ValidationError","findPrimaryKey","Reflection","inject","injectable","sf","InjectableRegistryImp","Injectables","required","Validation","ValidationKeys","propMetadata","ConflictError","onCreateUpdate","onCreate","populate","prop","type","onUpdate","onDelete","afterAny","pop","list","readonly","timestamp","DBOperations","User","model","DEFAULT_ERROR_MESSAGES","ClauseSequenceValidator","Validator","isEqual","validator","minlength","stringFormat"],"mappings":"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","x_google_ignoreList":[16]}