@decaf-ts/for-typeorm 0.0.6

package/lib/TypeORMAdapter.d.ts

@@ -0,0 +1,221 @@
+import { Adapter, RelationsMetadata, Sequence, type SequenceOptions } from "@decaf-ts/core";
+import { BaseError, Context, OperationKeys } from "@decaf-ts/db-decorators";
+import "reflect-metadata";
+import { type Constructor, Model } from "@decaf-ts/decorator-validation";
+import { TypeORMStatement } from "./query";
+import { TypeORMFlags, TypeORMQuery, TypeORMTableSpec } from "./types";
+import { TypeORMRepository } from "./TypeORMRepository";
+import { TypeORMDispatch } from "./TypeORMDispatch";
+import { DataSource } from "typeorm";
+import { DataSourceOptions } from "typeorm/data-source/DataSourceOptions";
+export declare function createdByOnPostgresCreateUpdate<M extends Model, R extends TypeORMRepository<M>, V extends RelationsMetadata>(this: R, context: Context<TypeORMFlags>, data: V, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Adapter for TypeORM-backed persistence operations.
+ * @summary Implements the Decaf.ts Adapter over a TypeORM DataSource, providing CRUD operations, query/statement factories, sequence management, error parsing, and decoration helpers.
+ * @template Y The native configuration type (TypeORM DataSourceOptions).
+ * @template F The repository flags type.
+ * @template C The context type.
+ * @param {DataSourceOptions} scope The DataSource options for the adapter.
+ * @param {string} flavour The flavour of the adapter.
+ * @param {string} [alias] Optional alias for the adapter.
+ * @class TypeORMAdapter
+ * @example
+ * const adapter = new TypeORMAdapter({ type: 'postgres', /* ... *\/ });
+ * await adapter.initialize();
+ * const repo = new (adapter.repository<User>())(adapter, User);
+ * const created = await repo.create(new User({ name: 'Alice' }));
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Adapter as TypeORMAdapter
+ *   participant Repo as TypeORMRepository
+ *   participant DS as TypeORM DataSource
+ *
+ *   App->>Adapter: new TypeORMAdapter(opts)
+ *   Adapter->>DS: initialize()
+ *   App->>Adapter: repository()
+ *   Adapter-->>App: TypeORMRepository
+ *   App->>Repo: create(model)
+ *   Repo->>Adapter: prepare/create/revert
+ *   Adapter-->>Repo: Model
+ *   Repo-->>App: Model
+ */
+export declare class TypeORMAdapter extends Adapter<DataSourceOptions, TypeORMQuery, TypeORMFlags, Context<TypeORMFlags>> {
+    private _dataSource?;
+    get dataSource(): DataSource;
+    constructor(options: DataSourceOptions, alias?: string);
+    protected flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<TypeORMFlags>): Promise<TypeORMFlags>;
+    protected Dispatch(): TypeORMDispatch;
+    repository<M extends Model>(): Constructor<TypeORMRepository<M>>;
+    /**
+     * @description Creates a new Postgres statement for querying
+     * @summary Factory method that creates a new PostgresStatement instance for building queries
+     * @template M - The model type
+     * @return {TypeORMStatement<M, any>} A new PostgresStatement instance
+     */
+    Statement<M extends Model>(): TypeORMStatement<M, any>;
+    /**
+     * @description Creates a new PostgreSQL sequence
+     * @summary Factory method that creates a new PostgreSQLSequence instance for managing sequences
+     * @param {SequenceOptions} options - The options for the sequence
+     * @return {Promise<Sequence>} A promise that resolves to a new Sequence instance
+     */
+    Sequence(options: SequenceOptions): Promise<Sequence>;
+    /**
+     * @description Initializes the adapter by creating indexes for all managed models
+     * @summary Sets up the necessary database indexes for all models managed by this adapter
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     */
+    initialize(): Promise<void>;
+    /**
+     * @description Creates indexes for the given models
+     * @summary Abstract method that must be implemented to create database indexes for the specified models
+     * @template M - The model type
+     * @param {...Constructor<M>} models - The model constructors to create indexes for
+     * @return {Promise<void>} A promise that resolves when all indexes are created
+     */
+    protected index<M extends Model>(...models: Constructor<M>[]): Promise<void>;
+    /**
+     * @description Executes a raw SQL query against the database
+     * @summary Abstract method that must be implemented to execute raw SQL queries
+     * @template R - The result type
+     * @param {TypeORMQuery} q - The query to execute
+     * @return {Promise<R>} A promise that resolves to the query result
+     */
+    raw<R>(q: TypeORMQuery): Promise<R>;
+    prepare<M extends Model>(model: M, pk: keyof M, child?: boolean): {
+        record: Record<string, any>;
+        id: string;
+        transient?: Record<string, any>;
+    };
+    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: keyof M, id: string | number | bigint, transient?: Record<string, any>): M;
+    /**
+     * @description Creates a new record in the database
+     * @summary Abstract method that must be implemented to create a new record
+     * @param {string} tableName - The name of the table
+     * @param {string|number} id - The ID of the record
+     * @param {Record<string, any>} model - The model to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<Record<string, any>>} A promise that resolves to the created record
+     */
+    create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Reads a record from the database
+     * @summary Abstract method that must be implemented to read a record
+     * @param {string} tableName - The name of the table
+     * @param {string|number} id - The ID of the record
+     * @param {string} pk - primary key colum
+     * @return {Promise<Record<string, any>>} A promise that resolves to the read record
+     */
+    read(tableName: string, id: string | number, pk: string): Promise<Record<string, any>>;
+    /**
+     * @description Updates a record in the database
+     * @summary Abstract method that must be implemented to update a record
+     * @param {string} tableName - The name of the table
+     * @param {string|number} id - The ID of the record
+     * @param {Record<string, any>} model - The model to update
+     * @param {string} pk - Additional arguments
+     * @return A promise that resolves to the updated record
+     */
+    update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Deletes a record from the database
+     * @summary Abstract method that must be implemented to delete a record
+     * @param {string} tableName - The name of the table
+     * @param {string|number} id - The ID of the record
+     * @param {string} pk - Additional arguments
+     * @return A promise that resolves to the deleted record
+     */
+    delete(tableName: string, id: string | number, pk: string, ...args: any[]): Promise<Record<string, any>>;
+    createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    readAll(tableName: string, id: (string | number | bigint)[], pk: string, ...args: any[]): Promise<Record<string, any>[]>;
+    updateAll(tableName: string, ids: string[] | number[], model: Record<string, any>[], pk: string, ...args: any[]): Promise<Record<string, any>[]>;
+    deleteAll(tableName: string, ids: (string | number | bigint)[], pk: string, ...args: any[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Parses an error and converts it to a BaseError
+     * @summary Converts various error types to appropriate BaseError subtypes
+     * @param {Error|string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error as a BaseError
+     */
+    parseError(err: Error | string, reason?: string): BaseError;
+    /**
+     * @description Checks if an attribute is reserved
+     * @summary Determines if an attribute name is reserved in PostgreSQL
+     * @param {string} attr - The attribute name to check
+     * @return {boolean} True if the attribute is reserved, false otherwise
+     */
+    protected isReserved(attr: string): boolean;
+    /**
+     * @description Static method to parse an error and convert it to a BaseError
+     * @summary Converts various error types to appropriate BaseError subtypes based on PostgreSQL error codes and messages
+     * @param {Error|string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error as a BaseError
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant parseError
+     *   participant ErrorTypes
+     *
+     *   Caller->>parseError: err, reason
+     *   Note over parseError: Check if err is already a BaseError
+     *   alt err is BaseError
+     *     parseError-->>Caller: return err
+     *   else err is string
+     *     Note over parseError: Extract code from string
+     *     alt code matches "duplicate key|already exists"
+     *       parseError->>ErrorTypes: new ConflictError(code)
+     *       ErrorTypes-->>Caller: ConflictError
+     *     else code matches "does not exist|not found"
+     *       parseError->>ErrorTypes: new NotFoundError(code)
+     *       ErrorTypes-->>Caller: NotFoundError
+     *     end
+     *   else err has code property
+     *     Note over parseError: Extract code and reason
+     *   else
+     *     Note over parseError: Use err.message as code
+     *   end
+     *
+     *   Note over parseError: Switch on PostgreSQL error code
+     *   alt code is 23505 (unique_violation)
+     *     parseError->>ErrorTypes: new ConflictError(reason)
+     *     ErrorTypes-->>Caller: ConflictError
+     *   else code is 23503 (foreign_key_violation)
+     *     parseError->>ErrorTypes: new ConflictError(reason)
+     *     ErrorTypes-->>Caller: ConflictError
+     *   else code is 42P01 (undefined_table)
+     *     parseError->>ErrorTypes: new NotFoundError(reason)
+     *     ErrorTypes-->>Caller: NotFoundError
+     *   else code is 42703 (undefined_column)
+     *     parseError->>ErrorTypes: new NotFoundError(reason)
+     *     ErrorTypes-->>Caller: NotFoundError
+     *   else code is 42P07 (duplicate_table)
+     *     parseError->>ErrorTypes: new ConflictError(reason)
+     *     ErrorTypes-->>Caller: ConflictError
+     *   else code is 42P16 (invalid_table_definition)
+     *     parseError->>ErrorTypes: new IndexError(err)
+     *     ErrorTypes-->>Caller: IndexError
+     *   else code matches "ECONNREFUSED"
+     *     parseError->>ErrorTypes: new ConnectionError(err)
+     *     ErrorTypes-->>Caller: ConnectionError
+     *   else
+     *     parseError->>ErrorTypes: new InternalError(err)
+     *     ErrorTypes-->>Caller: InternalError
+     *   end
+     */
+    protected static parseError(err: Error | string, reason?: string): BaseError;
+    static connect(config: DataSourceOptions): Promise<DataSource>;
+    static createDatabase(dataSource: DataSource, dbName: string): Promise<void>;
+    static createNotifyFunction(dataSource: DataSource, user: string): Promise<void>;
+    static deleteDatabase(dataSource: DataSource, dbName: string, user?: string): Promise<void>;
+    static createUser(dataSource: DataSource, dbName: string, user: string, password: string): Promise<void>;
+    static deleteUser(client: DataSource, user: string, admin: string): Promise<void>;
+    private static parseTypeToPostgres;
+    private static parseValidationToPostgres;
+    private static parseRelationsToPostgres;
+    static createTable<M extends Model>(client: DataSource, model: Constructor<M>): Promise<Record<string, TypeORMTableSpec>>;
+    static getCurrentUser(client: DataSource): Promise<string>;
+    static decoration(): void;
+}

package/lib/TypeORMDispatch.cjs

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMDispatch = void 0;
+const core_1 = require("@decaf-ts/core");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const TypeORMEventSubscriber_1 = require("./TypeORMEventSubscriber.cjs");
+/**
+ * @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
+ */
+class TypeORMDispatch extends core_1.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 db_decorators_1.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_1.TypeORMEventSubscriber(this.notificationHandler.bind(this)));
+            }
+            catch (e) {
+                throw new db_decorators_1.InternalError(e);
+            }
+        }
+        subscribeToTypeORM
+            .call(this)
+            .then(() => {
+            this.log.info(`Subscribed to TypeORM notifications`);
+        })
+            .catch((e) => {
+            throw new db_decorators_1.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();
+        // }
+    }
+}
+exports.TypeORMDispatch = TypeORMDispatch;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TypeORMDispatch.js","sourceRoot":"","sources":["../src/TypeORMDispatch.ts"],"names":[],"mappings":";;;AAAA,yCAAoD;AACpD,2DAAuE;AAGvE,yEAAkE;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAa,eAAgB,SAAQ,eAA2B;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,6BAAa,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,+CAAsB,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAChE,CAAC;YACJ,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,MAAM,IAAI,6BAAa,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,6BAAa,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;AAhHD,0CAgHC","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/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/TypeORMEventSubscriber.cjs

@@ -0,0 +1,96 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMEventSubscriber = void 0;
+const typeorm_1 = require("typeorm");
+const core_1 = require("@decaf-ts/core");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const decorator_validation_1 = require("@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 = decorator_validation_1.Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new db_decorators_1.InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = core_1.Repository.table(constructor);
+        this.handler(tableName, db_decorators_1.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 = decorator_validation_1.Model.get(event.entity.constructor.name);
+        if (!constructor)
+            throw new db_decorators_1.InternalError(`No registered model found for ${event.entity.constructor.name}`);
+        const tableName = core_1.Repository.table(constructor);
+        this.handler(tableName, db_decorators_1.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 = decorator_validation_1.Model.get(event.databaseEntity.constructor.name);
+        if (!constructor)
+            throw new db_decorators_1.InternalError(`No registered model found for ${event.databaseEntity.constructor.name}`);
+        const tableName = core_1.Repository.table(constructor);
+        return this.handler(tableName, db_decorators_1.OperationKeys.UPDATE, [
+            event.entity["id"],
+        ]);
+    }
+};
+exports.TypeORMEventSubscriber = TypeORMEventSubscriber;
+exports.TypeORMEventSubscriber = TypeORMEventSubscriber = __decorate([
+    (0, typeorm_1.EventSubscriber)(),
+    __metadata("design:paramtypes", [Function])
+], TypeORMEventSubscriber);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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;
+}