@decaf-ts/core 0.5.1 → 0.5.3

package/lib/persistence/Adapter.d.ts

@@ -13,19 +13,96 @@ import { Dispatch } from "./Dispatch";
 import { type EventIds, type ObserverFilter } from "./types";
 import { ObserverHandler } from "./ObserverHandler";
 /**
- * @summary Abstract Decaf-ts Persistence Adapter Class
- * @description Offers the base implementation for all Adapter Classes
- * and manages them various registered {@link Adapter}s
+ * @description Abstract base class for database adapters
+ * @summary Provides the foundation for all database adapters in the persistence layer. This class
+ * implements several interfaces to provide a consistent API for database operations, observer
+ * pattern support, and error handling. It manages adapter registration, CRUD operations, and
+ * observer notifications.
+ * @template Y - The underlying database driver type
+ * @template Q - The query object type used by the adapter
+ * @template F - The repository flags type
+ * @template C - The context type
+ * @param {Y} _native - The underlying database driver instance
+ * @param {string} flavour - The identifier for this adapter type
+ * @param {string} [_alias] - Optional alternative name for this adapter
+ * @class Adapter
+ * @example
+ * ```typescript
+ * // Implementing a concrete adapter
+ * class PostgresAdapter extends Adapter<pg.Client, pg.Query, PostgresFlags, PostgresContext> {
+ *   constructor(client: pg.Client) {
+ *     super(client, 'postgres');
+ *   }
  *
- * @typedef Y the underlying persistence object type or the required config to set it up
- * @typedef Q The query object the adapter uses
+ *   async initialize() {
+ *     // Set up the adapter
+ *     await this.native.connect();
+ *   }
  *
- * @param {Y} native the underlying persistence object
- * @param {string} flavour the under witch the persistence adapter should be stored
+ *   async create(tableName, id, model) {
+ *     // Implementation for creating records
+ *     const columns = Object.keys(model).join(', ');
+ *     const values = Object.values(model);
+ *     const placeholders = values.map((_, i) => `$${i+1}`).join(', ');
  *
- * @class Adapter
- * @implements RawExecutor
- * @implements Observable
+ *     const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders}) RETURNING *`;
+ *     const result = await this.native.query(query, values);
+ *     return result.rows[0];
+ *   }
+ *
+ *   // Other required method implementations...
+ * }
+ *
+ * // Using the adapter
+ * const pgClient = new pg.Client(connectionString);
+ * const adapter = new PostgresAdapter(pgClient);
+ * await adapter.initialize();
+ *
+ * // Set as the default adapter
+ * Adapter.setCurrent('postgres');
+ *
+ * // Perform operations
+ * const user = await adapter.create('users', 1, { name: 'John', email: 'john@example.com' });
+ * ```
+ * @mermaid
+ * classDiagram
+ *   class Adapter {
+ *     +Y native
+ *     +string flavour
+ *     +string alias
+ *     +create(tableName, id, model)
+ *     +read(tableName, id)
+ *     +update(tableName, id, model)
+ *     +delete(tableName, id)
+ *     +observe(observer, filter)
+ *     +unObserve(observer)
+ *     +static current
+ *     +static get(flavour)
+ *     +static setCurrent(flavour)
+ *   }
+ *
+ *   class RawExecutor {
+ *     +raw(query)
+ *   }
+ *
+ *   class Observable {
+ *     +observe(observer, filter)
+ *     +unObserve(observer)
+ *     +updateObservers(table, event, id)
+ *   }
+ *
+ *   class Observer {
+ *     +refresh(table, event, id)
+ *   }
+ *
+ *   class ErrorParser {
+ *     +parseError(err)
+ *   }
+ *
+ *   Adapter --|> RawExecutor
+ *   Adapter --|> Observable
+ *   Adapter --|> Observer
+ *   Adapter --|> ErrorParser
  */
 export declare abstract class Adapter<Y, Q, F extends RepositoryFlags, C extends Context<F>> implements RawExecutor<Q>, Contextual<F, C>, Observable, Observer, ErrorParser {
     private readonly _native;
@@ -36,55 +113,319 @@ export declare abstract class Adapter<Y, Q, F extends RepositoryFlags, C extends
     private logger;
     protected dispatch?: Dispatch<Y>;
     protected readonly observerHandler?: ObserverHandler;
+    /**
+     * @description Logger accessor
+     * @summary Gets or initializes the logger for this adapter instance
+     * @return {Logger} The logger instance
+     */
     protected get log(): Logger;
+    /**
+     * @description Gets the native database driver
+     * @summary Provides access to the underlying database driver instance
+     * @return {Y} The native database driver
+     */
     get native(): Y;
+    /**
+     * @description Gets the adapter's alias or flavor name
+     * @summary Returns the alias if set, otherwise returns the flavor name
+     * @return {string} The adapter's identifier
+     */
     get alias(): string;
+    /**
+     * @description Gets the repository constructor for this adapter
+     * @summary Returns the constructor for creating repositories that work with this adapter
+     * @template M - The model type
+     * @return {Constructor<Repository<M, Q, Adapter<Y, Q, F, C>, F, C>>} The repository constructor
+     */
     repository<M extends Model>(): Constructor<Repository<M, Q, Adapter<Y, Q, F, C>, F, C>>;
+    /**
+     * @description Creates a new adapter instance
+     * @summary Initializes the adapter with the native driver and registers it in the adapter cache
+     */
     protected constructor(_native: Y, flavour: string, _alias?: string | undefined);
+    /**
+     * @description Creates a new statement builder for a model
+     * @summary Returns a statement builder that can be used to construct queries for a specific model
+     * @template M - The model type
+     * @return {Statement} A statement builder for the model
+     */
     abstract Statement<M extends Model>(): Statement<Q, M, any>;
+    /**
+     * @description Creates a new dispatch instance
+     * @summary Factory method that creates a dispatch instance for this adapter
+     * @return {Dispatch<Y>} A new dispatch instance
+     */
     protected Dispatch(): Dispatch<Y>;
+    /**
+     * @description Creates a new observer handler
+     * @summary Factory method that creates an observer handler for this adapter
+     * @return {ObserverHandler} A new observer handler instance
+     */
     protected ObserverHandler(): ObserverHandler;
+    /**
+     * @description Checks if an attribute name is reserved
+     * @summary Determines if a given attribute name is reserved and cannot be used as a column name
+     * @param {string} attr - The attribute name to check
+     * @return {boolean} True if the attribute is reserved, false otherwise
+     */
     protected isReserved(attr: string): boolean;
+    /**
+     * @description Parses a database error into a standardized error
+     * @summary Converts database-specific errors into standardized application errors
+     * @param {Error} err - The original database error
+     * @return {BaseError} A standardized error
+     */
     abstract parseError(err: Error): BaseError;
+    /**
+     * @description Initializes the adapter
+     * @summary Performs any necessary setup for the adapter, such as establishing connections
+     * @param {...any[]} args - Initialization arguments
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     */
     abstract initialize(...args: any[]): Promise<void>;
+    /**
+     * @description Creates a sequence generator
+     * @summary Factory method that creates a sequence generator for generating sequential values
+     * @param {SequenceOptions} options - Configuration options for the sequence
+     * @return {Promise<Sequence>} A promise that resolves to a new sequence instance
+     */
     abstract Sequence(options: SequenceOptions): Promise<Sequence>;
+    /**
+     * @description Creates repository flags for an operation
+     * @summary Generates a set of flags that describe a database operation, combining default flags with overrides
+     * @template F - The Repository Flags type
+     * @template M - The model type
+     * @param {OperationKeys} operation - The type of operation being performed
+     * @param {Constructor<M>} model - The model constructor
+     * @param {Partial<F>} flags - Custom flag overrides
+     * @param {...any[]} args - Additional arguments
+     * @return {F} The complete set of flags
+     */
     protected flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<F>, ...args: any[]): F;
-    protected Context: Constructor<C>;
+    /**
+     * @description The context constructor for this adapter
+     * @summary Reference to the context class constructor used by this adapter
+     */
+    protected Context: {
+        new (): Context<F>;
+        factory: import("@decaf-ts/db-decorators").ContextFactory<any>;
+        childFrom<F_1 extends RepositoryFlags, C_1 extends Context<F_1>>(context: C_1, overrides?: Partial<F_1>): C_1;
+        from<M extends Model, F_1 extends RepositoryFlags, C_1 extends Context<F_1>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, overrides: Partial<F_1>, model: Constructor<M>, ...args: any[]): Promise<C_1>;
+        args<M extends Model, C_1 extends Context<F_1>, F_1 extends RepositoryFlags>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>, args: any[], contextual?: Contextual<F_1>, overrides?: Partial<F_1>): Promise<import("@decaf-ts/db-decorators").ContextArgs<F_1, C_1>>;
+    };
+    /**
+     * @description Creates a context for a database operation
+     * @summary Generates a context object that describes a database operation, used for tracking and auditing
+     * @template F - The Repository flags type
+     * @template M - The model type
+     * @param {OperationKeys.CREATE|OperationKeys.READ|OperationKeys.UPDATE|OperationKeys.DELETE} operation - The type of operation
+     * @param {Partial<F>} overrides - Custom flag overrides
+     * @param {Constructor<M>} model - The model constructor
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<C>} A promise that resolves to the context object
+     */
     context<M extends Model>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, overrides: Partial<F>, model: Constructor<M>, ...args: any[]): Promise<C>;
+    /**
+     * @description Prepares a model for persistence
+     * @summary Converts a model instance into a format suitable for database storage,
+     * handling column mapping and separating transient properties
+     * @template M - The model type
+     * @param {M} model - The model instance to prepare
+     * @param pk - The primary key property name
+     * @return The prepared data
+     */
     prepare<M extends Model>(model: M, pk: keyof M): {
         record: Record<string, any>;
         id: string;
         transient?: Record<string, any>;
     };
+    /**
+     * @description Converts database data back into a model instance
+     * @summary Reconstructs a model instance from database data, handling column mapping
+     * and reattaching transient properties
+     * @template M - The model type
+     * @param obj - The database record
+     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param pk - The primary key property name
+     * @param {string|number|bigint} id - The primary key value
+     * @param [transient] - Transient properties to reattach
+     * @return {M} The reconstructed model instance
+     */
     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 Inserts a new record with the given ID and data into the specified table
+     * @param {string} tableName - The name of the table to insert into
+     * @param {string|number} id - The identifier for the new record
+     * @param model - The data to insert
+     * @param {any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to the created record
+     */
     abstract create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Creates multiple records in the database
+     * @summary Inserts multiple records with the given IDs and data into the specified table
+     * @param {string} tableName - The name of the table to insert into
+     * @param id - The identifiers for the new records
+     * @param model - The data to insert for each record
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to an array of created records
+     */
     createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Retrieves a record from the database
+     * @summary Fetches a record with the given ID from the specified table
+     * @param {string} tableName - The name of the table to read from
+     * @param {string|number|bigint} id - The identifier of the record to retrieve
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to the retrieved record
+     */
     abstract read(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Retrieves multiple records from the database
+     * @summary Fetches multiple records with the given IDs from the specified table
+     * @param {string} tableName - The name of the table to read from
+     * @param id - The identifiers of the records to retrieve
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to an array of retrieved records
+     */
     readAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Updates a record in the database
+     * @summary Modifies an existing record with the given ID in the specified table
+     * @param {string} tableName - The name of the table to update
+     * @param {string|number} id - The identifier of the record to update
+     * @param  model - The new data for the record
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to the updated record
+     */
     abstract update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Updates multiple records in the database
+     * @summary Modifies multiple existing records with the given IDs in the specified table
+     * @param {string} tableName - The name of the table to update
+     * @param {string[]|number[]} id - The identifiers of the records to update
+     * @param model - The new data for each record
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to an array of updated records
+     */
     updateAll(tableName: string, id: string[] | number[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Deletes a record from the database
+     * @summary Removes a record with the given ID from the specified table
+     * @param {string} tableName - The name of the table to delete from
+     * @param {string|number|bigint} id - The identifier of the record to delete
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to the deleted record
+     */
     abstract delete(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Deletes multiple records from the database
+     * @summary Removes multiple records with the given IDs from the specified table
+     * @param {string} tableName - The name of the table to delete from
+     * @param id - The identifiers of the records to delete
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return A promise that resolves to an array of deleted records
+     */
     deleteAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Executes a raw query against the database
+     * @summary Allows executing database-specific queries directly
+     * @template Q - The raw query type
+     * @template R - The return type of the query
+     * @param {Q} rawInput - The query to execute
+     * @param {...any[]} args - Additional arguments specific to the adapter implementation
+     * @return {Promise<R>} A promise that resolves to the query result
+     */
     abstract raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
     /**
-     *
-     * @see {Observable#observe}
+     * @description Registers an observer for database events
+     * @summary Adds an observer to be notified about database changes. The observer can optionally
+     * provide a filter function to receive only specific events.
+     * @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;
     /**
-     * @summary Unregisters an {@link Observer}
-     * @param {Observer} observer
-     *
-     * @see {Observable#unObserve}
+     * @description Unregisters an observer
+     * @summary Removes a previously registered observer so it no longer receives database event notifications
+     * @param {Observer} observer - The observer to unregister
+     * @return {void}
      */
     unObserve(observer: Observer): void;
+    /**
+     * @description Notifies all observers about a database event
+     * @summary Sends notifications to all registered observers about a change in the database,
+     * filtering based on each observer's filter function
+     * @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)
+     * @param {...any[]} args - Additional arguments to pass to the observers
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
     updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+    /**
+     * @description Refreshes data based on a database event
+     * @summary Implementation of the Observer interface method that delegates to updateObservers
+     * @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)
+     * @param {...any[]} args - Additional arguments related to the event
+     * @return {Promise<void>} A promise that resolves when the refresh is complete
+     */
     refresh(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+    /**
+     * @description Gets a string representation of the adapter
+     * @summary Returns a human-readable string identifying this adapter
+     * @return {string} A string representation of the adapter
+     */
     toString(): string;
+    /**
+     * @description Gets the adapter flavor associated with a model
+     * @summary Retrieves the adapter flavor that should be used for a specific model class
+     * @template M - The model type
+     * @param {Constructor<M>} model - The model constructor
+     * @return {string} The adapter flavor name
+     */
     static flavourOf<M extends Model>(model: Constructor<M>): string;
+    /**
+     * @description Gets the current default adapter
+     * @summary Retrieves the adapter that is currently set as the default for operations
+     * @return {Adapter<any, any, any, any>} The current adapter
+     */
     static get current(): Adapter<any, any, any, any>;
+    /**
+     * @description Gets an adapter by flavor
+     * @summary Retrieves a registered adapter by its flavor name
+     * @template Y - The database driver type
+     * @template Q - The query type
+     * @template C - The context type
+     * @template F - The repository flags type
+     * @param {string} flavour - The flavor name of the adapter to retrieve
+     * @return {Adapter<Y, Q, F, C> | undefined} The adapter instance or undefined if not found
+     */
     static get<Y, Q, C extends Context<F>, F extends RepositoryFlags>(flavour: any): Adapter<Y, Q, F, C> | undefined;
+    /**
+     * @description Sets the current default adapter
+     * @summary Changes which adapter is used as the default for operations
+     * @param {string} flavour - The flavor name of the adapter to set as current
+     * @return {void}
+     */
     static setCurrent(flavour: string): void;
+    /**
+     * @description Creates a metadata key
+     * @summary Generates a standardized metadata key for persistence-related metadata
+     * @param {string} key - The base key name
+     * @return {string} The formatted metadata key
+     */
     static key(key: string): string;
+    /**
+     * @description Gets all models associated with an adapter flavor
+     * @summary Retrieves all model constructors that are configured to use a specific adapter flavor
+     * @template M - The model type
+     * @param {string} flavour - The adapter flavor to find models for
+     * @return An array of model constructors
+     */
     static models<M extends Model>(flavour: string): ModelConstructor<any>[];
 }

package/lib/persistence/Dispatch.cjs

@@ -5,14 +5,85 @@ const db_decorators_1 = require("@decaf-ts/db-decorators");
 const Adapter_1 = require("./Adapter.cjs");
 const errors_1 = require("./errors.cjs");
 const logging_1 = require("@decaf-ts/logging");
+/**
+ * @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);
+ * ```
+ */
 class Dispatch {
+    /**
+     * @description Accessor for the logger
+     * @summary Gets or initializes the logger for this dispatch instance
+     * @return {Logger} The logger instance
+     */
     get log() {
         if (!this.logger)
             this.logger = logging_1.Logging.for(this).for(this.adapter);
         return this.logger;
     }
+    /**
+     * @description Creates a new Dispatch instance
+     * @summary Initializes a new Dispatch instance without any adapter
+     */
     constructor() { }
-    initialize() {
+    /**
+     * @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
+     */
+    async initialize() {
         if (!this.adapter)
             throw new db_decorators_1.InternalError(`No adapter observed for dispatch`);
         const adapter = this.adapter;
@@ -64,20 +135,47 @@ class Dispatch {
             });
         });
     }
+    /**
+     * @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
+     */
+    async close() {
+        // to nothing in this instance but may be required for closing connections
+    }
+    /**
+     * @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) {
         if (!(observer instanceof Adapter_1.Adapter))
             throw new errors_1.UnsupportedError("Only Adapters can be observed by dispatch");
         this.adapter = observer;
         this.native = observer.native;
         this.models = Adapter_1.Adapter.models(this.adapter.alias);
-        this.initialize();
-        this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`);
+        this.initialize().then(() => this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`));
     }
+    /**
+     * @description Stops observing an adapter
+     * @summary Disconnects this dispatch from an adapter
+     * @param {Observer} observer - The adapter to stop observing
+     * @return {void}
+     */
     unObserve(observer) {
         if (this.adapter !== observer)
             throw new errors_1.UnsupportedError("Only the adapter that was used to observe can be unobserved");
         this.adapter = undefined;
     }
+    /**
+     * @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
+     */
     async updateObservers(table, event, id) {
         if (!this.adapter)
             throw new db_decorators_1.InternalError(`No adapter observed for dispatch`);
@@ -90,4 +188,4 @@ class Dispatch {
     }
 }
 exports.Dispatch = Dispatch;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Dispatch.js","sourceRoot":"","sources":["../../src/persistence/Dispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  InternalError,\n  OperationKeys,\n  BulkCrudOperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer } from \"../interfaces\";\nimport { Adapter } from \"./Adapter\";\nimport { UnsupportedError } from \"./errors\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { EventIds } from \"./types\";\n\nexport class Dispatch<Y> implements Observable {\n  protected adapter?: Adapter<Y, any, any, any>;\n  protected native?: Y;\n  protected models!: ModelConstructor<any>[];\n\n  private logger!: Logger;\n\n  protected get log() {\n    if (!this.logger)\n      this.logger = Logging.for(this as any).for(this.adapter as any);\n    return this.logger;\n  }\n\n  constructor() {}\n\n  protected initialize(): void {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    const adapter = this.adapter as Adapter<Y, any, any, any>;\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<Y, any, any, any>)[]\n    ).forEach((method) => {\n      if (!adapter[method])\n        throw new InternalError(\n          `Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(adapter, method);\n      let proto: any = adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, method);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${method} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n      // @ts-expect-error because there are read only properties\n      adapter[method] = new Proxy(adapter[method], {\n        apply: async (target: any, thisArg, argArray: any[]) => {\n          const [tableName, ids] = argArray;\n          const result = await target.apply(thisArg, argArray);\n          this.updateObservers(tableName, bulkToSingle(method), ids as EventIds)\n            .then(() => {\n              this.log.verbose(\n                `Observer refresh dispatched by ${method} for ${tableName}`\n              );\n              this.log.debug(`pks: ${ids}`);\n            })\n            .catch((e: unknown) =>\n              this.log.error(\n                `Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`\n              )\n            );\n          return result;\n        },\n      });\n    });\n  }\n\n  observe(observer: Adapter<Y, any, any, any>): void {\n    if (!(observer instanceof Adapter))\n      throw new UnsupportedError(\"Only Adapters can be observed by dispatch\");\n    this.adapter = observer;\n    this.native = observer.native;\n    this.models = Adapter.models(this.adapter.alias);\n    this.initialize();\n    this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`);\n  }\n\n  unObserve(observer: Observer): void {\n    if (this.adapter !== observer)\n      throw new UnsupportedError(\n        \"Only the adapter that was used to observe can be unobserved\"\n      );\n    this.adapter = undefined;\n  }\n\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds\n  ): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    try {\n      await this.adapter.refresh(table, event, id);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Dispatch.js","sourceRoot":"","sources":["../../src/persistence/Dispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  InternalError,\n  OperationKeys,\n  BulkCrudOperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { Observable, Observer } from \"../interfaces\";\nimport { Adapter } from \"./Adapter\";\nimport { UnsupportedError } from \"./errors\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { EventIds } from \"./types\";\n\n/**\n * @description Dispatches database operation events to observers\n * @summary The Dispatch class implements the Observable interface and is responsible for intercepting\n * database operations from an Adapter and notifying observers when changes occur. It uses proxies to\n * wrap the adapter's CRUD methods and automatically trigger observer updates after operations complete.\n * @template Y - The native database driver type\n * @param {void} - No constructor parameters\n * @class Dispatch\n * @example\n * ```typescript\n * // Creating and using a Dispatch instance\n * const dispatch = new Dispatch<PostgresDriver>();\n *\n * // Connect it to an adapter\n * const adapter = new PostgresAdapter(connection);\n * dispatch.observe(adapter);\n *\n * // Now any CRUD operations on the adapter will automatically\n * // trigger observer notifications\n * await adapter.create('users', 123, userModel);\n * // Observers will be notified about the creation\n *\n * // When done, you can disconnect\n * dispatch.unObserve(adapter);\n * ```\n */\nexport class Dispatch<Y> implements Observable {\n  /**\n   * @description The adapter being observed\n   * @summary Reference to the database adapter whose operations are being monitored\n   */\n  protected adapter?: Adapter<Y, any, any, any>;\n\n  /**\n   * @description The native database driver\n   * @summary Reference to the underlying database driver from the adapter\n   */\n  protected native?: Y;\n\n  /**\n   * @description List of model constructors\n   * @summary Array of model constructors that are registered with the adapter\n   */\n  protected models!: ModelConstructor<any>[];\n\n  /**\n   * @description Logger instance\n   * @summary Logger for recording dispatch activities\n   */\n  private logger!: Logger;\n\n  /**\n   * @description Accessor for the logger\n   * @summary Gets or initializes the logger for this dispatch instance\n   * @return {Logger} The logger instance\n   */\n  protected get log() {\n    if (!this.logger)\n      this.logger = Logging.for(this as any).for(this.adapter as any);\n    return this.logger;\n  }\n\n  /**\n   * @description Creates a new Dispatch instance\n   * @summary Initializes a new Dispatch instance without any adapter\n   */\n  constructor() {}\n\n  /**\n   * @description Initializes the dispatch by proxying adapter methods\n   * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.\n   * This method is called automatically when an adapter is observed.\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   * @mermaid\n   * sequenceDiagram\n   *   participant Dispatch\n   *   participant Adapter\n   *   participant Proxy\n   *\n   *   Dispatch->>Dispatch: initialize()\n   *   Dispatch->>Dispatch: Check if adapter exists\n   *   alt No adapter\n   *     Dispatch-->>Dispatch: Throw InternalError\n   *   end\n   *\n   *   loop For each CRUD method\n   *     Dispatch->>Adapter: Check if method exists\n   *     alt Method doesn't exist\n   *       Dispatch-->>Dispatch: Throw InternalError\n   *     end\n   *\n   *     Dispatch->>Adapter: Get property descriptor\n   *     loop While descriptor not found\n   *       Dispatch->>Adapter: Check prototype chain\n   *     end\n   *\n   *     alt Descriptor not found or not writable\n   *       Dispatch->>Dispatch: Log error and continue\n   *     else Descriptor found and writable\n   *       Dispatch->>Proxy: Create proxy for method\n   *       Dispatch->>Adapter: Replace method with proxy\n   *     end\n   *   end\n   */\n  protected async initialize(): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    const adapter = this.adapter as Adapter<Y, any, any, any>;\n    (\n      [\n        OperationKeys.CREATE,\n        OperationKeys.UPDATE,\n        OperationKeys.DELETE,\n        BulkCrudOperationKeys.CREATE_ALL,\n        BulkCrudOperationKeys.UPDATE_ALL,\n        BulkCrudOperationKeys.DELETE_ALL,\n      ] as (keyof Adapter<Y, any, any, any>)[]\n    ).forEach((method) => {\n      if (!adapter[method])\n        throw new InternalError(\n          `Method ${method} not found in ${adapter.alias} adapter to bind Observables Dispatch`\n        );\n\n      let descriptor = Object.getOwnPropertyDescriptor(adapter, method);\n      let proto: any = adapter;\n      while (!descriptor && proto !== Object.prototype) {\n        proto = Object.getPrototypeOf(proto);\n        descriptor = Object.getOwnPropertyDescriptor(proto, method);\n      }\n\n      if (!descriptor || !descriptor.writable) {\n        this.log.error(\n          `Could not find method ${method} to bind Observables Dispatch`\n        );\n        return;\n      }\n      function bulkToSingle(method: string) {\n        switch (method) {\n          case BulkCrudOperationKeys.CREATE_ALL:\n            return OperationKeys.CREATE;\n          case BulkCrudOperationKeys.UPDATE_ALL:\n            return OperationKeys.UPDATE;\n          case BulkCrudOperationKeys.DELETE_ALL:\n            return OperationKeys.DELETE;\n          default:\n            return method;\n        }\n      }\n      // @ts-expect-error because there are read only properties\n      adapter[method] = new Proxy(adapter[method], {\n        apply: async (target: any, thisArg, argArray: any[]) => {\n          const [tableName, ids] = argArray;\n          const result = await target.apply(thisArg, argArray);\n          this.updateObservers(tableName, bulkToSingle(method), ids as EventIds)\n            .then(() => {\n              this.log.verbose(\n                `Observer refresh dispatched by ${method} for ${tableName}`\n              );\n              this.log.debug(`pks: ${ids}`);\n            })\n            .catch((e: unknown) =>\n              this.log.error(\n                `Failed to dispatch observer refresh for ${method} on ${tableName}: ${e}`\n              )\n            );\n          return result;\n        },\n      });\n    });\n  }\n\n  /**\n   * @description Closes the dispatch\n   * @summary Performs any necessary cleanup when the dispatch is no longer needed\n   * @return {Promise<void>} A promise that resolves when closing is complete\n   */\n  async close() {\n    // to nothing in this instance but may be required for closing connections\n  }\n\n  /**\n   * @description Starts observing an adapter\n   * @summary Connects this dispatch to an adapter to monitor its operations\n   * @param {Adapter<Y, any, any, any>} observer - The adapter to observe\n   * @return {void}\n   */\n  observe(observer: Adapter<Y, any, any, any>): void {\n    if (!(observer instanceof Adapter))\n      throw new UnsupportedError(\"Only Adapters can be observed by dispatch\");\n    this.adapter = observer;\n    this.native = observer.native;\n    this.models = Adapter.models(this.adapter.alias);\n    this.initialize().then(() =>\n      this.log.verbose(\n        `Dispatch initialized for ${this.adapter!.alias} adapter`\n      )\n    );\n  }\n\n  /**\n   * @description Stops observing an adapter\n   * @summary Disconnects this dispatch from an adapter\n   * @param {Observer} observer - The adapter to stop observing\n   * @return {void}\n   */\n  unObserve(observer: Observer): void {\n    if (this.adapter !== observer)\n      throw new UnsupportedError(\n        \"Only the adapter that was used to observe can be unobserved\"\n      );\n    this.adapter = undefined;\n  }\n\n  /**\n   * @description Updates observers about a database event\n   * @summary Notifies observers about a change in the database\n   * @param {string} table - The name of the table where the change 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   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   */\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds\n  ): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    try {\n      await this.adapter.refresh(table, event, id);\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n}\n"]}