@decaf-ts/core 0.4.1 → 0.5.1

package/lib/esm/persistence/Adapter.js

@@ -1,16 +1,36 @@
-import { DBKeys, InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
-import { Model, } from "@decaf-ts/decorator-validation";
+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 { DBKeys, InternalError, NotFoundError, Context, OperationKeys, DefaultRepositoryFlags, modelToTransient, } from "@decaf-ts/db-decorators";
+import { Decoration, DefaultFlavour, Model, } from "@decaf-ts/decorator-validation";
 import { PersistenceKeys } from "./constants";
-import { Query } from "../query/Query";
 import { Repository } from "../repository/Repository";
-import { Context as Ctx } from "../repository/Context";
-import { UnsupportedError } from "./errors";
+import { Logging } from "@decaf-ts/logging";
+import { final } from "../utils";
+import { Dispatch } from "./Dispatch";
+import { ObserverHandler } from "./ObserverHandler";
+Decoration.setFlavourResolver((obj) => {
+    try {
+        return (Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : obj) ||
+            DefaultFlavour);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        return DefaultFlavour;
+    }
+});
 /**
  * @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 Y the underlying persistence object type or the required config to set it up
  * @typedef Q The query object the adapter uses
  *
  * @param {Y} native the underlying persistence object
@@ -22,72 +42,93 @@ import { UnsupportedError } from "./errors";
  */
 export class Adapter {
     static { this._cache = {}; }
+    get log() {
+        if (!this.logger)
+            this.logger = Logging.for(this);
+        return this.logger;
+    }
     get native() {
         return this._native;
     }
+    get alias() {
+        return this._alias || this.flavour;
+    }
     repository() {
         return Repository;
     }
-    constructor(native, flavour) {
+    constructor(_native, flavour, _alias) {
+        this._native = _native;
         this.flavour = flavour;
-        this._observers = [];
+        this._alias = _alias;
+        this.Context = (Context);
         if (this.flavour in Adapter._cache)
-            throw new InternalError(`Persistence adapter flavour ${this.flavour} already registered`);
-        this._native = native;
-        Adapter._cache[this.flavour] = this;
+            throw new InternalError(`${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : ""} already registered`);
+        Adapter._cache[this.alias] = this;
+        this.log.info(`Created ${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : ""} persistence adapter`);
+        if (!Adapter._current) {
+            this.log.verbose(`Defined ${this.alias} persistence adapter as current`);
+            Adapter._current = this;
+        }
+    }
+    Dispatch() {
+        return new Dispatch();
     }
-    Query() {
-        return new Query(this);
+    ObserverHandler() {
+        return new ObserverHandler();
     }
     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 Ctx {
-            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;
+    flags(operation, model, flags, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return Object.assign({}, DefaultRepositoryFlags, flags, {
+            affectedTables: Repository.table(model),
+            writeOperation: operation !== OperationKeys.READ,
+            timestamp: new Date(),
+            operation: operation,
+        });
+    }
+    async context(operation, overrides, model, ...args) {
+        this.log
+            .for(this.context)
+            .debug(`Creating new context for ${operation} operation on ${model.name} model with flags: ${JSON.stringify(overrides)}`);
+        return new this.Context(this.flags(operation, model, overrides, ...args));
     }
     prepare(model, pk) {
-        const result = Object.entries(model).reduce((accum, [key, val]) => {
-            // if (key === pk) return accum;
+        const log = this.log.for(this.prepare);
+        log.silly(`Preparing model ${model.constructor.name} before persisting`);
+        const split = modelToTransient(model);
+        const result = Object.entries(split.model).reduce((accum, [key, val]) => {
+            if (typeof val === "undefined")
+                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])
+        if (model[PersistenceKeys.METADATA]) {
+            log.silly(`Passing along persistence metadata for ${model[PersistenceKeys.METADATA]}`);
             Object.defineProperty(result, PersistenceKeys.METADATA, {
                 enumerable: false,
                 writable: false,
                 configurable: true,
                 value: model[PersistenceKeys.METADATA],
             });
+        }
         return {
             record: result,
             id: model[pk],
+            transient: split.transient,
         };
     }
-    revert(obj, clazz, pk, id) {
+    revert(obj, clazz, pk, id, transient) {
+        const log = this.log.for(this.revert);
         const ob = {};
         ob[pk] = id;
         const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
+        log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
         const metadata = obj[PersistenceKeys.METADATA];
         const result = Object.keys(m).reduce((accum, key) => {
             if (key === pk)
@@ -95,42 +136,72 @@ export class Adapter {
             accum[key] = obj[Repository.column(accum, key)];
             return accum;
         }, m);
-        if (metadata)
+        if (transient) {
+            log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+            Object.entries(transient).forEach(([key, val]) => {
+                if (key in result)
+                    throw new InternalError(`Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`);
+                result[key] = val;
+            });
+        }
+        if (metadata) {
+            log.silly(`Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${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");
+        const log = this.log.for(this.createAll);
+        log.verbose(`Creating ${id.length} entries ${tableName} table`);
+        log.debug(`pks: ${id}`);
         return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...args)));
     }
     async readAll(tableName, id, ...args) {
+        const log = this.log.for(this.readAll);
+        log.verbose(`Reading ${id.length} entries ${tableName} table`);
+        log.debug(`pks: ${id}`);
         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");
+        const log = this.log.for(this.updateAll);
+        log.verbose(`Updating ${id.length} entries ${tableName} table`);
+        log.debug(`pks: ${id}`);
         return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...args)));
     }
     async deleteAll(tableName, id, ...args) {
+        const log = this.log.for(this.createAll);
+        log.verbose(`Deleting ${id.length} entries ${tableName} table`);
+        log.debug(`pks: ${id}`);
         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);
+    observe(observer, filter) {
+        if (!this.observerHandler)
+            Object.defineProperty(this, "observerHandler", {
+                value: this.ObserverHandler(),
+                writable: false,
+            });
+        this.observerHandler.observe(observer, filter);
+        this.log
+            .for(this.observe)
+            .verbose(`Registering new observer ${observer.toString()}`);
+        if (!this.dispatch) {
+            this.log.for(this.observe).info(`Creating dispatch for ${this.alias}`);
+            this.dispatch = this.Dispatch();
+            this.dispatch.observe(this);
+        }
     }
     /**
      * @summary Unregisters an {@link Observer}
@@ -139,24 +210,34 @@ export class Adapter {
      * @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);
+        if (!this.observerHandler)
+            throw new InternalError("ObserverHandler not initialized. Did you register any observables?");
+        this.observerHandler.unObserve(observer);
+        this.log
+            .for(this.unObserve)
+            .verbose(`Observer ${observer.toString()} removed`);
     }
-    /**
-     * @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}`);
-        });
+    async updateObservers(table, event, id, ...args) {
+        if (!this.observerHandler)
+            throw new InternalError("ObserverHandler not initialized. Did you register any observables?");
+        const log = this.log.for(this.updateObservers);
+        log.verbose(`Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`);
+        await this.observerHandler.updateObservers(this.log, table, event, id, ...args);
+    }
+    async refresh(table, event, id, ...args) {
+        return this.updateObservers(table, event, id, ...args);
+    }
+    toString() {
+        return `${this.flavour} persistence Adapter`;
+    }
+    static flavourOf(model) {
+        return (Reflect.getMetadata(this.key(PersistenceKeys.ADAPTER), model) ||
+            this.current.flavour);
     }
     static get current() {
-        return this._current;
+        if (!Adapter._current)
+            throw new InternalError(`No persistence flavour set. Please initialize your adapter`);
+        return Adapter._current;
     }
     static get(flavour) {
         if (flavour in this._cache)
@@ -198,4 +279,22 @@ export class Adapter {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Adapter.js","sourceRoot":"","sources":["../../../src/persistence/Adapter.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], Adapter.prototype, "context", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", void 0)
+], Adapter.prototype, "observe", null);
+__decorate([
+    final(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], Adapter.prototype, "unObserve", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Adapter.js","sourceRoot":"","sources":["../../../src/persistence/Adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseError,\n  DBKeys,\n  InternalError,\n  NotFoundError,\n  Context,\n  OperationKeys,\n  RepositoryFlags,\n  DefaultRepositoryFlags,\n  Contextual,\n  BulkCrudOperationKeys,\n  modelToTransient,\n} from \"@decaf-ts/db-decorators\";\nimport { type Observer } from \"../interfaces/Observer\";\nimport {\n  type Constructor,\n  Decoration,\n  DefaultFlavour,\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 { Repository } from \"../repository/Repository\";\nimport { Sequence } from \"./Sequence\";\nimport { ErrorParser } from \"../interfaces\";\nimport { Statement } from \"../query/Statement\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { final } from \"../utils\";\nimport { Dispatch } from \"./Dispatch\";\nimport { type EventIds, type ObserverFilter } from \"./types\";\nimport { ObserverHandler } from \"./ObserverHandler\";\n\nDecoration.setFlavourResolver((obj: object) => {\n  try {\n    return (\n      Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : (obj as any)) ||\n      DefaultFlavour\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    return DefaultFlavour;\n  }\n});\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 or the required config to set it up\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<\n    Y,\n    Q,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >\n  implements RawExecutor<Q>, Contextual<F, C>, Observable, Observer, ErrorParser\n{\n  private static _current: Adapter<any, any, any, any>;\n  private static _cache: Record<string, Adapter<any, any, any, any>> = {};\n\n  private logger!: Logger;\n\n  protected dispatch?: Dispatch<Y>;\n\n  protected readonly observerHandler?: ObserverHandler;\n\n  protected get log() {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  get native() {\n    return this._native;\n  }\n\n  get alias() {\n    return this._alias || this.flavour;\n  }\n\n  repository<M extends Model>(): Constructor<\n    Repository<M, Q, Adapter<Y, Q, F, C>, F, C>\n  > {\n    return Repository;\n  }\n\n  protected constructor(\n    private readonly _native: Y,\n    readonly flavour: string,\n    private readonly _alias?: string\n  ) {\n    if (this.flavour in Adapter._cache)\n      throw new InternalError(\n        `${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} already registered`\n      );\n    Adapter._cache[this.alias] = this;\n    this.log.info(\n      `Created ${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} persistence adapter`\n    );\n    if (!Adapter._current) {\n      this.log.verbose(`Defined ${this.alias} persistence adapter as current`);\n      Adapter._current = this;\n    }\n  }\n\n  abstract Statement<M extends Model>(): Statement<Q, M, any>;\n\n  protected Dispatch(): Dispatch<Y> {\n    return new Dispatch();\n  }\n\n  protected ObserverHandler() {\n    return new ObserverHandler();\n  }\n\n  protected isReserved(attr: string) {\n    return !attr;\n  }\n\n  abstract parseError(err: Error): BaseError;\n\n  abstract initialize(...args: any[]): Promise<void>;\n\n  abstract Sequence(options: SequenceOptions): Promise<Sequence>;\n\n  protected flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<F>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): F {\n    return Object.assign({}, DefaultRepositoryFlags, flags, {\n      affectedTables: Repository.table(model),\n      writeOperation: operation !== OperationKeys.READ,\n      timestamp: new Date(),\n      operation: operation,\n    }) as F;\n  }\n\n  protected Context: Constructor<C> = Context<F> as any;\n\n  @final()\n  async context<M extends Model>(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    overrides: Partial<F>,\n    model: Constructor<M>,\n    ...args: any[]\n  ): Promise<C> {\n    this.log\n      .for(this.context)\n      .debug(\n        `Creating new context for ${operation} operation on ${model.name} model with flags: ${JSON.stringify(overrides)}`\n      );\n    return new this.Context(\n      this.flags(operation, model, overrides, ...args)\n    ) as unknown as C;\n  }\n\n  prepare<M extends Model>(\n    model: M,\n    pk: keyof M\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const log = this.log.for(this.prepare);\n    log.silly(`Preparing model ${model.constructor.name} before persisting`);\n    const split = modelToTransient(model);\n    const result = Object.entries(split.model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        if (typeof val === \"undefined\") 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      log.silly(\n        `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    }\n\n    return {\n      record: result,\n      id: model[pk] as string,\n      transient: split.transient,\n    };\n  }\n\n  revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number | bigint,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    const ob: Record<string, any> = {};\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\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\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    if (metadata) {\n      log.silly(\n        `Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    }\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    const log = this.log.for(this.createAll);\n    log.verbose(`Creating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\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    const log = this.log.for(this.readAll);\n    log.verbose(`Reading ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\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    const log = this.log.for(this.updateAll);\n    log.verbose(`Updating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\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    const log = this.log.for(this.createAll);\n    log.verbose(`Deleting ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\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   *\n   * @see {Observable#observe}\n   */\n  @final()\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    if (!this.observerHandler)\n      Object.defineProperty(this, \"observerHandler\", {\n        value: this.ObserverHandler(),\n        writable: false,\n      });\n    this.observerHandler!.observe(observer, filter);\n    this.log\n      .for(this.observe)\n      .verbose(`Registering new observer ${observer.toString()}`);\n    if (!this.dispatch) {\n      this.log.for(this.observe).info(`Creating dispatch for ${this.alias}`);\n      this.dispatch = this.Dispatch();\n      this.dispatch.observe(this);\n    }\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  @final()\n  unObserve(observer: Observer): void {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.observerHandler.unObserve(observer);\n    this.log\n      .for(this.unObserve)\n      .verbose(`Observer ${observer.toString()} removed`);\n  }\n\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    const log = this.log.for(this.updateObservers);\n    log.verbose(\n      `Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`\n    );\n    await this.observerHandler.updateObservers(\n      this.log,\n      table,\n      event,\n      id,\n      ...args\n    );\n  }\n\n  async refresh(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ) {\n    return this.updateObservers(table, event, id, ...args);\n  }\n\n  toString() {\n    return `${this.flavour} persistence Adapter`;\n  }\n\n  static flavourOf<M extends Model>(model: Constructor<M>): string {\n    return (\n      Reflect.getMetadata(this.key(PersistenceKeys.ADAPTER), model) ||\n      this.current.flavour\n    );\n  }\n\n  static get current() {\n    if (!Adapter._current)\n      throw new InternalError(\n        `No persistence flavour set. Please initialize your adapter`\n      );\n    return Adapter._current;\n  }\n\n  static get<Y, Q, C extends Context<F>, F extends RepositoryFlags>(\n    flavour: any\n  ): Adapter<Y, Q, F, C> | 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"]}

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

@@ -0,0 +1,18 @@
+import { OperationKeys, BulkCrudOperationKeys } from "@decaf-ts/db-decorators";
+import { ModelConstructor } from "@decaf-ts/decorator-validation";
+import { Observable, Observer } from "../interfaces";
+import { Adapter } from "./Adapter";
+import { Logger } from "@decaf-ts/logging";
+import { EventIds } from "./types";
+export declare class Dispatch<Y> implements Observable {
+    protected adapter?: Adapter<Y, any, any, any>;
+    protected native?: Y;
+    protected models: ModelConstructor<any>[];
+    private logger;
+    protected get log(): Logger;
+    constructor();
+    protected initialize(): void;
+    observe(observer: Adapter<Y, any, any, any>): void;
+    unObserve(observer: Observer): void;
+    updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds): Promise<void>;
+}

package/lib/esm/persistence/Dispatch.js

@@ -0,0 +1,89 @@
+import { InternalError, OperationKeys, BulkCrudOperationKeys, } from "@decaf-ts/db-decorators";
+import { Adapter } from "./Adapter";
+import { UnsupportedError } from "./errors";
+import { Logging } from "@decaf-ts/logging";
+export class Dispatch {
+    get log() {
+        if (!this.logger)
+            this.logger = Logging.for(this).for(this.adapter);
+        return this.logger;
+    }
+    constructor() { }
+    initialize() {
+        if (!this.adapter)
+            throw new InternalError(`No adapter observed for dispatch`);
+        const adapter = this.adapter;
+        [
+            OperationKeys.CREATE,
+            OperationKeys.UPDATE,
+            OperationKeys.DELETE,
+            BulkCrudOperationKeys.CREATE_ALL,
+            BulkCrudOperationKeys.UPDATE_ALL,
+            BulkCrudOperationKeys.DELETE_ALL,
+        ].forEach((method) => {
+            if (!adapter[method])
+                throw new InternalError(`Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`);
+            let descriptor = Object.getOwnPropertyDescriptor(adapter, method);
+            let proto = adapter;
+            while (!descriptor && proto !== Object.prototype) {
+                proto = Object.getPrototypeOf(proto);
+                descriptor = Object.getOwnPropertyDescriptor(proto, method);
+            }
+            if (!descriptor || !descriptor.writable) {
+                this.log.error(`Could not find method ${method} to bind Observables Dispatch`);
+                return;
+            }
+            function bulkToSingle(method) {
+                switch (method) {
+                    case BulkCrudOperationKeys.CREATE_ALL:
+                        return OperationKeys.CREATE;
+                    case BulkCrudOperationKeys.UPDATE_ALL:
+                        return OperationKeys.UPDATE;
+                    case BulkCrudOperationKeys.DELETE_ALL:
+                        return OperationKeys.DELETE;
+                    default:
+                        return method;
+                }
+            }
+            // @ts-expect-error because there are read only properties
+            adapter[method] = new Proxy(adapter[method], {
+                apply: async (target, thisArg, argArray) => {
+                    const [tableName, ids] = argArray;
+                    const result = await target.apply(thisArg, argArray);
+                    this.updateObservers(tableName, bulkToSingle(method), ids)
+                        .then(() => {
+                        this.log.verbose(`Observer refresh dispatched by ${method} for ${tableName}`);
+                        this.log.debug(`pks: ${ids}`);
+                    })
+                        .catch((e) => this.log.error(`Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`));
+                    return result;
+                },
+            });
+        });
+    }
+    observe(observer) {
+        if (!(observer instanceof Adapter))
+            throw new UnsupportedError("Only Adapters can be observed by dispatch");
+        this.adapter = observer;
+        this.native = observer.native;
+        this.models = Adapter.models(this.adapter.alias);
+        this.initialize();
+        this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`);
+    }
+    unObserve(observer) {
+        if (this.adapter !== observer)
+            throw new UnsupportedError("Only the adapter that was used to observe can be unobserved");
+        this.adapter = undefined;
+    }
+    async updateObservers(table, event, id) {
+        if (!this.adapter)
+            throw new InternalError(`No adapter observed for dispatch`);
+        try {
+            await this.adapter.refresh(table, event, id);
+        }
+        catch (e) {
+            throw new InternalError(`Failed to refresh dispatch: ${e}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Dispatch.js","sourceRoot":"","sources":["../../../src/persistence/Dispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  InternalError,\n  OperationKeys,\n  BulkCrudOperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer } from \"../interfaces\";\nimport { Adapter } from \"./Adapter\";\nimport { UnsupportedError } from \"./errors\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { EventIds } from \"./types\";\n\nexport class Dispatch<Y> implements Observable {\n  protected adapter?: Adapter<Y, any, any, any>;\n  protected native?: Y;\n  protected models!: ModelConstructor<any>[];\n\n  private logger!: Logger;\n\n  protected get log() {\n    if (!this.logger)\n      this.logger = Logging.for(this as any).for(this.adapter as any);\n    return this.logger;\n  }\n\n  constructor() {}\n\n  protected initialize(): void {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    const adapter = this.adapter as Adapter<Y, any, any, any>;\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<Y, any, any, any>)[]\n    ).forEach((method) => {\n      if (!adapter[method])\n        throw new InternalError(\n          `Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(adapter, method);\n      let proto: any = adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, method);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${method} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n      // @ts-expect-error because there are read only properties\n      adapter[method] = new Proxy(adapter[method], {\n        apply: async (target: any, thisArg, argArray: any[]) => {\n          const [tableName, ids] = argArray;\n          const result = await target.apply(thisArg, argArray);\n          this.updateObservers(tableName, bulkToSingle(method), ids as EventIds)\n            .then(() => {\n              this.log.verbose(\n                `Observer refresh dispatched by ${method} for ${tableName}`\n              );\n              this.log.debug(`pks: ${ids}`);\n            })\n            .catch((e: unknown) =>\n              this.log.error(\n                `Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`\n              )\n            );\n          return result;\n        },\n      });\n    });\n  }\n\n  observe(observer: Adapter<Y, any, any, any>): void {\n    if (!(observer instanceof Adapter))\n      throw new UnsupportedError(\"Only Adapters can be observed by dispatch\");\n    this.adapter = observer;\n    this.native = observer.native;\n    this.models = Adapter.models(this.adapter.alias);\n    this.initialize();\n    this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`);\n  }\n\n  unObserve(observer: Observer): void {\n    if (this.adapter !== observer)\n      throw new UnsupportedError(\n        \"Only the adapter that was used to observe can be unobserved\"\n      );\n    this.adapter = undefined;\n  }\n\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds\n  ): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    try {\n      await this.adapter.refresh(table, event, id);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,14 @@
+import { Observable, Observer } from "../interfaces";
+import { EventIds, ObserverFilter } from "./types";
+import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
+import { Logger } from "@decaf-ts/logging";
+export declare class ObserverHandler implements Observable {
+    protected readonly observers: {
+        observer: Observer;
+        filter?: ObserverFilter;
+    }[];
+    count(): number;
+    observe(observer: Observer, filter?: ObserverFilter): void;
+    unObserve(observer: Observer): void;
+    updateObservers(log: Logger, table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+}