@decaf-ts/core 0.1.3 → 0.2.1

package/lib/esm/repository/Repository.js

@@ -1 +1,275 @@
-import{DBKeys,enforceDBDecorators,findModelId,findPrimaryKey,getDBKey,InternalError,OperationKeys,Repository as Rep,ValidationError}from"@decaf-ts/db-decorators";import{ObserverError}from"./errors";import{Adapter}from"../persistence/Adapter";import{getTableName}from"./utils";import{getPersistenceKey}from"../persistence/decorators";import{PersistenceKeys}from"../persistence/constants";class Repository extends Rep{get adapter(){if(this._adapter)return this._adapter;throw new InternalError("No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?")}get tableName(){return this._tableName||(this._tableName=getTableName(this.class)),this._tableName}get pk(){return this._pk||(this._pk=findPrimaryKey(new this.class).id),this._pk}constructor(e,r){super(r),this.observers=[],e&&(this._adapter=e)}async create(e,...r){var{record:e,id:t}=await this.adapter.prepare(e,this.pk),e=await this.adapter.create(this.tableName,t,e,...r);return this.adapter.revert(e,this.class,this.pk,t)}async read(e,...r){r=await this.adapter.read(this.tableName,e,...r);return this.adapter.revert(r,this.class,this.pk,e)}async update(e,...r){var{record:e,id:t}=await this.adapter.prepare(e,this.pk),e=await this.adapter.update(this.tableName,t,e,...r);return this.adapter.revert(e,this.class,this.pk,t)}async updatePrefix(e,...r){e=new this.class(e);var t=findModelId(e),t=await this.read(t),s=(await enforceDBDecorators(this,e,OperationKeys.UPDATE,OperationKeys.ON,t),e.hasErrors(t));if(s)throw new ValidationError(s.toString());return t[PersistenceKeys.METADATA]&&!e[PersistenceKeys.METADATA]&&Object.defineProperty(e,PersistenceKeys.METADATA,{enumerable:!1,writable:!1,configurable:!0,value:t[PersistenceKeys.METADATA]}),[e,...r]}async delete(e,...r){r=await this.adapter.delete(this.tableName,e,...r);return this.adapter.revert(r,this.class,this.pk,e)}observe(e){if(-1!==this.observers.indexOf(e))throw new InternalError("Observer already registered");this.observers.push(e)}unObserve(e){e=this.observers.indexOf(e);if(-1===e)throw new InternalError("Failed to find Observer");this.observers.splice(e,1)}async updateObservers(...t){return new Promise((e,r)=>{Promise.all(this.observers.map(e=>e.refresh(...t))).then(()=>{e()}).catch(e=>r(new ObserverError(e)))})}static forModel(r){var e=Reflect.getMetadata(getDBKey(DBKeys.REPOSITORY),r.constructor);if(!e)throw new InternalError("No registered repository found for model "+r.constructor.name);var t=Reflect.getMetadata(getPersistenceKey(PersistenceKeys.ADAPTER),e.constructor);if(!t)throw new InternalError("No registered persistence adapter found for model "+r.constructor.name);var s=Adapter.get(t);if(!s)throw new InternalError("No registered persistence adapter found flavour "+t);let a;try{a=e(s)}catch(e){throw new InternalError(`Failed to boot repository for ${r.constructor.name} using persistence adapter `+t)}return a}}export{Repository};
+import { DBKeys, enforceDBDecorators, findModelId, findPrimaryKey, InternalError, OperationKeys, Repository as Rep, ValidationError, wrapMethod, } from "@decaf-ts/db-decorators";
+import { ObserverError } from "./errors";
+import { Adapter } from "../persistence/Adapter";
+import { Model } from "@decaf-ts/decorator-validation";
+import { PersistenceKeys } from "../persistence/constants";
+import { Query, } from "../query";
+import { OrderDirection } from "./constants";
+import { sequenceNameForModel } from "../identity/utils";
+import { getAllPropertyDecorators } from "@decaf-ts/reflection";
+export class Repository extends Rep {
+    static { this._cache = {}; }
+    get adapter() {
+        if (!this._adapter)
+            throw new 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;
+    }
+    get pk() {
+        if (!this._pk)
+            this._pk = findPrimaryKey(new this.class()).id;
+        return this._pk;
+    }
+    constructor(adapter, clazz) {
+        super(clazz);
+        this.observers = [];
+        if (adapter)
+            this._adapter = adapter;
+        [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach((m) => {
+            const name = m.name;
+            wrapMethod(this, this[name + "Prefix"], m, this[name + "Suffix"]);
+        });
+    }
+    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) {
+        if (!models.length)
+            return [models, ...args];
+        const opts = Repository.getSequenceOptions(models[0]);
+        let ids = [];
+        if (opts.type) {
+            if (!opts.name)
+                opts.name = sequenceNameForModel(models[0], "pk");
+            ids = await (await this.adapter.Sequence(opts)).range(models.length);
+        }
+        const pk = findPrimaryKey(models[0]).id;
+        models = await Promise.all(models.map(async (m, i) => {
+            m = new this.class(m);
+            m[pk] = ids[i];
+            await enforceDBDecorators(this, m, OperationKeys.CREATE, 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 ValidationError(errors);
+        return [models, ...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 update(model, ...args) {
+        // eslint-disable-next-line prefer-const
+        let { record, id } = await 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 pk = findModelId(model);
+        const oldModel = await this.read(pk);
+        model = this.merge(oldModel, model);
+        await enforceDBDecorators(this, model, OperationKeys.UPDATE, OperationKeys.ON, oldModel);
+        const errors = model.hasErrors(oldModel);
+        if (errors)
+            throw new ValidationError(errors.toString());
+        if (Repository.getMetadata(oldModel)) {
+            if (!Repository.getMetadata(model))
+                Repository.setMetadata(model, Repository.getMetadata(oldModel));
+        }
+        return [model, ...args];
+    }
+    async updateAllPrefix(models, ...args) {
+        const ids = models.map((m) => findModelId(m));
+        const oldModels = await this.readAll(ids);
+        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) => enforceDBDecorators(this, m, OperationKeys.UPDATE, 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 ValidationError(errors);
+        return [models, ...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);
+    }
+    select(selector) {
+        return new Query(this.adapter).select(selector).from(this.class);
+    }
+    async query(condition, orderBy, order = 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 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 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) {
+        return new Promise((resolve, reject) => {
+            Promise.all(this.observers.map((o) => o.refresh(...args)))
+                .then(() => {
+                resolve();
+            })
+                .catch((e) => reject(new ObserverError(e)));
+        });
+    }
+    static forModel(model) {
+        const repoName = Reflect.getMetadata(Repository.key(DBKeys.REPOSITORY), model);
+        let flavour = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model);
+        let adapter = flavour
+            ? Adapter.get(flavour)
+            : undefined;
+        let repoConstructor;
+        if (!repoName) {
+            if (!adapter)
+                throw new InternalError(`Cannot boot a standard repository without an adapter definition. Did you @use on the model ${model.name}`);
+            repoConstructor = Repository;
+        }
+        else {
+            repoConstructor = this.get(repoName);
+            flavour =
+                flavour ||
+                    Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repoConstructor);
+            if (!flavour)
+                throw new InternalError(`No registered persistence adapter found for model ${model.name}`);
+            adapter = Adapter.get(flavour);
+        }
+        if (!adapter)
+            throw new InternalError(`No registered persistence adapter found flavour ${flavour}`);
+        return new repoConstructor(adapter, model);
+    }
+    static get(name) {
+        if (name in this._cache)
+            return this._cache[name];
+        throw new InternalError(`Could not find repository registered under ${name}`);
+    }
+    static register(name, repo) {
+        if (name in this._cache)
+            throw new InternalError(`${name} already registered as a repository`);
+        this._cache[name] = repo;
+    }
+    static setMetadata(model, metadata) {
+        Object.defineProperty(model, PersistenceKeys.METADATA, {
+            enumerable: false,
+            configurable: true,
+            writable: false,
+            value: metadata,
+        });
+    }
+    static getMetadata(model) {
+        const descriptor = Object.getOwnPropertyDescriptor(model, PersistenceKeys.METADATA);
+        return descriptor ? descriptor.value : undefined;
+    }
+    static removeMetadata(model) {
+        const descriptor = Object.getOwnPropertyDescriptor(model, PersistenceKeys.METADATA);
+        if (descriptor)
+            delete model[PersistenceKeys.METADATA];
+    }
+    static getSequenceOptions(model) {
+        const pk = findPrimaryKey(model).id;
+        const metadata = Reflect.getMetadata(Repository.key(DBKeys.ID), model, pk);
+        if (!metadata)
+            throw new InternalError("No sequence options defined for model. did you use the @pk decorator?");
+        return metadata;
+    }
+    static indexes(model) {
+        const indexDecorators = getAllPropertyDecorators(model instanceof Model ? model : new model(), DBKeys.REFLECT);
+        return Object.entries(indexDecorators || {}).reduce((accum, [k, val]) => {
+            const decs = val.filter((v) => v.key.startsWith(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 table(model) {
+        const metadata = Reflect.getMetadata(Adapter.key(PersistenceKeys.TABLE), model instanceof Model ? model.constructor : model);
+        if (metadata) {
+            return metadata;
+        }
+        if (model instanceof Model) {
+            return model.constructor.name;
+        }
+        return model.name;
+    }
+    static column(model, attribute) {
+        const metadata = Reflect.getMetadata(Adapter.key(PersistenceKeys.COLUMN), model, attribute);
+        return metadata ? metadata : attribute;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/repository/Repository.ts"],"names":[],"mappings":"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","file":"repository/Repository.js","sourcesContent":["import {\n  DBKeys,\n  enforceDBDecorators,\n  findModelId,\n  findPrimaryKey,\n  InternalError,\n  OperationKeys,\n  Repository as Rep,\n  ValidationError,\n  wrapMethod,\n} from \"@decaf-ts/db-decorators\";\nimport { ObserverError } from \"./errors\";\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 {\n  Condition,\n  OrderBySelector,\n  Query,\n  SelectSelector,\n  WhereOption,\n} from \"../query\";\nimport { OrderDirection } from \"./constants\";\nimport { SequenceOptions } from \"../interfaces\";\nimport { sequenceNameForModel } from \"../identity/utils\";\nimport { Queriable } from \"../interfaces/Queriable\";\nimport { getAllPropertyDecorators } from \"@decaf-ts/reflection\";\nimport { IndexMetadata } from \"./types\";\n\nexport class Repository<M extends Model, Q = any>\n  extends Rep<M>\n  implements Observable, Queriable\n{\n  private static _cache: Record<string, Constructor<Repository<Model, any>>> =\n    {};\n\n  private observers: Observer[] = [];\n\n  private readonly _adapter!: Adapter<any, Q>;\n  private _tableName!: string;\n  private _pk!: string;\n\n  get adapter() {\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  protected get pk() {\n    if (!this._pk) this._pk = findPrimaryKey(new this.class()).id;\n    return this._pk;\n  }\n\n  constructor(adapter?: Adapter<any, Q>, clazz?: Constructor<M>) {\n    super(clazz);\n    if (adapter) this._adapter = adapter;\n    [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach(\n      (m) => {\n        const name = m.name;\n        wrapMethod(\n          this,\n          (this as any)[name + \"Prefix\"],\n          m,\n          (this as any)[name + \"Suffix\"]\n        );\n      }\n    );\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(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    if (!models.length) return [models, ...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 = sequenceNameForModel(models[0], \"pk\");\n      ids = await (await this.adapter.Sequence(opts)).range(models.length);\n    }\n    const pk = findPrimaryKey(models[0]).id;\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        (m as Record<string, any>)[pk] = ids[i];\n        await enforceDBDecorators(\n          this,\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, ...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, this.class, this.pk, id);\n  }\n\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id } = await this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert(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 pk = findModelId(model);\n    const oldModel = await this.read(pk);\n    model = this.merge(oldModel, model);\n    await enforceDBDecorators(\n      this,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(oldModel);\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, ...args];\n  }\n\n  protected async updateAllPrefix(models: M[], ...args: any[]): Promise<any[]> {\n    const ids = models.map((m) => findModelId(m));\n    const oldModels = await this.readAll(ids);\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          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    return [models, ...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, this.class, this.pk, id);\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    return new Promise<void>((resolve, reject) => {\n      Promise.all(this.observers.map((o: Observer) => o.refresh(...args)))\n        .then(() => {\n          resolve();\n        })\n        .catch((e: any) => reject(new ObserverError(e)));\n    });\n  }\n\n  static forModel<M extends Model, R extends Repository<M, any>>(\n    model: Constructor<M>\n  ): R {\n    const repoName: string | undefined = Reflect.getMetadata(\n      Repository.key(DBKeys.REPOSITORY),\n      model\n    );\n    let flavour: string | undefined = Reflect.getMetadata(\n      Adapter.key(PersistenceKeys.ADAPTER),\n      model\n    );\n    let adapter: Adapter<any, any> | undefined = flavour\n      ? Adapter.get(flavour)\n      : undefined;\n\n    let repoConstructor: Constructor<R>;\n    if (!repoName) {\n      if (!adapter)\n        throw new InternalError(\n          `Cannot boot a standard repository without an adapter definition. Did you @use on the model ${model.name}`\n        );\n      repoConstructor = Repository as unknown as Constructor<R>;\n    } else {\n      repoConstructor = this.get(repoName) as unknown as Constructor<R>;\n      flavour =\n        flavour ||\n        Reflect.getMetadata(\n          Adapter.key(PersistenceKeys.ADAPTER),\n          repoConstructor\n        );\n      if (!flavour)\n        throw new InternalError(\n          `No registered persistence adapter found for model ${model.name}`\n        );\n\n      adapter = Adapter.get(flavour);\n    }\n\n    if (!adapter)\n      throw new InternalError(\n        `No registered persistence adapter found flavour ${flavour}`\n      );\n\n    return new repoConstructor(adapter, model);\n  }\n\n  private static get<M extends Model>(\n    name: string\n  ): Constructor<Repository<M>> {\n    if (name in this._cache)\n      return this._cache[name] as Constructor<Repository<M>>;\n    throw new InternalError(\n      `Could not find repository registered under ${name}`\n    );\n  }\n\n  static register<M extends Model>(\n    name: string,\n    repo: Constructor<Repository<M, any>>\n  ) {\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 = 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 table<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\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"]}

package/lib/esm/repository/constants.js

@@ -1 +1,31 @@
-var OrderDirection,Cascade;(e=>{e.ASC="asc",e.DSC="desc"})(OrderDirection=OrderDirection||{}),(e=>{e.CASCADE="cascade",e.NONE="none"})(Cascade=Cascade||{});let DefaultCascade={update:Cascade.CASCADE,delete:Cascade.NONE};export{OrderDirection,Cascade,DefaultCascade};
+/**
+ * @summary defines order directions when sorting
+ *
+ * @constant OrderDirection
+ *
+ * @category Query
+ */
+export var OrderDirection;
+(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";
+})(OrderDirection || (OrderDirection = {}));
+export var Cascade;
+(function (Cascade) {
+    Cascade["CASCADE"] = "cascade";
+    Cascade["NONE"] = "none";
+})(Cascade || (Cascade = {}));
+export const DefaultCascade = {
+    update: Cascade.CASCADE,
+    delete: Cascade.NONE,
+};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9yZXBvc2l0b3J5L2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQU4sSUFBWSxjQVdYO0FBWEQsV0FBWSxjQUFjO0lBQ3hCOzs7T0FHRztJQUNILDZCQUFXLENBQUE7SUFDWDs7O09BR0c7SUFDSCw4QkFBWSxDQUFBO0FBQ2QsQ0FBQyxFQVhXLGNBQWMsS0FBZCxjQUFjLFFBV3pCO0FBRUQsTUFBTSxDQUFOLElBQVksT0FHWDtBQUhELFdBQVksT0FBTztJQUNqQiw4QkFBbUIsQ0FBQTtJQUNuQix3QkFBYSxDQUFBO0FBQ2YsQ0FBQyxFQUhXLE9BQU8sS0FBUCxPQUFPLFFBR2xCO0FBRUQsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFvQjtJQUM3QyxNQUFNLEVBQUUsT0FBTyxDQUFDLE9BQU87SUFDdkIsTUFBTSxFQUFFLE9BQU8sQ0FBQyxJQUFJO0NBQ3JCLENBQUMiLCJmaWxlIjoicmVwb3NpdG9yeS9jb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYXNjYWRlTWV0YWRhdGEgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IGRlZmluZXMgb3JkZXIgZGlyZWN0aW9ucyB3aGVuIHNvcnRpbmdcbiAqXG4gKiBAY29uc3RhbnQgT3JkZXJEaXJlY3Rpb25cbiAqXG4gKiBAY2F0ZWdvcnkgUXVlcnlcbiAqL1xuZXhwb3J0IGVudW0gT3JkZXJEaXJlY3Rpb24ge1xuICAvKipcbiAgICogQHN1bW1hcnkgRGVmaW5lcyB0aGUgc29ydCBvcmRlciBhcyBhc2NlbmRpbmdcbiAgICogQHByb3AgQVNDXG4gICAqL1xuICBBU0MgPSBcImFzY1wiLFxuICAvKipcbiAgICogQHN1bW1hcnkgRGVmaW5lcyB0aGUgc29ydCBvcmRlciBhcyBkZXNjZW5kaW5nXG4gICAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBEU0NcbiAgICovXG4gIERTQyA9IFwiZGVzY1wiLFxufVxuXG5leHBvcnQgZW51bSBDYXNjYWRlIHtcbiAgQ0FTQ0FERSA9IFwiY2FzY2FkZVwiLFxuICBOT05FID0gXCJub25lXCIsXG59XG5cbmV4cG9ydCBjb25zdCBEZWZhdWx0Q2FzY2FkZTogQ2FzY2FkZU1ldGFkYXRhID0ge1xuICB1cGRhdGU6IENhc2NhZGUuQ0FTQ0FERSxcbiAgZGVsZXRlOiBDYXNjYWRlLk5PTkUsXG59O1xuIl19

package/lib/esm/repository/decorators.d.ts

@@ -1,3 +1,2 @@
-import { DBModel } from "@decaf-ts/db-decorators";
-import { Constructor } from "@decaf-ts/decorator-validation";
-export declare function repository<T extends DBModel>(model: Constructor<T>, nameOverride?: string): (original: any, propertyKey?: string) => any;
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+export declare function repository<T extends Model>(model: Constructor<T>, nameOverride?: string): any;

package/lib/esm/repository/decorators.js

@@ -1 +1,23 @@
-import{inject,injectable}from"@decaf-ts/injectable-decorators";import{DBKeys,getDBKey}from"@decaf-ts/db-decorators";import{metadata}from"@decaf-ts/reflection";import{bootRepository}from"./utils";function repository(o,a){return(e,t)=>{var r;return t?(r=bootRepository(o,e),inject(r)(e,t)):(metadata(getDBKey(DBKeys.REPOSITORY),a||e.name)(o),injectable(a||e.name,!0,e=>{Object.defineProperty(e,DBKeys.CLASS,{enumerable:!1,configurable:!1,writable:!1,value:o})})(e))}}export{repository};
+import { inject, injectable } from "@decaf-ts/injectable-decorators";
+import { DBKeys } from "@decaf-ts/db-decorators";
+import { metadata } from "@decaf-ts/reflection";
+import { Repository } from "./Repository";
+export function repository(model, nameOverride) {
+    return ((original, propertyKey) => {
+        if (propertyKey) {
+            return inject(nameOverride || model.name)(original, propertyKey);
+        }
+        metadata(Repository.key(DBKeys.REPOSITORY), nameOverride || original.name)(model);
+        Repository.register(nameOverride || original.name, original);
+        return injectable(nameOverride || original.name, true, (instance) => {
+            Object.defineProperty(instance, DBKeys.CLASS, {
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: model,
+            });
+        })(original);
+    });
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/repository/errors.js

@@ -1 +1,16 @@
-import{BaseError}from"@decaf-ts/db-decorators";class ObserverError extends BaseError{constructor(r){super(ObserverError.name,r)}}export{ObserverError};
+import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @summary Represents a failure in observer communication
+ *
+ * @param {string} msg the error message
+ *
+ * @class ObserverError
+ * @extends BaseError
+ */
+export class ObserverError extends BaseError {
+    constructor(msg) {
+        super(ObserverError.name, msg);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9yZXBvc2l0b3J5L2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sT0FBTyxhQUFjLFNBQVEsU0FBUztJQUMxQyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7Q0FDRiIsImZpbGUiOiJyZXBvc2l0b3J5L2Vycm9ycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VFcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgYSBmYWlsdXJlIGluIG9ic2VydmVyIGNvbW11bmljYXRpb25cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbXNnIHRoZSBlcnJvciBtZXNzYWdlXG4gKlxuICogQGNsYXNzIE9ic2VydmVyRXJyb3JcbiAqIEBleHRlbmRzIEJhc2VFcnJvclxuICovXG5leHBvcnQgY2xhc3MgT2JzZXJ2ZXJFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihPYnNlcnZlckVycm9yLm5hbWUsIG1zZyk7XG4gIH1cbn1cbiJdfQ==

package/lib/esm/repository/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./constants";
 export * from "./decorators";
 export * from "./errors";
+export * from "./injectables";
 export * from "./Repository";
 export * from "./types";
 export * from "./utils";

package/lib/esm/repository/index.js

@@ -1 +1,9 @@
-export*from"./constants";export*from"./decorators";export*from"./errors";export*from"./Repository";export*from"./types";export*from"./utils";
+export * from "./constants";
+export * from "./decorators";
+export * from "./errors";
+export * from "./injectables";
+export * from "./Repository";
+export * from "./types";
+export * from "./utils";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9yZXBvc2l0b3J5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDIiwiZmlsZSI6InJlcG9zaXRvcnkvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW5qZWN0YWJsZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuIl19

package/lib/esm/repository/injectables.d.ts

@@ -0,0 +1,5 @@
+import { InjectableRegistryImp } from "@decaf-ts/injectable-decorators";
+export declare class InjectablesRegistry extends InjectableRegistryImp {
+    constructor();
+    get<T>(name: string): T | undefined;
+}

package/lib/esm/repository/injectables.js

@@ -0,0 +1,32 @@
+import { InjectableRegistryImp, Injectables, } from "@decaf-ts/injectable-decorators";
+import { Repository } from "./Repository";
+import { Model } from "@decaf-ts/decorator-validation";
+import { generateInjectableNameForRepository } from "./utils";
+import { PersistenceKeys } from "../persistence/constants";
+import { Adapter } from "../persistence/Adapter";
+export class InjectablesRegistry extends InjectableRegistryImp {
+    constructor() {
+        super();
+    }
+    get(name) {
+        let injectable = super.get(name);
+        if (!injectable)
+            try {
+                const m = Model.get(name);
+                if (m)
+                    injectable = Repository.forModel(m);
+                if (injectable) {
+                    const flavour = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), injectable.constructor) ||
+                        Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), m);
+                    Injectables.register(injectable, generateInjectableNameForRepository(m, flavour));
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                return undefined;
+            }
+        return injectable;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/repository/types.d.ts

@@ -10,3 +10,6 @@ export type IndexMetadata = {
     directions?: OrderDirection[2];
     compositions?: string[];
 };
+export type NamedIndexMetadata = IndexMetadata & {
+    suffix: string;
+};

package/lib/esm/repository/types.js

@@ -0,0 +1,3 @@
+export {};
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9yZXBvc2l0b3J5L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoicmVwb3NpdG9yeS90eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhc2NhZGUsIE9yZGVyRGlyZWN0aW9uIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgZGVmaW5lcyB0aGUgY2FzY2FkaW5nIGJlaGF2aW91clxuICovXG5leHBvcnQgdHlwZSBDYXNjYWRlTWV0YWRhdGEgPSB7XG4gIHVwZGF0ZTogQ2FzY2FkZTtcbiAgZGVsZXRlOiBDYXNjYWRlO1xufTtcblxuZXhwb3J0IHR5cGUgSW5kZXhNZXRhZGF0YSA9IHtcbiAgZGlyZWN0aW9ucz86IE9yZGVyRGlyZWN0aW9uWzJdO1xuICBjb21wb3NpdGlvbnM/OiBzdHJpbmdbXTtcbn07XG5cbmV4cG9ydCB0eXBlIE5hbWVkSW5kZXhNZXRhZGF0YSA9IEluZGV4TWV0YWRhdGEgJiB7XG4gIHN1ZmZpeDogc3RyaW5nO1xufTtcbiJdfQ==

package/lib/esm/repository/utils.d.ts

@@ -1,5 +1,3 @@
-import { DBModel } from "@decaf-ts/db-decorators";
-import { Repository } from "./Repository";
 import { Constructor } from "@decaf-ts/decorator-validation";
-export declare function bootRepository<T extends DBModel>(model: Constructor<T>, original: (...args: any[]) => Repository<T>): string;
-export declare function getTableName<T extends DBModel>(model: T | any): any;
+import { Model } from "@decaf-ts/decorator-validation";
+export declare function generateInjectableNameForRepository<T extends Model>(model: Constructor<T> | T, flavour?: string): string;

package/lib/esm/repository/utils.js

@@ -1 +1,17 @@
-import{DBKeys,DBModel,getDBKey,InternalError}from"@decaf-ts/db-decorators";import{Injectables}from"@decaf-ts/injectable-decorators";import{Adapter}from"../persistence/Adapter";import{getPersistenceKey}from"../persistence/decorators";import{PersistenceKeys}from"../persistence/constants";function bootRepository(e,t){var r=Reflect.getMetadata(getDBKey(DBKeys.REPOSITORY),e);if(!r)throw new InternalError("No Repository defined for model "+e.constructor.name);e=Reflect.getMetadata(getPersistenceKey(PersistenceKeys.ADAPTER),t);if(!e)throw new InternalError("Could not find persistence adapter definition for repository "+t.name);try{var o=Adapter.get(e);Injectables.get(r,o)}catch(e){throw new InternalError(e)}return r}function getTableName(e){var t=Reflect.getMetadata(getPersistenceKey(PersistenceKeys.TABLE),e instanceof DBModel?e.constructor:e);return t||(e instanceof DBModel?e.constructor:e).name}export{bootRepository,getTableName};
+import { InternalError } from "@decaf-ts/db-decorators";
+import { sf } from "@decaf-ts/decorator-validation";
+import { Adapter } from "../persistence/Adapter";
+import { PersistenceKeys } from "../persistence/constants";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Repository } from "./Repository";
+export function generateInjectableNameForRepository(model, flavour) {
+    if (!flavour) {
+        const key = Adapter.key(PersistenceKeys.ADAPTER);
+        flavour = Reflect.getMetadata(key, model instanceof Model ? model.constructor : model);
+        if (!flavour)
+            throw new InternalError(`Could not retrieve flavour from model ${model instanceof Model ? model.constructor.name : model.name}`);
+    }
+    return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/validators/ClauseSequenceValidator.d.ts

@@ -0,0 +1,28 @@
+import { Validator } from "@decaf-ts/decorator-validation";
+/**
+ * @summary Validates a {@link Sequence}'s {@link Clause}s
+ *
+ * @param {string} [message]
+ *
+ * @class ClauseSequenceValidator
+ * @extends Validator
+ *
+ * @category Validation
+ * @subcategory Validators
+ */
+export declare class ClauseSequenceValidator extends Validator {
+    constructor(message?: string);
+    private validateSequence;
+    /**
+     * @summary Verifies the model for errors
+     * @param {string} value
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator
+     */
+    hasErrors(value: any, message?: string): string | undefined;
+}