@decaf-ts/core 0.1.3 → 0.2.1

package/lib/esm/persistence/Adapter.js

@@ -1 +1,178 @@
-import{InternalError,NotFoundError}from"@decaf-ts/db-decorators";import{ObserverError}from"../repository/errors";import{Model}from"@decaf-ts/decorator-validation";import{getColumnName}from"./utils";import{PersistenceKeys}from"./constants";class Adapter{static{this._cache={}}get native(){return this._native}constructor(e,r){this.observers=[],this._native=e,Adapter._cache[r]=this}isReserved(e){return!e}async prepare(s,i){var e=Object.entries(s).reduce((e,[r,t])=>{if(r!==i){r=getColumnName(s,r);if(this.isReserved(r))throw new InternalError(`Property name ${r} is reserved`);e[r]=t}return e},{});return s[PersistenceKeys.METADATA]&&Object.defineProperty(e,PersistenceKeys.METADATA,{enumerable:!1,writable:!1,configurable:!0,value:s[PersistenceKeys.METADATA]}),{record:e,id:s[i]}}async revert(t,e,s,r){var i={},r=(i[s]=r,"string"==typeof e?Model.build(i,e):new e(i)),e=t[PersistenceKeys.METADATA],i=Object.keys(r).reduce((e,r)=>(r!==s&&(e[r]=t[getColumnName(e,r)]),e),r);return e&&Object.defineProperty(i,PersistenceKeys.METADATA,{enumerable:!1,configurable:!1,writable:!1,value:e}),i}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 get current(){return this._current}static get(e){if(e in this._cache)return this._cache[e];throw new InternalError(`No Adapter registered under ${e}. Did you use the @adapter decorator?`)}static setCurrent(e){var r=this.get(e);if(!r)throw new NotFoundError(`No persistence flavour ${e} registered`);this._current=r}}export{Adapter};
+import { DBKeys, InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
+import { ObserverError } from "../repository/errors";
+import { Model, } from "@decaf-ts/decorator-validation";
+import { PersistenceKeys } from "./constants";
+import { Query } from "../query/Query";
+import { Repository } from "../repository/Repository";
+/**
+ * @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
+ */
+export class Adapter {
+    static { this._cache = {}; }
+    get native() {
+        return this._native;
+    }
+    constructor(native, flavour) {
+        this.flavour = flavour;
+        this._observers = [];
+        this._native = native;
+        Adapter._cache[flavour] = this;
+    }
+    Query() {
+        return new Query(this);
+    }
+    isReserved(attr) {
+        return !attr;
+    }
+    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 InternalError(`Property name ${mappedProp} is reserved`);
+            accum[mappedProp] = val;
+            return accum;
+        }, {});
+        if (model[PersistenceKeys.METADATA])
+            Object.defineProperty(result, PersistenceKeys.METADATA, {
+                enumerable: false,
+                writable: false,
+                configurable: true,
+                value: model[PersistenceKeys.METADATA],
+            });
+        return {
+            record: result,
+            id: model[pk],
+        };
+    }
+    revert(obj, clazz, pk, id) {
+        const ob = {};
+        ob[pk] = id;
+        const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
+        const metadata = obj[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, 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 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 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 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 get current() {
+        return this._current;
+    }
+    static get(flavour) {
+        if (flavour in this._cache)
+            return this._cache[flavour];
+        throw new InternalError(`No Adapter registered under ${flavour}.`);
+    }
+    static setCurrent(flavour) {
+        const adapter = this.get(flavour);
+        if (!adapter)
+            throw new NotFoundError(`No persistence flavour ${flavour} registered`);
+        this._current = adapter;
+    }
+    static key(key) {
+        return Repository.key(key);
+    }
+    static models(flavour) {
+        try {
+            const registry = Model.getRegistry();
+            const cache = registry.cache;
+            const managedModels = Object.values(cache)
+                .map((m) => {
+                let f = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), m);
+                if (f && f === flavour)
+                    return m;
+                if (!f) {
+                    const repo = Reflect.getMetadata(Repository.key(DBKeys.REPOSITORY), m);
+                    if (!repo)
+                        return;
+                    const repository = Repository.forModel(m);
+                    f = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repository);
+                    return f;
+                }
+            })
+                .filter((m) => !!m);
+            return managedModels;
+        }
+        catch (e) {
+            throw new InternalError(e);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/persistence/Adapter.ts"],"names":[],"mappings":"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","file":"persistence/Adapter.js","sourcesContent":["import {\n  BaseError,\n  DBKeys,\n  InternalError,\n  NotFoundError,\n} from \"@decaf-ts/db-decorators\";\nimport { Observer } from \"../interfaces/Observer\";\nimport { ObserverError } from \"../repository/errors\";\nimport { Sequence } from \"../interfaces/Sequence\";\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\";\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  private readonly _observers: Observer[] = [];\n  private readonly _native: Y;\n\n  get native() {\n    return this._native;\n  }\n\n  protected constructor(\n    native: Y,\n    readonly flavour: string\n  ) {\n    this._native = native;\n    Adapter._cache[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 index<M extends Model>(...models: M[]): Promise<any>;\n\n  abstract Sequence(options: SequenceOptions): Promise<Sequence>;\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, ...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    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 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 = this.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"]}

package/lib/esm/persistence/constants.d.ts

@@ -1 +1,10 @@
-export declare const PersistenceKeys: Record<string, string>;
+export declare enum PersistenceKeys {
+    INDEX = "index",
+    UNIQUE = "unique",
+    ADAPTER = "adapter",
+    INJECTABLE = "decaf_{0}_adapter_for_{1}",
+    TABLE = "table",
+    COLUMN = "column",
+    METADATA = "__metadata",
+    CLAUSE_SEQUENCE = "clause-sequence"
+}

package/lib/esm/persistence/constants.js

@@ -1 +1,13 @@
-let PersistenceKeys={REFLECT:"model.persistence.",INDEX:"index",UNIQUE:"unique",ADAPTER:"adapter",INJECTABLE:"decaf-adapter-{0}",TABLE:"table",COLUMN:"column",METADATA:"__metadata"};export{PersistenceKeys};
+export var PersistenceKeys;
+(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["CLAUSE_SEQUENCE"] = "clause-sequence";
+})(PersistenceKeys || (PersistenceKeys = {}));
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9wZXJzaXN0ZW5jZS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksZUFTWDtBQVRELFdBQVksZUFBZTtJQUN6QixrQ0FBZSxDQUFBO0lBQ2Ysb0NBQWlCLENBQUE7SUFDakIsc0NBQW1CLENBQUE7SUFDbkIsMkRBQXdDLENBQUE7SUFDeEMsa0NBQWUsQ0FBQTtJQUNmLG9DQUFpQixDQUFBO0lBQ2pCLDBDQUF1QixDQUFBO0lBQ3ZCLHNEQUFtQyxDQUFBO0FBQ3JDLENBQUMsRUFUVyxlQUFlLEtBQWYsZUFBZSxRQVMxQiIsImZpbGUiOiJwZXJzaXN0ZW5jZS9jb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBQZXJzaXN0ZW5jZUtleXMge1xuICBJTkRFWCA9IFwiaW5kZXhcIixcbiAgVU5JUVVFID0gXCJ1bmlxdWVcIixcbiAgQURBUFRFUiA9IFwiYWRhcHRlclwiLFxuICBJTkpFQ1RBQkxFID0gXCJkZWNhZl97MH1fYWRhcHRlcl9mb3JfezF9XCIsXG4gIFRBQkxFID0gXCJ0YWJsZVwiLFxuICBDT0xVTU4gPSBcImNvbHVtblwiLFxuICBNRVRBREFUQSA9IFwiX19tZXRhZGF0YVwiLFxuICBDTEFVU0VfU0VRVUVOQ0UgPSBcImNsYXVzZS1zZXF1ZW5jZVwiLFxufVxuIl19

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

@@ -1,2 +1 @@
-export declare function getPersistenceKey(key: string): string;
-export declare function uses(flavour: string): import("@decaf-ts/reflection").CustomDecorator<V>;
+export declare function uses(flavour: string): ClassDecorator;

package/lib/esm/persistence/decorators.js

@@ -1 +1,10 @@
-import{metadata}from"@decaf-ts/reflection";import{PersistenceKeys}from"./constants";function getPersistenceKey(e){return PersistenceKeys.REFLECT+e}function uses(e){return metadata(getPersistenceKey(PersistenceKeys.ADAPTER),e)}export{getPersistenceKey,uses};
+import { metadata } from "@decaf-ts/reflection";
+import { PersistenceKeys } from "./constants";
+import { Adapter } from "./Adapter";
+export function uses(flavour) {
+    return (original) => {
+        return metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour)(original);
+    };
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9wZXJzaXN0ZW5jZS9kZWNvcmF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUNoRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQzlDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFcEMsTUFBTSxVQUFVLElBQUksQ0FBQyxPQUFlO0lBQ2xDLE9BQU8sQ0FBQyxRQUFnQixFQUFFLEVBQUU7UUFDMUIsT0FBTyxRQUFRLENBQ2IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLEVBQ3BDLE9BQU8sQ0FDUixDQUFDLFFBQWUsQ0FBQyxDQUFDO0lBQ3JCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJmaWxlIjoicGVyc2lzdGVuY2UvZGVjb3JhdG9ycy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1ldGFkYXRhIH0gZnJvbSBcIkBkZWNhZi10cy9yZWZsZWN0aW9uXCI7XG5pbXBvcnQgeyBQZXJzaXN0ZW5jZUtleXMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IEFkYXB0ZXIgfSBmcm9tIFwiLi9BZGFwdGVyXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VzKGZsYXZvdXI6IHN0cmluZyk6IENsYXNzRGVjb3JhdG9yIHtcbiAgcmV0dXJuIChvcmlnaW5hbDogb2JqZWN0KSA9PiB7XG4gICAgcmV0dXJuIG1ldGFkYXRhKFxuICAgICAgQWRhcHRlci5rZXkoUGVyc2lzdGVuY2VLZXlzLkFEQVBURVIpLFxuICAgICAgZmxhdm91clxuICAgICkob3JpZ2luYWwgYXMgYW55KTtcbiAgfTtcbn1cbiJdfQ==

package/lib/esm/persistence/errors.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export declare class ConnectionError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/esm/persistence/errors.js

@@ -0,0 +1,8 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+export class ConnectionError extends BaseError {
+    constructor(msg) {
+        super(ConnectionError.name, msg);
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9wZXJzaXN0ZW5jZS9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXBELE1BQU0sT0FBTyxlQUFnQixTQUFRLFNBQVM7SUFDNUMsWUFBWSxHQUFtQjtRQUM3QixLQUFLLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztJQUNuQyxDQUFDO0NBQ0YiLCJmaWxlIjoicGVyc2lzdGVuY2UvZXJyb3JzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCBjbGFzcyBDb25uZWN0aW9uRXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZyB8IEVycm9yKSB7XG4gICAgc3VwZXIoQ29ubmVjdGlvbkVycm9yLm5hbWUsIG1zZyk7XG4gIH1cbn1cbiJdfQ==

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

@@ -1,4 +1,4 @@
 export * from "./Adapter";
 export * from "./constants";
 export * from "./decorators";
-export * from "./utils";
+export * from "./errors";

package/lib/esm/persistence/index.js

@@ -1 +1,6 @@
-export*from"./Adapter";export*from"./constants";export*from"./decorators";export*from"./utils";
+export * from "./Adapter";
+export * from "./constants";
+export * from "./decorators";
+export * from "./errors";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9wZXJzaXN0ZW5jZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFVBQVUsQ0FBQyIsImZpbGUiOiJwZXJzaXN0ZW5jZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0FkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXJyb3JzXCI7XG4iXX0=

package/lib/esm/query/Clause.d.ts

@@ -0,0 +1,43 @@
+import { Executor } from "../interfaces";
+import { Model, ModelArg } from "@decaf-ts/decorator-validation";
+import { QueryBuilder } from "./options";
+import { Priority } from "./constants";
+import { Statement } from "./Statement";
+/**
+ */
+/**
+ * @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
+ */
+export declare abstract class Clause<Q> extends Model implements Executor, QueryBuilder<Q> {
+    readonly priority: Priority;
+    readonly statement: Statement<Q>;
+    protected constructor(clause?: ModelArg<Clause<Q>>);
+    protected get adapter(): import("..").Adapter<any, Q>;
+    protected get Clauses(): import("./ClauseFactory").ClauseFactory<any, Q>;
+    /**
+     * @summary return the priority of the clause
+     * @see Priority
+     */
+    getPriority(): number;
+    abstract build(previous: Q): Q;
+    /**
+     * @inheritDoc
+     * @abstract
+     */
+    execute<R>(): Promise<R>;
+    toString(): string;
+}

package/lib/esm/query/Clause.js

@@ -0,0 +1,76 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Model, required, type, } from "@decaf-ts/decorator-validation";
+import { QueryError } from "./errors";
+import { Priority } from "./constants";
+import { Statement } from "./Statement";
+/**
+ */
+/**
+ * @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
+ */
+export class Clause extends 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();
+    }
+    toString() {
+        return this.constructor.name;
+    }
+}
+__decorate([
+    required(),
+    __metadata("design:type", Number)
+], Clause.prototype, "priority", void 0);
+__decorate([
+    required(),
+    type("object"),
+    __metadata("design:type", Statement)
+], Clause.prototype, "statement", void 0);
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/ClauseFactory.d.ts

@@ -0,0 +1,71 @@
+import { FromClause } from "./clauses";
+import { GroupByClause } from "./clauses/GroupByClause";
+import { InsertClause } from "./clauses/InsertClause";
+import { LimitClause } from "./clauses/LimitClause";
+import { OffsetClause } from "./clauses/OffsetClause";
+import { OrderByClause } from "./clauses/OrderByClause";
+import { SelectClause } from "./clauses/SelectClause";
+import { ValuesClause } from "./clauses/ValuesClause";
+import { WhereClause } from "./clauses/WhereClause";
+import { Adapter } from "../persistence";
+import { Condition } from "./Condition";
+import { FromSelector, GroupBySelector, LimitSelector, OffsetSelector, OrderBySelector, SelectSelector } from "./selectors";
+import { Statement } from "./Statement";
+import { Model } from "@decaf-ts/decorator-validation";
+export declare abstract class ClauseFactory<Y, Q> {
+    protected adapter: Adapter<Y, Q>;
+    /**
+     * @summary Factory method for {@link FromClause}
+     * @param {Statement} statement
+     * @param {FromSelector} selector
+     */
+    abstract from<M extends Model>(statement: Statement<Q>, selector: FromSelector<M>): FromClause<Q, M>;
+    /**
+     * @summary Factory method for {@link GroupByClause}
+     * @param {Statement} statement
+     * @param {GroupBySelector} selector
+     */
+    abstract groupBy(statement: Statement<Q>, selector: GroupBySelector): GroupByClause<Q>;
+    /**
+     * @summary Factory method for {@link InsertClause}
+     * @param {Statement} statement
+     */
+    abstract insert<M extends Model>(): InsertClause<Q, M>;
+    /**
+     * @summary Factory method for {@link LimitClause}
+     * @param {Statement} statement
+     * @param {LimitSelector} selector
+     */
+    abstract limit(statement: Statement<Q>, selector: LimitSelector): LimitClause<Q>;
+    /**
+     * @summary Factory method for {@link OffsetClause}
+     * @param {Statement} statement
+     * @param {OffsetSelector} selector
+     */
+    abstract offset(statement: Statement<Q>, selector: OffsetSelector): OffsetClause<Q>;
+    /**
+     * @summary Factory method for {@link OrderByClause}
+     * @param {Statement} statement
+     * @param {OrderBySelector} selector
+     */
+    abstract orderBy(statement: Statement<Q>, selector: OrderBySelector[]): OrderByClause<Q>;
+    /**
+     * @summary Factory method for {@link SelectClause}
+     * @param {Statement} statement
+     * @param {SelectSelector} [selector]
+     */
+    abstract select<M extends Model>(selector?: SelectSelector): SelectClause<Q, M>;
+    /**
+     * @summary Factory method for {@link ValuesClause}
+     * @param {Statement} statement
+     * @param {M[]} values
+     */
+    abstract values<M extends Model>(statement: Statement<Q>, values: M[]): ValuesClause<Q, M>;
+    /**
+     * @summary Factory method for {@link WhereClause}
+     * @param {Statement} statement
+     * @param {Condition} condition
+     */
+    abstract where(statement: Statement<Q>, condition: Condition): WhereClause<Q>;
+    protected constructor(adapter: Adapter<Y, Q>);
+}

package/lib/esm/query/ClauseFactory.js

@@ -0,0 +1,7 @@
+export class ClauseFactory {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/query/Condition.d.ts

@@ -0,0 +1,75 @@
+import { AttributeOption, ConditionBuilderOption } from "./options";
+import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { GroupOperator, Operator } from "./constants";
+/**
+ * @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
+ */
+export declare class Condition extends Model {
+    protected attr1?: string | Condition;
+    protected operator?: Operator | GroupOperator;
+    protected comparison?: any;
+    private constructor();
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition
+     */
+    and(condition: Condition): Condition;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition
+     */
+    or(condition: Condition): Condition;
+    /**
+     * @summary excludes a valut from the result
+     * @param val
+     */
+    not(val: any): Condition;
+    /**
+     * @inheritDoc
+     */
+    hasErrors(...exceptions: string[]): ModelErrorDefinition | undefined;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static and(condition1: Condition, condition2: Condition): Condition;
+    /**
+     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
+     * @param {Condition} condition1
+     * @param {Condition} condition2
+     */
+    static or(condition1: Condition, condition2: Condition): Condition;
+    /**
+     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
+     * @param {Condition} condition1
+     * @param {GroupOperator} operator
+     * @param {Condition} condition2
+     */
+    private static group;
+    static attribute(attr: string): AttributeOption;
+    /**
+     * @summary Condition Builder Class
+     * @description provides a simple API to build {@link Condition}s
+     *
+     * @class ConditionBuilder
+     * @implements Builder
+     * @implements AttributeOption
+     *
+     * @category Query
+     * @subcategory Conditions
+     */
+    private static Builder;
+    static get builder(): ConditionBuilderOption;
+}