@decaf-ts/core 0.5.1 → 0.5.2

package/lib/persistence/Dispatch.d.ts

@@ -4,15 +4,128 @@ import { Observable, Observer } from "../interfaces";
 import { Adapter } from "./Adapter";
 import { Logger } from "@decaf-ts/logging";
 import { EventIds } from "./types";
+/**
+ * @description Dispatches database operation events to observers
+ * @summary The Dispatch class implements the Observable interface and is responsible for intercepting
+ * database operations from an Adapter and notifying observers when changes occur. It uses proxies to
+ * wrap the adapter's CRUD methods and automatically trigger observer updates after operations complete.
+ * @template Y - The native database driver type
+ * @param {void} - No constructor parameters
+ * @class Dispatch
+ * @example
+ * ```typescript
+ * // Creating and using a Dispatch instance
+ * const dispatch = new Dispatch<PostgresDriver>();
+ *
+ * // Connect it to an adapter
+ * const adapter = new PostgresAdapter(connection);
+ * dispatch.observe(adapter);
+ *
+ * // Now any CRUD operations on the adapter will automatically
+ * // trigger observer notifications
+ * await adapter.create('users', 123, userModel);
+ * // Observers will be notified about the creation
+ *
+ * // When done, you can disconnect
+ * dispatch.unObserve(adapter);
+ * ```
+ */
 export declare class Dispatch<Y> implements Observable {
+    /**
+     * @description The adapter being observed
+     * @summary Reference to the database adapter whose operations are being monitored
+     */
     protected adapter?: Adapter<Y, any, any, any>;
+    /**
+     * @description The native database driver
+     * @summary Reference to the underlying database driver from the adapter
+     */
     protected native?: Y;
+    /**
+     * @description List of model constructors
+     * @summary Array of model constructors that are registered with the adapter
+     */
     protected models: ModelConstructor<any>[];
+    /**
+     * @description Logger instance
+     * @summary Logger for recording dispatch activities
+     */
     private logger;
+    /**
+     * @description Accessor for the logger
+     * @summary Gets or initializes the logger for this dispatch instance
+     * @return {Logger} The logger instance
+     */
     protected get log(): Logger;
+    /**
+     * @description Creates a new Dispatch instance
+     * @summary Initializes a new Dispatch instance without any adapter
+     */
     constructor();
-    protected initialize(): void;
+    /**
+     * @description Initializes the dispatch by proxying adapter methods
+     * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.
+     * This method is called automatically when an adapter is observed.
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     * @mermaid
+     * sequenceDiagram
+     *   participant Dispatch
+     *   participant Adapter
+     *   participant Proxy
+     *
+     *   Dispatch->>Dispatch: initialize()
+     *   Dispatch->>Dispatch: Check if adapter exists
+     *   alt No adapter
+     *     Dispatch-->>Dispatch: Throw InternalError
+     *   end
+     *
+     *   loop For each CRUD method
+     *     Dispatch->>Adapter: Check if method exists
+     *     alt Method doesn't exist
+     *       Dispatch-->>Dispatch: Throw InternalError
+     *     end
+     *
+     *     Dispatch->>Adapter: Get property descriptor
+     *     loop While descriptor not found
+     *       Dispatch->>Adapter: Check prototype chain
+     *     end
+     *
+     *     alt Descriptor not found or not writable
+     *       Dispatch->>Dispatch: Log error and continue
+     *     else Descriptor found and writable
+     *       Dispatch->>Proxy: Create proxy for method
+     *       Dispatch->>Adapter: Replace method with proxy
+     *     end
+     *   end
+     */
+    protected initialize(): Promise<void>;
+    /**
+     * @description Closes the dispatch
+     * @summary Performs any necessary cleanup when the dispatch is no longer needed
+     * @return {Promise<void>} A promise that resolves when closing is complete
+     */
+    close(): Promise<void>;
+    /**
+     * @description Starts observing an adapter
+     * @summary Connects this dispatch to an adapter to monitor its operations
+     * @param {Adapter<Y, any, any, any>} observer - The adapter to observe
+     * @return {void}
+     */
     observe(observer: Adapter<Y, any, any, any>): void;
+    /**
+     * @description Stops observing an adapter
+     * @summary Disconnects this dispatch from an adapter
+     * @param {Observer} observer - The adapter to stop observing
+     * @return {void}
+     */
     unObserve(observer: Observer): void;
+    /**
+     * @description Updates observers about a database event
+     * @summary Notifies observers about a change in the database
+     * @param {string} table - The name of the table where the change occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
     updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds): Promise<void>;
 }

package/lib/persistence/ObserverHandler.cjs

@@ -2,25 +2,120 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObserverHandler = void 0;
 const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @description Manages a collection of observers for database events
+ * @summary The ObserverHandler class implements the Observable interface and provides a centralized
+ * way to manage multiple observers. It allows registering observers with optional filters to control
+ * which events they receive notifications for, and handles the process of notifying all relevant
+ * observers when database events occur.
+ * @class ObserverHandler
+ * @example
+ * ```typescript
+ * // Create an observer handler
+ * const handler = new ObserverHandler();
+ *
+ * // Register an observer
+ * const myObserver = {
+ *   refresh: async (table, event, id) => {
+ *     console.log(`Change in ${table}: ${event} for ID ${id}`);
+ *   }
+ * };
+ *
+ * // Add observer with a filter for only user table events
+ * handler.observe(myObserver, (table, event, id) => table === 'users');
+ *
+ * // Notify observers about an event
+ * await handler.updateObservers(logger, 'users', 'CREATE', 123);
+ *
+ * // Remove an observer when no longer needed
+ * handler.unObserve(myObserver);
+ * ```
+ */
 class ObserverHandler {
     constructor() {
+        /**
+         * @description Collection of registered observers
+         * @summary Array of observer objects along with their optional filters
+         */
         this.observers = [];
     }
+    /**
+     * @description Gets the number of registered observers
+     * @summary Returns the count of observers currently registered with this handler
+     * @return {number} The number of registered observers
+     */
     count() {
         return this.observers.length;
     }
+    /**
+     * @description Registers a new observer
+     * @summary Adds an observer to the collection with an optional filter function
+     * @param {Observer} observer - The observer to register
+     * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives
+     * @return {void}
+     */
     observe(observer, filter) {
         const index = this.observers.map((o) => o.observer).indexOf(observer);
         if (index !== -1)
             throw new db_decorators_1.InternalError("Observer already registered");
         this.observers.push({ observer: observer, filter: filter });
     }
+    /**
+     * @description Unregisters an observer
+     * @summary Removes an observer from the collection
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     */
     unObserve(observer) {
         const index = this.observers.map((o) => o.observer).indexOf(observer);
         if (index === -1)
             throw new db_decorators_1.InternalError("Failed to find Observer");
         this.observers.splice(index, 1);
     }
+    /**
+     * @description Notifies all relevant observers about a database event
+     * @summary Filters observers based on their filter functions and calls refresh on each matching observer
+     * @param {Logger} log - Logger for recording notification activities
+     * @param {string} table - The name of the table where the event occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @param {...any[]} args - Additional arguments to pass to the observers
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant ObserverHandler
+     *   participant Observer
+     *
+     *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)
+     *
+     *   ObserverHandler->>ObserverHandler: Filter observers
+     *
+     *   loop For each observer with matching filter
+     *     alt Observer has filter
+     *       ObserverHandler->>Observer: Apply filter(table, event, id)
+     *       alt Filter throws error
+     *         ObserverHandler->>Logger: Log error
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       else Filter returns true
+     *         ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *       else Filter returns false
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       end
+     *     else No filter
+     *       ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *     end
+     *   end
+     *
+     *   ObserverHandler->>ObserverHandler: Process results
+     *   loop For each result
+     *     alt Result is rejected
+     *       ObserverHandler->>Logger: Log error
+     *     end
+     *   end
+     *
+     *   ObserverHandler-->>Client: Return
+     */
     async updateObservers(log, table, event, id, ...args) {
         const results = await Promise.allSettled(this.observers
             .filter((o) => {
@@ -43,4 +138,4 @@ class ObserverHandler {
     }
 }
 exports.ObserverHandler = ObserverHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ObserverHandler.js","sourceRoot":"","sources":["../../src/persistence/ObserverHandler.ts"],"names":[],"mappings":";;;AAEA,2DAIiC;AAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,eAAe;IAA5B;QACE;;;WAGG;QACgB,cAAS,GAGtB,EAAE,CAAC;IA8GX,CAAC;IA5GC;;;;OAIG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,QAAkB,EAAE,MAAuB;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,6BAA6B,CAAC,CAAC;QACzE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACH,SAAS,CAAC,QAAkB;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtE,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM,IAAI,6BAAa,CAAC,yBAAyB,CAAC,CAAC;QACrE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,KAAK,CAAC,eAAe,CACnB,GAAW,EACX,KAAa,EACb,KAAqD,EACrD,EAAY,EACZ,GAAG,IAAW;QAEd,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CACtC,IAAI,CAAC,SAAS;aACX,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;YACZ,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;YACrB,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC;YACzB,IAAI,CAAC;gBACH,OAAO,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YAClC,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,GAAG,CAAC,KAAK,CACP,6BAA6B,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAC3D,CAAC;gBACF,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC;aACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAC7D,CAAC;QACF,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5B,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAC9B,GAAG,CAAC,KAAK,CACP,+BAA+B,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,CAChF,CAAC;QACN,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAtHD,0CAsHC","sourcesContent":["import { Observable, Observer } from \"../interfaces\";\nimport { EventIds, ObserverFilter } from \"./types\";\nimport {\n  BulkCrudOperationKeys,\n  InternalError,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { Logger } from \"@decaf-ts/logging\";\n\n/**\n * @description Manages a collection of observers for database events\n * @summary The ObserverHandler class implements the Observable interface and provides a centralized\n * way to manage multiple observers. It allows registering observers with optional filters to control\n * which events they receive notifications for, and handles the process of notifying all relevant\n * observers when database events occur.\n * @class ObserverHandler\n * @example\n * ```typescript\n * // Create an observer handler\n * const handler = new ObserverHandler();\n * \n * // Register an observer\n * const myObserver = {\n *   refresh: async (table, event, id) => {\n *     console.log(`Change in ${table}: ${event} for ID ${id}`);\n *   }\n * };\n * \n * // Add observer with a filter for only user table events\n * handler.observe(myObserver, (table, event, id) => table === 'users');\n * \n * // Notify observers about an event\n * await handler.updateObservers(logger, 'users', 'CREATE', 123);\n * \n * // Remove an observer when no longer needed\n * handler.unObserve(myObserver);\n * ```\n */\nexport class ObserverHandler implements Observable {\n  /**\n   * @description Collection of registered observers\n   * @summary Array of observer objects along with their optional filters\n   */\n  protected readonly observers: {\n    observer: Observer;\n    filter?: ObserverFilter;\n  }[] = [];\n\n  /**\n   * @description Gets the number of registered observers\n   * @summary Returns the count of observers currently registered with this handler\n   * @return {number} The number of registered observers\n   */\n  count() {\n    return this.observers.length;\n  }\n\n  /**\n   * @description Registers a new observer\n   * @summary Adds an observer to the collection with an optional filter function\n   * @param {Observer} observer - The observer to register\n   * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives\n   * @return {void}\n   */\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    const index = this.observers.map((o) => o.observer).indexOf(observer);\n    if (index !== -1) throw new InternalError(\"Observer already registered\");\n    this.observers.push({ observer: observer, filter: filter });\n  }\n\n  /**\n   * @description Unregisters an observer\n   * @summary Removes an observer from the collection\n   * @param {Observer} observer - The observer to unregister\n   * @return {void}\n   */\n  unObserve(observer: Observer): void {\n    const index = this.observers.map((o) => o.observer).indexOf(observer);\n    if (index === -1) throw new InternalError(\"Failed to find Observer\");\n    this.observers.splice(index, 1);\n  }\n\n  /**\n   * @description Notifies all relevant observers about a database event\n   * @summary Filters observers based on their filter functions and calls refresh on each matching observer\n   * @param {Logger} log - Logger for recording notification activities\n   * @param {string} table - The name of the table where the event occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {EventIds} id - The identifier(s) of the affected record(s)\n   * @param {...any[]} args - Additional arguments to pass to the observers\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant ObserverHandler\n   *   participant Observer\n   *   \n   *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)\n   *   \n   *   ObserverHandler->>ObserverHandler: Filter observers\n   *   \n   *   loop For each observer with matching filter\n   *     alt Observer has filter\n   *       ObserverHandler->>Observer: Apply filter(table, event, id)\n   *       alt Filter throws error\n   *         ObserverHandler->>Logger: Log error\n   *         ObserverHandler-->>ObserverHandler: Skip observer\n   *       else Filter returns true\n   *         ObserverHandler->>Observer: refresh(table, event, id, ...args)\n   *       else Filter returns false\n   *         ObserverHandler-->>ObserverHandler: Skip observer\n   *       end\n   *     else No filter\n   *       ObserverHandler->>Observer: refresh(table, event, id, ...args)\n   *     end\n   *   end\n   *   \n   *   ObserverHandler->>ObserverHandler: Process results\n   *   loop For each result\n   *     alt Result is rejected\n   *       ObserverHandler->>Logger: Log error\n   *     end\n   *   end\n   *   \n   *   ObserverHandler-->>Client: Return\n   */\n  async updateObservers(\n    log: Logger,\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    const results = await Promise.allSettled(\n      this.observers\n        .filter((o) => {\n          const { filter } = o;\n          if (!filter) return true;\n          try {\n            return filter(table, event, id);\n          } catch (e: unknown) {\n            log.error(\n              `Failed to filter observer ${o.observer.toString()}: ${e}`\n            );\n            return false;\n          }\n        })\n        .map((o) => o.observer.refresh(table, event, id, ...args))\n    );\n    results.forEach((result, i) => {\n      if (result.status === \"rejected\")\n        log.error(\n          `Failed to update observable ${this.observers[i].toString()}: ${result.reason}`\n        );\n    });\n  }\n}\n"]}

package/lib/persistence/ObserverHandler.d.ts

@@ -2,13 +2,108 @@ import { Observable, Observer } from "../interfaces";
 import { EventIds, ObserverFilter } from "./types";
 import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
 import { Logger } from "@decaf-ts/logging";
+/**
+ * @description Manages a collection of observers for database events
+ * @summary The ObserverHandler class implements the Observable interface and provides a centralized
+ * way to manage multiple observers. It allows registering observers with optional filters to control
+ * which events they receive notifications for, and handles the process of notifying all relevant
+ * observers when database events occur.
+ * @class ObserverHandler
+ * @example
+ * ```typescript
+ * // Create an observer handler
+ * const handler = new ObserverHandler();
+ *
+ * // Register an observer
+ * const myObserver = {
+ *   refresh: async (table, event, id) => {
+ *     console.log(`Change in ${table}: ${event} for ID ${id}`);
+ *   }
+ * };
+ *
+ * // Add observer with a filter for only user table events
+ * handler.observe(myObserver, (table, event, id) => table === 'users');
+ *
+ * // Notify observers about an event
+ * await handler.updateObservers(logger, 'users', 'CREATE', 123);
+ *
+ * // Remove an observer when no longer needed
+ * handler.unObserve(myObserver);
+ * ```
+ */
 export declare class ObserverHandler implements Observable {
+    /**
+     * @description Collection of registered observers
+     * @summary Array of observer objects along with their optional filters
+     */
     protected readonly observers: {
         observer: Observer;
         filter?: ObserverFilter;
     }[];
+    /**
+     * @description Gets the number of registered observers
+     * @summary Returns the count of observers currently registered with this handler
+     * @return {number} The number of registered observers
+     */
     count(): number;
+    /**
+     * @description Registers a new observer
+     * @summary Adds an observer to the collection with an optional filter function
+     * @param {Observer} observer - The observer to register
+     * @param {ObserverFilter} [filter] - Optional filter function to determine which events the observer receives
+     * @return {void}
+     */
     observe(observer: Observer, filter?: ObserverFilter): void;
+    /**
+     * @description Unregisters an observer
+     * @summary Removes an observer from the collection
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
+     */
     unObserve(observer: Observer): void;
+    /**
+     * @description Notifies all relevant observers about a database event
+     * @summary Filters observers based on their filter functions and calls refresh on each matching observer
+     * @param {Logger} log - Logger for recording notification activities
+     * @param {string} table - The name of the table where the event occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {EventIds} id - The identifier(s) of the affected record(s)
+     * @param {...any[]} args - Additional arguments to pass to the observers
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant ObserverHandler
+     *   participant Observer
+     *
+     *   Client->>ObserverHandler: updateObservers(log, table, event, id, ...args)
+     *
+     *   ObserverHandler->>ObserverHandler: Filter observers
+     *
+     *   loop For each observer with matching filter
+     *     alt Observer has filter
+     *       ObserverHandler->>Observer: Apply filter(table, event, id)
+     *       alt Filter throws error
+     *         ObserverHandler->>Logger: Log error
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       else Filter returns true
+     *         ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *       else Filter returns false
+     *         ObserverHandler-->>ObserverHandler: Skip observer
+     *       end
+     *     else No filter
+     *       ObserverHandler->>Observer: refresh(table, event, id, ...args)
+     *     end
+     *   end
+     *
+     *   ObserverHandler->>ObserverHandler: Process results
+     *   loop For each result
+     *     alt Result is rejected
+     *       ObserverHandler->>Logger: Log error
+     *     end
+     *   end
+     *
+     *   ObserverHandler-->>Client: Return
+     */
     updateObservers(log: Logger, table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
 }

package/lib/persistence/Sequence.cjs

@@ -4,18 +4,87 @@ exports.Sequence = void 0;
 const utils_1 = require("./../identity/utils.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Abstract base class for sequence generation
+ * @summary Provides a framework for generating sequential values (like primary keys) in the persistence layer.
+ * Implementations of this class handle the specifics of how sequences are stored and incremented in different
+ * database systems.
+ * @param {SequenceOptions} options - Configuration options for the sequence generator
+ * @class Sequence
+ * @example
+ * ```typescript
+ * // Example implementation for a specific database
+ * class PostgresSequence extends Sequence {
+ *   constructor(options: SequenceOptions) {
+ *     super(options);
+ *   }
+ *
+ *   async next(): Promise<number> {
+ *     // Implementation to get next value from PostgreSQL sequence
+ *     const result = await this.options.executor.raw(`SELECT nextval('${this.options.name}')`);
+ *     return parseInt(result.rows[0].nextval);
+ *   }
+ *
+ *   async current(): Promise<number> {
+ *     // Implementation to get current value from PostgreSQL sequence
+ *     const result = await this.options.executor.raw(`SELECT currval('${this.options.name}')`);
+ *     return parseInt(result.rows[0].currval);
+ *   }
+ *
+ *   async range(count: number): Promise<number[]> {
+ *     // Implementation to get a range of values
+ *     const values: number[] = [];
+ *     for (let i = 0; i < count; i++) {
+ *       values.push(await this.next());
+ *     }
+ *     return values;
+ *   }
+ * }
+ *
+ * // Usage
+ * const sequence = new PostgresSequence({
+ *   name: 'user_id_seq',
+ *   executor: dbExecutor
+ * });
+ *
+ * const nextId = await sequence.next();
+ * ```
+ */
 class Sequence {
+    /**
+     * @description Accessor for the logger instance
+     * @summary Gets or initializes the logger for this sequence
+     * @return {Logger} The logger instance
+     */
     get log() {
         if (!this.logger)
             this.logger = logging_1.Logging.for(this);
         return this.logger;
     }
+    /**
+     * @description Creates a new sequence instance
+     * @summary Protected constructor that initializes the sequence with the provided options
+     */
     constructor(options) {
         this.options = options;
     }
+    /**
+     * @description Gets the primary key sequence name for a model
+     * @summary Utility method that returns the standardized sequence name for a model's primary key
+     * @template M - The model type
+     * @param {M|Constructor<M>} model - The model instance or constructor
+     * @return {string} The sequence name for the model's primary key
+     */
     static pk(model) {
         return (0, utils_1.sequenceNameForModel)(model, "pk");
     }
+    /**
+     * @description Parses a sequence value to the appropriate type
+     * @summary Converts a sequence value to the specified type (Number or BigInt)
+     * @param {"Number"|"BigInt"|undefined} type - The target type to convert to
+     * @param {string|number|bigint} value - The value to convert
+     * @return {string|number|bigint} The converted value
+     */
     static parseValue(type, value) {
         switch (type) {
             case "Number":
@@ -32,4 +101,4 @@ class Sequence {
     }
 }
 exports.Sequence = Sequence;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Sequence.js","sourceRoot":"","sources":["../../src/persistence/Sequence.ts"],"names":[],"mappings":";;;AACA,mDAAyD;AAEzD,2DAAwD;AACxD,+CAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAsB,QAAQ;IAO5B;;;;OAIG;IACH,IAAc,GAAG;QACf,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,MAAM,GAAG,iBAAO,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,YAAyC,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAwBrE;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAkB,KAAyB;QAClD,OAAO,IAAA,4BAAoB,EAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CACf,IAAqC,EACrC,KAA+B;QAE/B,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,QAAQ;gBACX,OAAO,OAAO,KAAK,KAAK,QAAQ;oBAC9B,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC;oBACjB,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ;wBACzB,CAAC,CAAC,KAAK;wBACP,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACtB,KAAK,QAAQ;gBACX,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;YACvB;gBACE,MAAM,IAAI,6BAAa,CAAC,qBAAqB,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;CACF;AAhFD,4BAgFC","sourcesContent":["import { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { sequenceNameForModel } from \"../identity/utils\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Abstract base class for sequence generation\n * @summary Provides a framework for generating sequential values (like primary keys) in the persistence layer.\n * Implementations of this class handle the specifics of how sequences are stored and incremented in different\n * database systems.\n * @param {SequenceOptions} options - Configuration options for the sequence generator\n * @class Sequence\n * @example\n * ```typescript\n * // Example implementation for a specific database\n * class PostgresSequence extends Sequence {\n *   constructor(options: SequenceOptions) {\n *     super(options);\n *   }\n *\n *   async next(): Promise<number> {\n *     // Implementation to get next value from PostgreSQL sequence\n *     const result = await this.options.executor.raw(`SELECT nextval('${this.options.name}')`);\n *     return parseInt(result.rows[0].nextval);\n *   }\n *\n *   async current(): Promise<number> {\n *     // Implementation to get current value from PostgreSQL sequence\n *     const result = await this.options.executor.raw(`SELECT currval('${this.options.name}')`);\n *     return parseInt(result.rows[0].currval);\n *   }\n *\n *   async range(count: number): Promise<number[]> {\n *     // Implementation to get a range of values\n *     const values: number[] = [];\n *     for (let i = 0; i < count; i++) {\n *       values.push(await this.next());\n *     }\n *     return values;\n *   }\n * }\n *\n * // Usage\n * const sequence = new PostgresSequence({\n *   name: 'user_id_seq',\n *   executor: dbExecutor\n * });\n *\n * const nextId = await sequence.next();\n * ```\n */\nexport abstract class Sequence {\n  /**\n   * @description Logger instance for this sequence\n   * @summary Lazily initialized logger for the sequence instance\n   */\n  private logger!: Logger;\n\n  /**\n   * @description Accessor for the logger instance\n   * @summary Gets or initializes the logger for this sequence\n   * @return {Logger} The logger instance\n   */\n  protected get log() {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  /**\n   * @description Creates a new sequence instance\n   * @summary Protected constructor that initializes the sequence with the provided options\n   */\n  protected constructor(protected readonly options: SequenceOptions) {}\n\n  /**\n   * @description Gets the next value in the sequence\n   * @summary Retrieves the next value from the sequence, incrementing it in the process\n   * @return A promise that resolves to the next value in the sequence\n   */\n  abstract next(): Promise<string | number | bigint>;\n\n  /**\n   * @description Gets the current value of the sequence\n   * @summary Retrieves the current value of the sequence without incrementing it\n   * @return A promise that resolves to the current value in the sequence\n   */\n  abstract current(): Promise<string | number | bigint>;\n\n  /**\n   * @description Gets a range of sequential values\n   * @summary Retrieves multiple sequential values at once, which can be more efficient than calling next() multiple times\n   * @param {number} count - The number of sequential values to retrieve\n   * @return A promise that resolves to an array of sequential values\n   */\n  abstract range(count: number): Promise<(number | string | bigint)[]>;\n\n  /**\n   * @description Gets the primary key sequence name for a model\n   * @summary Utility method that returns the standardized sequence name for a model's primary key\n   * @template M - The model type\n   * @param {M|Constructor<M>} model - The model instance or constructor\n   * @return {string} The sequence name for the model's primary key\n   */\n  static pk<M extends Model>(model: M | Constructor<M>) {\n    return sequenceNameForModel(model, \"pk\");\n  }\n\n  /**\n   * @description Parses a sequence value to the appropriate type\n   * @summary Converts a sequence value to the specified type (Number or BigInt)\n   * @param {\"Number\"|\"BigInt\"|undefined} type - The target type to convert to\n   * @param {string|number|bigint} value - The value to convert\n   * @return {string|number|bigint} The converted value\n   */\n  static parseValue(\n    type: \"Number\" | \"BigInt\" | undefined,\n    value: string | number | bigint\n  ): string | number | bigint {\n    switch (type) {\n      case \"Number\":\n        return typeof value === \"string\"\n          ? parseInt(value)\n          : typeof value === \"number\"\n            ? value\n            : BigInt(value);\n      case \"BigInt\":\n        return BigInt(value);\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n  }\n}\n"]}

package/lib/persistence/Sequence.d.ts

@@ -1,14 +1,103 @@
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { SequenceOptions } from "../interfaces/SequenceOptions";
 import { Logger } from "@decaf-ts/logging";
+/**
+ * @description Abstract base class for sequence generation
+ * @summary Provides a framework for generating sequential values (like primary keys) in the persistence layer.
+ * Implementations of this class handle the specifics of how sequences are stored and incremented in different
+ * database systems.
+ * @param {SequenceOptions} options - Configuration options for the sequence generator
+ * @class Sequence
+ * @example
+ * ```typescript
+ * // Example implementation for a specific database
+ * class PostgresSequence extends Sequence {
+ *   constructor(options: SequenceOptions) {
+ *     super(options);
+ *   }
+ *
+ *   async next(): Promise<number> {
+ *     // Implementation to get next value from PostgreSQL sequence
+ *     const result = await this.options.executor.raw(`SELECT nextval('${this.options.name}')`);
+ *     return parseInt(result.rows[0].nextval);
+ *   }
+ *
+ *   async current(): Promise<number> {
+ *     // Implementation to get current value from PostgreSQL sequence
+ *     const result = await this.options.executor.raw(`SELECT currval('${this.options.name}')`);
+ *     return parseInt(result.rows[0].currval);
+ *   }
+ *
+ *   async range(count: number): Promise<number[]> {
+ *     // Implementation to get a range of values
+ *     const values: number[] = [];
+ *     for (let i = 0; i < count; i++) {
+ *       values.push(await this.next());
+ *     }
+ *     return values;
+ *   }
+ * }
+ *
+ * // Usage
+ * const sequence = new PostgresSequence({
+ *   name: 'user_id_seq',
+ *   executor: dbExecutor
+ * });
+ *
+ * const nextId = await sequence.next();
+ * ```
+ */
 export declare abstract class Sequence {
     protected readonly options: SequenceOptions;
+    /**
+     * @description Logger instance for this sequence
+     * @summary Lazily initialized logger for the sequence instance
+     */
     private logger;
+    /**
+     * @description Accessor for the logger instance
+     * @summary Gets or initializes the logger for this sequence
+     * @return {Logger} The logger instance
+     */
     protected get log(): Logger;
+    /**
+     * @description Creates a new sequence instance
+     * @summary Protected constructor that initializes the sequence with the provided options
+     */
     protected constructor(options: SequenceOptions);
+    /**
+     * @description Gets the next value in the sequence
+     * @summary Retrieves the next value from the sequence, incrementing it in the process
+     * @return A promise that resolves to the next value in the sequence
+     */
     abstract next(): Promise<string | number | bigint>;
+    /**
+     * @description Gets the current value of the sequence
+     * @summary Retrieves the current value of the sequence without incrementing it
+     * @return A promise that resolves to the current value in the sequence
+     */
     abstract current(): Promise<string | number | bigint>;
+    /**
+     * @description Gets a range of sequential values
+     * @summary Retrieves multiple sequential values at once, which can be more efficient than calling next() multiple times
+     * @param {number} count - The number of sequential values to retrieve
+     * @return A promise that resolves to an array of sequential values
+     */
     abstract range(count: number): Promise<(number | string | bigint)[]>;
+    /**
+     * @description Gets the primary key sequence name for a model
+     * @summary Utility method that returns the standardized sequence name for a model's primary key
+     * @template M - The model type
+     * @param {M|Constructor<M>} model - The model instance or constructor
+     * @return {string} The sequence name for the model's primary key
+     */
     static pk<M extends Model>(model: M | Constructor<M>): string;
+    /**
+     * @description Parses a sequence value to the appropriate type
+     * @summary Converts a sequence value to the specified type (Number or BigInt)
+     * @param {"Number"|"BigInt"|undefined} type - The target type to convert to
+     * @param {string|number|bigint} value - The value to convert
+     * @return {string|number|bigint} The converted value
+     */
     static parseValue(type: "Number" | "BigInt" | undefined, value: string | number | bigint): string | number | bigint;
 }