@decaf-ts/for-typeorm 0.0.6

package/lib/esm/TypeORMDispatch.d.ts

@@ -0,0 +1,87 @@
+import { Dispatch, EventIds } from "@decaf-ts/core";
+import { OperationKeys } from "@decaf-ts/db-decorators";
+import { DataSourceOptions } from "typeorm/data-source/DataSourceOptions";
+/**
+ * @description Dispatcher for TypeORM-driven change events.
+ * @summary Subscribes a TypeORM DataSource with a custom EntitySubscriber to notify observers when records are created, updated, or deleted.
+ * @param {number} [timeout=5000] Timeout in milliseconds for initialization retries.
+ * @class TypeORMDispatch
+ * @example
+ * // Create a dispatcher for a TypeORM DataSource
+ * const dispatch = new TypeORMDispatch();
+ * await dispatch.observe(adapter, adapter.dataSource.options);
+ *
+ * // The dispatcher registers a TypeORMEventSubscriber and notifies observers when entities change.
+ * @mermaid
+ * classDiagram
+ *   class Dispatch {
+ *     +initialize()
+ *     +updateObservers()
+ *   }
+ *   class TypeORMDispatch {
+ *     -observerLastUpdate?: string
+ *     -attemptCounter: number
+ *     -timeout: number
+ *     +constructor(timeout)
+ *     #notificationHandler()
+ *     #initialize()
+ *   }
+ *   Dispatch <|-- TypeORMDispatch
+ */
+export declare class TypeORMDispatch extends Dispatch<DataSourceOptions> {
+    private timeout;
+    private observerLastUpdate?;
+    private attemptCounter;
+    constructor(timeout?: number);
+    /**
+     * @description Processes TypeORM notification events.
+     * @summary Handles change notifications (translated from TypeORM events) and notifies observers about record changes.
+     * @param {string} table The notification payload.
+     * @param {OperationKeys} operation The notification payload.
+     * @param {EventIds} ids The notification payload.
+     * @return {Promise<void>} A promise that resolves when all notifications have been processed.
+     * @mermaid
+     * sequenceDiagram
+     *   participant D as PostgreSQLDispatch
+     *   participant L as Logger
+     *   participant O as Observers
+     *   Note over D: Receive notification from PostgreSQL
+     *   D->>D: Parse notification payload
+     *   D->>D: Extract table, operation, and ids
+     *   D->>O: updateObservers(table, operation, ids)
+     *   D->>D: Update observerLastUpdate
+     *   D->>L: Log successful dispatch
+     */
+    protected notificationHandler(table: string, operation: OperationKeys, ids: EventIds): Promise<void>;
+    /**
+     * @description Initializes the dispatcher and subscribes to TypeORM notifications.
+     * @summary Registers the TypeORMEventSubscriber on the DataSource and logs the subscription lifecycle.
+     * @return {Promise<void>} A promise that resolves when the subscription is established.
+     * @mermaid
+     * sequenceDiagram
+     *   participant D as TypeORMDispatch
+     *   participant S as subscribeToTypeORM
+     *   participant DS as TypeORM DataSource
+     *   participant L as Logger
+     *   D->>S: Call subscribeToTypeORM
+     *   S->>S: Check adapter and native
+     *   alt No adapter or native
+     *     S-->>S: throw InternalError
+     *   end
+     *   S->>DS: initialize()
+     *   S->>DS: subscribers.push(TypeORMEventSubscriber)
+     *   alt Success
+     *     DS-->>S: Subscription established
+     *     S-->>D: Promise resolves
+     *     D->>L: Log successful subscription
+     *   else Error
+     *     DS-->>S: Error
+     *     S-->>D: Promise rejects
+     *   end
+     */
+    protected initialize(): Promise<void>;
+    /**
+     * Cleanup method to release resources when the dispatcher is no longer needed
+     */
+    cleanup(): void;
+}

package/lib/esm/TypeORMDispatch.js

@@ -0,0 +1,130 @@
+import { Dispatch } from "@decaf-ts/core";
+import { InternalError } from "@decaf-ts/db-decorators";
+import { TypeORMEventSubscriber } from "./TypeORMEventSubscriber.js";
+/**
+ * @description Dispatcher for TypeORM-driven change events.
+ * @summary Subscribes a TypeORM DataSource with a custom EntitySubscriber to notify observers when records are created, updated, or deleted.
+ * @param {number} [timeout=5000] Timeout in milliseconds for initialization retries.
+ * @class TypeORMDispatch
+ * @example
+ * // Create a dispatcher for a TypeORM DataSource
+ * const dispatch = new TypeORMDispatch();
+ * await dispatch.observe(adapter, adapter.dataSource.options);
+ *
+ * // The dispatcher registers a TypeORMEventSubscriber and notifies observers when entities change.
+ * @mermaid
+ * classDiagram
+ *   class Dispatch {
+ *     +initialize()
+ *     +updateObservers()
+ *   }
+ *   class TypeORMDispatch {
+ *     -observerLastUpdate?: string
+ *     -attemptCounter: number
+ *     -timeout: number
+ *     +constructor(timeout)
+ *     #notificationHandler()
+ *     #initialize()
+ *   }
+ *   Dispatch <|-- TypeORMDispatch
+ */
+export class TypeORMDispatch extends Dispatch {
+    constructor(timeout = 5000) {
+        super();
+        this.timeout = timeout;
+        this.attemptCounter = 0;
+    }
+    /**
+     * @description Processes TypeORM notification events.
+     * @summary Handles change notifications (translated from TypeORM events) and notifies observers about record changes.
+     * @param {string} table The notification payload.
+     * @param {OperationKeys} operation The notification payload.
+     * @param {EventIds} ids The notification payload.
+     * @return {Promise<void>} A promise that resolves when all notifications have been processed.
+     * @mermaid
+     * sequenceDiagram
+     *   participant D as PostgreSQLDispatch
+     *   participant L as Logger
+     *   participant O as Observers
+     *   Note over D: Receive notification from PostgreSQL
+     *   D->>D: Parse notification payload
+     *   D->>D: Extract table, operation, and ids
+     *   D->>O: updateObservers(table, operation, ids)
+     *   D->>D: Update observerLastUpdate
+     *   D->>L: Log successful dispatch
+     */
+    async notificationHandler(table, operation, ids) {
+        const log = this.log.for(this.notificationHandler);
+        try {
+            // Notify observers
+            await this.updateObservers(table, operation, ids);
+            this.observerLastUpdate = new Date().toISOString();
+            log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);
+            log.debug(`pks: ${ids}`);
+        }
+        catch (e) {
+            log.error(`Failed to process notification: ${e}`);
+        }
+    }
+    /**
+     * @description Initializes the dispatcher and subscribes to TypeORM notifications.
+     * @summary Registers the TypeORMEventSubscriber on the DataSource and logs the subscription lifecycle.
+     * @return {Promise<void>} A promise that resolves when the subscription is established.
+     * @mermaid
+     * sequenceDiagram
+     *   participant D as TypeORMDispatch
+     *   participant S as subscribeToTypeORM
+     *   participant DS as TypeORM DataSource
+     *   participant L as Logger
+     *   D->>S: Call subscribeToTypeORM
+     *   S->>S: Check adapter and native
+     *   alt No adapter or native
+     *     S-->>S: throw InternalError
+     *   end
+     *   S->>DS: initialize()
+     *   S->>DS: subscribers.push(TypeORMEventSubscriber)
+     *   alt Success
+     *     DS-->>S: Subscription established
+     *     S-->>D: Promise resolves
+     *     D->>L: Log successful subscription
+     *   else Error
+     *     DS-->>S: Error
+     *     S-->>D: Promise rejects
+     *   end
+     */
+    async initialize() {
+        async function subscribeToTypeORM() {
+            if (!this.adapter || !this.native) {
+                throw new InternalError(`No adapter/native observed for dispatch`);
+            }
+            const adapter = this.adapter;
+            try {
+                if (!adapter.dataSource.isInitialized)
+                    await adapter.dataSource.initialize();
+                adapter.dataSource.subscribers.push(new TypeORMEventSubscriber(this.notificationHandler.bind(this)));
+            }
+            catch (e) {
+                throw new InternalError(e);
+            }
+        }
+        subscribeToTypeORM
+            .call(this)
+            .then(() => {
+            this.log.info(`Subscribed to TypeORM notifications`);
+        })
+            .catch((e) => {
+            throw new InternalError(`Failed to subscribe to TypeORM notifications: ${e}`);
+        });
+    }
+    /**
+     * Cleanup method to release resources when the dispatcher is no longer needed
+     */
+    cleanup() {
+        // if (this.adapter) {
+        //
+        //   const adapter = this.adapter as TypeORMAdapter;
+        //   await adapter.dataSource.destroy();
+        // }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TypeORMDispatch.js","sourceRoot":"","sources":["../../src/TypeORMDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAY,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAiB,MAAM,yBAAyB,CAAC;AAGvE,OAAO,EAAE,sBAAsB,EAAE,oCAAiC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,OAAO,eAAgB,SAAQ,QAA2B;IAI9D,YAAoB,UAAU,IAAI;QAChC,KAAK,EAAE,CAAC;QADU,YAAO,GAAP,OAAO,CAAO;QAF1B,mBAAc,GAAW,CAAC,CAAC;IAInC,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACO,KAAK,CAAC,mBAAmB,CACjC,KAAa,EACb,SAAwB,EACxB,GAAa;QAEb,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACnD,IAAI,CAAC;YACH,mBAAmB;YACnB,MAAM,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;YAClD,IAAI,CAAC,kBAAkB,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACnD,GAAG,CAAC,OAAO,CAAC,kCAAkC,SAAS,QAAQ,KAAK,EAAE,CAAC,CAAC;YACxE,GAAG,CAAC,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC,CAAC;QAC3B,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,GAAG,CAAC,KAAK,CAAC,mCAAmC,CAAC,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACgB,KAAK,CAAC,UAAU;QACjC,KAAK,UAAU,kBAAkB;YAC/B,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;gBAClC,MAAM,IAAI,aAAa,CAAC,yCAAyC,CAAC,CAAC;YACrE,CAAC;YAED,MAAM,OAAO,GAAG,IAAI,CAAC,OAAyB,CAAC;YAE/C,IAAI,CAAC;gBACH,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,aAAa;oBACnC,MAAM,OAAO,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;gBAExC,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CACjC,IAAI,sBAAsB,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAChE,CAAC;YACJ,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,MAAM,IAAI,aAAa,CAAC,CAAU,CAAC,CAAC;YACtC,CAAC;QACH,CAAC;QAED,kBAAkB;aACf,IAAI,CAAC,IAAI,CAAC;aACV,IAAI,CAAC,GAAG,EAAE;YACT,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,qCAAqC,CAAC,CAAC;QACvD,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,CAAU,EAAE,EAAE;YACpB,MAAM,IAAI,aAAa,CACrB,iDAAiD,CAAC,EAAE,CACrD,CAAC;QACJ,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,sBAAsB;QACtB,EAAE;QACF,oDAAoD;QACpD,wCAAwC;QACxC,IAAI;IACN,CAAC;CACF","sourcesContent":["import { Dispatch, EventIds } from \"@decaf-ts/core\";\nimport { InternalError, OperationKeys } from \"@decaf-ts/db-decorators\";\nimport { DataSourceOptions } from \"typeorm/data-source/DataSourceOptions\";\nimport { TypeORMAdapter } from \"./TypeORMAdapter\";\nimport { TypeORMEventSubscriber } from \"./TypeORMEventSubscriber\";\n\n/**\n * @description Dispatcher for TypeORM-driven change events.\n * @summary Subscribes a TypeORM DataSource with a custom EntitySubscriber to notify observers when records are created, updated, or deleted.\n * @param {number} [timeout=5000] Timeout in milliseconds for initialization retries.\n * @class TypeORMDispatch\n * @example\n * // Create a dispatcher for a TypeORM DataSource\n * const dispatch = new TypeORMDispatch();\n * await dispatch.observe(adapter, adapter.dataSource.options);\n *\n * // The dispatcher registers a TypeORMEventSubscriber and notifies observers when entities change.\n * @mermaid\n * classDiagram\n *   class Dispatch {\n *     +initialize()\n *     +updateObservers()\n *   }\n *   class TypeORMDispatch {\n *     -observerLastUpdate?: string\n *     -attemptCounter: number\n *     -timeout: number\n *     +constructor(timeout)\n *     #notificationHandler()\n *     #initialize()\n *   }\n *   Dispatch <|-- TypeORMDispatch\n */\nexport class TypeORMDispatch extends Dispatch<DataSourceOptions> {\n  private observerLastUpdate?: string;\n  private attemptCounter: number = 0;\n\n  constructor(private timeout = 5000) {\n    super();\n  }\n\n  /**\n   * @description Processes TypeORM notification events.\n   * @summary Handles change notifications (translated from TypeORM events) and notifies observers about record changes.\n   * @param {string} table The notification payload.\n   * @param {OperationKeys} operation The notification payload.\n   * @param {EventIds} ids The notification payload.\n   * @return {Promise<void>} A promise that resolves when all notifications have been processed.\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as PostgreSQLDispatch\n   *   participant L as Logger\n   *   participant O as Observers\n   *   Note over D: Receive notification from PostgreSQL\n   *   D->>D: Parse notification payload\n   *   D->>D: Extract table, operation, and ids\n   *   D->>O: updateObservers(table, operation, ids)\n   *   D->>D: Update observerLastUpdate\n   *   D->>L: Log successful dispatch\n   */\n  protected async notificationHandler(\n    table: string,\n    operation: OperationKeys,\n    ids: EventIds\n  ): Promise<void> {\n    const log = this.log.for(this.notificationHandler);\n    try {\n      // Notify observers\n      await this.updateObservers(table, operation, ids);\n      this.observerLastUpdate = new Date().toISOString();\n      log.verbose(`Observer refresh dispatched by ${operation} for ${table}`);\n      log.debug(`pks: ${ids}`);\n    } catch (e: unknown) {\n      log.error(`Failed to process notification: ${e}`);\n    }\n  }\n\n  /**\n   * @description Initializes the dispatcher and subscribes to TypeORM notifications.\n   * @summary Registers the TypeORMEventSubscriber on the DataSource and logs the subscription lifecycle.\n   * @return {Promise<void>} A promise that resolves when the subscription is established.\n   * @mermaid\n   * sequenceDiagram\n   *   participant D as TypeORMDispatch\n   *   participant S as subscribeToTypeORM\n   *   participant DS as TypeORM DataSource\n   *   participant L as Logger\n   *   D->>S: Call subscribeToTypeORM\n   *   S->>S: Check adapter and native\n   *   alt No adapter or native\n   *     S-->>S: throw InternalError\n   *   end\n   *   S->>DS: initialize()\n   *   S->>DS: subscribers.push(TypeORMEventSubscriber)\n   *   alt Success\n   *     DS-->>S: Subscription established\n   *     S-->>D: Promise resolves\n   *     D->>L: Log successful subscription\n   *   else Error\n   *     DS-->>S: Error\n   *     S-->>D: Promise rejects\n   *   end\n   */\n  protected override async initialize(): Promise<void> {\n    async function subscribeToTypeORM(this: TypeORMDispatch): Promise<void> {\n      if (!this.adapter || !this.native) {\n        throw new InternalError(`No adapter/native observed for dispatch`);\n      }\n\n      const adapter = this.adapter as TypeORMAdapter;\n\n      try {\n        if (!adapter.dataSource.isInitialized)\n          await adapter.dataSource.initialize();\n\n        adapter.dataSource.subscribers.push(\n          new TypeORMEventSubscriber(this.notificationHandler.bind(this))\n        );\n      } catch (e: unknown) {\n        throw new InternalError(e as Error);\n      }\n    }\n\n    subscribeToTypeORM\n      .call(this)\n      .then(() => {\n        this.log.info(`Subscribed to TypeORM notifications`);\n      })\n      .catch((e: unknown) => {\n        throw new InternalError(\n          `Failed to subscribe to TypeORM notifications: ${e}`\n        );\n      });\n  }\n\n  /**\n   * Cleanup method to release resources when the dispatcher is no longer needed\n   */\n  public cleanup(): void {\n    // if (this.adapter) {\n    //\n    //   const adapter = this.adapter as TypeORMAdapter;\n    //   await adapter.dataSource.destroy();\n    // }\n  }\n}\n"]}

package/lib/esm/TypeORMEventSubscriber.d.ts

@@ -0,0 +1,56 @@
+import { EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from "typeorm";
+import { EventIds } from "@decaf-ts/core";
+import { OperationKeys } from "@decaf-ts/db-decorators";
+/**
+ * @description TypeORM event subscriber that forwards entity lifecycle events to the adapter.
+ * @summary Listens for insert, update, and remove events emitted by TypeORM and notifies the Decaf.ts adapter so that observers can be updated accordingly.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter used to propagate events and look up metadata.
+ * @class
+ * @example
+ * // Registering the subscriber when creating a DataSource
+ * // dataSourceOptions.subscribers = [new TypeORMEventSubscriber(adapter)];
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant TypeORM
+ *   participant Subscriber as TypeORMEventSubscriber
+ *   participant Adapter as TypeORMAdapter
+ *   participant Observers
+ *
+ *   TypeORM->>Subscriber: afterInsert(entity)
+ *   Subscriber->>Adapter: updateObservers(table, CREATE, [id])
+ *   Adapter->>Observers: notify(table, CREATE, [id])
+ *
+ *   TypeORM->>Subscriber: afterUpdate(event)
+ *   Subscriber->>Adapter: updateObservers(table, UPDATE, [id])
+ *   Adapter->>Observers: notify(table, UPDATE, [id])
+ *
+ *   TypeORM->>Subscriber: afterRemove(event)
+ *   Subscriber->>Adapter: updateObservers(table, DELETE, [id])
+ *   Adapter->>Observers: notify(table, DELETE, [id])
+ */
+export declare class TypeORMEventSubscriber implements EntitySubscriberInterface {
+    protected readonly handler: (tableName: string, operation: OperationKeys, ids: EventIds) => void;
+    constructor(handler: (tableName: string, operation: OperationKeys, ids: EventIds) => void);
+    /**
+     * @description Handles post-insert events.
+     * @summary Notifies observers about a create operation for the inserted entity.
+     * @param {InsertEvent<any>} event The TypeORM insert event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterInsert(event: InsertEvent<any>): Promise<any> | void;
+    /**
+     * @description Handles post-remove events.
+     * @summary Notifies observers about a delete operation for the removed entity.
+     * @param {RemoveEvent<any>} event The TypeORM remove event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterRemove(event: RemoveEvent<any>): Promise<any> | void;
+    /**
+     * @description Handles post-update events.
+     * @summary Notifies observers about an update operation for the modified entity.
+     * @param {UpdateEvent<any>} event The TypeORM update event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterUpdate(event: UpdateEvent<any>): Promise<any> | void;
+}

package/lib/esm/TypeORMEventSubscriber.js

@@ -0,0 +1,93 @@
+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 { EventSubscriber, } from "typeorm";
+import { Repository } from "@decaf-ts/core";
+import { InternalError, OperationKeys } from "@decaf-ts/db-decorators";
+import { Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description TypeORM event subscriber that forwards entity lifecycle events to the adapter.
+ * @summary Listens for insert, update, and remove events emitted by TypeORM and notifies the Decaf.ts adapter so that observers can be updated accordingly.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter used to propagate events and look up metadata.
+ * @class
+ * @example
+ * // Registering the subscriber when creating a DataSource
+ * // dataSourceOptions.subscribers = [new TypeORMEventSubscriber(adapter)];
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant TypeORM
+ *   participant Subscriber as TypeORMEventSubscriber
+ *   participant Adapter as TypeORMAdapter
+ *   participant Observers
+ *
+ *   TypeORM->>Subscriber: afterInsert(entity)
+ *   Subscriber->>Adapter: updateObservers(table, CREATE, [id])
+ *   Adapter->>Observers: notify(table, CREATE, [id])
+ *
+ *   TypeORM->>Subscriber: afterUpdate(event)
+ *   Subscriber->>Adapter: updateObservers(table, UPDATE, [id])
+ *   Adapter->>Observers: notify(table, UPDATE, [id])
+ *
+ *   TypeORM->>Subscriber: afterRemove(event)
+ *   Subscriber->>Adapter: updateObservers(table, DELETE, [id])
+ *   Adapter->>Observers: notify(table, DELETE, [id])
+ */
+let TypeORMEventSubscriber = class TypeORMEventSubscriber {
+    constructor(handler) {
+        this.handler = handler;
+    }
+    /**
+     * @description Handles post-insert events.
+     * @summary Notifies observers about a create operation for the inserted entity.
+     * @param {InsertEvent<any>} event The TypeORM insert event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterInsert(event) {
+        const constructor = Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        this.handler(tableName, OperationKeys.CREATE, [event.entityId]);
+    }
+    /**
+     * @description Handles post-remove events.
+     * @summary Notifies observers about a delete operation for the removed entity.
+     * @param {RemoveEvent<any>} event The TypeORM remove event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterRemove(event) {
+        const constructor = Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        this.handler(tableName, OperationKeys.DELETE, [event.entityId]);
+    }
+    /**
+     * @description Handles post-update events.
+     * @summary Notifies observers about an update operation for the modified entity.
+     * @param {UpdateEvent<any>} event The TypeORM update event.
+     * @return {Promise<any>|void} A promise when async or void otherwise.
+     */
+    afterUpdate(event) {
+        const constructor = Model.get(event.databaseEntity.constructor.name);
+        if (!constructor)
+            throw new InternalError(`No registered model found for ${event.databaseEntity.constructor.name}`);
+        const tableName = Repository.table(constructor);
+        return this.handler(tableName, OperationKeys.UPDATE, [
+            event.entity["id"],
+        ]);
+    }
+};
+TypeORMEventSubscriber = __decorate([
+    EventSubscriber(),
+    __metadata("design:paramtypes", [Function])
+], TypeORMEventSubscriber);
+export { TypeORMEventSubscriber };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/TypeORMRepository.d.ts

@@ -0,0 +1,125 @@
+import { type Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Repository } from "@decaf-ts/core";
+import { Context } from "@decaf-ts/db-decorators";
+import { TypeORMFlags, TypeORMQuery } from "./types";
+import { TypeORMAdapter } from "./TypeORMAdapter";
+/**
+ * @description Repository implementation backed by TypeORM.
+ * @summary Provides CRUD operations for a given Model using the {@link TypeORMAdapter}, including bulk operations and query builder access while preserving Decaf.ts repository semantics.
+ * @template M Type extending Model that this repository will manage.
+ * @param {TypeORMAdapter} adapter The adapter used to execute persistence operations.
+ * @param {Constructor<M>} model The Model constructor associated with this repository.
+ * @param {...any[]} args Optional arguments forwarded to the base Repository.
+ * @class TypeORMRepository
+ * @example
+ * // Creating a repository
+ * const repo = new TypeORMRepository<User>(adapter, User);
+ * const created = await repo.create(new User({ name: "Alice" }));
+ * const read = await repo.read(created.id);
+ *
+ * // Bulk create
+ * await repo.createAll([new User({ name: "A" }), new User({ name: "B" })]);
+ *
+ * // Using the query builder
+ * const qb = repo.queryBuilder();
+ * const rows = await qb.where("name = :name", { name: "Alice" }).getMany();
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as TypeORMRepository
+ *   participant Adapter as TypeORMAdapter
+ *   participant DB as TypeORM/DataSource
+ *
+ *   App->>Repo: create(model)
+ *   Repo->>Adapter: prepare(model, pk)
+ *   Adapter-->>Repo: { record, id, transient }
+ *   Repo->>Adapter: create(table, id, model, ...args)
+ *   Adapter->>DB: INSERT ...
+ *   DB-->>Adapter: row
+ *   Adapter-->>Repo: row
+ *   Repo->>Adapter: revert(row, clazz, pk, id)
+ *   Adapter-->>Repo: model
+ *   Repo-->>App: model
+ */
+export declare class TypeORMRepository<M extends Model> extends Repository<M, TypeORMQuery<M, any>, TypeORMAdapter, TypeORMFlags, Context<TypeORMFlags>> {
+    constructor(adapter: TypeORMAdapter, model: Constructor<M>, ...args: any[]);
+    /**
+     * @description Creates a TypeORM query builder for the repository entity.
+     * @summary Returns a SelectQueryBuilder bound to this repository's entity for advanced querying.
+     * @return {import("typeorm").SelectQueryBuilder<any>} A TypeORM SelectQueryBuilder instance.
+     */
+    queryBuilder(): import("typeorm").SelectQueryBuilder<import("typeorm").ObjectLiteral>;
+    /**
+     * @description Creates and persists a model instance.
+     * @summary Prepares the model, delegates insertion to the adapter, and rehydrates the persisted state back into a Model instance.
+     * @param {M} model The model to create.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M>} The created model instance.
+     */
+    create(model: M, ...args: any[]): Promise<M>;
+    /**
+     * @description Reads a model from the database by ID.
+     * @summary Retrieves a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The retrieved model instance.
+     */
+    read(id: string | number | bigint, ...args: any[]): Promise<M>;
+    /**
+     * @description Updates and persists a model instance.
+     * @summary Prepares the model, delegates update to the adapter, and rehydrates the persisted state back into a Model instance.
+     * @param {M} model The model to update.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M>} The updated model instance.
+     */
+    update(model: M, ...args: any[]): Promise<M>;
+    /**
+     * @description Deletes a model from the database by ID.
+     * @summary Removes a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The deleted model instance.
+     */
+    delete(id: string | number | bigint, ...args: any[]): Promise<M>;
+    /**
+     * @description Validates and prepares models for bulk creation.
+     * @summary Applies decorator-based validations and returns transformed models with context args for createAll.
+     * @param {M[]} models The models to be created.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<[M[], ...any[]]>} The prepared models and forwarded args tuple.
+     */
+    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Creates multiple models at once.
+     * @summary Prepares, persists, and rehydrates a batch of models.
+     * @param {M[]} models The models to create.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The created models.
+     */
+    createAll(models: M[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Reads multiple models by their primary keys.
+     * @summary Retrieves a list of models corresponding to the provided keys.
+     * @param {(string[]|number[])} keys The primary keys to read.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The retrieved models.
+     */
+    readAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Updates multiple models at once.
+     * @summary Persists a batch of model updates and returns their rehydrated instances.
+     * @param {M[]} models The models to update.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The updated models.
+     */
+    updateAll(models: M[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Deletes multiple models at once.
+     * @summary Removes a list of models by their primary keys and returns their last persisted states.
+     * @param {(string[]|number[])} keys The primary keys to delete.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The deleted models.
+     */
+    deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
+}