@decaf-ts/core 0.5.1 → 0.5.2

package/dist/core.esm.cjs

@@ -1,46 +1,101 @@
 import { inject, injectable, InjectableRegistryImp, Injectables } from '@decaf-ts/injectable-decorators';
-import { BaseError, InternalError, OperationKeys, BulkCrudOperationKeys, Context, DefaultRepositoryFlags, modelToTransient, NotFoundError, DBKeys, Repository as Repository$1, wrapMethodWithContext, enforceDBDecorators, ValidationError, findPrimaryKey, ConflictError, onCreateUpdate, onCreate, onUpdate, onDelete, afterAny, readonly, timestamp, DBOperations } from '@decaf-ts/db-decorators';
+import { BaseError, InternalError, OperationKeys, BulkCrudOperationKeys, Context, DefaultRepositoryFlags, modelToTransient, NotFoundError, DBKeys, Repository as Repository$1, wrapMethodWithContext, enforceDBDecorators, ValidationError, findPrimaryKey, DefaultSeparator, ConflictError, onCreateUpdate, onCreate, onUpdate, onDelete, afterAny, readonly, timestamp, DBOperations } from '@decaf-ts/db-decorators';
 import { apply, metadata, Reflection } from '@decaf-ts/reflection';
 import { __decorate, __metadata } from 'tslib';
 import { Decoration, DefaultFlavour, Model, sf, required, Validation, ValidationKeys, propMetadata, prop, type, list } from '@decaf-ts/decorator-validation';
 import { Logging } from '@decaf-ts/logging';
 
+/**
+ * @description Enumeration of possible sort directions.
+ * @summary Defines the available sort directions for ordering query results.
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var OrderDirection;
 (function (OrderDirection) {
+    /** Ascending order (A to Z, 0 to 9) */
     OrderDirection["ASC"] = "asc";
+    /** Descending order (Z to A, 9 to 0) */
     OrderDirection["DSC"] = "desc";
 })(OrderDirection || (OrderDirection = {}));
+/**
+ * @description Enumeration of cascade operation types.
+ * @summary Defines the available cascade behaviors for entity relationships.
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var Cascade;
 (function (Cascade) {
+    /** Perform cascade operation on related entities */
     Cascade["CASCADE"] = "cascade";
+    /** Do not perform cascade operation on related entities */
     Cascade["NONE"] = "none";
 })(Cascade || (Cascade = {}));
+/**
+ * @description Default cascade configuration for entity relationships.
+ * @summary Provides the default cascade behavior where updates cascade but deletes do not.
+ * @type {CascadeMetadata}
+ * @const DefaultCascade
+ * @memberOf module:core
+ */
 const DefaultCascade = {
     update: Cascade.CASCADE,
     delete: Cascade.NONE,
 };
 
+/**
+ * @description Persistence-related constant keys
+ * @summary Enum containing string constants used throughout the persistence layer for metadata, relations, and other persistence-related operations
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var PersistenceKeys;
 (function (PersistenceKeys) {
+    /** @description Key for index metadata */
     PersistenceKeys["INDEX"] = "index";
+    /** @description Key for unique constraint metadata */
     PersistenceKeys["UNIQUE"] = "unique";
+    /** @description Key for adapter metadata */
     PersistenceKeys["ADAPTER"] = "adapter";
+    /** @description Template for injectable adapter names */
     PersistenceKeys["INJECTABLE"] = "decaf_{0}_adapter_for_{1}";
+    /** @description Key for table name metadata */
     PersistenceKeys["TABLE"] = "table";
+    /** @description Key for column name metadata */
     PersistenceKeys["COLUMN"] = "column";
+    /** @description Key for general metadata storage */
     PersistenceKeys["METADATA"] = "__metadata";
+    /** @description Key for relations metadata storage */
     PersistenceKeys["RELATIONS"] = "__relations";
+    /** @description Key for clause sequence metadata */
     PersistenceKeys["CLAUSE_SEQUENCE"] = "clause-sequence";
     // Ownership
+    /** @description Key for created-by ownership metadata */
     PersistenceKeys["CREATED_BY"] = "ownership.created-by";
+    /** @description Key for updated-by ownership metadata */
     PersistenceKeys["UPDATED_BY"] = "ownership.updated-by";
     // Relations
+    /** @description Key for one-to-one relation metadata */
     PersistenceKeys["ONE_TO_ONE"] = "relations.one-to-one";
+    /** @description Key for one-to-many relation metadata */
     PersistenceKeys["ONE_TO_MANY"] = "relations.one-to-many";
+    /** @description Key for many-to-one relation metadata */
     PersistenceKeys["MANY_TO_ONE"] = "relations.many-to-one";
+    /** @description Key for populate metadata */
     PersistenceKeys["POPULATE"] = "populate";
 })(PersistenceKeys || (PersistenceKeys = {}));
 
+/**
+ * @description Creates a decorator that makes a method non-configurable
+ * @summary This decorator prevents a method from being overridden by making it non-configurable.
+ * It throws an error if used on anything other than a method.
+ * @return {Function} A decorator function that can be applied to methods
+ * @function final
+ * @category Method Decorators
+ */
 function final() {
     return (target, propertyKey, descriptor) => {
         if (!descriptor)
@@ -52,36 +107,176 @@ function final() {
     };
 }
 
+/**
+ * @description Error thrown when a user is not authorized to perform an action
+ * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication
+ * @param {string|Error} msg - The error message or Error object
+ * @class AuthorizationError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing an AuthorizationError
+ * if (!user.isAuthenticated()) {
+ *   throw new AuthorizationError('User not authenticated');
+ * }
+ * ```
+ */
 class AuthorizationError extends BaseError {
     constructor(msg) {
         super(AuthorizationError.name, msg, 401);
     }
 }
+/**
+ * @description Error thrown when a user is forbidden from accessing a resource
+ * @summary This error is thrown when an authenticated user attempts to access a resource or perform an action they don't have permission for
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ForbiddenError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ForbiddenError
+ * if (!user.hasPermission('admin')) {
+ *   throw new ForbiddenError('User does not have admin permissions');
+ * }
+ * ```
+ */
 class ForbiddenError extends BaseError {
     constructor(msg) {
         super(ForbiddenError.name, msg, 403);
     }
 }
+/**
+ * @description Error thrown when a connection to a service fails
+ * @summary This error is thrown when the application fails to establish a connection to a required service or resource
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ConnectionError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ConnectionError
+ * try {
+ *   await database.connect();
+ * } catch (error) {
+ *   throw new ConnectionError('Failed to connect to database');
+ * }
+ * ```
+ */
 class ConnectionError extends BaseError {
     constructor(msg) {
         super(ConnectionError.name, msg, 503);
     }
 }
 
+/**
+ * @description Error thrown when an unsupported operation is attempted
+ * @summary This error is thrown when an operation is requested that is not supported by the current
+ * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.
+ * @param {string|Error} msg - The error message or an Error object to wrap
+ * @class UnsupportedError
+ * @example
+ * ```typescript
+ * // Throwing an UnsupportedError
+ * if (!adapter.supportsTransactions()) {
+ *   throw new UnsupportedError('Transactions are not supported by this adapter');
+ * }
+ *
+ * // Catching an UnsupportedError
+ * try {
+ *   await adapter.beginTransaction();
+ * } catch (error) {
+ *   if (error instanceof UnsupportedError) {
+ *     console.error('Operation not supported:', error.message);
+ *   }
+ * }
+ * ```
+ */
 class UnsupportedError extends BaseError {
     constructor(msg) {
         super(UnsupportedError.name, msg, 500);
     }
 }
 
+/**
+ * @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.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 InternalError(`No adapter observed for dispatch`);
         const adapter = this.adapter;
@@ -133,20 +328,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))
             throw new UnsupportedError("Only Adapters can be observed by dispatch");
         this.adapter = observer;
         this.native = observer.native;
         this.models = Adapter.models(this.adapter.alias);
-        this.initialize();
-        this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`);
+        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 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 InternalError(`No adapter observed for dispatch`);
@@ -159,25 +381,120 @@ class Dispatch {
     }
 }
 
+/**
+ * @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 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 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) => {
@@ -211,40 +528,146 @@ Decoration.setFlavourResolver((obj) => {
     }
 });
 /**
- * @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
  */
 class Adapter {
     static { this._cache = {}; }
+    /**
+     * @description Logger accessor
+     * @summary Gets or initializes the logger for this adapter instance
+     * @return {Logger} The logger instance
+     */
     get log() {
         if (!this.logger)
             this.logger = Logging.for(this);
         return this.logger;
     }
+    /**
+     * @description Gets the native database driver
+     * @summary Provides access to the underlying database driver instance
+     * @return {Y} The native database driver
+     */
     get native() {
         return this._native;
     }
+    /**
+     * @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() {
         return this._alias || this.flavour;
     }
+    /**
+     * @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() {
         return Repository;
     }
+    /**
+     * @description Creates a new adapter instance
+     * @summary Initializes the adapter with the native driver and registers it in the adapter cache
+     */
     constructor(_native, flavour, _alias) {
         this._native = _native;
         this.flavour = flavour;
         this._alias = _alias;
+        /**
+         * @description The context constructor for this adapter
+         * @summary Reference to the context class constructor used by this adapter
+         */
         this.Context = (Context);
         if (this.flavour in Adapter._cache)
             throw new InternalError(`${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : ""} already registered`);
@@ -255,15 +678,42 @@ class Adapter {
             Adapter._current = this;
         }
     }
+    /**
+     * @description Creates a new dispatch instance
+     * @summary Factory method that creates a dispatch instance for this adapter
+     * @return {Dispatch<Y>} A new dispatch instance
+     */
     Dispatch() {
         return new Dispatch();
     }
+    /**
+     * @description Creates a new observer handler
+     * @summary Factory method that creates an observer handler for this adapter
+     * @return {ObserverHandler} A new observer handler instance
+     */
     ObserverHandler() {
         return new 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
+     */
     isReserved(attr) {
         return !attr;
     }
+    /**
+     * @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
+     */
     flags(operation, model, flags, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     ...args) {
@@ -274,12 +724,32 @@ class Adapter {
             operation: operation,
         });
     }
+    /**
+     * @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
+     */
     async context(operation, overrides, model, ...args) {
         this.log
             .for(this.context)
-            .debug(`Creating new context for ${operation} operation on ${model.name} model with flags: ${JSON.stringify(overrides)}`);
-        return new this.Context(this.flags(operation, model, overrides, ...args));
+            .debug(`Creating new context for ${operation} operation on ${model.name} model with flag overrides: ${JSON.stringify(overrides)}`);
+        return new this.Context().accumulate(this.flags(operation, model, overrides, ...args));
     }
+    /**
+     * @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(model, pk) {
         const log = this.log.for(this.prepare);
         log.silly(`Preparing model ${model.constructor.name} before persisting`);
@@ -308,6 +778,18 @@ class Adapter {
             transient: split.transient,
         };
     }
+    /**
+     * @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(obj, clazz, pk, id, transient) {
         const log = this.log.for(this.revert);
         const ob = {};
@@ -340,6 +822,15 @@ class Adapter {
         }
         return result;
     }
+    /**
+     * @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
+     */
     async createAll(tableName, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
@@ -348,12 +839,29 @@ class Adapter {
         log.debug(`pks: ${id}`);
         return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...args)));
     }
+    /**
+     * @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
+     */
     async readAll(tableName, id, ...args) {
         const log = this.log.for(this.readAll);
         log.verbose(`Reading ${id.length} entries ${tableName} table`);
         log.debug(`pks: ${id}`);
         return Promise.all(id.map((i) => this.read(tableName, i, ...args)));
     }
+    /**
+     * @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
+     */
     async updateAll(tableName, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
@@ -362,6 +870,14 @@ class Adapter {
         log.debug(`pks: ${id}`);
         return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...args)));
     }
+    /**
+     * @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
+     */
     async deleteAll(tableName, id, ...args) {
         const log = this.log.for(this.createAll);
         log.verbose(`Deleting ${id.length} entries ${tableName} table`);
@@ -369,8 +885,12 @@ class Adapter {
         return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));
     }
     /**
-     *
-     * @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, filter) {
         if (!this.observerHandler)
@@ -389,10 +909,10 @@ class Adapter {
         }
     }
     /**
-     * @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) {
         if (!this.observerHandler)
@@ -402,6 +922,16 @@ class Adapter {
             .for(this.unObserve)
             .verbose(`Observer ${observer.toString()} removed`);
     }
+    /**
+     * @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
+     */
     async updateObservers(table, event, id, ...args) {
         if (!this.observerHandler)
             throw new InternalError("ObserverHandler not initialized. Did you register any observables?");
@@ -409,35 +939,90 @@ class Adapter {
         log.verbose(`Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`);
         await this.observerHandler.updateObservers(this.log, table, event, id, ...args);
     }
+    /**
+     * @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
+     */
     async refresh(table, event, id, ...args) {
         return this.updateObservers(table, event, id, ...args);
     }
+    /**
+     * @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() {
         return `${this.flavour} persistence Adapter`;
     }
+    /**
+     * @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(model) {
         return (Reflect.getMetadata(this.key(PersistenceKeys.ADAPTER), model) ||
             this.current.flavour);
     }
+    /**
+     * @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() {
         if (!Adapter._current)
             throw new InternalError(`No persistence flavour set. Please initialize your adapter`);
         return Adapter._current;
     }
+    /**
+     * @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(flavour) {
         if (flavour in this._cache)
             return this._cache[flavour];
         throw new InternalError(`No Adapter registered under ${flavour}.`);
     }
+    /**
+     * @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) {
         const adapter = Adapter.get(flavour);
         if (!adapter)
             throw new NotFoundError(`No persistence flavour ${flavour} registered`);
         this._current = adapter;
     }
+    /**
+     * @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) {
         return Repository.key(key);
     }
+    /**
+     * @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(flavour) {
         try {
             const registry = Model.getRegistry();
@@ -483,6 +1068,15 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], Adapter.prototype, "unObserve", null);
 
+/**
+ * @description Gets the table name for a model
+ * @summary Retrieves the table name associated with a model by checking metadata or falling back to the constructor name
+ * @template M - Type that extends Model
+ * @param {M | Constructor<M>} model - The model instance or constructor to get the table name for
+ * @return {string} The table name for the model
+ * @function getTableName
+ * @memberOf module:core
+ */
 function getTableName(model) {
     const obj = model instanceof Model ? model.constructor : model;
     const metadata = Reflect.getOwnMetadata(Adapter.key(PersistenceKeys.TABLE), obj);
@@ -494,22 +1088,101 @@ function getTableName(model) {
     }
     return model.name;
 }
+/**
+ * @description Generates a sequence name for a model
+ * @summary Creates a standardized sequence name by combining the table name with additional arguments
+ * @template M - Type that extends Model
+ * @param {M | Constructor<M>} model - The model instance or constructor to generate the sequence name for
+ * @param {...string} args - Additional string arguments to append to the sequence name
+ * @return {string} The generated sequence name
+ * @function sequenceNameForModel
+ * @memberOf module:core
+ */
 function sequenceNameForModel(model, ...args) {
     return [getTableName(model), ...args].join("_");
 }
 
+/**
+ * @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.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 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":
@@ -526,27 +1199,112 @@ class Sequence {
     }
 }
 
+/**
+ * @description Specifies which persistence adapter flavor a model should use
+ * @summary This decorator applies metadata to a model class to indicate which persistence adapter flavor
+ * should be used when performing database operations on instances of the model. The flavor is a string
+ * identifier that corresponds to a registered adapter configuration.
+ * @param {string} flavour - The identifier of the adapter flavor to use
+ * @return {Function} A decorator function that can be applied to a model class
+ * @function uses
+ * @category Class Decorators
+ */
 function uses(flavour) {
     return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour));
 }
 
+/**
+ * @description Core repository implementation for database operations on models on a table by table way.
+ * @summary Provides CRUD operations, querying capabilities, and observer pattern implementation for model persistence.
+ * @template M - The model type that extends Model.
+ * @template Q - The query type used by the adapter.
+ * @template A - The adapter type for database operations.
+ * @template F - The repository flags type.
+ * @template C - The context type for operations.
+ * @param {A} [adapter] - Optional adapter instance for database operations.
+ * @param {Constructor<M>} [clazz] - Optional constructor for the model class.
+ * @param {...any[]} [args] - Additional arguments for repository initialization.
+ * @class Repository
+ * @example
+ * // Creating a repository for User model
+ * const userRepo = Repository.forModel(User);
+ *
+ * // Using the repository for CRUD operations
+ * const user = await userRepo.create(new User({ name: 'John' }));
+ * const retrievedUser = await userRepo.read(user.id);
+ * user.name = 'Jane';
+ * await userRepo.update(user);
+ * await userRepo.delete(user.id);
+ *
+ * // Querying with conditions
+ * const users = await userRepo
+ *   .select()
+ *   .where({ name: 'Jane' })
+ *   .orderBy('createdAt', OrderDirection.DSC)
+ *   .limit(10)
+ *   .execute();
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client Code
+ *   participant R as Repository
+ *   participant A as Adapter
+ *   participant DB as Database
+ *   participant O as Observers
+ *
+ *   C->>+R: create(model)
+ *   R->>R: createPrefix(model)
+ *   R->>+A: prepare(model)
+ *   A-->>-R: prepared data
+ *   R->>+A: create(table, id, record)
+ *   A->>+DB: Insert Operation
+ *   DB-->>-A: Result
+ *   A-->>-R: record
+ *   R->>+A: revert(record)
+ *   A-->>-R: model instance
+ *   R->>R: createSuffix(model)
+ *   R->>+O: updateObservers(table, CREATE, id)
+ *   O-->>-R: Notification complete
+ *   R-->>-C: created model
+ */
 class Repository extends Repository$1 {
     static { this._cache = {}; }
+    /**
+     * @description Logger instance for this repository.
+     * @summary Provides access to the logger for this repository instance.
+     * @return {Logger} The logger instance.
+     */
     get log() {
         if (!this.logger)
             this.logger = Logging.for(this);
         return this.logger;
     }
+    /**
+     * @description Adapter for database operations.
+     * @summary Provides access to the adapter instance for this repository.
+     * @template A - The adapter type.
+     * @return {A} The adapter instance.
+     * @throws {InternalError} If no adapter is found.
+     */
     get adapter() {
         if (!this._adapter)
             throw new InternalError(`No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?`);
         return this._adapter;
     }
+    /**
+     * @description Table name for this repository's model.
+     * @summary Gets the database table name associated with this repository's model.
+     * @return {string} The table name.
+     */
     get tableName() {
         if (!this._tableName)
             this._tableName = Repository.table(this.class);
         return this._tableName;
     }
+    /**
+     * @description Primary key properties for this repository's model.
+     * @summary Gets the sequence options containing primary key information.
+     * @return {SequenceOptions} The primary key properties.
+     */
     get pkProps() {
         return super.pkProps;
     }
@@ -557,7 +1315,7 @@ class Repository extends Repository$1 {
         if (adapter)
             this._adapter = adapter;
         if (clazz) {
-            Repository.register(clazz, this);
+            Repository.register(clazz, this, this.adapter.alias);
             if (adapter) {
                 const flavour = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), clazz);
                 if (flavour && flavour !== adapter.flavour)
@@ -570,6 +1328,12 @@ class Repository extends Repository$1 {
             wrapMethodWithContext(this, this[name + "Prefix"], m, this[name + "Suffix"]);
         });
     }
+    /**
+     * @description Creates a proxy with overridden repository flags.
+     * @summary Returns a proxy of this repository with the specified flags overridden.
+     * @param {Partial<F>} flags - The flags to override.
+     * @return {Repository} A proxy of this repository with overridden flags.
+     */
     override(flags) {
         this.log
             .for(this.override)
@@ -583,9 +1347,23 @@ class Repository extends Repository$1 {
             },
         });
     }
+    /**
+     * @description Creates a new observer handler.
+     * @summary Factory method for creating an observer handler instance.
+     * @return {ObserverHandler} A new observer handler instance.
+     */
     ObserverHandler() {
         return new ObserverHandler();
     }
+    /**
+     * @description Prepares a model for creation.
+     * @summary Validates the model and prepares it for creation in the database.
+     * @template M - The model type.
+     * @param {M} model - The model to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared model and context arguments.
+     * @throws {ValidationError} If the model fails validation.
+     */
     async createPrefix(model, ...args) {
         const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
         model = new this.class(model);
@@ -595,6 +1373,13 @@ class Repository extends Repository$1 {
             throw new ValidationError(errors.toString());
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Creates a model in the database.
+     * @summary Persists a model instance to the database.
+     * @param {M} model - The model to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The created model with updated properties.
+     */
     async create(model, ...args) {
         // eslint-disable-next-line prefer-const
         let { record, id, transient } = this.adapter.prepare(model, this.pk);
@@ -604,9 +1389,23 @@ class Repository extends Repository$1 {
             c = args[args.length - 1];
         return this.adapter.revert(record, this.class, this.pk, id, c && c.get("rebuildWithTransient") ? transient : undefined);
     }
+    /**
+     * @description Post-creation hook.
+     * @summary Executes after a model is created to perform additional operations.
+     * @param {M} model - The created model.
+     * @param {C} context - The operation context.
+     * @return {Promise<M>} The processed model.
+     */
     async createSuffix(model, context) {
         return super.createSuffix(model, context);
     }
+    /**
+     * @description Creates multiple models in the database.
+     * @summary Persists multiple model instances to the database in a batch operation.
+     * @param {M[]} models - The models to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M[]>} The created models with updated properties.
+     */
     async createAll(models, ...args) {
         if (!models.length)
             return models;
@@ -616,6 +1415,14 @@ class Repository extends Repository$1 {
         records = await this.adapter.createAll(this.tableName, ids, records, ...args);
         return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i]));
     }
+    /**
+     * @description Prepares multiple models for creation.
+     * @summary Validates multiple models and prepares them for creation in the database.
+     * @param {M[]} models - The models to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared models and context arguments.
+     * @throws {ValidationError} If any model fails validation.
+     */
     async createAllPrefix(models, ...args) {
         const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
         if (!models.length)
@@ -647,6 +1454,13 @@ class Repository extends Repository$1 {
             throw new ValidationError(errors);
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Prepares for reading a model by ID.
+     * @summary Prepares the context and enforces decorators before reading a model.
+     * @param {string} key - The primary key of the model to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return The key and context arguments.
+     */
     async readPrefix(key, ...args) {
         const contextArgs = await Context.args(OperationKeys.READ, this.class, args, this.adapter, this._overrides || {});
         const model = new this.class();
@@ -654,10 +1468,24 @@ class Repository extends Repository$1 {
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.READ, OperationKeys.ON);
         return [key, ...contextArgs.args];
     }
+    /**
+     * @description Reads a model from the database by ID.
+     * @summary Retrieves a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The retrieved model instance.
+     */
     async read(id, ...args) {
         const m = await this.adapter.read(this.tableName, id, ...args);
         return this.adapter.revert(m, this.class, this.pk, id);
     }
+    /**
+     * @description Prepares for reading multiple models by IDs.
+     * @summary Prepares the context and enforces decorators before reading multiple models.
+     * @param {string[]|number[]} keys - The primary keys of the models to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return The keys and context arguments.
+     */
     async readAllPrefix(keys, ...args) {
         const contextArgs = await Context.args(OperationKeys.READ, this.class, args, this.adapter, this._overrides || {});
         await Promise.all(keys.map(async (k) => {
@@ -667,16 +1495,39 @@ class Repository extends Repository$1 {
         }));
         return [keys, ...contextArgs.args];
     }
+    /**
+     * @description Reads multiple models from the database by IDs.
+     * @summary Retrieves multiple model instances from the database using their primary keys.
+     * @param {string[]|number[]} keys - The primary keys of the models to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M[]>} The retrieved model instances.
+     */
     async readAll(keys, ...args) {
         const records = await this.adapter.readAll(this.tableName, keys, ...args);
         return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
     }
+    /**
+     * @description Updates a model in the database.
+     * @summary Persists changes to an existing model instance in the database.
+     * @param {M} model - The model to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The updated model with refreshed properties.
+     */
     async update(model, ...args) {
         // eslint-disable-next-line prefer-const
         let { record, id, transient } = this.adapter.prepare(model, this.pk);
         record = await this.adapter.update(this.tableName, id, record, ...args);
         return this.adapter.revert(record, this.class, this.pk, id, transient);
     }
+    /**
+     * @description Prepares a model for update.
+     * @summary Validates the model and prepares it for update in the database.
+     * @param {M} model - The model to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared model and context arguments.
+     * @throws {InternalError} If the model has no primary key value.
+     * @throws {ValidationError} If the model fails validation.
+     */
     async updatePrefix(model, ...args) {
         const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args, this.adapter, this._overrides || {});
         const pk = model[this.pk];
@@ -694,11 +1545,27 @@ class Repository extends Repository$1 {
         }
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Updates multiple models in the database.
+     * @summary Persists changes to multiple existing model instances in the database in a batch operation.
+     * @param {M[]} models - The models to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M[]>} The updated models with refreshed properties.
+     */
     async updateAll(models, ...args) {
         const records = models.map((m) => this.adapter.prepare(m, this.pk));
         const updated = await this.adapter.updateAll(this.tableName, records.map((r) => r.id), records.map((r) => r.record), ...args);
         return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id));
     }
+    /**
+     * @description Prepares multiple models for update.
+     * @summary Validates multiple models and prepares them for update in the database.
+     * @param {M[]} models - The models to update.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<any[]>} The prepared models and context arguments.
+     * @throws {InternalError} If any model has no primary key value.
+     * @throws {ValidationError} If any model fails validation.
+     */
     async updateAllPrefix(models, ...args) {
         const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args, this.adapter, this._overrides || {});
         const ids = models.map((m) => {
@@ -737,16 +1604,37 @@ class Repository extends Repository$1 {
         });
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Prepares for deleting a model by ID.
+     * @summary Prepares the context and enforces decorators before deleting a model.
+     * @param {any} key - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return The key and context arguments.
+     */
     async deletePrefix(key, ...args) {
         const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args, this.adapter, this._overrides || {});
         const model = await this.read(key, ...contextArgs.args);
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.DELETE, OperationKeys.ON);
         return [key, ...contextArgs.args];
     }
+    /**
+     * @description Deletes a model from the database by ID.
+     * @summary Removes a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The deleted model instance.
+     */
     async delete(id, ...args) {
         const m = await this.adapter.delete(this.tableName, id, ...args);
         return this.adapter.revert(m, this.class, this.pk, id);
     }
+    /**
+     * @description Prepares for deleting multiple models by IDs.
+     * @summary Prepares the context and enforces decorators before deleting multiple models.
+     * @param {string[]|number[]} keys - The primary keys of the models to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return The keys and context arguments.
+     */
     async deleteAllPrefix(keys, ...args) {
         const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args, this.adapter, this._overrides || {});
         const models = await this.readAll(keys, ...contextArgs.args);
@@ -755,16 +1643,40 @@ class Repository extends Repository$1 {
         }));
         return [keys, ...contextArgs.args];
     }
+    /**
+     * @description Deletes multiple models from the database by IDs.
+     * @summary Removes multiple model instances from the database using their primary keys.
+     * @param {string[]|number[]} keys - The primary keys of the models to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M[]>} The deleted model instances.
+     */
     async deleteAll(keys, ...args) {
         const results = await this.adapter.deleteAll(this.tableName, keys, ...args);
         return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
     }
+    /**
+     * @description Implementation of the select method.
+     * @summary Creates a query builder for the model with optional field selection.
+     * @template S - The array type of select selectors.
+     * @param [selector] - Optional fields to select.
+     * @return A query builder.
+     */
     select(selector) {
         return this.adapter
             .Statement()
             .select(selector)
             .from(this.class);
     }
+    /**
+     * @description Executes a query with the specified conditions and options.
+     * @summary Provides a simplified way to query the database with common query parameters.
+     * @param {Condition<M>} condition - The condition to filter records.
+     * @param orderBy - The field to order results by.
+     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
+     * @param {number} [limit] - Optional maximum number of results to return.
+     * @param {number} [skip] - Optional number of results to skip.
+     * @return {Promise<M[]>} The query results as model instances.
+     */
     async query(condition, orderBy, order = OrderDirection.ASC, limit, skip) {
         const sort = [orderBy, order];
         const query = this.select().where(condition).orderBy(sort);
@@ -775,7 +1687,11 @@ class Repository extends Repository$1 {
         return query.execute();
     }
     /**
-     *
+     * @description Registers an observer for this repository.
+     * @summary Adds an observer that will be notified of changes to models in this repository.
+     * @param {Observer} observer - The observer to register.
+     * @param {ObserverFilter} [filter] - Optional filter to limit which events the observer receives.
+     * @return {void}
      * @see {Observable#observe}
      */
     observe(observer, filter) {
@@ -792,9 +1708,11 @@ class Repository extends Repository$1 {
         log.verbose(`Registered new observer ${observer.toString()}`);
     }
     /**
-     * @summary Unregisters an {@link Observer}
-     * @param {Observer} observer
-     *
+     * @description Unregisters an observer from this repository.
+     * @summary Removes an observer so it will no longer receive notifications of changes.
+     * @param {Observer} observer - The observer to unregister.
+     * @return {void}
+     * @throws {InternalError} If the observer handler is not initialized.
      * @see {Observable#unObserve}
      */
     unObserve(observer) {
@@ -810,6 +1728,16 @@ class Repository extends Repository$1 {
             this.log.verbose(`No longer observing adapter ${this.adapter.flavour}`);
         }
     }
+    /**
+     * @description Notifies all observers of an event.
+     * @summary Updates all registered observers with information about a database event.
+     * @param {string} table - The table name where the event occurred.
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
+     * @param {EventIds} id - The ID or IDs of the affected records.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<void>} A promise that resolves when all observers have been notified.
+     * @throws {InternalError} If the observer handler is not initialized.
+     */
     async updateObservers(table, event, id, ...args) {
         if (!this.observerHandler)
             throw new InternalError("ObserverHandler not initialized. Did you register any observables?");
@@ -820,13 +1748,34 @@ class Repository extends Repository$1 {
             ? id.map((i) => Sequence.parseValue(this.pkProps.type, i))
             : Sequence.parseValue(this.pkProps.type, id), ...args);
     }
+    /**
+     * @description Alias for updateObservers.
+     * @summary Notifies all observers of an event (alias for updateObservers).
+     * @param {string} table - The table name where the event occurred.
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.
+     * @param {EventIds} id - The ID or IDs of the affected records.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<void>} A promise that resolves when all observers have been notified.
+     */
     async refresh(table, event, id, ...args) {
         return this.updateObservers(table, event, id, ...args);
     }
-    static forModel(model, defaultFlavour, ...args) {
+    /**
+     * @description Creates or retrieves a repository for a model.
+     * @summary Factory method that returns a repository instance for the specified model.
+     * @template M - The model type that extends Model.
+     * @template R - The repository type that extends Repo<M>.
+     * @param {Constructor<M>} model - The model constructor.
+     * @param {string} [defaultFlavour] - Optional default adapter flavour if not specified on the model.
+     * @param {...any[]} [args] - Additional arguments to pass to the repository constructor.
+     * @return {R} A repository instance for the model.
+     * @throws {InternalError} If no adapter is registered for the flavour.
+     */
+    static forModel(model, alias, ...args) {
         let repo;
+        const _alias = alias || Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model);
         try {
-            repo = this.get(model);
+            repo = this.get(model, _alias);
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
         catch (e) {
@@ -834,10 +1783,10 @@ class Repository extends Repository$1 {
         }
         if (repo instanceof Repository)
             return repo;
-        const flavour = Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||
+        const flavour = alias ||
+            Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||
             (repo &&
-                Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repo)) ||
-            defaultFlavour;
+                Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repo));
         const adapter = flavour
             ? Adapter.get(flavour)
             : undefined;
@@ -846,18 +1795,47 @@ class Repository extends Repository$1 {
         repo = repo || adapter.repository();
         return new repo(adapter, model, ...args);
     }
-    static get(model) {
-        const name = Repository.table(model);
+    /**
+     * @description Retrieves a repository for a model from the cache.
+     * @summary Gets a repository constructor or instance for the specified model from the internal cache.
+     * @template M - The model type that extends Model.
+     * @param {Constructor<M>} model - The model constructor.
+     * @return {Constructor<Repo<M>> | Repo<M>} The repository constructor or instance.
+     * @throws {InternalError} If no repository is registered for the model.
+     */
+    static get(model, alias) {
+        let name = Repository.table(model);
+        if (alias) {
+            name = [name, alias].join(DefaultSeparator);
+        }
         if (name in this._cache)
             return this._cache[name];
         throw new InternalError(`Could not find repository registered under ${name}`);
     }
-    static register(model, repo) {
-        const name = Repository.table(model);
+    /**
+     * @description Registers a repository for a model.
+     * @summary Associates a repository constructor or instance with a model in the internal cache.
+     * @template M - The model type that extends Model.
+     * @param {Constructor<M>} model - The model constructor.
+     * @param {Constructor<Repo<M>> | Repo<M>} repo - The repository constructor or instance.
+     * @throws {InternalError} If a repository is already registered for the model.
+     */
+    static register(model, repo, alias) {
+        let name = Repository.table(model);
+        if (alias) {
+            name = [name, alias].join(DefaultSeparator);
+        }
         if (name in this._cache)
             throw new InternalError(`${name} already registered as a repository`);
         this._cache[name] = repo;
     }
+    /**
+     * @description Sets metadata on a model instance.
+     * @summary Attaches metadata to a model instance using a non-enumerable property.
+     * @template M - The model type that extends Model.
+     * @param {M} model - The model instance.
+     * @param {any} metadata - The metadata to attach to the model.
+     */
     static setMetadata(model, metadata) {
         Object.defineProperty(model, PersistenceKeys.METADATA, {
             enumerable: false,
@@ -866,15 +1844,36 @@ class Repository extends Repository$1 {
             value: metadata,
         });
     }
+    /**
+     * @description Gets metadata from a model instance.
+     * @summary Retrieves previously attached metadata from a model instance.
+     * @template M - The model type that extends Model.
+     * @param {M} model - The model instance.
+     * @return {any} The metadata or undefined if not found.
+     */
     static getMetadata(model) {
         const descriptor = Object.getOwnPropertyDescriptor(model, PersistenceKeys.METADATA);
         return descriptor ? descriptor.value : undefined;
     }
+    /**
+     * @description Removes metadata from a model instance.
+     * @summary Deletes the metadata property from a model instance.
+     * @template M - The model type that extends Model.
+     * @param {M} model - The model instance.
+     */
     static removeMetadata(model) {
         const descriptor = Object.getOwnPropertyDescriptor(model, PersistenceKeys.METADATA);
         if (descriptor)
             delete model[PersistenceKeys.METADATA];
     }
+    /**
+     * @description Gets sequence options for a model's primary key.
+     * @summary Retrieves the sequence configuration for a model's primary key from metadata.
+     * @template M - The model type that extends Model.
+     * @param {M} model - The model instance.
+     * @return {SequenceOptions} The sequence options for the model's primary key.
+     * @throws {InternalError} If no sequence options are defined for the model.
+     */
     static getSequenceOptions(model) {
         const pk = findPrimaryKey(model).id;
         const metadata = Reflect.getMetadata(Repository.key(DBKeys.ID), model, pk);
@@ -882,6 +1881,13 @@ class Repository extends Repository$1 {
             throw new InternalError("No sequence options defined for model. did you use the @pk decorator?");
         return metadata;
     }
+    /**
+     * @description Gets all indexes defined on a model.
+     * @summary Retrieves all index metadata from a model's property decorators.
+     * @template M - The model type that extends Model.
+     * @param {M | Constructor<M>} model - The model instance or constructor.
+     * @return {Record<string, Record<string, IndexMetadata>>} A nested record of property names to index metadata.
+     */
     static indexes(model) {
         const indexDecorators = Reflection.getAllPropertyDecorators(model instanceof Model ? model : new model(), DBKeys.REFLECT);
         return Object.entries(indexDecorators || {}).reduce((accum, [k, val]) => {
@@ -896,6 +1902,13 @@ class Repository extends Repository$1 {
             return accum;
         }, {});
     }
+    /**
+     * @description Gets all relation properties defined on a model.
+     * @summary Retrieves the names of all properties marked as relations in the model hierarchy.
+     * @template M - The model type that extends Model.
+     * @param {M | Constructor<M>} model - The model instance or constructor.
+     * @return {string[]} An array of property names that are relations.
+     */
     static relations(model) {
         const result = [];
         let prototype = model instanceof Model
@@ -910,9 +1923,24 @@ class Repository extends Repository$1 {
         }
         return result;
     }
+    /**
+     * @description Gets the table name for a model.
+     * @summary Retrieves the database table name associated with a model.
+     * @template M - The model type that extends Model.
+     * @param {M | Constructor<M>} model - The model instance or constructor.
+     * @return {string} The table name for the model.
+     */
     static table(model) {
         return getTableName(model);
     }
+    /**
+     * @description Gets the column name for a model attribute.
+     * @summary Retrieves the database column name for a model property.
+     * @template M - The model type that extends Model.
+     * @param {M} model - The model instance.
+     * @param {string} attribute - The attribute/property name.
+     * @return {string} The column name for the attribute.
+     */
     static column(model, attribute) {
         const metadata = Reflect.getMetadata(Adapter.key(PersistenceKeys.COLUMN), model, attribute);
         return metadata ? metadata : attribute;
@@ -931,6 +1959,33 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], Repository.prototype, "unObserve", null);
 
+/**
+ * @description Repository decorator for model classes.
+ * @summary Creates and registers a repository for a model class. Can be used as both a property decorator and a class decorator.
+ * @template T - The model type that extends Model.
+ * @param {Constructor<T>} model - The constructor of the model class.
+ * @param {string} [nameOverride] - Optional name override for the repository.
+ * @return {any} - The decorator function.
+ * @function repository
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client Code
+ *   participant D as Decorator
+ *   participant R as Repository
+ *   participant M as Metadata
+ *
+ *   C->>D: Apply @repository(Model)
+ *   alt Property Decorator
+ *     D->>D: Check if propertyKey exists
+ *     D->>+C: Return inject(name) decorator
+ *   else Class Decorator
+ *     D->>M: Set repository metadata on model
+ *     D->>R: Register model with Repository
+ *     D->>+C: Return injectable decorator with config
+ *     C->>C: Define DBKeys.CLASS property
+ *   end
+ * @category Decorators
+ */
 function repository(model, nameOverride) {
     return ((original, propertyKey) => {
         if (propertyKey) {
@@ -950,12 +2005,19 @@ function repository(model, nameOverride) {
 }
 
 /**
- * @summary Represents a failure in observer communication
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when observer communication fails.
+ * @summary Represents a failure in observer communication between repositories.
+ * @param {string|Error} msg - The error message or Error object.
  * @class ObserverError
- * @extends BaseError
+ * @category Errors
+ * @example
+ * try {
+ *   // Some repository observer operation
+ * } catch (error) {
+ *   if (error instanceof ObserverError) {
+ *     console.error('Observer communication failed:', error.message);
+ *   }
+ * }
  */
 class ObserverError extends BaseError {
     constructor(msg) {
@@ -963,6 +2025,17 @@ class ObserverError extends BaseError {
     }
 }
 
+/**
+ * @description Generates a unique injectable name for a repository.
+ * @summary Creates a standardized name for repository injectables based on model and adapter flavour.
+ * @template T - The model type that extends Model.
+ * @param {Constructor<T> | T} model - The model constructor or instance.
+ * @param {string} [flavour] - Optional adapter flavour. If not provided, it will be retrieved from the model metadata.
+ * @return {string} The generated injectable name.
+ * @throws {InternalError} If no flavour is provided and none can be retrieved from the model.
+ * @function generateInjectableNameForRepository
+ * @memberOf module:core
+ */
 function generateInjectableNameForRepository(model, flavour) {
     if (!flavour) {
         const key = Adapter.key(PersistenceKeys.ADAPTER);
@@ -973,10 +2046,28 @@ function generateInjectableNameForRepository(model, flavour) {
     return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));
 }
 
+/**
+ * @description Registry for injectable repositories.
+ * @summary Extends the base injectable registry to provide automatic repository resolution for models.
+ * @param {void} - No constructor parameters required.
+ * @class InjectablesRegistry
+ * @example
+ * const registry = new InjectablesRegistry();
+ * const userRepo = registry.get<UserRepository>('User');
+ * // If UserRepository exists, it will be returned
+ * // If not, but User model exists, a repository will be created for it
+ */
 class InjectablesRegistry extends InjectableRegistryImp {
     constructor() {
         super();
     }
+    /**
+     * @description Gets an injectable by name with repository auto-resolution.
+     * @summary Extends the base get method to automatically resolve repositories for models when not found directly.
+     * @template T - The type of injectable to return.
+     * @param {string} name - The name of the injectable to retrieve.
+     * @return {T | undefined} - The injectable instance or undefined if not found.
+     */
     get(name) {
         let injectable = super.get(name);
         if (!injectable)
@@ -1000,18 +2091,36 @@ class InjectablesRegistry extends InjectableRegistryImp {
     }
 }
 
+/**
+ * @description Default options for sequences
+ * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1
+ * @const DefaultSequenceOptions
+ * @memberOf module:core
+ */
 const DefaultSequenceOptions = {
     type: "Number",
     startWith: 0,
     incrementBy: 1,
     cycle: false,
 };
+/**
+ * @description Predefined options for numeric sequences
+ * @summary Configuration for standard number sequences starting at 0 and incrementing by 1
+ * @const NumericSequence
+ * @memberOf module:core
+ */
 const NumericSequence = {
     type: "Number",
     startWith: 0,
     incrementBy: 1,
     cycle: false,
 };
+/**
+ * @description Predefined options for BigInt sequences
+ * @summary Configuration for BigInt sequences starting at 0 and incrementing by 1
+ * @const BigIntSequence
+ * @memberOf module:core
+ */
 const BigIntSequence = {
     type: "BigInt",
     startWith: 0,
@@ -1019,31 +2128,70 @@ const BigIntSequence = {
     cycle: false,
 };
 
+/**
+ * @description Comparison operators for query conditions
+ * @summary Enum defining the available operators for comparing values in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var Operator;
 (function (Operator) {
+    /** Equal comparison (=) */
     Operator["EQUAL"] = "EQUAL";
+    /** Not equal comparison (!=) */
     Operator["DIFFERENT"] = "DIFFERENT";
+    /** Greater than comparison (>) */
     Operator["BIGGER"] = "BIGGER";
+    /** Greater than or equal comparison (>=) */
     Operator["BIGGER_EQ"] = "BIGGER_EQ";
+    /** Less than comparison (<) */
     Operator["SMALLER"] = "SMALLER";
+    /** Less than or equal comparison (<=) */
     Operator["SMALLER_EQ"] = "SMALLER_EQ";
     // BETWEEN = "BETWEEN",
+    /** Negation operator (NOT) */
     Operator["NOT"] = "NOT";
+    /** Inclusion operator (IN) */
     Operator["IN"] = "IN";
     // IS = "IS",
+    /** Regular expression matching */
     Operator["REGEXP"] = "REGEXP";
 })(Operator || (Operator = {}));
+/**
+ * @description Logical operators for combining query conditions
+ * @summary Enum defining the available operators for grouping multiple conditions in database queries
+ * @enum {string}
+ * @readonly
+ * @memberOf module:core
+ */
 var GroupOperator;
 (function (GroupOperator) {
+    /** Logical AND operator - all conditions must be true */
     GroupOperator["AND"] = "AND";
+    /** Logical OR operator - at least one condition must be true */
     GroupOperator["OR"] = "OR";
 })(GroupOperator || (GroupOperator = {}));
 
+/**
+ * @description Error thrown during query operations
+ * @summary Represents errors that occur during query building or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class QueryError
+ * @category Errors
+ */
 class QueryError extends BaseError {
     constructor(msg) {
         super(QueryError.name, msg, 500);
     }
 }
+/**
+ * @description Error thrown during pagination operations
+ * @summary Represents errors that occur during pagination setup or execution
+ * @param {string | Error} msg - The error message or Error object
+ * @class PagingError
+ * @category Errors
+ */
 class PagingError extends BaseError {
     constructor(msg) {
         super(PagingError.name, msg, 500);
@@ -1051,14 +2199,27 @@ class PagingError extends BaseError {
 }
 
 /**
- * @summary Condition Class
- * @description Represents a logical condition
+ * @description Represents a logical condition for database queries
+ * @summary A class that encapsulates query conditions with support for complex logical operations.
+ * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)
+ * and comparison operators (equals, not equals, greater than, etc.).
+ * @template M - The model type this condition operates on
+ * @param {string | Condition<M>} attr1 - The attribute name or a nested condition
+ * @param {Operator | GroupOperator} operator - The operator to use for the condition
+ * @param {any} comparison - The value to compare against or another condition
+ * @class Condition
+ * @example
+ * // Create a simple condition
+ * const nameCondition = Condition.attribute("name").eq("John");
  *
- * @param {string | Condition} attr1
- * @param {Operator | GroupOperator} operator
- * @param {string | Condition} comparison
+ * // Create a complex condition
+ * const complexCondition = Condition.attribute("age").gt(18)
+ *   .and(Condition.attribute("status").eq("active"));
  *
- * @class Condition
+ * // Use the builder pattern
+ * const userQuery = Condition.builder()
+ *   .attribute("email").regexp(".*@example.com")
+ *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
  */
 class Condition extends Model {
     constructor(attr1, operator, comparison) {
@@ -1071,28 +2232,37 @@ class Condition extends Model {
         this.comparison = comparison;
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical AND
+     * @summary Joins two conditions with an AND operator, requiring both to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the AND operation
      */
     and(condition) {
         return Condition.and(this, condition);
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition
+     * @description Combines this condition with another using logical OR
+     * @summary Joins two conditions with an OR operator, requiring at least one to be true
+     * @param {Condition<M>} condition - The condition to combine with this one
+     * @return {Condition<M>} A new condition representing the OR operation
      */
     or(condition) {
         return Condition.or(this, condition);
     }
     /**
-     * @summary excludes a valut from the result
-     * @param val
+     * @description Creates a negation condition
+     * @summary Excludes a value from the result by applying a NOT operator
+     * @param {any} val - The value to negate
+     * @return {Condition<M>} A new condition representing the NOT operation
      */
     not(val) {
         return new Condition(this, Operator.NOT, val);
     }
     /**
-     * @inheritDoc
+     * @description Validates the condition and checks for errors
+     * @summary Extends the base validation to ensure the condition is properly formed
+     * @param {...string[]} exceptions - Fields to exclude from validation
+     * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise
      */
     hasErrors(...exceptions) {
         const errors = super.hasErrors(...exceptions);
@@ -1138,46 +2308,65 @@ class Condition extends Model {
         }
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical AND
+     * @summary Static method that joins two conditions with an AND operator, requiring both to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the AND operation
      */
     static and(condition1, condition2) {
         return Condition.group(condition1, GroupOperator.AND, condition2);
     }
     /**
-     * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation
-     * @param {Condition} condition1
-     * @param {Condition} condition2
+     * @description Creates a new condition that combines two conditions with logical OR
+     * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the OR operation
      */
     static or(condition1, condition2) {
         return Condition.group(condition1, GroupOperator.OR, condition2);
     }
     /**
-     * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}
-     * @param {Condition} condition1
-     * @param {GroupOperator} operator
-     * @param {Condition} condition2
+     * @description Creates a new condition that groups two conditions with a specified operator
+     * @summary Private static method that combines two conditions using the specified group operator
+     * @template M - The model type this condition operates on
+     * @param {Condition<M>} condition1 - The first condition
+     * @param {GroupOperator} operator - The group operator to use (AND, OR)
+     * @param {Condition<M>} condition2 - The second condition
+     * @return {Condition<M>} A new condition representing the grouped operation
      */
     static group(condition1, operator, condition2) {
         return new Condition(condition1, operator, condition2);
     }
+    /**
+     * @description Creates a condition builder for a specific model attribute
+     * @summary Static method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
     static attribute(attr) {
         return new Condition.Builder().attribute(attr);
     }
+    /**
+     * @description Alias for the attribute method
+     * @summary Shorthand method that initializes a condition builder with the specified attribute
+     * @template M - The model type this condition operates on
+     * @param attr - The model attribute to build a condition for
+     * @return {AttributeOption<M>} A condition builder initialized with the attribute
+     */
     static attr(attr) {
         return this.attribute(attr);
     }
     /**
-     * @summary Condition Builder Class
-     * @description provides a simple API to build {@link Condition}s
-     *
+     * @description Provides a fluent API to build query conditions
+     * @summary A builder class that simplifies the creation of database query conditions
+     * with a chainable interface for setting attributes and operators
+     * @template M - The model type this condition builder operates on
      * @class ConditionBuilder
-     * @implements Builder
-     * @implements AttributeOption
-     *
-     * @category Query
-     * @subcategory Conditions
      */
     static { this.Builder = class ConditionBuilder {
         constructor() {
@@ -1186,71 +2375,102 @@ class Condition extends Model {
             this.comparison = undefined;
         }
         /**
-         * @inheritDoc
+         * @description Sets the attribute for the condition
+         * @summary Specifies which model attribute the condition will operate on
+         * @param attr - The model attribute to use in the condition
+         * @return {AttributeOption<M>} This builder instance for method chaining
          */
         attribute(attr) {
             this.attr1 = attr;
             return this;
         }
+        /**
+         * @description Alias for the attribute method
+         * @summary Shorthand method to specify which model attribute the condition will operate on
+         * @param attr - The model attribute to use in the condition
+         * @return {AttributeOption<M>} This builder instance for method chaining
+         */
         attr(attr) {
             return this.attribute(attr);
         }
         /**
-         * @summary Creates an Equality Comparison
-         * @param {any} val
+         * @description Creates an equality condition
+         * @summary Builds a condition that checks if the attribute equals the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the equality comparison
          */
         eq(val) {
             return this.setOp(Operator.EQUAL, val);
         }
         /**
-         * @summary Creates a Different Comparison
-         * @param {any} val
+         * @description Creates an inequality condition
+         * @summary Builds a condition that checks if the attribute is different from the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the inequality comparison
          */
         dif(val) {
             return this.setOp(Operator.DIFFERENT, val);
         }
         /**
-         * @summary Creates a Greater Than Comparison
-         * @param {any} val
+         * @description Creates a greater than condition
+         * @summary Builds a condition that checks if the attribute is greater than the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the greater than comparison
          */
         gt(val) {
             return this.setOp(Operator.BIGGER, val);
         }
         /**
-         * @summary Creates a Lower Than Comparison
-         * @param {any} val
+         * @description Creates a less than condition
+         * @summary Builds a condition that checks if the attribute is less than the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the less than comparison
          */
         lt(val) {
             return this.setOp(Operator.SMALLER, val);
         }
         /**
-         * @summary Creates a Greater or Equal to Comparison
-         * @param {any} val
+         * @description Creates a greater than or equal to condition
+         * @summary Builds a condition that checks if the attribute is greater than or equal to the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the greater than or equal comparison
          */
         gte(val) {
             return this.setOp(Operator.BIGGER_EQ, val);
         }
         /**
-         * @summary Creates a Lower or Equal to Comparison
-         * @param {any} val
+         * @description Creates a less than or equal to condition
+         * @summary Builds a condition that checks if the attribute is less than or equal to the specified value
+         * @param {any} val - The value to compare the attribute against
+         * @return {Condition<M>} A new condition representing the less than or equal comparison
          */
         lte(val) {
             return this.setOp(Operator.SMALLER_EQ, val);
         }
+        /**
+         * @description Creates an inclusion condition
+         * @summary Builds a condition that checks if the attribute value is included in the specified array
+         * @param {any[]} arr - The array of values to check against
+         * @return {Condition<M>} A new condition representing the inclusion comparison
+         */
         in(arr) {
             return this.setOp(Operator.IN, arr);
         }
         /**
-         * @summary Creates a Regexpo Comparison
-         * @param {any} val
+         * @description Creates a regular expression condition
+         * @summary Builds a condition that checks if the attribute matches the specified regular expression pattern
+         * @param {any} val - The regular expression pattern to match against
+         * @return {Condition<M>} A new condition representing the regular expression comparison
          */
         regexp(val) {
             return this.setOp(Operator.REGEXP, new RegExp(val).source);
         }
         /**
-         * @summary Creates an {@link Operator} based Comparison
-         * @param {Operator} op
-         * @param {any} val
+         * @description Sets the operator and comparison value for the condition
+         * @summary Private method that configures the condition with the specified operator and value
+         * @param {Operator} op - The operator to use for the condition
+         * @param {any} val - The value to compare against
+         * @return {Condition<M>} A new condition with the specified operator and value
          */
         setOp(op, val) {
             this.operator = op;
@@ -1258,9 +2478,10 @@ class Condition extends Model {
             return this.build();
         }
         /**
-         * @summary Builds the Database Object
-         * @throws {QueryError} if it fails to build the {@link Condition}
-         * @private
+         * @description Constructs a Condition instance from the builder's state
+         * @summary Finalizes the condition building process by creating a new Condition instance
+         * @throws {QueryError} If the condition cannot be built due to invalid parameters
+         * @return {Condition<M>} A new condition instance with the configured attributes
          */
         build() {
             try {
@@ -1271,6 +2492,12 @@ class Condition extends Model {
             }
         }
     }; }
+    /**
+     * @description Creates a new condition builder
+     * @summary Factory method that returns a new instance of the condition builder
+     * @template M - The model type this condition builder will operate on
+     * @return {ConditionBuilderOption<M>} A new condition builder instance
+     */
     static builder() {
         return new Condition.Builder();
     }
@@ -1288,6 +2515,47 @@ __decorate([
     __metadata("design:type", Object)
 ], Condition.prototype, "comparison", void 0);
 
+/**
+ * @description Creates or updates a model instance
+ * @summary Determines whether to create a new model or update an existing one based on the presence of a primary key
+ * @template M - The model type extending Model
+ * @template F - The repository flags type
+ * @param {M} model - The model instance to create or update
+ * @param {Context<F>} context - The context for the operation
+ * @param {Repo<M, F, Context<F>>} [repository] - Optional repository to use for the operation
+ * @return {Promise<M>} A promise that resolves to the created or updated model
+ * @function createOrUpdate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant createOrUpdate
+ *   participant Repository
+ *   participant Model
+ *
+ *   Caller->>createOrUpdate: model, context, repository?
+ *   alt repository not provided
+ *     createOrUpdate->>Model: get(model.constructor.name)
+ *     Model-->>createOrUpdate: constructor
+ *     createOrUpdate->>Repository: forModel(constructor)
+ *     Repository-->>createOrUpdate: repository
+ *   end
+ *
+ *   alt primary key undefined
+ *     createOrUpdate->>Repository: create(model, context)
+ *     Repository-->>createOrUpdate: created model
+ *   else primary key defined
+ *     createOrUpdate->>Repository: update(model, context)
+ *     alt update successful
+ *       Repository-->>createOrUpdate: updated model
+ *     else NotFoundError
+ *       createOrUpdate->>Repository: create(model, context)
+ *       Repository-->>createOrUpdate: created model
+ *     end
+ *   end
+ *
+ *   createOrUpdate-->>Caller: model
+ */
 async function createOrUpdate(model, context, repository) {
     if (!repository) {
         const constructor = Model.get(model.constructor.name);
@@ -1308,6 +2576,56 @@ async function createOrUpdate(model, context, repository) {
         }
     }
 }
+/**
+ * @description Handles one-to-one relationship creation
+ * @summary Processes a one-to-one relationship when creating a model, either by referencing an existing model or creating a new one
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param {string} key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnCreate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnCreate
+ *   participant repositoryFromTypeMetadata
+ *   participant Model
+ *   participant Repository
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnCreate: this, context, data, key, model
+ *   oneToOneOnCreate->>oneToOneOnCreate: check if propertyValue exists
+ *
+ *   alt propertyValue is not an object
+ *     oneToOneOnCreate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToOneOnCreate: innerRepo
+ *     oneToOneOnCreate->>innerRepo: read(propertyValue)
+ *     innerRepo-->>oneToOneOnCreate: read
+ *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, propertyValue, read
+ *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = propertyValue
+ *   else propertyValue is an object
+ *     oneToOneOnCreate->>Model: get(data.class)
+ *     Model-->>oneToOneOnCreate: constructor
+ *     oneToOneOnCreate->>Repository: forModel(constructor)
+ *     Repository-->>oneToOneOnCreate: repo
+ *     oneToOneOnCreate->>repo: create(propertyValue)
+ *     repo-->>oneToOneOnCreate: created
+ *     oneToOneOnCreate->>findPrimaryKey: created
+ *     findPrimaryKey-->>oneToOneOnCreate: pk
+ *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, created[pk], created
+ *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = created[pk]
+ *   end
+ *
+ *   oneToOneOnCreate-->>Caller: void
+ */
 async function oneToOneOnCreate(context, data, key, model) {
     const propertyValue = model[key];
     if (!propertyValue)
@@ -1328,6 +2646,53 @@ async function oneToOneOnCreate(context, data, key, model) {
     await cacheModelForPopulate(context, model, key, created[pk], created);
     model[key] = created[pk];
 }
+/**
+ * @description Handles one-to-one relationship updates
+ * @summary Processes a one-to-one relationship when updating a model, either by referencing an existing model or updating the related model
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnUpdate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnUpdate
+ *   participant repositoryFromTypeMetadata
+ *   participant createOrUpdate
+ *   participant findPrimaryKey
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnUpdate: this, context, data, key, model
+ *   oneToOneOnUpdate->>oneToOneOnUpdate: check if propertyValue exists
+ *   oneToOneOnUpdate->>oneToOneOnUpdate: check if cascade.update is CASCADE
+ *
+ *   alt propertyValue is not an object
+ *     oneToOneOnUpdate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToOneOnUpdate: innerRepo
+ *     oneToOneOnUpdate->>innerRepo: read(propertyValue)
+ *     innerRepo-->>oneToOneOnUpdate: read
+ *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, propertyValue, read
+ *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = propertyValue
+ *   else propertyValue is an object
+ *     oneToOneOnUpdate->>createOrUpdate: model[key], context
+ *     createOrUpdate-->>oneToOneOnUpdate: updated
+ *     oneToOneOnUpdate->>findPrimaryKey: updated
+ *     findPrimaryKey-->>oneToOneOnUpdate: pk
+ *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, updated[pk], updated
+ *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = updated[pk]
+ *   end
+ *
+ *   oneToOneOnUpdate-->>Caller: void
+ */
 async function oneToOneOnUpdate(context, data, key, model) {
     const propertyValue = model[key];
     if (!propertyValue)
@@ -1346,6 +2711,47 @@ async function oneToOneOnUpdate(context, data, key, model) {
     await cacheModelForPopulate(context, model, key, updated[pk], updated);
     model[key] = updated[pk];
 }
+/**
+ * @description Handles one-to-one relationship deletion
+ * @summary Processes a one-to-one relationship when deleting a model, deleting the related model if cascade is enabled
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToOneOnDelete
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToOneOnDelete
+ *   participant repositoryFromTypeMetadata
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToOneOnDelete: this, context, data, key, model
+ *   oneToOneOnDelete->>oneToOneOnDelete: check if propertyValue exists
+ *   oneToOneOnDelete->>oneToOneOnDelete: check if cascade.update is CASCADE
+ *
+ *   oneToOneOnDelete->>repositoryFromTypeMetadata: model, key
+ *   repositoryFromTypeMetadata-->>oneToOneOnDelete: innerRepo
+ *
+ *   alt propertyValue is not a Model instance
+ *     oneToOneOnDelete->>innerRepo: delete(model[key], context)
+ *     innerRepo-->>oneToOneOnDelete: deleted
+ *   else propertyValue is a Model instance
+ *     oneToOneOnDelete->>innerRepo: delete(model[key][innerRepo.pk], context)
+ *     innerRepo-->>oneToOneOnDelete: deleted
+ *   end
+ *
+ *   oneToOneOnDelete->>cacheModelForPopulate: context, model, key, deleted[innerRepo.pk], deleted
+ *   oneToOneOnDelete-->>Caller: void
+ */
 async function oneToOneOnDelete(context, data, key, model) {
     const propertyValue = model[key];
     if (!propertyValue)
@@ -1360,6 +2766,60 @@ async function oneToOneOnDelete(context, data, key, model) {
         deleted = await innerRepo.delete(model[key][innerRepo.pk], context);
     await cacheModelForPopulate(context, model, key, deleted[innerRepo.pk], deleted);
 }
+/**
+ * @description Handles one-to-many relationship creation
+ * @summary Processes a one-to-many relationship when creating a model, either by referencing existing models or creating new ones
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToManyOnCreate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToManyOnCreate
+ *   participant repositoryFromTypeMetadata
+ *   participant createOrUpdate
+ *   participant findPrimaryKey
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToManyOnCreate: this, context, data, key, model
+ *   oneToManyOnCreate->>oneToManyOnCreate: check if propertyValues exists and has length
+ *   oneToManyOnCreate->>oneToManyOnCreate: check if all elements have same type
+ *   oneToManyOnCreate->>oneToManyOnCreate: create uniqueValues set
+ *
+ *   alt arrayType is not "object"
+ *     oneToManyOnCreate->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToManyOnCreate: repo
+ *     loop for each id in uniqueValues
+ *       oneToManyOnCreate->>repo: read(id)
+ *       repo-->>oneToManyOnCreate: read
+ *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, id, read
+ *     end
+ *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...uniqueValues]
+ *   else arrayType is "object"
+ *     oneToManyOnCreate->>findPrimaryKey: propertyValues[0]
+ *     findPrimaryKey-->>oneToManyOnCreate: pkName
+ *     oneToManyOnCreate->>oneToManyOnCreate: create result set
+ *     loop for each m in propertyValues
+ *       oneToManyOnCreate->>createOrUpdate: m, context
+ *       createOrUpdate-->>oneToManyOnCreate: record
+ *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, record[pkName], record
+ *       oneToManyOnCreate->>oneToManyOnCreate: add record[pkName] to result
+ *     end
+ *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...result]
+ *   end
+ *
+ *   oneToManyOnCreate-->>Caller: void
+ */
 async function oneToManyOnCreate(context, data, key, model) {
     const propertyValues = model[key];
     if (!propertyValues || !propertyValues.length)
@@ -1386,6 +2846,38 @@ async function oneToManyOnCreate(context, data, key, model) {
     }
     model[key] = [...result];
 }
+/**
+ * @description Handles one-to-many relationship updates
+ * @summary Processes a one-to-many relationship when updating a model, delegating to oneToManyOnCreate if cascade update is enabled
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToManyOnUpdate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToManyOnUpdate
+ *   participant oneToManyOnCreate
+ *
+ *   Caller->>oneToManyOnUpdate: this, context, data, key, model
+ *   oneToManyOnUpdate->>oneToManyOnUpdate: check if cascade.update is CASCADE
+ *
+ *   alt cascade.update is CASCADE
+ *     oneToManyOnUpdate->>oneToManyOnCreate: apply(this, [context, data, key, model])
+ *     oneToManyOnCreate-->>oneToManyOnUpdate: void
+ *   end
+ *
+ *   oneToManyOnUpdate-->>Caller: void
+ */
 async function oneToManyOnUpdate(context, data, key, model) {
     const { cascade } = data;
     if (cascade.update !== Cascade.CASCADE)
@@ -1397,6 +2889,54 @@ async function oneToManyOnUpdate(context, data, key, model) {
         model,
     ]);
 }
+/**
+ * @description Handles one-to-many relationship deletion
+ * @summary Processes a one-to-many relationship when deleting a model, deleting all related models if cascade delete is enabled
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function oneToManyOnDelete
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant oneToManyOnDelete
+ *   participant Repository
+ *   participant repositoryFromTypeMetadata
+ *   participant cacheModelForPopulate
+ *
+ *   Caller->>oneToManyOnDelete: this, context, data, key, model
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if cascade.delete is CASCADE
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if values exists and has length
+ *   oneToManyOnDelete->>oneToManyOnDelete: check if all elements have same type
+ *
+ *   alt isInstantiated (arrayType is "object")
+ *     oneToManyOnDelete->>Repository: forModel(values[0])
+ *     Repository-->>oneToManyOnDelete: repo
+ *   else not instantiated
+ *     oneToManyOnDelete->>repositoryFromTypeMetadata: model, key
+ *     repositoryFromTypeMetadata-->>oneToManyOnDelete: repo
+ *   end
+ *
+ *   oneToManyOnDelete->>oneToManyOnDelete: create uniqueValues set
+ *
+ *   loop for each id in uniqueValues
+ *     oneToManyOnDelete->>repo: delete(id, context)
+ *     repo-->>oneToManyOnDelete: deleted
+ *     oneToManyOnDelete->>cacheModelForPopulate: context, model, key, id, deleted
+ *   end
+ *
+ *   oneToManyOnDelete->>oneToManyOnDelete: set model[key] = [...uniqueValues]
+ *   oneToManyOnDelete-->>Caller: void
+ */
 async function oneToManyOnDelete(context, data, key, model) {
     if (data.cascade.delete !== Cascade.CASCADE)
         return;
@@ -1409,7 +2949,7 @@ async function oneToManyOnDelete(context, data, key, model) {
         throw new InternalError(`Invalid operation. All elements of property ${key} must match the same type.`);
     const isInstantiated = arrayType === "object";
     const repo = isInstantiated
-        ? Repository.forModel(values[0])
+        ? Repository.forModel(values[0], this.adapter.alias)
         : repositoryFromTypeMetadata(model, key);
     const uniqueValues = new Set([
         ...(isInstantiated
@@ -1422,13 +2962,91 @@ async function oneToManyOnDelete(context, data, key, model) {
     }
     model[key] = [...uniqueValues];
 }
+/**
+ * @description Generates a key for caching populated model relationships
+ * @summary Creates a unique key for storing and retrieving populated model relationships in the cache
+ * @param {string} tableName - The name of the table or model
+ * @param {string} fieldName - The name of the field or property
+ * @param {string|number} id - The identifier of the related model
+ * @return {string} A dot-separated string that uniquely identifies the relationship
+ * @function getPopulateKey
+ * @memberOf module:core
+ */
 function getPopulateKey(tableName, fieldName, id) {
     return [PersistenceKeys.POPULATE, tableName, fieldName, id].join(".");
 }
+/**
+ * @description Caches a model for later population
+ * @summary Stores a model in the context cache for efficient retrieval during relationship population
+ * @template M - The model type extending Model
+ * @template F - The repository flags type
+ * @param {Context<F>} context - The context for the operation
+ * @param {M} parentModel - The parent model that contains the relationship
+ * @param propertyKey - The property key of the relationship
+ * @param {string | number} pkValue - The primary key value of the related model
+ * @param {any} cacheValue - The model instance to cache
+ * @return {Promise<any>} A promise that resolves with the result of the cache operation
+ * @function cacheModelForPopulate
+ * @memberOf module:core
+ */
 async function cacheModelForPopulate(context, parentModel, propertyKey, pkValue, cacheValue) {
     const cacheKey = getPopulateKey(parentModel.constructor.name, propertyKey, pkValue);
     return context.accumulate({ [cacheKey]: cacheValue });
 }
+/**
+ * @description Populates a model's relationship
+ * @summary Retrieves and attaches related models to a model's relationship property
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The relations metadata
+ * @param key - The property key of the relationship
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the operation is complete
+ * @function populate
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant populate
+ *   participant fetchPopulateValues
+ *   participant getPopulateKey
+ *   participant Context
+ *   participant repositoryFromTypeMetadata
+ *
+ *   Caller->>populate: this, context, data, key, model
+ *   populate->>populate: check if data.populate is true
+ *   populate->>populate: get nested value and check if it exists
+ *
+ *   populate->>fetchPopulateValues: context, model, key, isArr ? nested : [nested]
+ *
+ *   fetchPopulateValues->>fetchPopulateValues: initialize variables
+ *
+ *   loop for each proKeyValue in propKeyValues
+ *     fetchPopulateValues->>getPopulateKey: model.constructor.name, propName, proKeyValue
+ *     getPopulateKey-->>fetchPopulateValues: cacheKey
+ *
+ *     alt try to get from cache
+ *       fetchPopulateValues->>Context: get(cacheKey)
+ *       Context-->>fetchPopulateValues: val
+ *     else catch error
+ *       fetchPopulateValues->>repositoryFromTypeMetadata: model, propName
+ *       repositoryFromTypeMetadata-->>fetchPopulateValues: repo
+ *       fetchPopulateValues->>repo: read(proKeyValue)
+ *       repo-->>fetchPopulateValues: val
+ *     end
+ *
+ *     fetchPopulateValues->>fetchPopulateValues: add val to results
+ *   end
+ *
+ *   fetchPopulateValues-->>populate: results
+ *   populate->>populate: set model[key] = isArr ? res : res[0]
+ *   populate-->>Caller: void
+ */
 async function populate(context, data, key, model) {
     if (!data.populate)
         return;
@@ -1459,6 +3077,12 @@ async function populate(context, data, key, model) {
     const res = await fetchPopulateValues(context, model, key, isArr ? nested : [nested]);
     model[key] = isArr ? res : res[0];
 }
+/**
+ * @description List of common JavaScript types
+ * @summary An array of strings representing common JavaScript types that are not custom model types
+ * @const commomTypes
+ * @memberOf module:core
+ */
 const commomTypes = [
     "array",
     "string",
@@ -1471,6 +3095,48 @@ const commomTypes = [
     "null",
     "bigint",
 ];
+/**
+ * @description Retrieves a repository for a model property based on its type metadata
+ * @summary Examines a model property's type metadata to determine the appropriate repository for related models
+ * @template M - The model type extending Model
+ * @param {any} model - The model instance containing the property
+ * @param propertyKey - The property key to examine
+ * @return {Repo<M>} A repository for the model type associated with the property
+ * @function repositoryFromTypeMetadata
+ * @memberOf module:core
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant repositoryFromTypeMetadata
+ *   participant Reflect
+ *   participant Validation
+ *   participant Model
+ *   participant Repository
+ *
+ *   Caller->>repositoryFromTypeMetadata: model, propertyKey
+ *
+ *   repositoryFromTypeMetadata->>Validation: key(Array.isArray(model[propertyKey]) ? ValidationKeys.LIST : ValidationKeys.TYPE)
+ *   Validation-->>repositoryFromTypeMetadata: validationKey
+ *
+ *   repositoryFromTypeMetadata->>Reflect: getMetadata(validationKey, model, propertyKey)
+ *   Reflect-->>repositoryFromTypeMetadata: types
+ *
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: determine customTypes based on property type
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if types and customTypes exist
+ *
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: create allowedTypes array
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: find constructorName not in commomTypes
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if constructorName exists
+ *
+ *   repositoryFromTypeMetadata->>Model: get(constructorName)
+ *   Model-->>repositoryFromTypeMetadata: constructor
+ *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if constructor exists
+ *
+ *   repositoryFromTypeMetadata->>Repository: forModel(constructor)
+ *   Repository-->>repositoryFromTypeMetadata: repo
+ *
+ *   repositoryFromTypeMetadata-->>Caller: repo
+ */
 function repositoryFromTypeMetadata(model, propertyKey) {
     const types = Reflect.getMetadata(Validation.key(Array.isArray(model[propertyKey])
         ? ValidationKeys.LIST
@@ -1492,21 +3158,36 @@ function repositoryFromTypeMetadata(model, propertyKey) {
     return Repository.forModel(constructor);
 }
 
+/**
+ * @description Specifies the database table name for a model
+ * @summary Decorator that sets the table name for a model class in the database
+ * @param {string} tableName - The name of the table in the database
+ * @return {Function} A decorator function that can be applied to a class
+ * @function table
+ * @category Class Decorators
+ */
 function table(tableName) {
     return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);
 }
+/**
+ * @description Specifies the database column name for a model property
+ * @summary Decorator that maps a model property to a specific column name in the database
+ * @param {string} columnName - The name of the column in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function column
+ * @category Property Decorators
+ */
 function column(columnName) {
     return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);
 }
 /**
- * @summary Index Decorator
- * @description properties decorated will the index in the
- * DB for performance in queries
- *
- * @param {OrderDirection[]} [directions]
- * @param {string[]} [compositions]
- *
+ * @description Creates an index on a model property for improved query performance
+ * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions
+ * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index
+ * @param {string[]} [compositions] - Optional array of property names to create a composite index
+ * @return {Function} A decorator function that can be applied to a class property
  * @function index
+ * @category Property Decorators
  */
 function index(directions, compositions) {
     return propMetadata(Repository.key(`${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(".")}` : ""}`), {
@@ -1514,6 +3195,23 @@ function index(directions, compositions) {
         compositions: compositions,
     });
 }
+/**
+ * @description Enforces uniqueness constraint during model creation and update
+ * @summary Internal function used by the unique decorator to check if a property value already exists in the database
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The metadata type
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to check for uniqueness
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError
+ * @function uniqueOnCreateUpdate
+ * @memberOf module:core
+ */
 async function uniqueOnCreateUpdate(context, data, key, model) {
     if (!model[key])
         return;
@@ -1524,16 +3222,40 @@ async function uniqueOnCreateUpdate(context, data, key, model) {
         throw new ConflictError(`model already exists with property ${key} equal to ${JSON.stringify(model[key], undefined, 2)}`);
 }
 /**
- * @summary Unique Decorator
- * @description Tags a property as unique.
- *  No other elements in that table can have the same property value
- *
+ * @description Tags a property as unique
+ * @summary Decorator that ensures a property value is unique across all instances of a model in the database
+ * @return {Function} A decorator function that can be applied to a class property
  * @function unique
- *
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @unique()
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
  */
 function unique() {
     return apply(onCreateUpdate(uniqueOnCreateUpdate), propMetadata(Repository.key(PersistenceKeys.UNIQUE), {}));
 }
+/**
+ * @description Handles user identification for ownership tracking
+ * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to store the user identifier
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported
+ * @function createdByOnCreateUpdate
+ * @memberOf module:core
+ */
 async function createdByOnCreateUpdate(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 context, 
@@ -1545,12 +3267,40 @@ key,
 model) {
     throw new AuthorizationError("This adapter does not support user identification");
 }
+/**
+ * @description Tracks the creator of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who created the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function createdBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @createdBy()
+ *   creator!: string;
+ * }
+ * ```
+ */
 function createdBy() {
     const key = Repository.key(PersistenceKeys.CREATED_BY);
     return Decoration.for(key)
         .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))
         .apply();
 }
+/**
+ * @description Tracks the last updater of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function updatedBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @updatedBy()
+ *   lastEditor!: string;
+ * }
+ * ```
+ */
 function updatedBy() {
     const key = Repository.key(PersistenceKeys.UPDATED_BY);
     return Decoration.for(key)
@@ -1558,15 +3308,27 @@ function updatedBy() {
         .apply();
 }
 /**
- * @summary One To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence}
- * @param {CascadeMetadata} [cascadeOptions]
- * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
- *
+ * @description Defines a one-to-one relationship between models
+ * @summary Decorator that establishes a one-to-one relationship between the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function oneToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @oneToOne(Profile)
+ *   profile!: string | Profile;
+ * }
  *
- *
+ * class Profile extends BaseModel {
+ *   @required()
+ *   bio!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see manyToOne
  */
@@ -1583,13 +3345,30 @@ function oneToOne(clazz, cascadeOptions = DefaultCascade, populate$1 = true) {
         .apply();
 }
 /**
- * @summary One To Many relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use.
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a one-to-many relationship between models
+ * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function oneToMany
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
  *
+ *   @oneToMany(Book)
+ *   books!: string[] | Book[];
+ * }
+ *
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ * }
+ * ```
  * @see oneToOne
  * @see manyToOne
  */
@@ -1608,13 +3387,30 @@ function oneToMany(clazz, cascadeOptions = DefaultCascade, populate$1 = true) {
         .apply();
 }
 /**
- * @summary Many To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
  *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see oneToOne
  */
@@ -1636,6 +3432,42 @@ function manyToOne(clazz, cascadeOptions = DefaultCascade, populate = true) {
         .apply();
 }
 
+/**
+ * @description Callback function for primary key creation
+ * @summary Handles the creation of primary key values for models using sequences
+ * @template M - Type that extends Model
+ * @template R - Type that extends Repo<M, F, C>
+ * @template V - Type that extends SequenceOptions
+ * @template F - Type that extends RepositoryFlags
+ * @template C - Type that extends Context<F>
+ * @param {Context<F>} context - The execution context
+ * @param {V} data - The sequence options
+ * @param key - The property key to set as primary key
+ * @param {M} model - The model instance
+ * @return {Promise<void>} A promise that resolves when the primary key is set
+ * @function pkOnCreate
+ * @category Property Decorators
+ * @mermaid
+ * sequenceDiagram
+ *   participant Model
+ *   participant pkOnCreate
+ *   participant Adapter
+ *   participant Sequence
+ *
+ *   Model->>pkOnCreate: Call with model instance
+ *   Note over pkOnCreate: Check if key already exists
+ *   alt Key exists or no type specified
+ *     pkOnCreate-->>Model: Return early
+ *   else Key needs to be created
+ *     pkOnCreate->>pkOnCreate: Generate sequence name if not provided
+ *     pkOnCreate->>Adapter: Request Sequence(data)
+ *     Adapter->>Sequence: Create sequence
+ *     Sequence-->>pkOnCreate: Return sequence
+ *     pkOnCreate->>Sequence: Call next()
+ *     Sequence-->>pkOnCreate: Return next value
+ *     pkOnCreate->>Model: Set primary key value
+ *   end
+ */
 async function pkOnCreate(context, data, key, model) {
     if (!data.type || model[key]) {
         return;
@@ -1661,15 +3493,24 @@ async function pkOnCreate(context, data, key, model) {
     setPrimaryKeyValue(model, key, next);
 }
 /**
- * @summary Primary Key Decorator
- * @description Marks the property as the {@link Model}s primary key.
- *  Also marks the property as {@link unique} as {@required} and ensures the index is created properly according to the provided {@link Sequence}
- *
+ * @description Primary Key Decorator
+ * @summary Marks a property as the model's primary key with automatic sequence generation
+ * This decorator combines multiple behaviors: it marks the property as unique, required,
+ * and ensures the index is created properly according to the provided sequence options.
+ * @param {Omit<SequenceOptions, "cycle" | "startWith" | "incrementBy">} opts - Options for the sequence generation
+ * @return {PropertyDecorator} A property decorator that can be applied to model properties
  * @function pk
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @pk()
+ *   id!: string;
  *
- * @see unique
- * @see required
- * @see on
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
  */
 function pk(opts = DefaultSequenceOptions) {
     opts = Object.assign({}, DefaultSequenceOptions, opts);
@@ -1681,6 +3522,29 @@ function pk(opts = DefaultSequenceOptions) {
         .apply();
 }
 
+/**
+ * @description Base model class for all domain models
+ * @summary An abstract base class that extends the Model class from decorator-validation and adds timestamp functionality.
+ * All domain models in the application should extend this class to inherit common properties and behaviors.
+ * @param {ModelArg<BaseModel>} arg - Optional initialization data for the model
+ * @class BaseModel
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @required()
+ *   username!: string;
+ *
+ *   @email()
+ *   email!: string;
+ *
+ *   constructor(data?: ModelArg<User>) {
+ *     super(data);
+ *   }
+ * }
+ *
+ * const user = new User({ username: 'john', email: 'john@example.com' });
+ * ```
+ */
 class BaseModel extends Model {
     constructor(arg) {
         super(arg);
@@ -1695,6 +3559,62 @@ __decorate([
     __metadata("design:type", Date)
 ], BaseModel.prototype, "updatedOn", void 0);
 
+/**
+ * @description Handles pagination for database queries
+ * @summary Provides functionality for navigating through paginated query results
+ *
+ * This abstract class manages the state and navigation of paginated database query results.
+ * It tracks the current page, total pages, and record count, and provides methods for
+ * moving between pages.
+ *
+ * @template M - The model type this paginator operates on
+ * @template R - The return type of the paginated query (defaults to M[])
+ * @template Q - The query type (defaults to any)
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @param {Q} query - The query to paginate
+ * @param {number} size - The number of records per page
+ * @param {Constructor<M>} clazz - The constructor for the model type
+ * @class Paginator
+ * @example
+ * // Create a paginator for a user query
+ * const userQuery = db.select().from(User);
+ * const paginator = await userQuery.paginate(10); // 10 users per page
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Navigate to the next page
+ * const secondPage = await paginator.next();
+ *
+ * // Get information about the pagination
+ * console.log(`Page ${paginator.current} of ${paginator.total}, ${paginator.count} total records`);
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Paginator
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Paginator: new Paginator(adapter, query, size, clazz)
+ *   Client->>Paginator: page(1)
+ *   Paginator->>Paginator: validatePage(1)
+ *   Paginator->>Paginator: prepare(query)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ *
+ *   Client->>Paginator: next()
+ *   Paginator->>Paginator: page(current + 1)
+ *   Paginator->>Paginator: validatePage(current + 1)
+ *   Paginator->>Adapter: execute query with pagination
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Paginator: return results
+ *   Paginator-->>Client: return page results
+ */
 class Paginator {
     get current() {
         return this._currentPage;
@@ -1732,6 +3652,57 @@ class Paginator {
 }
 
 var _a, _b, _c, _d;
+/**
+ * @description Base class for database query statements
+ * @summary Provides a foundation for building and executing database queries
+ *
+ * This abstract class implements the query builder pattern for constructing
+ * database queries. It supports various query operations like select, from,
+ * where, orderBy, groupBy, limit, and offset. It also provides methods for
+ * executing queries and handling pagination.
+ *
+ * @template Q - The query type specific to the database adapter
+ * @template M - The model type this statement operates on
+ * @template R - The return type of the query
+ * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries
+ * @class Statement
+ * @example
+ * // Create a statement to query users
+ * const statement = new SQLStatement(adapter);
+ * const users = await statement
+ *   .select()
+ *   .from(User)
+ *   .where(Condition.attribute("status").eq("active"))
+ *   .orderBy(["createdAt", "DESC"])
+ *   .limit(10)
+ *   .execute();
+ *
+ * // Use pagination
+ * const paginator = await statement
+ *   .select()
+ *   .from(User)
+ *   .paginate(20); // 20 users per page
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Statement
+ *   participant Adapter
+ *   participant Database
+ *
+ *   Client->>Statement: select()
+ *   Client->>Statement: from(Model)
+ *   Client->>Statement: where(condition)
+ *   Client->>Statement: orderBy([field, direction])
+ *   Client->>Statement: limit(value)
+ *   Client->>Statement: execute()
+ *   Statement->>Statement: build()
+ *   Statement->>Adapter: raw(query)
+ *   Adapter->>Database: execute query
+ *   Database-->>Adapter: return results
+ *   Adapter-->>Statement: return processed results
+ *   Statement-->>Client: return final results
+ */
 class Statement {
     constructor(adapter) {
         this.adapter = adapter;
@@ -1881,15 +3852,22 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], Statement.prototype, "execute", null);
 
+/**
+ * @module core
+ * @description Core module for the Decaf TypeScript framework
+ * @summary This module provides the foundational components of the Decaf framework, including identity management,
+ * model definitions, repository patterns, persistence layer, query building, and utility functions.
+ * It exports functionality from various submodules and sets up the injectable registry for repository decorators.
+ */
 // overrides the previous Injectables registry to enable the @repository decorator
 Injectables.setRegistry(new InjectablesRegistry());
 /**
- * @summary stores the current package version
- * @description this is how you should document a constant
+ * @description Stores the current package version
+ * @summary A constant representing the version of the core package
  * @const VERSION
  * @memberOf module:core
  */
 const VERSION = "0.5.1";
 
 export { Adapter, AuthorizationError, BaseModel, BigIntSequence, Cascade, Condition, ConnectionError, DefaultCascade, DefaultSequenceOptions, Dispatch, ForbiddenError, GroupOperator, InjectablesRegistry, NumericSequence, ObserverError, ObserverHandler, Operator, OrderDirection, Paginator, PagingError, PersistenceKeys, QueryError, Repository, Sequence, Statement, UnsupportedError, VERSION, cacheModelForPopulate, column, createOrUpdate, createdBy, createdByOnCreateUpdate, final, generateInjectableNameForRepository, getPopulateKey, getTableName, index, manyToOne, oneToMany, oneToManyOnCreate, oneToManyOnDelete, oneToManyOnUpdate, oneToOne, oneToOneOnCreate, oneToOneOnDelete, oneToOneOnUpdate, pk, pkOnCreate, populate, repository, repositoryFromTypeMetadata, sequenceNameForModel, table, unique, uniqueOnCreateUpdate, updatedBy, uses };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.esm.cjs","sources":["../src/repository/constants.ts","../src/persistence/constants.ts","../src/utils/decorators.ts","../src/utils/errors.ts","../src/persistence/errors.ts","../src/persistence/Dispatch.ts","../src/persistence/ObserverHandler.ts","../src/persistence/Adapter.ts","../src/identity/utils.ts","../src/persistence/Sequence.ts","../src/persistence/decorators.ts","../src/repository/Repository.ts","../src/repository/decorators.ts","../src/repository/errors.ts","../src/repository/utils.ts","../src/repository/injectables.ts","../src/interfaces/SequenceOptions.ts","../src/query/constants.ts","../src/query/errors.ts","../src/query/Condition.ts","../src/model/construction.ts","../src/model/decorators.ts","../src/identity/decorators.ts","../src/model/BaseModel.ts","../src/query/Paginator.ts","../src/query/Statement.ts","../src/index.ts"],"sourcesContent":["import { CascadeMetadata } from \"./types\";\n\nexport enum OrderDirection {\n  ASC = \"asc\",\n\n  DSC = \"desc\",\n}\n\nexport enum Cascade {\n  CASCADE = \"cascade\",\n  NONE = \"none\",\n}\n\nexport const DefaultCascade: CascadeMetadata = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n};\n","export enum PersistenceKeys {\n  INDEX = \"index\",\n  UNIQUE = \"unique\",\n  ADAPTER = \"adapter\",\n  INJECTABLE = \"decaf_{0}_adapter_for_{1}\",\n  TABLE = \"table\",\n  COLUMN = \"column\",\n  METADATA = \"__metadata\",\n  RELATIONS = \"__relations\",\n  CLAUSE_SEQUENCE = \"clause-sequence\",\n  // Ownership\n  CREATED_BY = \"ownership.created-by\",\n  UPDATED_BY = \"ownership.updated-by\",\n  // Relations\n  ONE_TO_ONE = \"relations.one-to-one\",\n  ONE_TO_MANY = \"relations.one-to-many\",\n  MANY_TO_ONE = \"relations.many-to-one\",\n  POPULATE = \"populate\",\n}\n","export function final() {\n  return (\n    target: object,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) => {\n    if (!descriptor)\n      throw new Error(\"final decorator can only be used on methods\");\n    if (descriptor?.configurable) {\n      descriptor.configurable = false;\n    }\n    return descriptor;\n  };\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class AuthorizationError extends BaseError {\n  constructor(msg: string | Error) {\n    super(AuthorizationError.name, msg, 401);\n  }\n}\n\nexport class ForbiddenError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ForbiddenError.name, msg, 403);\n  }\n}\n\nexport class ConnectionError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ConnectionError.name, msg, 503);\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class UnsupportedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(UnsupportedError.name, msg, 500);\n  }\n}\n","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","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\nexport class ObserverHandler implements Observable {\n  protected readonly observers: {\n    observer: Observer;\n    filter?: ObserverFilter;\n  }[] = [];\n\n  count() {\n    return this.observers.length;\n  }\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  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  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","import {\n  BaseError,\n  DBKeys,\n  InternalError,\n  NotFoundError,\n  Context,\n  OperationKeys,\n  RepositoryFlags,\n  DefaultRepositoryFlags,\n  Contextual,\n  BulkCrudOperationKeys,\n  modelToTransient,\n} from \"@decaf-ts/db-decorators\";\nimport { type Observer } from \"../interfaces/Observer\";\nimport {\n  type Constructor,\n  Decoration,\n  DefaultFlavour,\n  Model,\n  ModelConstructor,\n  ModelRegistry,\n} from \"@decaf-ts/decorator-validation\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { RawExecutor } from \"../interfaces/RawExecutor\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Repository } from \"../repository/Repository\";\nimport { Sequence } from \"./Sequence\";\nimport { ErrorParser } from \"../interfaces\";\nimport { Statement } from \"../query/Statement\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { final } from \"../utils\";\nimport { Dispatch } from \"./Dispatch\";\nimport { type EventIds, type ObserverFilter } from \"./types\";\nimport { ObserverHandler } from \"./ObserverHandler\";\n\nDecoration.setFlavourResolver((obj: object) => {\n  try {\n    return (\n      Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : (obj as any)) ||\n      DefaultFlavour\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    return DefaultFlavour;\n  }\n});\n\n/**\n * @summary Abstract Decaf-ts Persistence Adapter Class\n * @description Offers the base implementation for all Adapter Classes\n * and manages them various registered {@link Adapter}s\n *\n * @typedef Y the underlying persistence object type or the required config to set it up\n * @typedef Q The query object the adapter uses\n *\n * @param {Y} native the underlying persistence object\n * @param {string} flavour the under witch the persistence adapter should be stored\n *\n * @class Adapter\n * @implements RawExecutor\n * @implements Observable\n */\nexport abstract class Adapter<\n    Y,\n    Q,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >\n  implements RawExecutor<Q>, Contextual<F, C>, Observable, Observer, ErrorParser\n{\n  private static _current: Adapter<any, any, any, any>;\n  private static _cache: Record<string, Adapter<any, any, any, any>> = {};\n\n  private logger!: Logger;\n\n  protected dispatch?: Dispatch<Y>;\n\n  protected readonly observerHandler?: ObserverHandler;\n\n  protected get log() {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  get native() {\n    return this._native;\n  }\n\n  get alias() {\n    return this._alias || this.flavour;\n  }\n\n  repository<M extends Model>(): Constructor<\n    Repository<M, Q, Adapter<Y, Q, F, C>, F, C>\n  > {\n    return Repository;\n  }\n\n  protected constructor(\n    private readonly _native: Y,\n    readonly flavour: string,\n    private readonly _alias?: string\n  ) {\n    if (this.flavour in Adapter._cache)\n      throw new InternalError(\n        `${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} already registered`\n      );\n    Adapter._cache[this.alias] = this;\n    this.log.info(\n      `Created ${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} persistence adapter`\n    );\n    if (!Adapter._current) {\n      this.log.verbose(`Defined ${this.alias} persistence adapter as current`);\n      Adapter._current = this;\n    }\n  }\n\n  abstract Statement<M extends Model>(): Statement<Q, M, any>;\n\n  protected Dispatch(): Dispatch<Y> {\n    return new Dispatch();\n  }\n\n  protected ObserverHandler() {\n    return new ObserverHandler();\n  }\n\n  protected isReserved(attr: string) {\n    return !attr;\n  }\n\n  abstract parseError(err: Error): BaseError;\n\n  abstract initialize(...args: any[]): Promise<void>;\n\n  abstract Sequence(options: SequenceOptions): Promise<Sequence>;\n\n  protected flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<F>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): F {\n    return Object.assign({}, DefaultRepositoryFlags, flags, {\n      affectedTables: Repository.table(model),\n      writeOperation: operation !== OperationKeys.READ,\n      timestamp: new Date(),\n      operation: operation,\n    }) as F;\n  }\n\n  protected Context: Constructor<C> = Context<F> as any;\n\n  @final()\n  async context<M extends Model>(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    overrides: Partial<F>,\n    model: Constructor<M>,\n    ...args: any[]\n  ): Promise<C> {\n    this.log\n      .for(this.context)\n      .debug(\n        `Creating new context for ${operation} operation on ${model.name} model with flags: ${JSON.stringify(overrides)}`\n      );\n    return new this.Context(\n      this.flags(operation, model, overrides, ...args)\n    ) as unknown as C;\n  }\n\n  prepare<M extends Model>(\n    model: M,\n    pk: keyof M\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const log = this.log.for(this.prepare);\n    log.silly(`Preparing model ${model.constructor.name} before persisting`);\n    const split = modelToTransient(model);\n    const result = Object.entries(split.model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        if (typeof val === \"undefined\") return accum;\n        const mappedProp = Repository.column(model, key);\n        if (this.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n    if ((model as any)[PersistenceKeys.METADATA]) {\n      log.silly(\n        `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    }\n\n    return {\n      record: result,\n      id: model[pk] as string,\n      transient: split.transient,\n    };\n  }\n\n  revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number | bigint,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    const ob: Record<string, any> = {};\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\n    const metadata = obj[PersistenceKeys.METADATA];\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      if (key === pk) return accum;\n      (accum as Record<string, any>)[key] = obj[Repository.column(accum, key)];\n      return accum;\n    }, m);\n\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    if (metadata) {\n      log.silly(\n        `Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    }\n\n    return result;\n  }\n\n  abstract create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async createAll(\n    tableName: string,\n    id: (string | number)[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const log = this.log.for(this.createAll);\n    log.verbose(`Creating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(\n      id.map((i, count) => this.create(tableName, i, model[count], ...args))\n    );\n  }\n\n  abstract read(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async readAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.readAll);\n    log.verbose(`Reading ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(id.map((i) => this.read(tableName, i, ...args)));\n  }\n\n  abstract update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async updateAll(\n    tableName: string,\n    id: string[] | number[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const log = this.log.for(this.updateAll);\n    log.verbose(`Updating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(\n      id.map((i, count) => this.update(tableName, i, model[count], ...args))\n    );\n  }\n\n  abstract delete(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  async deleteAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.createAll);\n    log.verbose(`Deleting ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));\n  }\n\n  abstract raw<R>(rawInput: Q, ...args: any[]): Promise<R>;\n\n  /**\n   *\n   * @see {Observable#observe}\n   */\n  @final()\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    if (!this.observerHandler)\n      Object.defineProperty(this, \"observerHandler\", {\n        value: this.ObserverHandler(),\n        writable: false,\n      });\n    this.observerHandler!.observe(observer, filter);\n    this.log\n      .for(this.observe)\n      .verbose(`Registering new observer ${observer.toString()}`);\n    if (!this.dispatch) {\n      this.log.for(this.observe).info(`Creating dispatch for ${this.alias}`);\n      this.dispatch = this.Dispatch();\n      this.dispatch.observe(this);\n    }\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  @final()\n  unObserve(observer: Observer): void {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.observerHandler.unObserve(observer);\n    this.log\n      .for(this.unObserve)\n      .verbose(`Observer ${observer.toString()} removed`);\n  }\n\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    const log = this.log.for(this.updateObservers);\n    log.verbose(\n      `Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`\n    );\n    await this.observerHandler.updateObservers(\n      this.log,\n      table,\n      event,\n      id,\n      ...args\n    );\n  }\n\n  async refresh(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ) {\n    return this.updateObservers(table, event, id, ...args);\n  }\n\n  toString() {\n    return `${this.flavour} persistence Adapter`;\n  }\n\n  static flavourOf<M extends Model>(model: Constructor<M>): string {\n    return (\n      Reflect.getMetadata(this.key(PersistenceKeys.ADAPTER), model) ||\n      this.current.flavour\n    );\n  }\n\n  static get current() {\n    if (!Adapter._current)\n      throw new InternalError(\n        `No persistence flavour set. Please initialize your adapter`\n      );\n    return Adapter._current;\n  }\n\n  static get<Y, Q, C extends Context<F>, F extends RepositoryFlags>(\n    flavour: any\n  ): Adapter<Y, Q, F, C> | undefined {\n    if (flavour in this._cache) return this._cache[flavour];\n    throw new InternalError(`No Adapter registered under ${flavour}.`);\n  }\n\n  static setCurrent(flavour: string) {\n    const adapter = Adapter.get(flavour);\n    if (!adapter)\n      throw new NotFoundError(`No persistence flavour ${flavour} registered`);\n    this._current = adapter;\n  }\n\n  static key(key: string) {\n    return Repository.key(key);\n  }\n\n  static models<M extends Model>(flavour: string) {\n    try {\n      const registry = (Model as any).getRegistry() as ModelRegistry<any>;\n      const cache = (\n        registry as unknown as { cache: Record<string, ModelConstructor<any>> }\n      ).cache;\n      const managedModels: ModelConstructor<any>[] = Object.values(cache)\n        .map((m: ModelConstructor<M>) => {\n          let f = Reflect.getMetadata(\n            Adapter.key(PersistenceKeys.ADAPTER),\n            m as ModelConstructor<any>\n          );\n          if (f && f === flavour) return m;\n          if (!f) {\n            const repo = Reflect.getMetadata(\n              Repository.key(DBKeys.REPOSITORY),\n              m as ModelConstructor<any>\n            );\n            if (!repo) return;\n            const repository = Repository.forModel(m);\n\n            f = Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              repository\n            );\n            return f;\n          }\n        })\n        .filter((m) => !!m);\n      return managedModels;\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n}\n","import { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\n\nexport function getTableName<M extends Model>(\n  model: M | Constructor<M>\n): string {\n  const obj = model instanceof Model ? model.constructor : model;\n\n  const metadata = Reflect.getOwnMetadata(\n    Adapter.key(PersistenceKeys.TABLE),\n    obj\n  );\n  if (metadata) {\n    return metadata;\n  }\n  if (model instanceof Model) {\n    return model.constructor.name;\n  }\n  return model.name;\n}\n\nexport function sequenceNameForModel<M extends Model>(\n  model: M | Constructor<M>,\n  ...args: string[]\n) {\n  return [getTableName(model), ...args].join(\"_\");\n}\n","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\nexport abstract class Sequence {\n  private logger!: Logger;\n\n  protected get log() {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  protected constructor(protected readonly options: SequenceOptions) {}\n\n  abstract next(): Promise<string | number | bigint>;\n  abstract current(): Promise<string | number | bigint>;\n  abstract range(count: number): Promise<(number | string | bigint)[]>;\n\n  static pk<M extends Model>(model: M | Constructor<M>) {\n    return sequenceNameForModel(model, \"pk\");\n  }\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","import { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Adapter } from \"./Adapter\";\n\nexport function uses(flavour: string) {\n  return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour));\n}\n","import {\n  BulkCrudOperationKeys,\n  Context,\n  DBKeys,\n  enforceDBDecorators,\n  findPrimaryKey,\n  InternalError,\n  IRepository,\n  OperationKeys,\n  Repository as Rep,\n  RepositoryFlags,\n  ValidationError,\n  wrapMethodWithContext,\n} from \"@decaf-ts/db-decorators\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { type Observer } from \"../interfaces/Observer\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { OrderDirection } from \"./constants\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { Queriable } from \"../interfaces/Queriable\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { IndexMetadata } from \"./types\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Condition } from \"../query/Condition\";\nimport { WhereOption } from \"../query/options\";\nimport { OrderBySelector, SelectSelector } from \"../query/selectors\";\nimport { getTableName } from \"../identity/utils\";\nimport { uses } from \"../persistence/decorators\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { ObserverHandler } from \"../persistence/ObserverHandler\";\nimport { final } from \"../utils\";\nimport type { EventIds, ObserverFilter } from \"../persistence\";\n\nexport type Repo<\n  M extends Model,\n  F extends RepositoryFlags = any,\n  C extends Context<F> = any,\n  Q = any,\n  A extends Adapter<any, Q, F, C> = any,\n> = Repository<M, Q, A, F, C>;\n\nexport class Repository<\n    M extends Model,\n    Q,\n    A extends Adapter<any, Q, F, C>,\n    F extends RepositoryFlags = RepositoryFlags,\n    C extends Context<F> = Context<F>,\n  >\n  extends Rep<M, F, C>\n  implements Observable, Observer, Queriable<M>, IRepository<M, F, C>\n{\n  private static _cache: Record<\n    string,\n    Constructor<Repo<Model>> | Repo<Model>\n  > = {};\n\n  protected observers: Observer[] = [];\n\n  protected observerHandler?: ObserverHandler;\n\n  private readonly _adapter!: A;\n  private _tableName!: string;\n  private _overrides?: Partial<F>;\n\n  private logger!: Logger;\n\n  get log() {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  protected get adapter(): A {\n    if (!this._adapter)\n      throw new InternalError(\n        `No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?`\n      );\n    return this._adapter;\n  }\n\n  protected get tableName() {\n    if (!this._tableName) this._tableName = Repository.table(this.class);\n    return this._tableName;\n  }\n\n  protected override get pkProps(): SequenceOptions {\n    return super.pkProps;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  constructor(adapter?: A, clazz?: Constructor<M>, ...args: any[]) {\n    super(clazz);\n    if (adapter) this._adapter = adapter;\n    if (clazz) {\n      Repository.register(clazz, this);\n      if (adapter) {\n        const flavour = Reflect.getMetadata(\n          Adapter.key(PersistenceKeys.ADAPTER),\n          clazz\n        );\n        if (flavour && flavour !== adapter.flavour)\n          throw new InternalError(\"Incompatible flavours\");\n        uses(adapter.flavour)(clazz);\n      }\n    }\n    [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach(\n      (m) => {\n        const name = m.name;\n        wrapMethodWithContext(\n          this,\n          (this as any)[name + \"Prefix\"],\n          m,\n          (this as any)[name + \"Suffix\"]\n        );\n      }\n    );\n  }\n\n  override(flags: Partial<F>) {\n    this.log\n      .for(this.override)\n      .debug(`Overriding repository flags with ${JSON.stringify(flags)}`);\n    return new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        const result = Reflect.get(target, p, receiver);\n        if (p !== \"_overrides\") return result;\n        return Object.assign({}, result, flags);\n      },\n    });\n  }\n\n  protected ObserverHandler() {\n    return new ObserverHandler();\n  }\n\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    model = new this.class(model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n\n    const errors = model.hasErrors(\n      ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n    );\n    if (errors) throw new ValidationError(errors.toString());\n\n    return [model, ...contextArgs.args];\n  }\n\n  async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    let c: C | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as C;\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  override async createSuffix(model: M, context: C): Promise<M> {\n    return super.createSuffix(model, context);\n  }\n\n  override async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids as (string | number)[],\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n    const opts = Repository.getSequenceOptions(models[0]);\n    let ids: (string | number | bigint | undefined)[] = [];\n    if (opts.type) {\n      if (!opts.name) opts.name = Sequence.pk(models[0]);\n      ids = await (await this.adapter.Sequence(opts)).range(models.length);\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        m[this.pk] = ids[i] as M[keyof M];\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) =>\n        m.hasErrors(\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  protected override async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const model: M = new this.class();\n    model[this.pk] = key as M[keyof M];\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  async read(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.read(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  protected override async readAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    await Promise.all(\n      keys.map(async (k) => {\n        const m = new this.class();\n        m[this.pk] = k as M[keyof M];\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  override async readAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const records = await this.adapter.readAll(this.tableName, keys, ...args);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert<M>(record, this.class, this.pk, id, transient);\n  }\n\n  protected override async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const pk = model[this.pk] as string;\n    if (!pk)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n    const oldModel = await this.read(pk, ...contextArgs.args);\n    model = this.merge(oldModel, model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(\n      oldModel,\n      ...Repository.relations(this.class),\n      ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n    );\n    if (errors) throw new ValidationError(errors.toString());\n    if (Repository.getMetadata(oldModel)) {\n      if (!Repository.getMetadata(model))\n        Repository.setMetadata(model, Repository.getMetadata(oldModel));\n    }\n    return [model, ...contextArgs.args];\n  }\n\n  override async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  protected override async updateAllPrefix(\n    models: M[],\n    ...args: any[]\n  ): Promise<any[]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const ids = models.map((m) => {\n      const id = m[this.pk] as string;\n      if (!id) throw new InternalError(\"missing id on update operation\");\n      return id;\n    });\n    const oldModels = await this.readAll(ids, ...contextArgs.args);\n    models = models.map((m, i) => {\n      m = this.merge(oldModels[i], m);\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n      return m;\n    });\n    await Promise.all(\n      models.map((m, i) =>\n        enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON,\n          oldModels[i]\n        )\n      )\n    );\n\n    const errors = models\n      .map((m, i) =>\n        m.hasErrors(\n          oldModels[i],\n          m,\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n\n    models.forEach((m, i) => {\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n    });\n    return [models, ...contextArgs.args];\n  }\n\n  protected override async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const model = await this.read(key, ...contextArgs.args);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  async delete(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.delete(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  protected override async deleteAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const models = await this.readAll(keys, ...contextArgs.args);\n    await Promise.all(\n      models.map(async (m) => {\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  override async deleteAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const results = await this.adapter.deleteAll(this.tableName, keys, ...args);\n    return results.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): WhereOption<M, M[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): WhereOption<M, Pick<M, S[number]>[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): WhereOption<M, M[]> | WhereOption<M, Pick<M, S[number]>[]> {\n    return this.adapter\n      .Statement<M>()\n      .select(selector as readonly [...S])\n      .from(this.class);\n  }\n\n  async query(\n    condition: Condition<M>,\n    orderBy: keyof M,\n    order: OrderDirection = OrderDirection.ASC,\n    limit?: number,\n    skip?: number\n  ): Promise<M[]> {\n    const sort: OrderBySelector<M> = [orderBy, order as OrderDirection];\n    const query = this.select().where(condition).orderBy(sort);\n    if (limit) query.limit(limit);\n    if (skip) query.offset(skip);\n    return query.execute();\n  }\n\n  /**\n   *\n   * @see {Observable#observe}\n   */\n  @final()\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    if (!this.observerHandler)\n      Object.defineProperty(this, \"observerHandler\", {\n        value: this.ObserverHandler(),\n        writable: false,\n      });\n    const log = this.log.for(this.observe);\n    const tableName = Repository.table(this.class);\n    this.adapter.observe(this, (table: string) => tableName === table);\n    log.verbose(\n      `now observing ${this.adapter} filtering on table === ${tableName}`\n    );\n    this.observerHandler!.observe(observer, filter);\n    log.verbose(`Registered new observer ${observer.toString()}`);\n  }\n\n  /**\n   * @summary Unregisters an {@link Observer}\n   * @param {Observer} observer\n   *\n   * @see {Observable#unObserve}\n   */\n  @final()\n  unObserve(observer: Observer): void {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.observerHandler.unObserve(observer);\n    this.log\n      .for(this.unObserve)\n      .verbose(`Observer ${observer.toString()} removed`);\n    if (!this.observerHandler.count()) {\n      this.log.verbose(\n        `No more observers registered for ${this.adapter}, unsubscribing`\n      );\n      this.adapter.unObserve(this);\n      this.log.verbose(`No longer observing adapter ${this.adapter.flavour}`);\n    }\n  }\n\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.log\n      .for(this.updateObservers)\n      .verbose(\n        `Updating ${this.observerHandler.count()} observers for ${this}`\n      );\n    await this.observerHandler.updateObservers(\n      this.log,\n      table,\n      event,\n      Array.isArray(id)\n        ? id.map((i) => Sequence.parseValue(this.pkProps.type, i) as string)\n        : (Sequence.parseValue(this.pkProps.type, id) as string),\n      ...args\n    );\n  }\n\n  async refresh(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ) {\n    return this.updateObservers(table, event, id, ...args);\n  }\n\n  static forModel<M extends Model, R extends Repo<M>>(\n    model: Constructor<M>,\n    defaultFlavour?: string,\n    ...args: any[]\n  ): R {\n    let repo: R | Constructor<R> | undefined;\n    try {\n      repo = this.get(model) as Constructor<R> | R;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      repo = undefined;\n    }\n\n    if (repo instanceof Repository) return repo as R;\n\n    const flavour: string | undefined =\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||\n      (repo &&\n        Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repo)) ||\n      defaultFlavour;\n    const adapter: Adapter<any, any, any, any> | undefined = flavour\n      ? Adapter.get(flavour)\n      : undefined;\n\n    if (!adapter)\n      throw new InternalError(\n        `No registered persistence adapter found flavour ${flavour}`\n      );\n\n    repo = repo || (adapter.repository() as Constructor<R>);\n    return new repo(adapter, model, ...args) as R;\n  }\n\n  private static get<M extends Model>(\n    model: Constructor<M>\n  ): Constructor<Repo<M>> | Repo<M> {\n    const name = Repository.table(model);\n    if (name in this._cache)\n      return this._cache[name] as unknown as Constructor<Repo<M>> | Repo<M>;\n    throw new InternalError(\n      `Could not find repository registered under ${name}`\n    );\n  }\n\n  static register<M extends Model>(\n    model: Constructor<M>,\n    repo: Constructor<Repo<M>> | Repo<M>\n  ) {\n    const name = Repository.table(model);\n    if (name in this._cache)\n      throw new InternalError(`${name} already registered as a repository`);\n    this._cache[name] = repo as any;\n  }\n\n  static setMetadata<M extends Model>(model: M, metadata: any) {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: true,\n      writable: false,\n      value: metadata,\n    });\n  }\n\n  static getMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    return descriptor ? descriptor.value : undefined;\n  }\n\n  static removeMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    if (descriptor) delete (model as any)[PersistenceKeys.METADATA];\n  }\n\n  static getSequenceOptions<M extends Model>(model: M) {\n    const pk = findPrimaryKey(model).id;\n    const metadata = Reflect.getMetadata(\n      Repository.key(DBKeys.ID),\n      model,\n      pk as string\n    );\n    if (!metadata)\n      throw new InternalError(\n        \"No sequence options defined for model. did you use the @pk decorator?\"\n      );\n    return metadata as SequenceOptions;\n  }\n\n  static indexes<M extends Model>(model: M | Constructor<M>) {\n    const indexDecorators = Reflection.getAllPropertyDecorators(\n      model instanceof Model ? model : new model(),\n      DBKeys.REFLECT\n    );\n    return Object.entries(indexDecorators || {}).reduce(\n      (accum: Record<string, Record<string, IndexMetadata>>, [k, val]) => {\n        const decs = val.filter((v) => v.key.startsWith(PersistenceKeys.INDEX));\n        if (decs && decs.length) {\n          for (const dec of decs) {\n            const { key, props } = dec;\n            accum[k] = accum[k] || {};\n            accum[k][key] = props as IndexMetadata;\n          }\n        }\n        return accum;\n      },\n      {}\n    );\n  }\n\n  static relations<M extends Model>(model: M | Constructor<M>) {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[PersistenceKeys.RELATIONS];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  static table<M extends Model>(model: M | Constructor<M>) {\n    return getTableName(model);\n  }\n\n  static column<M extends Model>(model: M, attribute: string) {\n    const metadata = Reflect.getMetadata(\n      Adapter.key(PersistenceKeys.COLUMN),\n      model,\n      attribute\n    );\n    return metadata ? metadata : attribute;\n  }\n}\n","import { inject, injectable } from \"@decaf-ts/injectable-decorators\";\nimport { DBKeys, IRepository } from \"@decaf-ts/db-decorators\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\nexport function repository<T extends Model>(\n  model: Constructor<T>,\n  nameOverride?: string\n): any {\n  return ((original: any, propertyKey?: any) => {\n    if (propertyKey) {\n      return inject(nameOverride || model.name)(original, propertyKey);\n    }\n\n    metadata(\n      Repository.key(DBKeys.REPOSITORY),\n      nameOverride || original.name\n    )(model);\n    Repository.register(model, original);\n    return injectable(\n      nameOverride || original.name,\n      true,\n      (instance: IRepository<T>) => {\n        Object.defineProperty(instance, DBKeys.CLASS, {\n          enumerable: false,\n          configurable: false,\n          writable: false,\n          value: model,\n        });\n      }\n    )(original);\n  }) as any;\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @summary Represents a failure in observer communication\n *\n * @param {string} msg the error message\n *\n * @class ObserverError\n * @extends BaseError\n */\nexport class ObserverError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ObserverError.name, msg, 500);\n  }\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Constructor, sf } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\nexport function generateInjectableNameForRepository<T extends Model>(\n  model: Constructor<T> | T,\n  flavour?: string\n) {\n  if (!flavour) {\n    const key = Adapter.key(PersistenceKeys.ADAPTER);\n    flavour = Reflect.getMetadata(\n      key,\n      model instanceof Model ? model.constructor : model\n    );\n    if (!flavour)\n      throw new InternalError(\n        `Could not retrieve flavour from model ${model instanceof Model ? model.constructor.name : model.name}`\n      );\n  }\n  return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));\n}\n","import {\n  InjectableRegistryImp,\n  Injectables,\n} from \"@decaf-ts/injectable-decorators\";\nimport { Repository } from \"./Repository\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { generateInjectableNameForRepository } from \"./utils\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Adapter } from \"../persistence/Adapter\";\n\nexport class InjectablesRegistry extends InjectableRegistryImp {\n  constructor() {\n    super();\n  }\n\n  override get<T>(name: string): T | undefined {\n    let injectable = super.get(name);\n    if (!injectable)\n      try {\n        const m = Model.get(name);\n        if (m) injectable = Repository.forModel(m);\n        if (injectable) {\n          if (injectable instanceof Repository) return injectable as T;\n          const flavour =\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              injectable.constructor\n            ) ||\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              m as ModelConstructor<any>\n            );\n          Injectables.register(\n            injectable,\n            generateInjectableNameForRepository(\n              m as ModelConstructor<any>,\n              flavour\n            )\n          );\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        return undefined;\n      }\n    return injectable as T | undefined;\n  }\n}\n","export interface SequenceOptions {\n  name?: string;\n  type: \"Number\" | \"BigInt\" | undefined;\n  startWith: number;\n  incrementBy: number;\n  minValue?: number;\n  maxValue?: number;\n  cycle: boolean;\n}\n\nexport const DefaultSequenceOptions: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\nexport const NumericSequence: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\nexport const BigIntSequence: SequenceOptions = {\n  type: \"BigInt\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n","export enum Operator {\n  EQUAL = \"EQUAL\",\n  DIFFERENT = \"DIFFERENT\",\n  BIGGER = \"BIGGER\",\n  BIGGER_EQ = \"BIGGER_EQ\",\n  SMALLER = \"SMALLER\",\n  SMALLER_EQ = \"SMALLER_EQ\",\n  // BETWEEN = \"BETWEEN\",\n  NOT = \"NOT\",\n  IN = \"IN\",\n  // IS = \"IS\",\n  REGEXP = \"REGEXP\",\n}\n\nexport enum GroupOperator {\n  AND = \"AND\",\n  OR = \"OR\",\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\nexport class QueryError extends BaseError {\n  constructor(msg: string | Error) {\n    super(QueryError.name, msg, 500);\n  }\n}\n\nexport class PagingError extends BaseError {\n  constructor(msg: string | Error) {\n    super(PagingError.name, msg, 500);\n  }\n}\n","import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @summary Condition Class\n * @description Represents a logical condition\n *\n * @param {string | Condition} attr1\n * @param {Operator | GroupOperator} operator\n * @param {string | Condition} comparison\n *\n * @class Condition\n */\nexport class Condition<M extends Model> extends Model {\n  @required()\n  protected attr1?: string | Condition<M> = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition<M>,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition\n   */\n  and(condition: Condition<M>): Condition<M> {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition\n   */\n  or(condition: Condition<M>): Condition<M> {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @summary excludes a valut from the result\n   * @param val\n   */\n  not(val: any): Condition<M> {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  override hasErrors(\n    ...exceptions: string[]\n  ): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    const invalidOpMessage = `Invalid operator ${this.operator}}`;\n\n    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#AND} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static and<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @summary Joins 2 {@link Condition}s on an {@link Operator#OR} operation\n   * @param {Condition} condition1\n   * @param {Condition} condition2\n   */\n  static or<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @summary Groups 2 {@link Condition}s by the specified {@link GroupOperator}\n   * @param {Condition} condition1\n   * @param {GroupOperator} operator\n   * @param {Condition} condition2\n   */\n  private static group<M extends Model>(\n    condition1: Condition<M>,\n    operator: GroupOperator,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  static attribute<M extends Model>(attr: keyof M) {\n    return new Condition.Builder<M>().attribute(attr);\n  }\n\n  static attr<M extends Model>(attr: keyof M) {\n    return this.attribute(attr);\n  }\n\n  /**\n   * @summary Condition Builder Class\n   * @description provides a simple API to build {@link Condition}s\n   *\n   * @class ConditionBuilder\n   * @implements Builder\n   * @implements AttributeOption\n   *\n   * @category Query\n   * @subcategory Conditions\n   */\n  private static Builder = class ConditionBuilder<M extends Model>\n    implements ConditionBuilderOption<M>, AttributeOption<M>\n  {\n    attr1?: keyof M | Condition<M> = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @inheritDoc\n     */\n    attribute(attr: keyof M): AttributeOption<M> {\n      this.attr1 = attr;\n      return this;\n    }\n\n    attr(attr: keyof M) {\n      return this.attribute(attr);\n    }\n\n    /**\n     * @summary Creates an Equality Comparison\n     * @param {any} val\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @summary Creates a Different Comparison\n     * @param {any} val\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @summary Creates a Greater Than Comparison\n     * @param {any} val\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @summary Creates a Lower Than Comparison\n     * @param {any} val\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @summary Creates a Greater or Equal to Comparison\n     * @param {any} val\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @summary Creates a Lower or Equal to Comparison\n     * @param {any} val\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @summary Creates a Regexpo Comparison\n     * @param {any} val\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @summary Creates an {@link Operator} based Comparison\n     * @param {Operator} op\n     * @param {any} val\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @summary Builds the Database Object\n     * @throws {QueryError} if it fails to build the {@link Condition}\n     * @private\n     */\n    private build(): Condition<M> {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition<M>,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  static builder<M extends Model>(): ConditionBuilderOption<M> {\n    return new Condition.Builder<M>();\n  }\n}\n","import {\n  Constructor,\n  Model,\n  ModelConstructor,\n  Validation,\n  ValidationKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Cascade } from \"../repository/constants\";\nimport { Context } from \"@decaf-ts/db-decorators\";\n\nexport async function createOrUpdate<\n  M extends Model,\n  F extends RepositoryFlags,\n>(\n  model: M,\n  context: Context<F>,\n  repository?: Repo<M, F, Context<F>>\n): Promise<M> {\n  if (!repository) {\n    const constructor = Model.get(model.constructor.name);\n    if (!constructor)\n      throw new InternalError(`Could not find model ${model.constructor.name}`);\n    repository = Repository.forModel<M, Repo<M>>(\n      constructor as unknown as ModelConstructor<M>\n    );\n  }\n  if (typeof model[repository.pk] === \"undefined\")\n    return repository.create(model, context);\n  else {\n    try {\n      return repository.update(model, context);\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      return repository.create(model, context);\n    }\n  }\n}\n\nexport async function oneToOneOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  const constructor = Model.get(data.class);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor);\n  const created = await repo.create(propertyValue);\n  const pk = findPrimaryKey(created).id;\n  await cacheModelForPopulate(context, model, key, created[pk], created);\n  (model as any)[key] = created[pk];\n}\n\nexport async function oneToOneOnUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  const updated = await createOrUpdate(model[key] as M, context);\n  const pk = findPrimaryKey(updated).id;\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    updated[pk] as string,\n    updated\n  );\n  model[key] = updated[pk];\n}\n\nexport async function oneToOneOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n  const innerRepo: Repo<M> = repositoryFromTypeMetadata(model, key);\n  let deleted: M;\n  if (!(propertyValue instanceof Model))\n    deleted = await innerRepo.delete(model[key] as string, context);\n  else\n    deleted = await innerRepo.delete(\n      (model[key] as M)[innerRepo.pk as keyof M] as string,\n      context\n    );\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    deleted[innerRepo.pk] as string,\n    deleted\n  );\n}\n\nexport async function oneToManyOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValues: any = model[key];\n  if (!propertyValues || !propertyValues.length) return;\n  const arrayType = typeof propertyValues[0];\n  if (!propertyValues.every((item: any) => typeof item === arrayType))\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const uniqueValues = new Set([...propertyValues]);\n  if (arrayType !== \"object\") {\n    const repo = repositoryFromTypeMetadata(model, key);\n    for (const id of uniqueValues) {\n      const read = await repo.read(id);\n      await cacheModelForPopulate(context, model, key, id, read);\n    }\n    (model as any)[key] = [...uniqueValues];\n    return;\n  }\n\n  const pkName = findPrimaryKey(propertyValues[0]).id;\n\n  const result: Set<string> = new Set();\n\n  for (const m of propertyValues) {\n    const record = await createOrUpdate(m, context);\n    await cacheModelForPopulate(context, model, key, record[pkName], record);\n    result.add(record[pkName]);\n  }\n\n  (model as any)[key] = [...result];\n}\n\nexport async function oneToManyOnUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { cascade } = data;\n  if (cascade.update !== Cascade.CASCADE) return;\n  return oneToManyOnCreate.apply(this as any, [\n    context,\n    data,\n    key as keyof Model,\n    model,\n  ]);\n}\n\nexport async function oneToManyOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (data.cascade.delete !== Cascade.CASCADE) return;\n  const values = model[key] as any;\n  if (!values || !values.length) return;\n  const arrayType = typeof values[0];\n  const areAllSameType = values.every((item: any) => typeof item === arrayType);\n  if (!areAllSameType)\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const isInstantiated = arrayType === \"object\";\n  const repo = isInstantiated\n    ? Repository.forModel(values[0])\n    : repositoryFromTypeMetadata(model, key);\n\n  const uniqueValues = new Set([\n    ...(isInstantiated\n      ? values.map((v: Record<string, any>) => v[repo.pk as string])\n      : values),\n  ]);\n\n  for (const id of uniqueValues.values()) {\n    const deleted = await repo.delete(id, context);\n    await cacheModelForPopulate(context, model, key, id, deleted);\n  }\n  (model as any)[key] = [...uniqueValues];\n}\n\nexport function getPopulateKey(\n  tableName: string,\n  fieldName: string,\n  id: string | number\n) {\n  return [PersistenceKeys.POPULATE, tableName, fieldName, id].join(\".\");\n}\n\nexport async function cacheModelForPopulate<\n  M extends Model,\n  F extends RepositoryFlags,\n>(\n  context: Context<F>,\n  parentModel: M,\n  propertyKey: keyof M | string,\n  pkValue: string | number,\n  cacheValue: any\n) {\n  const cacheKey = getPopulateKey(\n    parentModel.constructor.name,\n    propertyKey as string,\n    pkValue\n  );\n  return context.accumulate({ [cacheKey]: cacheValue });\n}\n\nexport async function populate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.populate) return;\n  const nested: any = model[key];\n  const isArr = Array.isArray(nested);\n  if (typeof nested === \"undefined\" || (isArr && nested.length === 0)) return;\n\n  async function fetchPopulateValues(\n    c: Context<F>,\n    model: M,\n    propName: string,\n    propKeyValues: any[]\n  ) {\n    let cacheKey: string;\n    let val: any;\n    const results: M[] = [];\n    for (const proKeyValue of propKeyValues) {\n      cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);\n      try {\n        val = await c.get(cacheKey as any);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        const repo = repositoryFromTypeMetadata(model, propName);\n        if (!repo) throw new InternalError(\"Could not find repo\");\n        val = await repo.read(proKeyValue);\n      }\n      results.push(val);\n    }\n    return results;\n  }\n  const res = await fetchPopulateValues(\n    context,\n    model,\n    key as string,\n    isArr ? nested : [nested]\n  );\n  (model as any)[key] = isArr ? res : res[0];\n}\n\nconst commomTypes = [\n  \"array\",\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"symbol\",\n  \"function\",\n  \"object\",\n  \"undefined\",\n  \"null\",\n  \"bigint\",\n];\n\nexport function repositoryFromTypeMetadata<M extends Model>(\n  model: any,\n  propertyKey: string | keyof M\n): Repo<M> {\n  const types = Reflect.getMetadata(\n    Validation.key(\n      Array.isArray(model[propertyKey])\n        ? ValidationKeys.LIST\n        : ValidationKeys.TYPE\n    ),\n    model,\n    propertyKey as string\n  );\n  const customTypes: any = Array.isArray(model[propertyKey])\n    ? types.clazz\n    : types.customTypes;\n  if (!types || !customTypes)\n    throw new InternalError(\n      `Failed to find types decorators for property ${propertyKey as string}`\n    );\n\n  const allowedTypes: string[] = Array.isArray(customTypes)\n    ? [...customTypes]\n    : [customTypes];\n  const constructorName = allowedTypes.find(\n    (t) => !commomTypes.includes(`${t}`.toLowerCase())\n  );\n  if (!constructorName)\n    throw new InternalError(\n      `Property key ${propertyKey as string} does not have a valid constructor type`\n    );\n  const constructor: Constructor<M> | undefined = Model.get(constructorName);\n  if (!constructor)\n    throw new InternalError(`No registered model found for ${constructorName}`);\n\n  return Repository.forModel(constructor);\n}\n","import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n} from \"@decaf-ts/db-decorators\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { CascadeMetadata, IndexMetadata } from \"../repository/types\";\nimport { DefaultCascade, OrderDirection } from \"../repository/constants\";\nimport {\n  Constructor,\n  Decoration,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { Condition } from \"../query/Condition\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToManyOnUpdate,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./construction\";\nimport { AuthorizationError } from \"../utils\";\n\nexport function table(tableName: string) {\n  return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);\n}\n\nexport function column(columnName: string) {\n  return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);\n}\n\n/**\n * @summary Index Decorator\n * @description properties decorated will the index in the\n * DB for performance in queries\n *\n * @param {OrderDirection[]} [directions]\n * @param {string[]} [compositions]\n *\n * @function index\n */\nexport function index(directions?: OrderDirection[], compositions?: string[]) {\n  return propMetadata(\n    Repository.key(\n      `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n    ),\n    {\n      directions: directions,\n      compositions: compositions,\n    } as IndexMetadata\n  );\n}\n\nexport async function uniqueOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends object,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!(model as any)[key]) return;\n  const existing = await this.select()\n    .where(Condition.attribute(key).eq(model[key]))\n    .execute();\n  if (existing.length)\n    throw new ConflictError(\n      `model already exists with property ${key as string} equal to ${JSON.stringify((model as any)[key], undefined, 2)}`\n    );\n}\n\n/**\n * @summary Unique Decorator\n * @description Tags a property as unique.\n *  No other elements in that table can have the same property value\n *\n * @function unique\n *\n */\nexport function unique() {\n  return apply(\n    onCreateUpdate(uniqueOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.UNIQUE), {})\n  );\n}\n\nexport async function createdByOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  context: Context<F>,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  data: V,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  throw new AuthorizationError(\n    \"This adapter does not support user identification\"\n  );\n}\n\nexport function createdBy() {\n  const key = Repository.key(PersistenceKeys.CREATED_BY);\n  return Decoration.for(key)\n    .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\nexport function updatedBy() {\n  const key = Repository.key(PersistenceKeys.UPDATED_BY);\n  return Decoration.for(key)\n    .define(onCreateUpdate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @summary One To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence}\n * @param {CascadeMetadata} [cascadeOptions]\n * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database\n *\n * @function oneToOne\n *\n *\n * @see oneToMany\n * @see manyToOne\n */\nexport function oneToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      onCreate(oneToOneOnCreate, metadata),\n      onUpdate(oneToOneOnUpdate, metadata),\n      onDelete(oneToOneOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @summary One To Many relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use.\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function oneToMany\n *\n * @see oneToOne\n * @see manyToOne\n */\nexport function oneToMany<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      // @ts-expect-error purposeful override\n      list([clazz, String, Number, BigInt]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @summary Many To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function manyToOne\n *\n * @see oneToMany\n * @see oneToOne\n */\nexport function manyToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n","import {\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  InternalError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\n\nexport async function pkOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends SequenceOptions,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @summary Primary Key Decorator\n * @description Marks the property as the {@link Model}s primary key.\n *  Also marks the property as {@link unique} as {@required} and ensures the index is created properly according to the provided {@link Sequence}\n *\n * @function pk\n *\n * @see unique\n * @see required\n * @see on\n */\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts) as SequenceOptions;\n  const key = Repository.key(DBKeys.ID);\n  return Decoration.for(key)\n    .define(\n      index([OrderDirection.ASC, OrderDirection.DSC]),\n      required(),\n      readonly(),\n      // type([String.name, Number.name, BigInt.name]),\n      propMetadata(key, opts as SequenceOptions),\n      onCreate(pkOnCreate, opts as SequenceOptions)\n    )\n    .apply();\n}\n","import { DBOperations, timestamp } from \"@decaf-ts/db-decorators\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\n\nexport abstract class BaseModel extends Model {\n  @timestamp(DBOperations.CREATE)\n  createdOn!: Date;\n  @timestamp()\n  updatedOn!: Date;\n\n  protected constructor(arg?: ModelArg<BaseModel>) {\n    super(arg);\n  }\n}\n","import { PagingError } from \"./errors\";\nimport { Adapter } from \"../persistence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\n\nexport abstract class Paginator<M extends Model, R = M[], Q = any> {\n  protected _currentPage!: number;\n  protected _totalPages!: number;\n  protected _recordCount!: number;\n  protected limit!: number;\n\n  private _statement?: Q;\n\n  get current() {\n    return this._currentPage;\n  }\n\n  get total() {\n    return this._totalPages;\n  }\n\n  get count(): number {\n    return this._recordCount;\n  }\n\n  protected get statement() {\n    if (!this._statement) this._statement = this.prepare(this.query);\n    return this._statement;\n  }\n\n  protected constructor(\n    protected readonly adapter: Adapter<any, Q, any, any>,\n    protected readonly query: Q,\n    readonly size: number,\n    protected readonly clazz: Constructor<M>\n  ) {}\n\n  protected abstract prepare(rawStatement: Q): Q;\n\n  async next() {\n    return this.page(this.current + 1);\n  }\n\n  async previous() {\n    return this.page(this.current - 1);\n  }\n\n  protected validatePage(page: number) {\n    if (page < 1 || !Number.isInteger(page))\n      throw new PagingError(\n        \"Page number cannot be under 1 and must be an integer\"\n      );\n    if (typeof this._totalPages !== \"undefined\" && page > this._totalPages)\n      throw new PagingError(\n        `Only ${this._totalPages} are available. Cannot go to page ${page}`\n      );\n    return page;\n  }\n\n  abstract page(page?: number): Promise<R[]>;\n}\n","import { type Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport type { Executor, RawExecutor } from \"../interfaces\";\nimport type {\n  FromSelector,\n  GroupBySelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Condition } from \"./Condition\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { final } from \"../utils/decorators\";\nimport type {\n  CountOption,\n  DistinctOption,\n  LimitOption,\n  MaxOption,\n  MinOption,\n  OffsetOption,\n  OrderAndGroupOption,\n  SelectOption,\n  WhereOption,\n} from \"./options\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\nimport { Paginator } from \"./Paginator\";\nimport { Adapter } from \"../persistence\";\nimport { QueryError } from \"./errors\";\n\nexport abstract class Statement<Q, M extends Model, R>\n  implements Executor<R>, RawExecutor<Q>, Paginatable<M, R, Q>\n{\n  protected readonly selectSelector?: SelectSelector<M>[];\n  protected distinctSelector?: SelectSelector<M>;\n  protected maxSelector?: SelectSelector<M>;\n  protected minSelector?: SelectSelector<M>;\n  protected countSelector?: SelectSelector<M>;\n  protected fromSelector!: Constructor<M>;\n  protected whereCondition?: Condition<M>;\n  protected orderBySelector?: OrderBySelector<M>;\n  protected groupBySelector?: GroupBySelector<M>;\n  protected limitSelector?: number;\n  protected offsetSelector?: number;\n\n  protected constructor(protected adapter: Adapter<any, Q, any, any>) {}\n\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): SelectOption<M, M[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): SelectOption<M, Pick<M, S[number]>[]>;\n\n  @final()\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]> {\n    Object.defineProperty(this, \"selectSelector\", {\n      value: selector,\n      writable: false,\n    });\n    return this as SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]>;\n  }\n\n  @final()\n  distinct<S extends SelectSelector<M>>(\n    selector: S\n  ): DistinctOption<M, M[S][]> {\n    this.distinctSelector = selector;\n    return this as DistinctOption<M, M[S][]>;\n  }\n\n  @final()\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]> {\n    this.maxSelector = selector;\n    return this as MaxOption<M, M[S]>;\n  }\n\n  @final()\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]> {\n    this.minSelector = selector;\n    return this as MinOption<M, M[S]>;\n  }\n\n  @final()\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number> {\n    this.countSelector = selector;\n    return this as CountOption<M, number>;\n  }\n\n  @final()\n  public from(selector: FromSelector<M>): WhereOption<M, R> {\n    this.fromSelector = (\n      typeof selector === \"string\" ? Model.get(selector) : selector\n    ) as Constructor<M>;\n    if (!this.fromSelector)\n      throw new QueryError(`Could not find selector model: ${selector}`);\n    return this;\n  }\n\n  @final()\n  public where(condition: Condition<M>): OrderAndGroupOption<M, R> {\n    this.whereCondition = condition;\n    return this;\n  }\n\n  @final()\n  public orderBy(\n    selector: OrderBySelector<M>\n  ): LimitOption<M, R> & OffsetOption<R> {\n    this.orderBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public groupBy(selector: GroupBySelector<M>): LimitOption<M, R> {\n    this.groupBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public limit(value: number): OffsetOption<R> {\n    this.limitSelector = value;\n    return this;\n  }\n\n  @final()\n  public offset(value: number): Executor<R> {\n    this.offsetSelector = value;\n    return this;\n  }\n\n  @final()\n  async execute(): Promise<R> {\n    try {\n      const query: Q = this.build();\n      return (await this.raw(query)) as R;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  async raw<R>(rawInput: Q): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput);\n    if (!this.selectSelector) return results;\n    const pkAttr = findPrimaryKey(\n      new (this.fromSelector as Constructor<M>)()\n    ).id;\n\n    const processor = function recordProcessor(\n      this: Statement<Q, M, R>,\n      r: any\n    ) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.fromSelector as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this as any);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  protected abstract build(): Q;\n  protected abstract parseCondition(condition: Condition<M>): Q;\n  abstract paginate(size: number): Promise<Paginator<M, R, Q>>;\n}\n","import { InjectablesRegistry } from \"./repository\";\nimport { Injectables } from \"@decaf-ts/injectable-decorators\";\n\n// overrides the previous Injectables registry to enable the @repository decorator\nInjectables.setRegistry(new InjectablesRegistry());\n\nexport * from \"./identity\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./query\";\nexport * from \"./repository\";\nexport * from \"./utils\";\n//left to last on purpose\nexport * from \"./persistence\";\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:core\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["Rep","populate","pop"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.esm.cjs","sources":["../src/repository/constants.ts","../src/persistence/constants.ts","../src/utils/decorators.ts","../src/utils/errors.ts","../src/persistence/errors.ts","../src/persistence/Dispatch.ts","../src/persistence/ObserverHandler.ts","../src/persistence/Adapter.ts","../src/identity/utils.ts","../src/persistence/Sequence.ts","../src/persistence/decorators.ts","../src/repository/Repository.ts","../src/repository/decorators.ts","../src/repository/errors.ts","../src/repository/utils.ts","../src/repository/injectables.ts","../src/interfaces/SequenceOptions.ts","../src/query/constants.ts","../src/query/errors.ts","../src/query/Condition.ts","../src/model/construction.ts","../src/model/decorators.ts","../src/identity/decorators.ts","../src/model/BaseModel.ts","../src/query/Paginator.ts","../src/query/Statement.ts","../src/index.ts"],"sourcesContent":["import { CascadeMetadata } from \"./types\";\n\n/**\n * @description Enumeration of possible sort directions.\n * @summary Defines the available sort directions for ordering query results.\n * @enum {string}\n * @readonly\n * @memberOf module:core\n */\nexport enum OrderDirection {\n  /** Ascending order (A to Z, 0 to 9) */\n  ASC = \"asc\",\n\n  /** Descending order (Z to A, 9 to 0) */\n  DSC = \"desc\",\n}\n\n/**\n * @description Enumeration of cascade operation types.\n * @summary Defines the available cascade behaviors for entity relationships.\n * @enum {string}\n * @readonly\n * @memberOf module:core\n */\nexport enum Cascade {\n  /** Perform cascade operation on related entities */\n  CASCADE = \"cascade\",\n  /** Do not perform cascade operation on related entities */\n  NONE = \"none\",\n}\n\n/**\n * @description Default cascade configuration for entity relationships.\n * @summary Provides the default cascade behavior where updates cascade but deletes do not.\n * @type {CascadeMetadata}\n * @const DefaultCascade\n * @memberOf module:core\n */\nexport const DefaultCascade: CascadeMetadata = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n};\n","/**\n * @description Persistence-related constant keys\n * @summary Enum containing string constants used throughout the persistence layer for metadata, relations, and other persistence-related operations\n * @enum {string}\n * @readonly\n * @memberOf module:core\n */\nexport enum PersistenceKeys {\n  /** @description Key for index metadata */\n  INDEX = \"index\",\n\n  /** @description Key for unique constraint metadata */\n  UNIQUE = \"unique\",\n\n  /** @description Key for adapter metadata */\n  ADAPTER = \"adapter\",\n\n  /** @description Template for injectable adapter names */\n  INJECTABLE = \"decaf_{0}_adapter_for_{1}\",\n\n  /** @description Key for table name metadata */\n  TABLE = \"table\",\n\n  /** @description Key for column name metadata */\n  COLUMN = \"column\",\n\n  /** @description Key for general metadata storage */\n  METADATA = \"__metadata\",\n\n  /** @description Key for relations metadata storage */\n  RELATIONS = \"__relations\",\n\n  /** @description Key for clause sequence metadata */\n  CLAUSE_SEQUENCE = \"clause-sequence\",\n\n  // Ownership\n  /** @description Key for created-by ownership metadata */\n  CREATED_BY = \"ownership.created-by\",\n\n  /** @description Key for updated-by ownership metadata */\n  UPDATED_BY = \"ownership.updated-by\",\n\n  // Relations\n  /** @description Key for one-to-one relation metadata */\n  ONE_TO_ONE = \"relations.one-to-one\",\n\n  /** @description Key for one-to-many relation metadata */\n  ONE_TO_MANY = \"relations.one-to-many\",\n\n  /** @description Key for many-to-one relation metadata */\n  MANY_TO_ONE = \"relations.many-to-one\",\n\n  /** @description Key for populate metadata */\n  POPULATE = \"populate\",\n}\n","/**\n * @description Creates a decorator that makes a method non-configurable\n * @summary This decorator prevents a method from being overridden by making it non-configurable.\n * It throws an error if used on anything other than a method.\n * @return {Function} A decorator function that can be applied to methods\n * @function final\n * @category Method Decorators\n */\nexport function final() {\n  return (\n    target: object,\n    propertyKey?: any,\n    descriptor?: PropertyDescriptor\n  ) => {\n    if (!descriptor)\n      throw new Error(\"final decorator can only be used on methods\");\n    if (descriptor?.configurable) {\n      descriptor.configurable = false;\n    }\n    return descriptor;\n  };\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when a user is not authorized to perform an action\n * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication\n * @param {string|Error} msg - The error message or Error object\n * @class AuthorizationError\n * @category Errors\n * @example\n * ```typescript\n * // Example of throwing an AuthorizationError\n * if (!user.isAuthenticated()) {\n *   throw new AuthorizationError('User not authenticated');\n * }\n * ```\n */\nexport class AuthorizationError extends BaseError {\n  constructor(msg: string | Error) {\n    super(AuthorizationError.name, msg, 401);\n  }\n}\n\n/**\n * @description Error thrown when a user is forbidden from accessing a resource\n * @summary This error is thrown when an authenticated user attempts to access a resource or perform an action they don't have permission for\n * @param {string|Error} msg - The error message or Error object\n * @return {void}\n * @class ForbiddenError\n * @category Errors\n * @example\n * ```typescript\n * // Example of throwing a ForbiddenError\n * if (!user.hasPermission('admin')) {\n *   throw new ForbiddenError('User does not have admin permissions');\n * }\n * ```\n */\nexport class ForbiddenError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ForbiddenError.name, msg, 403);\n  }\n}\n\n/**\n * @description Error thrown when a connection to a service fails\n * @summary This error is thrown when the application fails to establish a connection to a required service or resource\n * @param {string|Error} msg - The error message or Error object\n * @return {void}\n * @class ConnectionError\n * @category Errors\n * @example\n * ```typescript\n * // Example of throwing a ConnectionError\n * try {\n *   await database.connect();\n * } catch (error) {\n *   throw new ConnectionError('Failed to connect to database');\n * }\n * ```\n */\nexport class ConnectionError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ConnectionError.name, msg, 503);\n  }\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when an unsupported operation is attempted\n * @summary This error is thrown when an operation is requested that is not supported by the current\n * persistence adapter or configuration. It extends the BaseError class and sets a 500 status code.\n * @param {string|Error} msg - The error message or an Error object to wrap\n * @class UnsupportedError\n * @example\n * ```typescript\n * // Throwing an UnsupportedError\n * if (!adapter.supportsTransactions()) {\n *   throw new UnsupportedError('Transactions are not supported by this adapter');\n * }\n * \n * // Catching an UnsupportedError\n * try {\n *   await adapter.beginTransaction();\n * } catch (error) {\n *   if (error instanceof UnsupportedError) {\n *     console.error('Operation not supported:', error.message);\n *   }\n * }\n * ```\n */\nexport class UnsupportedError extends BaseError {\n  constructor(msg: string | Error) {\n    super(UnsupportedError.name, msg, 500);\n  }\n}\n","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","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","import {\n  BaseError,\n  DBKeys,\n  InternalError,\n  NotFoundError,\n  Context,\n  OperationKeys,\n  RepositoryFlags,\n  DefaultRepositoryFlags,\n  Contextual,\n  BulkCrudOperationKeys,\n  modelToTransient,\n} from \"@decaf-ts/db-decorators\";\nimport { type Observer } from \"../interfaces/Observer\";\nimport {\n  type Constructor,\n  Decoration,\n  DefaultFlavour,\n  Model,\n  ModelConstructor,\n  ModelRegistry,\n} from \"@decaf-ts/decorator-validation\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { RawExecutor } from \"../interfaces/RawExecutor\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Repository } from \"../repository/Repository\";\nimport { Sequence } from \"./Sequence\";\nimport { ErrorParser } from \"../interfaces\";\nimport { Statement } from \"../query/Statement\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { final } from \"../utils\";\nimport { Dispatch } from \"./Dispatch\";\nimport { type EventIds, type ObserverFilter } from \"./types\";\nimport { ObserverHandler } from \"./ObserverHandler\";\n\nDecoration.setFlavourResolver((obj: object) => {\n  try {\n    return (\n      Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : (obj as any)) ||\n      DefaultFlavour\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    return DefaultFlavour;\n  }\n});\n\n/**\n * @description Abstract base class for database adapters\n * @summary Provides the foundation for all database adapters in the persistence layer. This class\n * implements several interfaces to provide a consistent API for database operations, observer\n * pattern support, and error handling. It manages adapter registration, CRUD operations, and\n * observer notifications.\n * @template Y - The underlying database driver type\n * @template Q - The query object type used by the adapter\n * @template F - The repository flags type\n * @template C - The context type\n * @param {Y} _native - The underlying database driver instance\n * @param {string} flavour - The identifier for this adapter type\n * @param {string} [_alias] - Optional alternative name for this adapter\n * @class Adapter\n * @example\n * ```typescript\n * // Implementing a concrete adapter\n * class PostgresAdapter extends Adapter<pg.Client, pg.Query, PostgresFlags, PostgresContext> {\n *   constructor(client: pg.Client) {\n *     super(client, 'postgres');\n *   }\n *\n *   async initialize() {\n *     // Set up the adapter\n *     await this.native.connect();\n *   }\n *\n *   async create(tableName, id, model) {\n *     // Implementation for creating records\n *     const columns = Object.keys(model).join(', ');\n *     const values = Object.values(model);\n *     const placeholders = values.map((_, i) => `$${i+1}`).join(', ');\n *\n *     const query = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders}) RETURNING *`;\n *     const result = await this.native.query(query, values);\n *     return result.rows[0];\n *   }\n *\n *   // Other required method implementations...\n * }\n *\n * // Using the adapter\n * const pgClient = new pg.Client(connectionString);\n * const adapter = new PostgresAdapter(pgClient);\n * await adapter.initialize();\n *\n * // Set as the default adapter\n * Adapter.setCurrent('postgres');\n *\n * // Perform operations\n * const user = await adapter.create('users', 1, { name: 'John', email: 'john@example.com' });\n * ```\n * @mermaid\n * classDiagram\n *   class Adapter {\n *     +Y native\n *     +string flavour\n *     +string alias\n *     +create(tableName, id, model)\n *     +read(tableName, id)\n *     +update(tableName, id, model)\n *     +delete(tableName, id)\n *     +observe(observer, filter)\n *     +unObserve(observer)\n *     +static current\n *     +static get(flavour)\n *     +static setCurrent(flavour)\n *   }\n *\n *   class RawExecutor {\n *     +raw(query)\n *   }\n *\n *   class Observable {\n *     +observe(observer, filter)\n *     +unObserve(observer)\n *     +updateObservers(table, event, id)\n *   }\n *\n *   class Observer {\n *     +refresh(table, event, id)\n *   }\n *\n *   class ErrorParser {\n *     +parseError(err)\n *   }\n *\n *   Adapter --|> RawExecutor\n *   Adapter --|> Observable\n *   Adapter --|> Observer\n *   Adapter --|> ErrorParser\n */\nexport abstract class Adapter<\n    Y,\n    Q,\n    F extends RepositoryFlags,\n    C extends Context<F>,\n  >\n  implements RawExecutor<Q>, Contextual<F, C>, Observable, Observer, ErrorParser\n{\n  private static _current: Adapter<any, any, any, any>;\n  private static _cache: Record<string, Adapter<any, any, any, any>> = {};\n\n  private logger!: Logger;\n\n  protected dispatch?: Dispatch<Y>;\n\n  protected readonly observerHandler?: ObserverHandler;\n\n  /**\n   * @description Logger accessor\n   * @summary Gets or initializes the logger for this adapter instance\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 Gets the native database driver\n   * @summary Provides access to the underlying database driver instance\n   * @return {Y} The native database driver\n   */\n  get native() {\n    return this._native;\n  }\n\n  /**\n   * @description Gets the adapter's alias or flavor name\n   * @summary Returns the alias if set, otherwise returns the flavor name\n   * @return {string} The adapter's identifier\n   */\n  get alias() {\n    return this._alias || this.flavour;\n  }\n\n  /**\n   * @description Gets the repository constructor for this adapter\n   * @summary Returns the constructor for creating repositories that work with this adapter\n   * @template M - The model type\n   * @return {Constructor<Repository<M, Q, Adapter<Y, Q, F, C>, F, C>>} The repository constructor\n   */\n  repository<M extends Model>(): Constructor<\n    Repository<M, Q, Adapter<Y, Q, F, C>, F, C>\n  > {\n    return Repository;\n  }\n\n  /**\n   * @description Creates a new adapter instance\n   * @summary Initializes the adapter with the native driver and registers it in the adapter cache\n   */\n  protected constructor(\n    private readonly _native: Y,\n    readonly flavour: string,\n    private readonly _alias?: string\n  ) {\n    if (this.flavour in Adapter._cache)\n      throw new InternalError(\n        `${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} already registered`\n      );\n    Adapter._cache[this.alias] = this;\n    this.log.info(\n      `Created ${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : \"\"} persistence adapter`\n    );\n    if (!Adapter._current) {\n      this.log.verbose(`Defined ${this.alias} persistence adapter as current`);\n      Adapter._current = this;\n    }\n  }\n\n  /**\n   * @description Creates a new statement builder for a model\n   * @summary Returns a statement builder that can be used to construct queries for a specific model\n   * @template M - The model type\n   * @return {Statement} A statement builder for the model\n   */\n  abstract Statement<M extends Model>(): Statement<Q, M, any>;\n\n  /**\n   * @description Creates a new dispatch instance\n   * @summary Factory method that creates a dispatch instance for this adapter\n   * @return {Dispatch<Y>} A new dispatch instance\n   */\n  protected Dispatch(): Dispatch<Y> {\n    return new Dispatch();\n  }\n\n  /**\n   * @description Creates a new observer handler\n   * @summary Factory method that creates an observer handler for this adapter\n   * @return {ObserverHandler} A new observer handler instance\n   */\n  protected ObserverHandler() {\n    return new ObserverHandler();\n  }\n\n  /**\n   * @description Checks if an attribute name is reserved\n   * @summary Determines if a given attribute name is reserved and cannot be used as a column name\n   * @param {string} attr - The attribute name to check\n   * @return {boolean} True if the attribute is reserved, false otherwise\n   */\n  protected isReserved(attr: string) {\n    return !attr;\n  }\n\n  /**\n   * @description Parses a database error into a standardized error\n   * @summary Converts database-specific errors into standardized application errors\n   * @param {Error} err - The original database error\n   * @return {BaseError} A standardized error\n   */\n  abstract parseError(err: Error): BaseError;\n\n  /**\n   * @description Initializes the adapter\n   * @summary Performs any necessary setup for the adapter, such as establishing connections\n   * @param {...any[]} args - Initialization arguments\n   * @return {Promise<void>} A promise that resolves when initialization is complete\n   */\n  abstract initialize(...args: any[]): Promise<void>;\n\n  /**\n   * @description Creates a sequence generator\n   * @summary Factory method that creates a sequence generator for generating sequential values\n   * @param {SequenceOptions} options - Configuration options for the sequence\n   * @return {Promise<Sequence>} A promise that resolves to a new sequence instance\n   */\n  abstract Sequence(options: SequenceOptions): Promise<Sequence>;\n\n  /**\n   * @description Creates repository flags for an operation\n   * @summary Generates a set of flags that describe a database operation, combining default flags with overrides\n   * @template F - The Repository Flags type\n   * @template M - The model type\n   * @param {OperationKeys} operation - The type of operation being performed\n   * @param {Constructor<M>} model - The model constructor\n   * @param {Partial<F>} flags - Custom flag overrides\n   * @param {...any[]} args - Additional arguments\n   * @return {F} The complete set of flags\n   */\n  protected flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<F>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): F {\n    return Object.assign({}, DefaultRepositoryFlags, flags, {\n      affectedTables: Repository.table(model),\n      writeOperation: operation !== OperationKeys.READ,\n      timestamp: new Date(),\n      operation: operation,\n    }) as F;\n  }\n\n  /**\n   * @description The context constructor for this adapter\n   * @summary Reference to the context class constructor used by this adapter\n   */\n  protected Context = Context<F>;\n\n  /**\n   * @description Creates a context for a database operation\n   * @summary Generates a context object that describes a database operation, used for tracking and auditing\n   * @template F - The Repository flags type\n   * @template M - The model type\n   * @param {OperationKeys.CREATE|OperationKeys.READ|OperationKeys.UPDATE|OperationKeys.DELETE} operation - The type of operation\n   * @param {Partial<F>} overrides - Custom flag overrides\n   * @param {Constructor<M>} model - The model constructor\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<C>} A promise that resolves to the context object\n   */\n  @final()\n  async context<M extends Model>(\n    operation:\n      | OperationKeys.CREATE\n      | OperationKeys.READ\n      | OperationKeys.UPDATE\n      | OperationKeys.DELETE,\n    overrides: Partial<F>,\n    model: Constructor<M>,\n    ...args: any[]\n  ): Promise<C> {\n    this.log\n      .for(this.context)\n      .debug(\n        `Creating new context for ${operation} operation on ${model.name} model with flag overrides: ${JSON.stringify(overrides)}`\n      );\n    return new this.Context().accumulate(\n      this.flags(operation, model, overrides, ...args)\n    ) as unknown as C;\n  }\n\n  /**\n   * @description Prepares a model for persistence\n   * @summary Converts a model instance into a format suitable for database storage,\n   * handling column mapping and separating transient properties\n   * @template M - The model type\n   * @param {M} model - The model instance to prepare\n   * @param pk - The primary key property name\n   * @return The prepared data\n   */\n  prepare<M extends Model>(\n    model: M,\n    pk: keyof M\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const log = this.log.for(this.prepare);\n    log.silly(`Preparing model ${model.constructor.name} before persisting`);\n    const split = modelToTransient(model);\n    const result = Object.entries(split.model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        if (typeof val === \"undefined\") return accum;\n        const mappedProp = Repository.column(model, key);\n        if (this.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n    if ((model as any)[PersistenceKeys.METADATA]) {\n      log.silly(\n        `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    }\n\n    return {\n      record: result,\n      id: model[pk] as string,\n      transient: split.transient,\n    };\n  }\n\n  /**\n   * @description Converts database data back into a model instance\n   * @summary Reconstructs a model instance from database data, handling column mapping\n   * and reattaching transient properties\n   * @template M - The model type\n   * @param obj - The database record\n   * @param {string|Constructor<M>} clazz - The model class or name\n   * @param pk - The primary key property name\n   * @param {string|number|bigint} id - The primary key value\n   * @param [transient] - Transient properties to reattach\n   * @return {M} The reconstructed model instance\n   */\n  revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number | bigint,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    const ob: Record<string, any> = {};\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\n    const metadata = obj[PersistenceKeys.METADATA];\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      if (key === pk) return accum;\n      (accum as Record<string, any>)[key] = obj[Repository.column(accum, key)];\n      return accum;\n    }, m);\n\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    if (metadata) {\n      log.silly(\n        `Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    }\n\n    return result;\n  }\n\n  /**\n   * @description Creates a new record in the database\n   * @summary Inserts a new record with the given ID and data into the specified table\n   * @param {string} tableName - The name of the table to insert into\n   * @param {string|number} id - The identifier for the new record\n   * @param model - The data to insert\n   * @param {any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to the created record\n   */\n  abstract create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Creates multiple records in the database\n   * @summary Inserts multiple records with the given IDs and data into the specified table\n   * @param {string} tableName - The name of the table to insert into\n   * @param id - The identifiers for the new records\n   * @param model - The data to insert for each record\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to an array of created records\n   */\n  async createAll(\n    tableName: string,\n    id: (string | number)[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const log = this.log.for(this.createAll);\n    log.verbose(`Creating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(\n      id.map((i, count) => this.create(tableName, i, model[count], ...args))\n    );\n  }\n\n  /**\n   * @description Retrieves a record from the database\n   * @summary Fetches a record with the given ID from the specified table\n   * @param {string} tableName - The name of the table to read from\n   * @param {string|number|bigint} id - The identifier of the record to retrieve\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to the retrieved record\n   */\n  abstract read(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Retrieves multiple records from the database\n   * @summary Fetches multiple records with the given IDs from the specified table\n   * @param {string} tableName - The name of the table to read from\n   * @param id - The identifiers of the records to retrieve\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to an array of retrieved records\n   */\n  async readAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.readAll);\n    log.verbose(`Reading ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(id.map((i) => this.read(tableName, i, ...args)));\n  }\n\n  /**\n   * @description Updates a record in the database\n   * @summary Modifies an existing record with the given ID in the specified table\n   * @param {string} tableName - The name of the table to update\n   * @param {string|number} id - The identifier of the record to update\n   * @param  model - The new data for the record\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to the updated record\n   */\n  abstract update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Updates multiple records in the database\n   * @summary Modifies multiple existing records with the given IDs in the specified table\n   * @param {string} tableName - The name of the table to update\n   * @param {string[]|number[]} id - The identifiers of the records to update\n   * @param model - The new data for each record\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to an array of updated records\n   */\n  async updateAll(\n    tableName: string,\n    id: string[] | number[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n    const log = this.log.for(this.updateAll);\n    log.verbose(`Updating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(\n      id.map((i, count) => this.update(tableName, i, model[count], ...args))\n    );\n  }\n\n  /**\n   * @description Deletes a record from the database\n   * @summary Removes a record with the given ID from the specified table\n   * @param {string} tableName - The name of the table to delete from\n   * @param {string|number|bigint} id - The identifier of the record to delete\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to the deleted record\n   */\n  abstract delete(\n    tableName: string,\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<Record<string, any>>;\n\n  /**\n   * @description Deletes multiple records from the database\n   * @summary Removes multiple records with the given IDs from the specified table\n   * @param {string} tableName - The name of the table to delete from\n   * @param id - The identifiers of the records to delete\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return A promise that resolves to an array of deleted records\n   */\n  async deleteAll(\n    tableName: string,\n    id: (string | number | bigint)[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    const log = this.log.for(this.createAll);\n    log.verbose(`Deleting ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n    return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));\n  }\n\n  /**\n   * @description Executes a raw query against the database\n   * @summary Allows executing database-specific queries directly\n   * @template Q - The raw query type\n   * @template R - The return type of the query\n   * @param {Q} rawInput - The query to execute\n   * @param {...any[]} args - Additional arguments specific to the adapter implementation\n   * @return {Promise<R>} A promise that resolves to the query result\n   */\n  abstract raw<R>(rawInput: Q, ...args: any[]): Promise<R>;\n\n  /**\n   * @description Registers an observer for database events\n   * @summary Adds an observer to be notified about database changes. The observer can optionally\n   * provide a filter function to receive only specific events.\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  @final()\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    if (!this.observerHandler)\n      Object.defineProperty(this, \"observerHandler\", {\n        value: this.ObserverHandler(),\n        writable: false,\n      });\n    this.observerHandler!.observe(observer, filter);\n    this.log\n      .for(this.observe)\n      .verbose(`Registering new observer ${observer.toString()}`);\n    if (!this.dispatch) {\n      this.log.for(this.observe).info(`Creating dispatch for ${this.alias}`);\n      this.dispatch = this.Dispatch();\n      this.dispatch.observe(this);\n    }\n  }\n\n  /**\n   * @description Unregisters an observer\n   * @summary Removes a previously registered observer so it no longer receives database event notifications\n   * @param {Observer} observer - The observer to unregister\n   * @return {void}\n   */\n  @final()\n  unObserve(observer: Observer): void {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.observerHandler.unObserve(observer);\n    this.log\n      .for(this.unObserve)\n      .verbose(`Observer ${observer.toString()} removed`);\n  }\n\n  /**\n   * @description Notifies all observers about a database event\n   * @summary Sends notifications to all registered observers about a change in the database,\n   * filtering based on each observer's filter function\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   * @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   */\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    const log = this.log.for(this.updateObservers);\n    log.verbose(\n      `Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`\n    );\n    await this.observerHandler.updateObservers(\n      this.log,\n      table,\n      event,\n      id,\n      ...args\n    );\n  }\n\n  /**\n   * @description Refreshes data based on a database event\n   * @summary Implementation of the Observer interface method that delegates to updateObservers\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   * @param {...any[]} args - Additional arguments related to the event\n   * @return {Promise<void>} A promise that resolves when the refresh is complete\n   */\n  async refresh(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ) {\n    return this.updateObservers(table, event, id, ...args);\n  }\n\n  /**\n   * @description Gets a string representation of the adapter\n   * @summary Returns a human-readable string identifying this adapter\n   * @return {string} A string representation of the adapter\n   */\n  toString() {\n    return `${this.flavour} persistence Adapter`;\n  }\n\n  /**\n   * @description Gets the adapter flavor associated with a model\n   * @summary Retrieves the adapter flavor that should be used for a specific model class\n   * @template M - The model type\n   * @param {Constructor<M>} model - The model constructor\n   * @return {string} The adapter flavor name\n   */\n  static flavourOf<M extends Model>(model: Constructor<M>): string {\n    return (\n      Reflect.getMetadata(this.key(PersistenceKeys.ADAPTER), model) ||\n      this.current.flavour\n    );\n  }\n\n  /**\n   * @description Gets the current default adapter\n   * @summary Retrieves the adapter that is currently set as the default for operations\n   * @return {Adapter<any, any, any, any>} The current adapter\n   */\n  static get current() {\n    if (!Adapter._current)\n      throw new InternalError(\n        `No persistence flavour set. Please initialize your adapter`\n      );\n    return Adapter._current;\n  }\n\n  /**\n   * @description Gets an adapter by flavor\n   * @summary Retrieves a registered adapter by its flavor name\n   * @template Y - The database driver type\n   * @template Q - The query type\n   * @template C - The context type\n   * @template F - The repository flags type\n   * @param {string} flavour - The flavor name of the adapter to retrieve\n   * @return {Adapter<Y, Q, F, C> | undefined} The adapter instance or undefined if not found\n   */\n  static get<Y, Q, C extends Context<F>, F extends RepositoryFlags>(\n    flavour: any\n  ): Adapter<Y, Q, F, C> | undefined {\n    if (flavour in this._cache) return this._cache[flavour];\n    throw new InternalError(`No Adapter registered under ${flavour}.`);\n  }\n\n  /**\n   * @description Sets the current default adapter\n   * @summary Changes which adapter is used as the default for operations\n   * @param {string} flavour - The flavor name of the adapter to set as current\n   * @return {void}\n   */\n  static setCurrent(flavour: string) {\n    const adapter = Adapter.get(flavour);\n    if (!adapter)\n      throw new NotFoundError(`No persistence flavour ${flavour} registered`);\n    this._current = adapter;\n  }\n\n  /**\n   * @description Creates a metadata key\n   * @summary Generates a standardized metadata key for persistence-related metadata\n   * @param {string} key - The base key name\n   * @return {string} The formatted metadata key\n   */\n  static key(key: string) {\n    return Repository.key(key);\n  }\n\n  /**\n   * @description Gets all models associated with an adapter flavor\n   * @summary Retrieves all model constructors that are configured to use a specific adapter flavor\n   * @template M - The model type\n   * @param {string} flavour - The adapter flavor to find models for\n   * @return An array of model constructors\n   */\n  static models<M extends Model>(flavour: string) {\n    try {\n      const registry = (Model as any).getRegistry() as ModelRegistry<any>;\n      const cache = (\n        registry as unknown as { cache: Record<string, ModelConstructor<any>> }\n      ).cache;\n      const managedModels: ModelConstructor<any>[] = Object.values(cache)\n        .map((m: ModelConstructor<M>) => {\n          let f = Reflect.getMetadata(\n            Adapter.key(PersistenceKeys.ADAPTER),\n            m as ModelConstructor<any>\n          );\n          if (f && f === flavour) return m;\n          if (!f) {\n            const repo = Reflect.getMetadata(\n              Repository.key(DBKeys.REPOSITORY),\n              m as ModelConstructor<any>\n            );\n            if (!repo) return;\n            const repository = Repository.forModel(m);\n\n            f = Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              repository\n            );\n            return f;\n          }\n        })\n        .filter((m) => !!m);\n      return managedModels;\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n}\n","import { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\n\n/**\n * @description Gets the table name for a model\n * @summary Retrieves the table name associated with a model by checking metadata or falling back to the constructor name\n * @template M - Type that extends Model\n * @param {M | Constructor<M>} model - The model instance or constructor to get the table name for\n * @return {string} The table name for the model\n * @function getTableName\n * @memberOf module:core\n */\nexport function getTableName<M extends Model>(\n  model: M | Constructor<M>\n): string {\n  const obj = model instanceof Model ? model.constructor : model;\n\n  const metadata = Reflect.getOwnMetadata(\n    Adapter.key(PersistenceKeys.TABLE),\n    obj\n  );\n  if (metadata) {\n    return metadata;\n  }\n  if (model instanceof Model) {\n    return model.constructor.name;\n  }\n  return model.name;\n}\n\n/**\n * @description Generates a sequence name for a model\n * @summary Creates a standardized sequence name by combining the table name with additional arguments\n * @template M - Type that extends Model\n * @param {M | Constructor<M>} model - The model instance or constructor to generate the sequence name for\n * @param {...string} args - Additional string arguments to append to the sequence name\n * @return {string} The generated sequence name\n * @function sequenceNameForModel\n * @memberOf module:core\n */\nexport function sequenceNameForModel<M extends Model>(\n  model: M | Constructor<M>,\n  ...args: string[]\n) {\n  return [getTableName(model), ...args].join(\"_\");\n}\n","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","import { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"./constants\";\nimport { Adapter } from \"./Adapter\";\n\n/**\n * @description Specifies which persistence adapter flavor a model should use\n * @summary This decorator applies metadata to a model class to indicate which persistence adapter flavor\n * should be used when performing database operations on instances of the model. The flavor is a string\n * identifier that corresponds to a registered adapter configuration.\n * @param {string} flavour - The identifier of the adapter flavor to use\n * @return {Function} A decorator function that can be applied to a model class\n * @function uses\n * @category Class Decorators\n */\nexport function uses(flavour: string) {\n  return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour));\n}\n","import {\n  BulkCrudOperationKeys,\n  Context,\n  DBKeys,\n  DefaultSeparator,\n  enforceDBDecorators,\n  findPrimaryKey,\n  InternalError,\n  IRepository,\n  OperationKeys,\n  Repository as Rep,\n  RepositoryFlags,\n  ValidationError,\n  wrapMethodWithContext,\n} from \"@decaf-ts/db-decorators\";\nimport { Observable } from \"../interfaces/Observable\";\nimport { type Observer } from \"../interfaces/Observer\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { OrderDirection } from \"./constants\";\nimport { SequenceOptions } from \"../interfaces/SequenceOptions\";\nimport { Queriable } from \"../interfaces/Queriable\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { IndexMetadata } from \"./types\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Condition } from \"../query/Condition\";\nimport { WhereOption } from \"../query/options\";\nimport { OrderBySelector, SelectSelector } from \"../query/selectors\";\nimport { getTableName } from \"../identity/utils\";\nimport { uses } from \"../persistence/decorators\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { ObserverHandler } from \"../persistence/ObserverHandler\";\nimport { final } from \"../utils\";\nimport type { EventIds, ObserverFilter } from \"../persistence\";\n\n/**\n * @description Type alias for Repository class with simplified generic parameters.\n * @summary Provides a more concise way to reference the Repository class with its generic parameters.\n * @template M - The model type that extends Model.\n * @template F - The repository flags type.\n * @template C - The context type.\n * @template Q - The query type.\n * @template A - The adapter type.\n * @typedef Repo\n * @memberOf module:core\n */\nexport type Repo<\n  M extends Model,\n  F extends RepositoryFlags = any,\n  C extends Context<F> = any,\n  Q = any,\n  A extends Adapter<any, Q, F, C> = any,\n> = Repository<M, Q, A, F, C>;\n\n/**\n * @description Core repository implementation for database operations on models on a table by table way.\n * @summary Provides CRUD operations, querying capabilities, and observer pattern implementation for model persistence.\n * @template M - The model type that extends Model.\n * @template Q - The query type used by the adapter.\n * @template A - The adapter type for database operations.\n * @template F - The repository flags type.\n * @template C - The context type for operations.\n * @param {A} [adapter] - Optional adapter instance for database operations.\n * @param {Constructor<M>} [clazz] - Optional constructor for the model class.\n * @param {...any[]} [args] - Additional arguments for repository initialization.\n * @class Repository\n * @example\n * // Creating a repository for User model\n * const userRepo = Repository.forModel(User);\n *\n * // Using the repository for CRUD operations\n * const user = await userRepo.create(new User({ name: 'John' }));\n * const retrievedUser = await userRepo.read(user.id);\n * user.name = 'Jane';\n * await userRepo.update(user);\n * await userRepo.delete(user.id);\n *\n * // Querying with conditions\n * const users = await userRepo\n *   .select()\n *   .where({ name: 'Jane' })\n *   .orderBy('createdAt', OrderDirection.DSC)\n *   .limit(10)\n *   .execute();\n * @mermaid\n * sequenceDiagram\n *   participant C as Client Code\n *   participant R as Repository\n *   participant A as Adapter\n *   participant DB as Database\n *   participant O as Observers\n *\n *   C->>+R: create(model)\n *   R->>R: createPrefix(model)\n *   R->>+A: prepare(model)\n *   A-->>-R: prepared data\n *   R->>+A: create(table, id, record)\n *   A->>+DB: Insert Operation\n *   DB-->>-A: Result\n *   A-->>-R: record\n *   R->>+A: revert(record)\n *   A-->>-R: model instance\n *   R->>R: createSuffix(model)\n *   R->>+O: updateObservers(table, CREATE, id)\n *   O-->>-R: Notification complete\n *   R-->>-C: created model\n */\nexport class Repository<\n    M extends Model,\n    Q,\n    A extends Adapter<any, Q, F, C>,\n    F extends RepositoryFlags = RepositoryFlags,\n    C extends Context<F> = Context<F>,\n  >\n  extends Rep<M, F, C>\n  implements Observable, Observer, Queriable<M>, IRepository<M, F, C>\n{\n  private static _cache: Record<\n    string,\n    Constructor<Repo<Model>> | Repo<Model>\n  > = {};\n\n  protected observers: Observer[] = [];\n\n  protected observerHandler?: ObserverHandler;\n\n  private readonly _adapter!: A;\n  private _tableName!: string;\n  private _overrides?: Partial<F>;\n\n  private logger!: Logger;\n\n  /**\n   * @description Logger instance for this repository.\n   * @summary Provides access to the logger for this repository instance.\n   * @return {Logger} The logger instance.\n   */\n  get log(): Logger {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  /**\n   * @description Adapter for database operations.\n   * @summary Provides access to the adapter instance for this repository.\n   * @template A - The adapter type.\n   * @return {A} The adapter instance.\n   * @throws {InternalError} If no adapter is found.\n   */\n  protected get adapter(): A {\n    if (!this._adapter)\n      throw new InternalError(\n        `No adapter found for this repository. did you use the @uses decorator or pass it in the constructor?`\n      );\n    return this._adapter;\n  }\n\n  /**\n   * @description Table name for this repository's model.\n   * @summary Gets the database table name associated with this repository's model.\n   * @return {string} The table name.\n   */\n  protected get tableName(): string {\n    if (!this._tableName) this._tableName = Repository.table(this.class);\n    return this._tableName;\n  }\n\n  /**\n   * @description Primary key properties for this repository's model.\n   * @summary Gets the sequence options containing primary key information.\n   * @return {SequenceOptions} The primary key properties.\n   */\n  protected override get pkProps(): SequenceOptions {\n    return super.pkProps;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  constructor(adapter?: A, clazz?: Constructor<M>, ...args: any[]) {\n    super(clazz);\n    if (adapter) this._adapter = adapter;\n    if (clazz) {\n      Repository.register(clazz, this, this.adapter.alias);\n      if (adapter) {\n        const flavour = Reflect.getMetadata(\n          Adapter.key(PersistenceKeys.ADAPTER),\n          clazz\n        );\n        if (flavour && flavour !== adapter.flavour)\n          throw new InternalError(\"Incompatible flavours\");\n        uses(adapter.flavour)(clazz);\n      }\n    }\n    [this.createAll, this.readAll, this.updateAll, this.deleteAll].forEach(\n      (m) => {\n        const name = m.name;\n        wrapMethodWithContext(\n          this,\n          (this as any)[name + \"Prefix\"],\n          m,\n          (this as any)[name + \"Suffix\"]\n        );\n      }\n    );\n  }\n\n  /**\n   * @description Creates a proxy with overridden repository flags.\n   * @summary Returns a proxy of this repository with the specified flags overridden.\n   * @param {Partial<F>} flags - The flags to override.\n   * @return {Repository} A proxy of this repository with overridden flags.\n   */\n  override(flags: Partial<F>): Repository<M, Q, A, F, C> {\n    this.log\n      .for(this.override)\n      .debug(`Overriding repository flags with ${JSON.stringify(flags)}`);\n    return new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        const result = Reflect.get(target, p, receiver);\n        if (p !== \"_overrides\") return result;\n        return Object.assign({}, result, flags);\n      },\n    });\n  }\n\n  /**\n   * @description Creates a new observer handler.\n   * @summary Factory method for creating an observer handler instance.\n   * @return {ObserverHandler} A new observer handler instance.\n   */\n  protected ObserverHandler(): ObserverHandler {\n    return new ObserverHandler();\n  }\n\n  /**\n   * @description Prepares a model for creation.\n   * @summary Validates the model and prepares it for creation in the database.\n   * @template M - The model type.\n   * @param {M} model - The model to create.\n   * @param {...any[]} args - Additional arguments.\n   * @return The prepared model and context arguments.\n   * @throws {ValidationError} If the model fails validation.\n   */\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    model = new this.class(model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n\n    const errors = model.hasErrors(\n      ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n    );\n    if (errors) throw new ValidationError(errors.toString());\n\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Creates a model in the database.\n   * @summary Persists a model instance to the database.\n   * @param {M} model - The model to create.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The created model with updated properties.\n   */\n  async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    let c: C | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as C;\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  /**\n   * @description Post-creation hook.\n   * @summary Executes after a model is created to perform additional operations.\n   * @param {M} model - The created model.\n   * @param {C} context - The operation context.\n   * @return {Promise<M>} The processed model.\n   */\n  override async createSuffix(model: M, context: C): Promise<M> {\n    return super.createSuffix(model, context);\n  }\n\n  /**\n   * @description Creates multiple models in the database.\n   * @summary Persists multiple model instances to the database in a batch operation.\n   * @param {M[]} models - The models to create.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M[]>} The created models with updated properties.\n   */\n  override async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids as (string | number)[],\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  /**\n   * @description Prepares multiple models for creation.\n   * @summary Validates multiple models and prepares them for creation in the database.\n   * @param {M[]} models - The models to create.\n   * @param {...any[]} args - Additional arguments.\n   * @return The prepared models and context arguments.\n   * @throws {ValidationError} If any model fails validation.\n   */\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n    const opts = Repository.getSequenceOptions(models[0]);\n    let ids: (string | number | bigint | undefined)[] = [];\n    if (opts.type) {\n      if (!opts.name) opts.name = Sequence.pk(models[0]);\n      ids = await (await this.adapter.Sequence(opts)).range(models.length);\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        m[this.pk] = ids[i] as M[keyof M];\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) =>\n        m.hasErrors(\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares for reading a model by ID.\n   * @summary Prepares the context and enforces decorators before reading a model.\n   * @param {string} key - The primary key of the model to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return The key and context arguments.\n   */\n  protected override async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const model: M = new this.class();\n    model[this.pk] = key as M[keyof M];\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Reads a model from the database by ID.\n   * @summary Retrieves a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The retrieved model instance.\n   */\n  async read(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.read(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Prepares for reading multiple models by IDs.\n   * @summary Prepares the context and enforces decorators before reading multiple models.\n   * @param {string[]|number[]} keys - The primary keys of the models to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return The keys and context arguments.\n   */\n  protected override async readAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    await Promise.all(\n      keys.map(async (k) => {\n        const m = new this.class();\n        m[this.pk] = k as M[keyof M];\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  /**\n   * @description Reads multiple models from the database by IDs.\n   * @summary Retrieves multiple model instances from the database using their primary keys.\n   * @param {string[]|number[]} keys - The primary keys of the models to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M[]>} The retrieved model instances.\n   */\n  override async readAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const records = await this.adapter.readAll(this.tableName, keys, ...args);\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  /**\n   * @description Updates a model in the database.\n   * @summary Persists changes to an existing model instance in the database.\n   * @param {M} model - The model to update.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The updated model with refreshed properties.\n   */\n  async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    return this.adapter.revert<M>(record, this.class, this.pk, id, transient);\n  }\n\n  /**\n   * @description Prepares a model for update.\n   * @summary Validates the model and prepares it for update in the database.\n   * @param {M} model - The model to update.\n   * @param {...any[]} args - Additional arguments.\n   * @return The prepared model and context arguments.\n   * @throws {InternalError} If the model has no primary key value.\n   * @throws {ValidationError} If the model fails validation.\n   */\n  protected override async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const pk = model[this.pk] as string;\n    if (!pk)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n    const oldModel = await this.read(pk, ...contextArgs.args);\n    model = this.merge(oldModel, model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(\n      oldModel,\n      ...Repository.relations(this.class),\n      ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n    );\n    if (errors) throw new ValidationError(errors.toString());\n    if (Repository.getMetadata(oldModel)) {\n      if (!Repository.getMetadata(model))\n        Repository.setMetadata(model, Repository.getMetadata(oldModel));\n    }\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Updates multiple models in the database.\n   * @summary Persists changes to multiple existing model instances in the database in a batch operation.\n   * @param {M[]} models - The models to update.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M[]>} The updated models with refreshed properties.\n   */\n  override async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  /**\n   * @description Prepares multiple models for update.\n   * @summary Validates multiple models and prepares them for update in the database.\n   * @param {M[]} models - The models to update.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<any[]>} The prepared models and context arguments.\n   * @throws {InternalError} If any model has no primary key value.\n   * @throws {ValidationError} If any model fails validation.\n   */\n  protected override async updateAllPrefix(\n    models: M[],\n    ...args: any[]\n  ): Promise<any[]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const ids = models.map((m) => {\n      const id = m[this.pk] as string;\n      if (!id) throw new InternalError(\"missing id on update operation\");\n      return id;\n    });\n    const oldModels = await this.readAll(ids, ...contextArgs.args);\n    models = models.map((m, i) => {\n      m = this.merge(oldModels[i], m);\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n      return m;\n    });\n    await Promise.all(\n      models.map((m, i) =>\n        enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON,\n          oldModels[i]\n        )\n      )\n    );\n\n    const errors = models\n      .map((m, i) =>\n        m.hasErrors(\n          oldModels[i],\n          m,\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n\n    models.forEach((m, i) => {\n      if (Repository.getMetadata(oldModels[i])) {\n        if (!Repository.getMetadata(m))\n          Repository.setMetadata(m, Repository.getMetadata(oldModels[i]));\n      }\n    });\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares for deleting a model by ID.\n   * @summary Prepares the context and enforces decorators before deleting a model.\n   * @param {any} key - The primary key of the model to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return The key and context arguments.\n   */\n  protected override async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const model = await this.read(key, ...contextArgs.args);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Deletes a model from the database by ID.\n   * @summary Removes a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The deleted model instance.\n   */\n  async delete(id: string | number | bigint, ...args: any[]): Promise<M> {\n    const m = await this.adapter.delete(this.tableName, id, ...args);\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Prepares for deleting multiple models by IDs.\n   * @summary Prepares the context and enforces decorators before deleting multiple models.\n   * @param {string[]|number[]} keys - The primary keys of the models to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return The keys and context arguments.\n   */\n  protected override async deleteAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    const models = await this.readAll(keys, ...contextArgs.args);\n    await Promise.all(\n      models.map(async (m) => {\n        return enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  /**\n   * @description Deletes multiple models from the database by IDs.\n   * @summary Removes multiple model instances from the database using their primary keys.\n   * @param {string[]|number[]} keys - The primary keys of the models to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M[]>} The deleted model instances.\n   */\n  override async deleteAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const results = await this.adapter.deleteAll(this.tableName, keys, ...args);\n    return results.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n  /**\n   * @description Creates a select query without specifying fields.\n   * @summary Starts building a query that will return all fields of the model.\n   * @template S - The array type of select selectors.\n   * @return A query builder for the model.\n   */\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): WhereOption<M, M[]>;\n\n  /**\n   * @description Creates a select query with specific fields.\n   * @summary Starts building a query that will return only the specified fields of the model.\n   * @template S - The array type of select selectors.\n   * @param selector - The fields to select.\n   * @return A query builder for the selected fields.\n   */\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): WhereOption<M, Pick<M, S[number]>[]>;\n\n  /**\n   * @description Implementation of the select method.\n   * @summary Creates a query builder for the model with optional field selection.\n   * @template S - The array type of select selectors.\n   * @param [selector] - Optional fields to select.\n   * @return A query builder.\n   */\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): WhereOption<M, M[]> | WhereOption<M, Pick<M, S[number]>[]> {\n    return this.adapter\n      .Statement<M>()\n      .select(selector as readonly [...S])\n      .from(this.class);\n  }\n\n  /**\n   * @description Executes a query with the specified conditions and options.\n   * @summary Provides a simplified way to query the database with common query parameters.\n   * @param {Condition<M>} condition - The condition to filter records.\n   * @param orderBy - The field to order results by.\n   * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.\n   * @param {number} [limit] - Optional maximum number of results to return.\n   * @param {number} [skip] - Optional number of results to skip.\n   * @return {Promise<M[]>} The query results as model instances.\n   */\n  async query(\n    condition: Condition<M>,\n    orderBy: keyof M,\n    order: OrderDirection = OrderDirection.ASC,\n    limit?: number,\n    skip?: number\n  ): Promise<M[]> {\n    const sort: OrderBySelector<M> = [orderBy, order as OrderDirection];\n    const query = this.select().where(condition).orderBy(sort);\n    if (limit) query.limit(limit);\n    if (skip) query.offset(skip);\n    return query.execute();\n  }\n\n  /**\n   * @description Registers an observer for this repository.\n   * @summary Adds an observer that will be notified of changes to models in this repository.\n   * @param {Observer} observer - The observer to register.\n   * @param {ObserverFilter} [filter] - Optional filter to limit which events the observer receives.\n   * @return {void}\n   * @see {Observable#observe}\n   */\n  @final()\n  observe(observer: Observer, filter?: ObserverFilter): void {\n    if (!this.observerHandler)\n      Object.defineProperty(this, \"observerHandler\", {\n        value: this.ObserverHandler(),\n        writable: false,\n      });\n    const log = this.log.for(this.observe);\n    const tableName = Repository.table(this.class);\n    this.adapter.observe(this, (table: string) => tableName === table);\n    log.verbose(\n      `now observing ${this.adapter} filtering on table === ${tableName}`\n    );\n    this.observerHandler!.observe(observer, filter);\n    log.verbose(`Registered new observer ${observer.toString()}`);\n  }\n\n  /**\n   * @description Unregisters an observer from this repository.\n   * @summary Removes an observer so it will no longer receive notifications of changes.\n   * @param {Observer} observer - The observer to unregister.\n   * @return {void}\n   * @throws {InternalError} If the observer handler is not initialized.\n   * @see {Observable#unObserve}\n   */\n  @final()\n  unObserve(observer: Observer): void {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.observerHandler.unObserve(observer);\n    this.log\n      .for(this.unObserve)\n      .verbose(`Observer ${observer.toString()} removed`);\n    if (!this.observerHandler.count()) {\n      this.log.verbose(\n        `No more observers registered for ${this.adapter}, unsubscribing`\n      );\n      this.adapter.unObserve(this);\n      this.log.verbose(`No longer observing adapter ${this.adapter.flavour}`);\n    }\n  }\n\n  /**\n   * @description Notifies all observers of an event.\n   * @summary Updates all registered observers with information about a database event.\n   * @param {string} table - The table name where the event occurred.\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.\n   * @param {EventIds} id - The ID or IDs of the affected records.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<void>} A promise that resolves when all observers have been notified.\n   * @throws {InternalError} If the observer handler is not initialized.\n   */\n  async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.observerHandler)\n      throw new InternalError(\n        \"ObserverHandler not initialized. Did you register any observables?\"\n      );\n    this.log\n      .for(this.updateObservers)\n      .verbose(\n        `Updating ${this.observerHandler.count()} observers for ${this}`\n      );\n    await this.observerHandler.updateObservers(\n      this.log,\n      table,\n      event,\n      Array.isArray(id)\n        ? id.map((i) => Sequence.parseValue(this.pkProps.type, i) as string)\n        : (Sequence.parseValue(this.pkProps.type, id) as string),\n      ...args\n    );\n  }\n\n  /**\n   * @description Alias for updateObservers.\n   * @summary Notifies all observers of an event (alias for updateObservers).\n   * @param {string} table - The table name where the event occurred.\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of event that occurred.\n   * @param {EventIds} id - The ID or IDs of the affected records.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<void>} A promise that resolves when all observers have been notified.\n   */\n  async refresh(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ...args: any[]\n  ) {\n    return this.updateObservers(table, event, id, ...args);\n  }\n\n  /**\n   * @description Creates or retrieves a repository for a model.\n   * @summary Factory method that returns a repository instance for the specified model.\n   * @template M - The model type that extends Model.\n   * @template R - The repository type that extends Repo<M>.\n   * @param {Constructor<M>} model - The model constructor.\n   * @param {string} [defaultFlavour] - Optional default adapter flavour if not specified on the model.\n   * @param {...any[]} [args] - Additional arguments to pass to the repository constructor.\n   * @return {R} A repository instance for the model.\n   * @throws {InternalError} If no adapter is registered for the flavour.\n   */\n  static forModel<M extends Model, R extends Repo<M>>(\n    model: Constructor<M>,\n    alias?: string,\n    ...args: any[]\n  ): R {\n    let repo: R | Constructor<R> | undefined;\n\n    const _alias: string | undefined = alias || Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ;\n    try {\n      repo = this.get(model,_alias) as Constructor<R> | R;\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      repo = undefined;\n    }\n\n    if (repo instanceof Repository) return repo as R;\n\n    const flavour: string | undefined =\n      alias ||\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||\n      (repo &&\n        Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), repo));\n    const adapter: Adapter<any, any, any, any> | undefined = flavour\n      ? Adapter.get(flavour)\n      : undefined;\n\n    if (!adapter)\n      throw new InternalError(\n        `No registered persistence adapter found flavour ${flavour}`\n      );\n\n    repo = repo || (adapter.repository() as Constructor<R>);\n    return new repo(adapter, model, ...args) as R;\n  }\n\n  /**\n   * @description Retrieves a repository for a model from the cache.\n   * @summary Gets a repository constructor or instance for the specified model from the internal cache.\n   * @template M - The model type that extends Model.\n   * @param {Constructor<M>} model - The model constructor.\n   * @return {Constructor<Repo<M>> | Repo<M>} The repository constructor or instance.\n   * @throws {InternalError} If no repository is registered for the model.\n   */\n  private static get<M extends Model>(\n    model: Constructor<M>,\n    alias ?: string\n  ): Constructor<Repo<M>> | Repo<M> {\n    let name = Repository.table(model);\n    if (alias) {\n      name = [name, alias].join(DefaultSeparator)\n    }\n    if (name in this._cache)\n      return this._cache[name] as unknown as Constructor<Repo<M>> | Repo<M>;\n    throw new InternalError(\n      `Could not find repository registered under ${name}`\n    );\n  }\n\n  /**\n   * @description Registers a repository for a model.\n   * @summary Associates a repository constructor or instance with a model in the internal cache.\n   * @template M - The model type that extends Model.\n   * @param {Constructor<M>} model - The model constructor.\n   * @param {Constructor<Repo<M>> | Repo<M>} repo - The repository constructor or instance.\n   * @throws {InternalError} If a repository is already registered for the model.\n   */\n  static register<M extends Model>(\n    model: Constructor<M>,\n    repo: Constructor<Repo<M>> | Repo<M>,\n    alias ?: string\n  ) {\n    let name = Repository.table(model);\n    if (alias) {\n      name = [name, alias].join(DefaultSeparator)\n    }\n    if (name in this._cache)\n      throw new InternalError(`${name} already registered as a repository`);\n    this._cache[name] = repo as any;\n  }\n\n  /**\n   * @description Sets metadata on a model instance.\n   * @summary Attaches metadata to a model instance using a non-enumerable property.\n   * @template M - The model type that extends Model.\n   * @param {M} model - The model instance.\n   * @param {any} metadata - The metadata to attach to the model.\n   */\n  static setMetadata<M extends Model>(model: M, metadata: any) {\n    Object.defineProperty(model, PersistenceKeys.METADATA, {\n      enumerable: false,\n      configurable: true,\n      writable: false,\n      value: metadata,\n    });\n  }\n\n  /**\n   * @description Gets metadata from a model instance.\n   * @summary Retrieves previously attached metadata from a model instance.\n   * @template M - The model type that extends Model.\n   * @param {M} model - The model instance.\n   * @return {any} The metadata or undefined if not found.\n   */\n  static getMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    return descriptor ? descriptor.value : undefined;\n  }\n\n  /**\n   * @description Removes metadata from a model instance.\n   * @summary Deletes the metadata property from a model instance.\n   * @template M - The model type that extends Model.\n   * @param {M} model - The model instance.\n   */\n  static removeMetadata<M extends Model>(model: M) {\n    const descriptor = Object.getOwnPropertyDescriptor(\n      model,\n      PersistenceKeys.METADATA\n    );\n    if (descriptor) delete (model as any)[PersistenceKeys.METADATA];\n  }\n\n  /**\n   * @description Gets sequence options for a model's primary key.\n   * @summary Retrieves the sequence configuration for a model's primary key from metadata.\n   * @template M - The model type that extends Model.\n   * @param {M} model - The model instance.\n   * @return {SequenceOptions} The sequence options for the model's primary key.\n   * @throws {InternalError} If no sequence options are defined for the model.\n   */\n  static getSequenceOptions<M extends Model>(model: M) {\n    const pk = findPrimaryKey(model).id;\n    const metadata = Reflect.getMetadata(\n      Repository.key(DBKeys.ID),\n      model,\n      pk as string\n    );\n    if (!metadata)\n      throw new InternalError(\n        \"No sequence options defined for model. did you use the @pk decorator?\"\n      );\n    return metadata as SequenceOptions;\n  }\n\n  /**\n   * @description Gets all indexes defined on a model.\n   * @summary Retrieves all index metadata from a model's property decorators.\n   * @template M - The model type that extends Model.\n   * @param {M | Constructor<M>} model - The model instance or constructor.\n   * @return {Record<string, Record<string, IndexMetadata>>} A nested record of property names to index metadata.\n   */\n  static indexes<M extends Model>(model: M | Constructor<M>) {\n    const indexDecorators = Reflection.getAllPropertyDecorators(\n      model instanceof Model ? model : new model(),\n      DBKeys.REFLECT\n    );\n    return Object.entries(indexDecorators || {}).reduce(\n      (accum: Record<string, Record<string, IndexMetadata>>, [k, val]) => {\n        const decs = val.filter((v) => v.key.startsWith(PersistenceKeys.INDEX));\n        if (decs && decs.length) {\n          for (const dec of decs) {\n            const { key, props } = dec;\n            accum[k] = accum[k] || {};\n            accum[k][key] = props as IndexMetadata;\n          }\n        }\n        return accum;\n      },\n      {}\n    );\n  }\n\n  /**\n   * @description Gets all relation properties defined on a model.\n   * @summary Retrieves the names of all properties marked as relations in the model hierarchy.\n   * @template M - The model type that extends Model.\n   * @param {M | Constructor<M>} model - The model instance or constructor.\n   * @return {string[]} An array of property names that are relations.\n   */\n  static relations<M extends Model>(model: M | Constructor<M>): string[] {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[PersistenceKeys.RELATIONS];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  /**\n   * @description Gets the table name for a model.\n   * @summary Retrieves the database table name associated with a model.\n   * @template M - The model type that extends Model.\n   * @param {M | Constructor<M>} model - The model instance or constructor.\n   * @return {string} The table name for the model.\n   */\n  static table<M extends Model>(model: M | Constructor<M>): string {\n    return getTableName(model);\n  }\n\n  /**\n   * @description Gets the column name for a model attribute.\n   * @summary Retrieves the database column name for a model property.\n   * @template M - The model type that extends Model.\n   * @param {M} model - The model instance.\n   * @param {string} attribute - The attribute/property name.\n   * @return {string} The column name for the attribute.\n   */\n  static column<M extends Model>(model: M, attribute: string): string {\n    const metadata = Reflect.getMetadata(\n      Adapter.key(PersistenceKeys.COLUMN),\n      model,\n      attribute\n    );\n    return metadata ? metadata : attribute;\n  }\n}\n","import { inject, injectable } from \"@decaf-ts/injectable-decorators\";\nimport { DBKeys, IRepository } from \"@decaf-ts/db-decorators\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\n/**\n * @description Repository decorator for model classes.\n * @summary Creates and registers a repository for a model class. Can be used as both a property decorator and a class decorator.\n * @template T - The model type that extends Model.\n * @param {Constructor<T>} model - The constructor of the model class.\n * @param {string} [nameOverride] - Optional name override for the repository.\n * @return {any} - The decorator function.\n * @function repository\n * @mermaid\n * sequenceDiagram\n *   participant C as Client Code\n *   participant D as Decorator\n *   participant R as Repository\n *   participant M as Metadata\n *\n *   C->>D: Apply @repository(Model)\n *   alt Property Decorator\n *     D->>D: Check if propertyKey exists\n *     D->>+C: Return inject(name) decorator\n *   else Class Decorator\n *     D->>M: Set repository metadata on model\n *     D->>R: Register model with Repository\n *     D->>+C: Return injectable decorator with config\n *     C->>C: Define DBKeys.CLASS property\n *   end\n * @category Decorators\n */\nexport function repository<T extends Model>(\n  model: Constructor<T>,\n  nameOverride?: string\n): any {\n  return ((original: any, propertyKey?: any) => {\n    if (propertyKey) {\n      return inject(nameOverride || model.name)(original, propertyKey);\n    }\n\n    metadata(\n      Repository.key(DBKeys.REPOSITORY),\n      nameOverride || original.name\n    )(model);\n    Repository.register(model, original);\n    return injectable(\n      nameOverride || original.name,\n      true,\n      (instance: IRepository<T>) => {\n        Object.defineProperty(instance, DBKeys.CLASS, {\n          enumerable: false,\n          configurable: false,\n          writable: false,\n          value: model,\n        });\n      }\n    )(original);\n  }) as any;\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown when observer communication fails.\n * @summary Represents a failure in observer communication between repositories.\n * @param {string|Error} msg - The error message or Error object.\n * @class ObserverError\n * @category Errors\n * @example\n * try {\n *   // Some repository observer operation\n * } catch (error) {\n *   if (error instanceof ObserverError) {\n *     console.error('Observer communication failed:', error.message);\n *   }\n * }\n */\nexport class ObserverError extends BaseError {\n  constructor(msg: string | Error) {\n    super(ObserverError.name, msg, 500);\n  }\n}\n","import { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Constructor, sf } from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\n\n/**\n * @description Generates a unique injectable name for a repository.\n * @summary Creates a standardized name for repository injectables based on model and adapter flavour.\n * @template T - The model type that extends Model.\n * @param {Constructor<T> | T} model - The model constructor or instance.\n * @param {string} [flavour] - Optional adapter flavour. If not provided, it will be retrieved from the model metadata.\n * @return {string} The generated injectable name.\n * @throws {InternalError} If no flavour is provided and none can be retrieved from the model.\n * @function generateInjectableNameForRepository\n * @memberOf module:core\n */\nexport function generateInjectableNameForRepository<T extends Model>(\n  model: Constructor<T> | T,\n  flavour?: string\n): string {\n  if (!flavour) {\n    const key = Adapter.key(PersistenceKeys.ADAPTER);\n    flavour = Reflect.getMetadata(\n      key,\n      model instanceof Model ? model.constructor : model\n    );\n    if (!flavour)\n      throw new InternalError(\n        `Could not retrieve flavour from model ${model instanceof Model ? model.constructor.name : model.name}`\n      );\n  }\n  return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));\n}\n","import {\n  InjectableRegistryImp,\n  Injectables,\n} from \"@decaf-ts/injectable-decorators\";\nimport { Repository } from \"./Repository\";\nimport { Model, ModelConstructor } from \"@decaf-ts/decorator-validation\";\nimport { generateInjectableNameForRepository } from \"./utils\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Adapter } from \"../persistence/Adapter\";\n\n/**\n * @description Registry for injectable repositories.\n * @summary Extends the base injectable registry to provide automatic repository resolution for models.\n * @param {void} - No constructor parameters required.\n * @class InjectablesRegistry\n * @example\n * const registry = new InjectablesRegistry();\n * const userRepo = registry.get<UserRepository>('User');\n * // If UserRepository exists, it will be returned\n * // If not, but User model exists, a repository will be created for it\n */\nexport class InjectablesRegistry extends InjectableRegistryImp {\n  constructor() {\n    super();\n  }\n\n  /**\n   * @description Gets an injectable by name with repository auto-resolution.\n   * @summary Extends the base get method to automatically resolve repositories for models when not found directly.\n   * @template T - The type of injectable to return.\n   * @param {string} name - The name of the injectable to retrieve.\n   * @return {T | undefined} - The injectable instance or undefined if not found.\n   */\n  override get<T>(name: string): T | undefined {\n    let injectable = super.get(name);\n    if (!injectable)\n      try {\n        const m = Model.get(name);\n        if (m) injectable = Repository.forModel(m);\n        if (injectable) {\n          if (injectable instanceof Repository) return injectable as T;\n          const flavour =\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              injectable.constructor\n            ) ||\n            Reflect.getMetadata(\n              Adapter.key(PersistenceKeys.ADAPTER),\n              m as ModelConstructor<any>\n            );\n          Injectables.register(\n            injectable,\n            generateInjectableNameForRepository(\n              m as ModelConstructor<any>,\n              flavour\n            )\n          );\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        return undefined;\n      }\n    return injectable as T | undefined;\n  }\n}\n","/**\n * @description Interface for sequence configuration options\n * @summary Defines the configuration options for creating and managing sequences\n * @interface SequenceOptions\n * @memberOf module:core\n */\nexport interface SequenceOptions {\n  /**\n   * @description Optional name for the sequence\n   * @summary A unique identifier for the sequence\n   */\n  name?: string;\n\n  /**\n   * @description The data type of the sequence\n   * @summary Specifies whether the sequence generates Number or BigInt values\n   */\n  type: \"Number\" | \"BigInt\" | undefined;\n\n  /**\n   * @description The initial value of the sequence\n   * @summary The value that the sequence starts with\n   */\n  startWith: number;\n\n  /**\n   * @description The increment value for each step in the sequence\n   * @summary The amount by which the sequence increases with each call\n   */\n  incrementBy: number;\n\n  /**\n   * @description Optional minimum value for the sequence\n   * @summary The lowest value that the sequence can generate\n   */\n  minValue?: number;\n\n  /**\n   * @description Optional maximum value for the sequence\n   * @summary The highest value that the sequence can generate\n   */\n  maxValue?: number;\n\n  /**\n   * @description Whether the sequence should cycle when reaching its limits\n   * @summary If true, the sequence will restart from minValue when reaching maxValue\n   */\n  cycle: boolean;\n}\n\n/**\n * @description Default options for sequences\n * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1\n * @const DefaultSequenceOptions\n * @memberOf module:core\n */\nexport const DefaultSequenceOptions: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\n/**\n * @description Predefined options for numeric sequences\n * @summary Configuration for standard number sequences starting at 0 and incrementing by 1\n * @const NumericSequence\n * @memberOf module:core\n */\nexport const NumericSequence: SequenceOptions = {\n  type: \"Number\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n\n/**\n * @description Predefined options for BigInt sequences\n * @summary Configuration for BigInt sequences starting at 0 and incrementing by 1\n * @const BigIntSequence\n * @memberOf module:core\n */\nexport const BigIntSequence: SequenceOptions = {\n  type: \"BigInt\",\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\n};\n","/**\n * @description Comparison operators for query conditions\n * @summary Enum defining the available operators for comparing values in database queries\n * @enum {string}\n * @readonly\n * @memberOf module:core\n */\nexport enum Operator {\n  /** Equal comparison (=) */\n  EQUAL = \"EQUAL\",\n  /** Not equal comparison (!=) */\n  DIFFERENT = \"DIFFERENT\",\n  /** Greater than comparison (>) */\n  BIGGER = \"BIGGER\",\n  /** Greater than or equal comparison (>=) */\n  BIGGER_EQ = \"BIGGER_EQ\",\n  /** Less than comparison (<) */\n  SMALLER = \"SMALLER\",\n  /** Less than or equal comparison (<=) */\n  SMALLER_EQ = \"SMALLER_EQ\",\n  // BETWEEN = \"BETWEEN\",\n  /** Negation operator (NOT) */\n  NOT = \"NOT\",\n  /** Inclusion operator (IN) */\n  IN = \"IN\",\n  // IS = \"IS\",\n  /** Regular expression matching */\n  REGEXP = \"REGEXP\",\n}\n\n/**\n * @description Logical operators for combining query conditions\n * @summary Enum defining the available operators for grouping multiple conditions in database queries\n * @enum {string}\n * @readonly\n * @memberOf module:core\n */\nexport enum GroupOperator {\n  /** Logical AND operator - all conditions must be true */\n  AND = \"AND\",\n  /** Logical OR operator - at least one condition must be true */\n  OR = \"OR\",\n}\n","import { BaseError } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Error thrown during query operations\n * @summary Represents errors that occur during query building or execution\n * @param {string | Error} msg - The error message or Error object\n * @class QueryError\n * @category Errors\n */\nexport class QueryError extends BaseError {\n  constructor(msg: string | Error) {\n    super(QueryError.name, msg, 500);\n  }\n}\n\n/**\n * @description Error thrown during pagination operations\n * @summary Represents errors that occur during pagination setup or execution\n * @param {string | Error} msg - The error message or Error object\n * @class PagingError\n * @category Errors\n */\nexport class PagingError extends BaseError {\n  constructor(msg: string | Error) {\n    super(PagingError.name, msg, 500);\n  }\n}\n","import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @description Represents a logical condition for database queries\n * @summary A class that encapsulates query conditions with support for complex logical operations.\n * This class allows for building and combining query conditions using logical operators (AND, OR, NOT)\n * and comparison operators (equals, not equals, greater than, etc.).\n * @template M - The model type this condition operates on\n * @param {string | Condition<M>} attr1 - The attribute name or a nested condition\n * @param {Operator | GroupOperator} operator - The operator to use for the condition\n * @param {any} comparison - The value to compare against or another condition\n * @class Condition\n * @example\n * // Create a simple condition\n * const nameCondition = Condition.attribute(\"name\").eq(\"John\");\n *\n * // Create a complex condition\n * const complexCondition = Condition.attribute(\"age\").gt(18)\n *   .and(Condition.attribute(\"status\").eq(\"active\"));\n *\n * // Use the builder pattern\n * const userQuery = Condition.builder()\n *   .attribute(\"email\").regexp(\".*@example.com\")\n *   .and(Condition.attribute(\"lastLogin\").gt(new Date(\"2023-01-01\")));\n */\nexport class Condition<M extends Model> extends Model {\n  @required()\n  protected attr1?: string | Condition<M> = undefined;\n  @required()\n  protected operator?: Operator | GroupOperator = undefined;\n  @required()\n  protected comparison?: any = undefined;\n\n  private constructor(\n    attr1: string | Condition<M>,\n    operator: Operator | GroupOperator,\n    comparison: any\n  ) {\n    super();\n    this.attr1 = attr1;\n    this.operator = operator;\n    this.comparison = comparison;\n  }\n\n  /**\n   * @description Combines this condition with another using logical AND\n   * @summary Joins two conditions with an AND operator, requiring both to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  and(condition: Condition<M>): Condition<M> {\n    return Condition.and(this, condition);\n  }\n\n  /**\n   * @description Combines this condition with another using logical OR\n   * @summary Joins two conditions with an OR operator, requiring at least one to be true\n   * @param {Condition<M>} condition - The condition to combine with this one\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  or(condition: Condition<M>): Condition<M> {\n    return Condition.or(this, condition);\n  }\n\n  /**\n   * @description Creates a negation condition\n   * @summary Excludes a value from the result by applying a NOT operator\n   * @param {any} val - The value to negate\n   * @return {Condition<M>} A new condition representing the NOT operation\n   */\n  not(val: any): Condition<M> {\n    return new Condition(this, Operator.NOT, val);\n  }\n\n  /**\n   * @description Validates the condition and checks for errors\n   * @summary Extends the base validation to ensure the condition is properly formed\n   * @param {...string[]} exceptions - Fields to exclude from validation\n   * @return {ModelErrorDefinition | undefined} Error definition if validation fails, undefined otherwise\n   */\n  override hasErrors(\n    ...exceptions: string[]\n  ): ModelErrorDefinition | undefined {\n    const errors = super.hasErrors(...exceptions);\n    if (errors) return errors;\n\n    const invalidOpMessage = `Invalid operator ${this.operator}}`;\n\n    if (typeof this.attr1 === \"string\") {\n      if (this.comparison instanceof Condition)\n        return {\n          comparison: {\n            condition: \"Both sides of the comparison must be of the same type\",\n          },\n        } as ModelErrorDefinition;\n      if (Object.values(Operator).indexOf(this.operator as Operator) === -1)\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n    }\n\n    if (this.attr1 instanceof Condition) {\n      if (\n        !(this.comparison instanceof Condition) &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          comparison: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      if (\n        Object.values(GroupOperator).indexOf(this.operator as GroupOperator) ===\n          -1 &&\n        this.operator !== Operator.NOT\n      )\n        return {\n          operator: {\n            condition: invalidOpMessage,\n          },\n        } as ModelErrorDefinition;\n      // if (this.operator !== Operator.NOT && typeof this.attr1.attr1 !== \"string\")\n      //     return {\n      //         attr1: {\n      //             condition: stringFormat(\"Parent condition attribute must be a string\")\n      //         }\n      //     } as ModelErrorDefinition\n    }\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical AND\n   * @summary Static method that joins two conditions with an AND operator, requiring both to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the AND operation\n   */\n  static and<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.AND, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that combines two conditions with logical OR\n   * @summary Static method that joins two conditions with an OR operator, requiring at least one to be true\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the OR operation\n   */\n  static or<M extends Model>(\n    condition1: Condition<M>,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return Condition.group(condition1, GroupOperator.OR, condition2);\n  }\n\n  /**\n   * @description Creates a new condition that groups two conditions with a specified operator\n   * @summary Private static method that combines two conditions using the specified group operator\n   * @template M - The model type this condition operates on\n   * @param {Condition<M>} condition1 - The first condition\n   * @param {GroupOperator} operator - The group operator to use (AND, OR)\n   * @param {Condition<M>} condition2 - The second condition\n   * @return {Condition<M>} A new condition representing the grouped operation\n   */\n  private static group<M extends Model>(\n    condition1: Condition<M>,\n    operator: GroupOperator,\n    condition2: Condition<M>\n  ): Condition<M> {\n    return new Condition(condition1, operator, condition2);\n  }\n\n  /**\n   * @description Creates a condition builder for a specific model attribute\n   * @summary Static method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attribute<M extends Model>(attr: keyof M) {\n    return new Condition.Builder<M>().attribute(attr);\n  }\n\n  /**\n   * @description Alias for the attribute method\n   * @summary Shorthand method that initializes a condition builder with the specified attribute\n   * @template M - The model type this condition operates on\n   * @param attr - The model attribute to build a condition for\n   * @return {AttributeOption<M>} A condition builder initialized with the attribute\n   */\n  static attr<M extends Model>(attr: keyof M) {\n    return this.attribute(attr);\n  }\n\n  /**\n   * @description Provides a fluent API to build query conditions\n   * @summary A builder class that simplifies the creation of database query conditions\n   * with a chainable interface for setting attributes and operators\n   * @template M - The model type this condition builder operates on\n   * @class ConditionBuilder\n   */\n  private static Builder = class ConditionBuilder<M extends Model>\n    implements ConditionBuilderOption<M>, AttributeOption<M>\n  {\n    attr1?: keyof M | Condition<M> = undefined;\n    operator?: Operator | GroupOperator = undefined;\n    comparison?: any = undefined;\n\n    /**\n     * @description Sets the attribute for the condition\n     * @summary Specifies which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attribute(attr: keyof M): AttributeOption<M> {\n      this.attr1 = attr;\n      return this;\n    }\n\n    /**\n     * @description Alias for the attribute method\n     * @summary Shorthand method to specify which model attribute the condition will operate on\n     * @param attr - The model attribute to use in the condition\n     * @return {AttributeOption<M>} This builder instance for method chaining\n     */\n    attr(attr: keyof M) {\n      return this.attribute(attr);\n    }\n\n    /**\n     * @description Creates an equality condition\n     * @summary Builds a condition that checks if the attribute equals the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the equality comparison\n     */\n    eq(val: any) {\n      return this.setOp(Operator.EQUAL, val);\n    }\n\n    /**\n     * @description Creates an inequality condition\n     * @summary Builds a condition that checks if the attribute is different from the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the inequality comparison\n     */\n    dif(val: any) {\n      return this.setOp(Operator.DIFFERENT, val);\n    }\n\n    /**\n     * @description Creates a greater than condition\n     * @summary Builds a condition that checks if the attribute is greater than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than comparison\n     */\n    gt(val: any) {\n      return this.setOp(Operator.BIGGER, val);\n    }\n\n    /**\n     * @description Creates a less than condition\n     * @summary Builds a condition that checks if the attribute is less than the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than comparison\n     */\n    lt(val: any) {\n      return this.setOp(Operator.SMALLER, val);\n    }\n\n    /**\n     * @description Creates a greater than or equal to condition\n     * @summary Builds a condition that checks if the attribute is greater than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the greater than or equal comparison\n     */\n    gte(val: any) {\n      return this.setOp(Operator.BIGGER_EQ, val);\n    }\n\n    /**\n     * @description Creates a less than or equal to condition\n     * @summary Builds a condition that checks if the attribute is less than or equal to the specified value\n     * @param {any} val - The value to compare the attribute against\n     * @return {Condition<M>} A new condition representing the less than or equal comparison\n     */\n    lte(val: any) {\n      return this.setOp(Operator.SMALLER_EQ, val);\n    }\n\n    /**\n     * @description Creates an inclusion condition\n     * @summary Builds a condition that checks if the attribute value is included in the specified array\n     * @param {any[]} arr - The array of values to check against\n     * @return {Condition<M>} A new condition representing the inclusion comparison\n     */\n    in(arr: any[]) {\n      return this.setOp(Operator.IN, arr);\n    }\n\n    /**\n     * @description Creates a regular expression condition\n     * @summary Builds a condition that checks if the attribute matches the specified regular expression pattern\n     * @param {any} val - The regular expression pattern to match against\n     * @return {Condition<M>} A new condition representing the regular expression comparison\n     */\n    regexp(val: any) {\n      return this.setOp(Operator.REGEXP, new RegExp(val).source);\n    }\n\n    /**\n     * @description Sets the operator and comparison value for the condition\n     * @summary Private method that configures the condition with the specified operator and value\n     * @param {Operator} op - The operator to use for the condition\n     * @param {any} val - The value to compare against\n     * @return {Condition<M>} A new condition with the specified operator and value\n     */\n    private setOp(op: Operator, val: any) {\n      this.operator = op;\n      this.comparison = val;\n      return this.build();\n    }\n\n    /**\n     * @description Constructs a Condition instance from the builder's state\n     * @summary Finalizes the condition building process by creating a new Condition instance\n     * @throws {QueryError} If the condition cannot be built due to invalid parameters\n     * @return {Condition<M>} A new condition instance with the configured attributes\n     */\n    private build(): Condition<M> {\n      try {\n        return new Condition(\n          this.attr1 as string | Condition<M>,\n          this.operator as Operator,\n          this.comparison as any\n        );\n      } catch (e: any) {\n        throw new QueryError(e);\n      }\n    }\n  };\n\n  /**\n   * @description Creates a new condition builder\n   * @summary Factory method that returns a new instance of the condition builder\n   * @template M - The model type this condition builder will operate on\n   * @return {ConditionBuilderOption<M>} A new condition builder instance\n   */\n  static builder<M extends Model>(): ConditionBuilderOption<M> {\n    return new Condition.Builder<M>();\n  }\n}\n","import {\n  Constructor,\n  Model,\n  ModelConstructor,\n  Validation,\n  ValidationKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Cascade } from \"../repository/constants\";\nimport { Context } from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Creates or updates a model instance\n * @summary Determines whether to create a new model or update an existing one based on the presence of a primary key\n * @template M - The model type extending Model\n * @template F - The repository flags type\n * @param {M} model - The model instance to create or update\n * @param {Context<F>} context - The context for the operation\n * @param {Repo<M, F, Context<F>>} [repository] - Optional repository to use for the operation\n * @return {Promise<M>} A promise that resolves to the created or updated model\n * @function createOrUpdate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant createOrUpdate\n *   participant Repository\n *   participant Model\n *\n *   Caller->>createOrUpdate: model, context, repository?\n *   alt repository not provided\n *     createOrUpdate->>Model: get(model.constructor.name)\n *     Model-->>createOrUpdate: constructor\n *     createOrUpdate->>Repository: forModel(constructor)\n *     Repository-->>createOrUpdate: repository\n *   end\n *\n *   alt primary key undefined\n *     createOrUpdate->>Repository: create(model, context)\n *     Repository-->>createOrUpdate: created model\n *   else primary key defined\n *     createOrUpdate->>Repository: update(model, context)\n *     alt update successful\n *       Repository-->>createOrUpdate: updated model\n *     else NotFoundError\n *       createOrUpdate->>Repository: create(model, context)\n *       Repository-->>createOrUpdate: created model\n *     end\n *   end\n *\n *   createOrUpdate-->>Caller: model\n */\nexport async function createOrUpdate<\n  M extends Model,\n  F extends RepositoryFlags,\n>(\n  model: M,\n  context: Context<F>,\n  repository?: Repo<M, F, Context<F>>\n): Promise<M> {\n  if (!repository) {\n    const constructor = Model.get(model.constructor.name);\n    if (!constructor)\n      throw new InternalError(`Could not find model ${model.constructor.name}`);\n    repository = Repository.forModel<M, Repo<M>>(\n      constructor as unknown as ModelConstructor<M>\n    );\n  }\n  if (typeof model[repository.pk] === \"undefined\")\n    return repository.create(model, context);\n  else {\n    try {\n      return repository.update(model, context);\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      return repository.create(model, context);\n    }\n  }\n}\n\n/**\n * @description Handles one-to-one relationship creation\n * @summary Processes a one-to-one relationship when creating a model, either by referencing an existing model or creating a new one\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param {string} key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnCreate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnCreate\n *   participant repositoryFromTypeMetadata\n *   participant Model\n *   participant Repository\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnCreate: this, context, data, key, model\n *   oneToOneOnCreate->>oneToOneOnCreate: check if propertyValue exists\n *\n *   alt propertyValue is not an object\n *     oneToOneOnCreate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToOneOnCreate: innerRepo\n *     oneToOneOnCreate->>innerRepo: read(propertyValue)\n *     innerRepo-->>oneToOneOnCreate: read\n *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, propertyValue, read\n *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = propertyValue\n *   else propertyValue is an object\n *     oneToOneOnCreate->>Model: get(data.class)\n *     Model-->>oneToOneOnCreate: constructor\n *     oneToOneOnCreate->>Repository: forModel(constructor)\n *     Repository-->>oneToOneOnCreate: repo\n *     oneToOneOnCreate->>repo: create(propertyValue)\n *     repo-->>oneToOneOnCreate: created\n *     oneToOneOnCreate->>findPrimaryKey: created\n *     findPrimaryKey-->>oneToOneOnCreate: pk\n *     oneToOneOnCreate->>cacheModelForPopulate: context, model, key, created[pk], created\n *     oneToOneOnCreate->>oneToOneOnCreate: set model[key] = created[pk]\n *   end\n *\n *   oneToOneOnCreate-->>Caller: void\n */\nexport async function oneToOneOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  const constructor = Model.get(data.class);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor);\n  const created = await repo.create(propertyValue);\n  const pk = findPrimaryKey(created).id;\n  await cacheModelForPopulate(context, model, key, created[pk], created);\n  (model as any)[key] = created[pk];\n}\n\n/**\n * @description Handles one-to-one relationship updates\n * @summary Processes a one-to-one relationship when updating a model, either by referencing an existing model or updating the related model\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnUpdate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnUpdate\n *   participant repositoryFromTypeMetadata\n *   participant createOrUpdate\n *   participant findPrimaryKey\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnUpdate: this, context, data, key, model\n *   oneToOneOnUpdate->>oneToOneOnUpdate: check if propertyValue exists\n *   oneToOneOnUpdate->>oneToOneOnUpdate: check if cascade.update is CASCADE\n *\n *   alt propertyValue is not an object\n *     oneToOneOnUpdate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToOneOnUpdate: innerRepo\n *     oneToOneOnUpdate->>innerRepo: read(propertyValue)\n *     innerRepo-->>oneToOneOnUpdate: read\n *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, propertyValue, read\n *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = propertyValue\n *   else propertyValue is an object\n *     oneToOneOnUpdate->>createOrUpdate: model[key], context\n *     createOrUpdate-->>oneToOneOnUpdate: updated\n *     oneToOneOnUpdate->>findPrimaryKey: updated\n *     findPrimaryKey-->>oneToOneOnUpdate: pk\n *     oneToOneOnUpdate->>cacheModelForPopulate: context, model, key, updated[pk], updated\n *     oneToOneOnUpdate->>oneToOneOnUpdate: set model[key] = updated[pk]\n *   end\n *\n *   oneToOneOnUpdate-->>Caller: void\n */\nexport async function oneToOneOnUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n\n  if (typeof propertyValue !== \"object\") {\n    const innerRepo = repositoryFromTypeMetadata(model, key);\n    const read = await innerRepo.read(propertyValue);\n    await cacheModelForPopulate(context, model, key, propertyValue, read);\n    (model as any)[key] = propertyValue;\n    return;\n  }\n\n  const updated = await createOrUpdate(model[key] as M, context);\n  const pk = findPrimaryKey(updated).id;\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    updated[pk] as string,\n    updated\n  );\n  model[key] = updated[pk];\n}\n\n/**\n * @description Handles one-to-one relationship deletion\n * @summary Processes a one-to-one relationship when deleting a model, deleting the related model if cascade is enabled\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToOneOnDelete\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToOneOnDelete\n *   participant repositoryFromTypeMetadata\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToOneOnDelete: this, context, data, key, model\n *   oneToOneOnDelete->>oneToOneOnDelete: check if propertyValue exists\n *   oneToOneOnDelete->>oneToOneOnDelete: check if cascade.update is CASCADE\n *\n *   oneToOneOnDelete->>repositoryFromTypeMetadata: model, key\n *   repositoryFromTypeMetadata-->>oneToOneOnDelete: innerRepo\n *\n *   alt propertyValue is not a Model instance\n *     oneToOneOnDelete->>innerRepo: delete(model[key], context)\n *     innerRepo-->>oneToOneOnDelete: deleted\n *   else propertyValue is a Model instance\n *     oneToOneOnDelete->>innerRepo: delete(model[key][innerRepo.pk], context)\n *     innerRepo-->>oneToOneOnDelete: deleted\n *   end\n *\n *   oneToOneOnDelete->>cacheModelForPopulate: context, model, key, deleted[innerRepo.pk], deleted\n *   oneToOneOnDelete-->>Caller: void\n */\nexport async function oneToOneOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValue: any = model[key];\n  if (!propertyValue) return;\n  if (data.cascade.update !== Cascade.CASCADE) return;\n  const innerRepo: Repo<M> = repositoryFromTypeMetadata(model, key);\n  let deleted: M;\n  if (!(propertyValue instanceof Model))\n    deleted = await innerRepo.delete(model[key] as string, context);\n  else\n    deleted = await innerRepo.delete(\n      (model[key] as M)[innerRepo.pk as keyof M] as string,\n      context\n    );\n  await cacheModelForPopulate(\n    context,\n    model,\n    key,\n    deleted[innerRepo.pk] as string,\n    deleted\n  );\n}\n\n/**\n * @description Handles one-to-many relationship creation\n * @summary Processes a one-to-many relationship when creating a model, either by referencing existing models or creating new ones\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToManyOnCreate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToManyOnCreate\n *   participant repositoryFromTypeMetadata\n *   participant createOrUpdate\n *   participant findPrimaryKey\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToManyOnCreate: this, context, data, key, model\n *   oneToManyOnCreate->>oneToManyOnCreate: check if propertyValues exists and has length\n *   oneToManyOnCreate->>oneToManyOnCreate: check if all elements have same type\n *   oneToManyOnCreate->>oneToManyOnCreate: create uniqueValues set\n *\n *   alt arrayType is not \"object\"\n *     oneToManyOnCreate->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToManyOnCreate: repo\n *     loop for each id in uniqueValues\n *       oneToManyOnCreate->>repo: read(id)\n *       repo-->>oneToManyOnCreate: read\n *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, id, read\n *     end\n *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...uniqueValues]\n *   else arrayType is \"object\"\n *     oneToManyOnCreate->>findPrimaryKey: propertyValues[0]\n *     findPrimaryKey-->>oneToManyOnCreate: pkName\n *     oneToManyOnCreate->>oneToManyOnCreate: create result set\n *     loop for each m in propertyValues\n *       oneToManyOnCreate->>createOrUpdate: m, context\n *       createOrUpdate-->>oneToManyOnCreate: record\n *       oneToManyOnCreate->>cacheModelForPopulate: context, model, key, record[pkName], record\n *       oneToManyOnCreate->>oneToManyOnCreate: add record[pkName] to result\n *     end\n *     oneToManyOnCreate->>oneToManyOnCreate: set model[key] = [...result]\n *   end\n *\n *   oneToManyOnCreate-->>Caller: void\n */\nexport async function oneToManyOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const propertyValues: any = model[key];\n  if (!propertyValues || !propertyValues.length) return;\n  const arrayType = typeof propertyValues[0];\n  if (!propertyValues.every((item: any) => typeof item === arrayType))\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const uniqueValues = new Set([...propertyValues]);\n  if (arrayType !== \"object\") {\n    const repo = repositoryFromTypeMetadata(model, key);\n    for (const id of uniqueValues) {\n      const read = await repo.read(id);\n      await cacheModelForPopulate(context, model, key, id, read);\n    }\n    (model as any)[key] = [...uniqueValues];\n    return;\n  }\n\n  const pkName = findPrimaryKey(propertyValues[0]).id;\n\n  const result: Set<string> = new Set();\n\n  for (const m of propertyValues) {\n    const record = await createOrUpdate(m, context);\n    await cacheModelForPopulate(context, model, key, record[pkName], record);\n    result.add(record[pkName]);\n  }\n\n  (model as any)[key] = [...result];\n}\n\n/**\n * @description Handles one-to-many relationship updates\n * @summary Processes a one-to-many relationship when updating a model, delegating to oneToManyOnCreate if cascade update is enabled\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToManyOnUpdate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToManyOnUpdate\n *   participant oneToManyOnCreate\n *\n *   Caller->>oneToManyOnUpdate: this, context, data, key, model\n *   oneToManyOnUpdate->>oneToManyOnUpdate: check if cascade.update is CASCADE\n *\n *   alt cascade.update is CASCADE\n *     oneToManyOnUpdate->>oneToManyOnCreate: apply(this, [context, data, key, model])\n *     oneToManyOnCreate-->>oneToManyOnUpdate: void\n *   end\n *\n *   oneToManyOnUpdate-->>Caller: void\n */\nexport async function oneToManyOnUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { cascade } = data;\n  if (cascade.update !== Cascade.CASCADE) return;\n  return oneToManyOnCreate.apply(this as any, [\n    context,\n    data,\n    key as keyof Model,\n    model,\n  ]);\n}\n\n/**\n * @description Handles one-to-many relationship deletion\n * @summary Processes a one-to-many relationship when deleting a model, deleting all related models if cascade delete is enabled\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function oneToManyOnDelete\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant oneToManyOnDelete\n *   participant Repository\n *   participant repositoryFromTypeMetadata\n *   participant cacheModelForPopulate\n *\n *   Caller->>oneToManyOnDelete: this, context, data, key, model\n *   oneToManyOnDelete->>oneToManyOnDelete: check if cascade.delete is CASCADE\n *   oneToManyOnDelete->>oneToManyOnDelete: check if values exists and has length\n *   oneToManyOnDelete->>oneToManyOnDelete: check if all elements have same type\n *\n *   alt isInstantiated (arrayType is \"object\")\n *     oneToManyOnDelete->>Repository: forModel(values[0])\n *     Repository-->>oneToManyOnDelete: repo\n *   else not instantiated\n *     oneToManyOnDelete->>repositoryFromTypeMetadata: model, key\n *     repositoryFromTypeMetadata-->>oneToManyOnDelete: repo\n *   end\n *\n *   oneToManyOnDelete->>oneToManyOnDelete: create uniqueValues set\n *\n *   loop for each id in uniqueValues\n *     oneToManyOnDelete->>repo: delete(id, context)\n *     repo-->>oneToManyOnDelete: deleted\n *     oneToManyOnDelete->>cacheModelForPopulate: context, model, key, id, deleted\n *   end\n *\n *   oneToManyOnDelete->>oneToManyOnDelete: set model[key] = [...uniqueValues]\n *   oneToManyOnDelete-->>Caller: void\n */\nexport async function oneToManyOnDelete<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (data.cascade.delete !== Cascade.CASCADE) return;\n  const values = model[key] as any;\n  if (!values || !values.length) return;\n  const arrayType = typeof values[0];\n  const areAllSameType = values.every((item: any) => typeof item === arrayType);\n  if (!areAllSameType)\n    throw new InternalError(\n      `Invalid operation. All elements of property ${key as string} must match the same type.`\n    );\n  const isInstantiated = arrayType === \"object\";\n  const repo = isInstantiated\n    ? Repository.forModel(values[0],this.adapter.alias)\n    : repositoryFromTypeMetadata(model, key);\n\n  const uniqueValues = new Set([\n    ...(isInstantiated\n      ? values.map((v: Record<string, any>) => v[repo.pk as string])\n      : values),\n  ]);\n\n  for (const id of uniqueValues.values()) {\n    const deleted = await repo.delete(id, context);\n    await cacheModelForPopulate(context, model, key, id, deleted);\n  }\n  (model as any)[key] = [...uniqueValues];\n}\n\n/**\n * @description Generates a key for caching populated model relationships\n * @summary Creates a unique key for storing and retrieving populated model relationships in the cache\n * @param {string} tableName - The name of the table or model\n * @param {string} fieldName - The name of the field or property\n * @param {string|number} id - The identifier of the related model\n * @return {string} A dot-separated string that uniquely identifies the relationship\n * @function getPopulateKey\n * @memberOf module:core\n */\nexport function getPopulateKey(\n  tableName: string,\n  fieldName: string,\n  id: string | number\n) {\n  return [PersistenceKeys.POPULATE, tableName, fieldName, id].join(\".\");\n}\n\n/**\n * @description Caches a model for later population\n * @summary Stores a model in the context cache for efficient retrieval during relationship population\n * @template M - The model type extending Model\n * @template F - The repository flags type\n * @param {Context<F>} context - The context for the operation\n * @param {M} parentModel - The parent model that contains the relationship\n * @param propertyKey - The property key of the relationship\n * @param {string | number} pkValue - The primary key value of the related model\n * @param {any} cacheValue - The model instance to cache\n * @return {Promise<any>} A promise that resolves with the result of the cache operation\n * @function cacheModelForPopulate\n * @memberOf module:core\n */\nexport async function cacheModelForPopulate<\n  M extends Model,\n  F extends RepositoryFlags,\n>(\n  context: Context<F>,\n  parentModel: M,\n  propertyKey: keyof M | string,\n  pkValue: string | number,\n  cacheValue: any\n) {\n  const cacheKey = getPopulateKey(\n    parentModel.constructor.name,\n    propertyKey as string,\n    pkValue\n  );\n  return context.accumulate({ [cacheKey]: cacheValue });\n}\n\n/**\n * @description Populates a model's relationship\n * @summary Retrieves and attaches related models to a model's relationship property\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The relations metadata\n * @param key - The property key of the relationship\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function populate\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant populate\n *   participant fetchPopulateValues\n *   participant getPopulateKey\n *   participant Context\n *   participant repositoryFromTypeMetadata\n *\n *   Caller->>populate: this, context, data, key, model\n *   populate->>populate: check if data.populate is true\n *   populate->>populate: get nested value and check if it exists\n *\n *   populate->>fetchPopulateValues: context, model, key, isArr ? nested : [nested]\n *\n *   fetchPopulateValues->>fetchPopulateValues: initialize variables\n *\n *   loop for each proKeyValue in propKeyValues\n *     fetchPopulateValues->>getPopulateKey: model.constructor.name, propName, proKeyValue\n *     getPopulateKey-->>fetchPopulateValues: cacheKey\n *\n *     alt try to get from cache\n *       fetchPopulateValues->>Context: get(cacheKey)\n *       Context-->>fetchPopulateValues: val\n *     else catch error\n *       fetchPopulateValues->>repositoryFromTypeMetadata: model, propName\n *       repositoryFromTypeMetadata-->>fetchPopulateValues: repo\n *       fetchPopulateValues->>repo: read(proKeyValue)\n *       repo-->>fetchPopulateValues: val\n *     end\n *\n *     fetchPopulateValues->>fetchPopulateValues: add val to results\n *   end\n *\n *   fetchPopulateValues-->>populate: results\n *   populate->>populate: set model[key] = isArr ? res : res[0]\n *   populate-->>Caller: void\n */\nexport async function populate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.populate) return;\n  const nested: any = model[key];\n  const isArr = Array.isArray(nested);\n  if (typeof nested === \"undefined\" || (isArr && nested.length === 0)) return;\n\n  async function fetchPopulateValues(\n    c: Context<F>,\n    model: M,\n    propName: string,\n    propKeyValues: any[]\n  ) {\n    let cacheKey: string;\n    let val: any;\n    const results: M[] = [];\n    for (const proKeyValue of propKeyValues) {\n      cacheKey = getPopulateKey(model.constructor.name, propName, proKeyValue);\n      try {\n        val = await c.get(cacheKey as any);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: any) {\n        const repo = repositoryFromTypeMetadata(model, propName);\n        if (!repo) throw new InternalError(\"Could not find repo\");\n        val = await repo.read(proKeyValue);\n      }\n      results.push(val);\n    }\n    return results;\n  }\n  const res = await fetchPopulateValues(\n    context,\n    model,\n    key as string,\n    isArr ? nested : [nested]\n  );\n  (model as any)[key] = isArr ? res : res[0];\n}\n\n/**\n * @description List of common JavaScript types\n * @summary An array of strings representing common JavaScript types that are not custom model types\n * @const commomTypes\n * @memberOf module:core\n */\nconst commomTypes = [\n  \"array\",\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"symbol\",\n  \"function\",\n  \"object\",\n  \"undefined\",\n  \"null\",\n  \"bigint\",\n];\n\n/**\n * @description Retrieves a repository for a model property based on its type metadata\n * @summary Examines a model property's type metadata to determine the appropriate repository for related models\n * @template M - The model type extending Model\n * @param {any} model - The model instance containing the property\n * @param propertyKey - The property key to examine\n * @return {Repo<M>} A repository for the model type associated with the property\n * @function repositoryFromTypeMetadata\n * @memberOf module:core\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant repositoryFromTypeMetadata\n *   participant Reflect\n *   participant Validation\n *   participant Model\n *   participant Repository\n *\n *   Caller->>repositoryFromTypeMetadata: model, propertyKey\n *\n *   repositoryFromTypeMetadata->>Validation: key(Array.isArray(model[propertyKey]) ? ValidationKeys.LIST : ValidationKeys.TYPE)\n *   Validation-->>repositoryFromTypeMetadata: validationKey\n *\n *   repositoryFromTypeMetadata->>Reflect: getMetadata(validationKey, model, propertyKey)\n *   Reflect-->>repositoryFromTypeMetadata: types\n *\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: determine customTypes based on property type\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if types and customTypes exist\n *\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: create allowedTypes array\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: find constructorName not in commomTypes\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if constructorName exists\n *\n *   repositoryFromTypeMetadata->>Model: get(constructorName)\n *   Model-->>repositoryFromTypeMetadata: constructor\n *   repositoryFromTypeMetadata->>repositoryFromTypeMetadata: check if constructor exists\n *\n *   repositoryFromTypeMetadata->>Repository: forModel(constructor)\n *   Repository-->>repositoryFromTypeMetadata: repo\n *\n *   repositoryFromTypeMetadata-->>Caller: repo\n */\nexport function repositoryFromTypeMetadata<M extends Model>(\n  model: any,\n  propertyKey: string | keyof M\n): Repo<M> {\n  const types = Reflect.getMetadata(\n    Validation.key(\n      Array.isArray(model[propertyKey])\n        ? ValidationKeys.LIST\n        : ValidationKeys.TYPE\n    ),\n    model,\n    propertyKey as string\n  );\n  const customTypes: any = Array.isArray(model[propertyKey])\n    ? types.clazz\n    : types.customTypes;\n  if (!types || !customTypes)\n    throw new InternalError(\n      `Failed to find types decorators for property ${propertyKey as string}`\n    );\n\n  const allowedTypes: string[] = Array.isArray(customTypes)\n    ? [...customTypes]\n    : [customTypes];\n  const constructorName = allowedTypes.find(\n    (t) => !commomTypes.includes(`${t}`.toLowerCase())\n  );\n  if (!constructorName)\n    throw new InternalError(\n      `Property key ${propertyKey as string} does not have a valid constructor type`\n    );\n  const constructor: Constructor<M> | undefined = Model.get(constructorName);\n  if (!constructor)\n    throw new InternalError(`No registered model found for ${constructorName}`);\n\n  return Repository.forModel(constructor);\n}\n\n","import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n} from \"@decaf-ts/db-decorators\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { CascadeMetadata, IndexMetadata } from \"../repository/types\";\nimport { DefaultCascade, OrderDirection } from \"../repository/constants\";\nimport {\n  Constructor,\n  Decoration,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { Condition } from \"../query/Condition\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToManyOnUpdate,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./construction\";\nimport { AuthorizationError } from \"../utils\";\n\n/**\n * @description Specifies the database table name for a model\n * @summary Decorator that sets the table name for a model class in the database\n * @param {string} tableName - The name of the table in the database\n * @return {Function} A decorator function that can be applied to a class\n * @function table\n * @category Class Decorators\n */\nexport function table(tableName: string) {\n  return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);\n}\n\n/**\n * @description Specifies the database column name for a model property\n * @summary Decorator that maps a model property to a specific column name in the database\n * @param {string} columnName - The name of the column in the database\n * @return {Function} A decorator function that can be applied to a class property\n * @function column\n * @category Property Decorators\n */\nexport function column(columnName: string) {\n  return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);\n}\n\n/**\n * @description Creates an index on a model property for improved query performance\n * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions\n * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index\n * @param {string[]} [compositions] - Optional array of property names to create a composite index\n * @return {Function} A decorator function that can be applied to a class property\n * @function index\n * @category Property Decorators\n */\nexport function index(directions?: OrderDirection[], compositions?: string[]) {\n  return propMetadata(\n    Repository.key(\n      `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n    ),\n    {\n      directions: directions,\n      compositions: compositions,\n    } as IndexMetadata\n  );\n}\n\n/**\n * @description Enforces uniqueness constraint during model creation and update\n * @summary Internal function used by the unique decorator to check if a property value already exists in the database\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The metadata type\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The metadata for the property\n * @param key - The property key to check for uniqueness\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError\n * @function uniqueOnCreateUpdate\n * @memberOf module:core\n */\nexport async function uniqueOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends object,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!(model as any)[key]) return;\n  const existing = await this.select()\n    .where(Condition.attribute(key).eq(model[key]))\n    .execute();\n  if (existing.length)\n    throw new ConflictError(\n      `model already exists with property ${key as string} equal to ${JSON.stringify((model as any)[key], undefined, 2)}`\n    );\n}\n\n/**\n * @description Tags a property as unique\n * @summary Decorator that ensures a property value is unique across all instances of a model in the database\n * @return {Function} A decorator function that can be applied to a class property\n * @function unique\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @unique()\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function unique() {\n  return apply(\n    onCreateUpdate(uniqueOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.UNIQUE), {})\n  );\n}\n\n/**\n * @description Handles user identification for ownership tracking\n * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The metadata for the property\n * @param key - The property key to store the user identifier\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported\n * @function createdByOnCreateUpdate\n * @memberOf module:core\n */\nexport async function createdByOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  context: Context<F>,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  data: V,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  throw new AuthorizationError(\n    \"This adapter does not support user identification\"\n  );\n}\n\n/**\n * @description Tracks the creator of a model instance\n * @summary Decorator that marks a property to store the identifier of the user who created the model instance\n * @return {Function} A decorator function that can be applied to a class property\n * @function createdBy\n * @category Property Decorators\n * @example\n * ```typescript\n * class Document extends BaseModel {\n *   @createdBy()\n *   creator!: string;\n * }\n * ```\n */\nexport function createdBy() {\n  const key = Repository.key(PersistenceKeys.CREATED_BY);\n  return Decoration.for(key)\n    .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @description Tracks the last updater of a model instance\n * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance\n * @return {Function} A decorator function that can be applied to a class property\n * @function updatedBy\n * @category Property Decorators\n * @example\n * ```typescript\n * class Document extends BaseModel {\n *   @updatedBy()\n *   lastEditor!: string;\n * }\n * ```\n */\nexport function updatedBy() {\n  const key = Repository.key(PersistenceKeys.UPDATED_BY);\n  return Decoration.for(key)\n    .define(onCreateUpdate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @description Defines a one-to-one relationship between models\n * @summary Decorator that establishes a one-to-one relationship between the current model and another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function oneToOne\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @oneToOne(Profile)\n *   profile!: string | Profile;\n * }\n *\n * class Profile extends BaseModel {\n *   @required()\n *   bio!: string;\n * }\n * ```\n * @see oneToMany\n * @see manyToOne\n */\nexport function oneToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      onCreate(oneToOneOnCreate, metadata),\n      onUpdate(oneToOneOnUpdate, metadata),\n      onDelete(oneToOneOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @description Defines a one-to-many relationship between models\n * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function oneToMany\n * @category Property Decorators\n * @example\n * ```typescript\n * class Author extends BaseModel {\n *   @required()\n *   name!: string;\n *\n *   @oneToMany(Book)\n *   books!: string[] | Book[];\n * }\n *\n * class Book extends BaseModel {\n *   @required()\n *   title!: string;\n * }\n * ```\n * @see oneToOne\n * @see manyToOne\n */\nexport function oneToMany<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      // @ts-expect-error purposeful override\n      list([clazz, String, Number, BigInt]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @description Defines a many-to-one relationship between models\n * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function manyToOne\n * @category Property Decorators\n * @example\n * ```typescript\n * class Book extends BaseModel {\n *   @required()\n *   title!: string;\n *\n *   @manyToOne(Author)\n *   author!: string | Author;\n * }\n *\n * class Author extends BaseModel {\n *   @required()\n *   name!: string;\n * }\n * ```\n * @see oneToMany\n * @see oneToOne\n */\nexport function manyToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n","import {\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  InternalError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\n\n/**\n * @description Callback function for primary key creation\n * @summary Handles the creation of primary key values for models using sequences\n * @template M - Type that extends Model\n * @template R - Type that extends Repo<M, F, C>\n * @template V - Type that extends SequenceOptions\n * @template F - Type that extends RepositoryFlags\n * @template C - Type that extends Context<F>\n * @param {Context<F>} context - The execution context\n * @param {V} data - The sequence options\n * @param key - The property key to set as primary key\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the primary key is set\n * @function pkOnCreate\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant pkOnCreate\n *   participant Adapter\n *   participant Sequence\n *\n *   Model->>pkOnCreate: Call with model instance\n *   Note over pkOnCreate: Check if key already exists\n *   alt Key exists or no type specified\n *     pkOnCreate-->>Model: Return early\n *   else Key needs to be created\n *     pkOnCreate->>pkOnCreate: Generate sequence name if not provided\n *     pkOnCreate->>Adapter: Request Sequence(data)\n *     Adapter->>Sequence: Create sequence\n *     Sequence-->>pkOnCreate: Return sequence\n *     pkOnCreate->>Sequence: Call next()\n *     Sequence-->>pkOnCreate: Return next value\n *     pkOnCreate->>Model: Set primary key value\n *   end\n */\nexport async function pkOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends SequenceOptions,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Primary Key Decorator\n * @summary Marks a property as the model's primary key with automatic sequence generation\n * This decorator combines multiple behaviors: it marks the property as unique, required,\n * and ensures the index is created properly according to the provided sequence options.\n * @param {Omit<SequenceOptions, \"cycle\" | \"startWith\" | \"incrementBy\">} opts - Options for the sequence generation\n * @return {PropertyDecorator} A property decorator that can be applied to model properties\n * @function pk\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @pk()\n *   id!: string;\n *\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts) as SequenceOptions;\n  const key = Repository.key(DBKeys.ID);\n  return Decoration.for(key)\n    .define(\n      index([OrderDirection.ASC, OrderDirection.DSC]),\n      required(),\n      readonly(),\n      // type([String.name, Number.name, BigInt.name]),\n      propMetadata(key, opts as SequenceOptions),\n      onCreate(pkOnCreate, opts as SequenceOptions)\n    )\n    .apply();\n}\n","import { DBOperations, timestamp } from \"@decaf-ts/db-decorators\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Base model class for all domain models\n * @summary An abstract base class that extends the Model class from decorator-validation and adds timestamp functionality.\n * All domain models in the application should extend this class to inherit common properties and behaviors.\n * @param {ModelArg<BaseModel>} arg - Optional initialization data for the model\n * @class BaseModel\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @required()\n *   username!: string;\n *   \n *   @email()\n *   email!: string;\n *   \n *   constructor(data?: ModelArg<User>) {\n *     super(data);\n *   }\n * }\n * \n * const user = new User({ username: 'john', email: 'john@example.com' });\n * ```\n */\nexport abstract class BaseModel extends Model {\n  /**\n   * @description Creation timestamp for the model\n   * @summary Automatically set to the current date and time when the model is created\n   */\n  @timestamp(DBOperations.CREATE)\n  createdOn!: Date;\n\n  /**\n   * @description Last update timestamp for the model\n   * @summary Automatically updated to the current date and time whenever the model is modified\n   */\n  @timestamp()\n  updatedOn!: Date;\n\n  protected constructor(arg?: ModelArg<BaseModel>) {\n    super(arg);\n  }\n}\n","import { PagingError } from \"./errors\";\nimport { Adapter } from \"../persistence\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\n\n/**\n * @description Handles pagination for database queries\n * @summary Provides functionality for navigating through paginated query results\n * \n * This abstract class manages the state and navigation of paginated database query results.\n * It tracks the current page, total pages, and record count, and provides methods for\n * moving between pages.\n * \n * @template M - The model type this paginator operates on\n * @template R - The return type of the paginated query (defaults to M[])\n * @template Q - The query type (defaults to any)\n * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries\n * @param {Q} query - The query to paginate\n * @param {number} size - The number of records per page\n * @param {Constructor<M>} clazz - The constructor for the model type\n * @class Paginator\n * @example\n * // Create a paginator for a user query\n * const userQuery = db.select().from(User);\n * const paginator = await userQuery.paginate(10); // 10 users per page\n * \n * // Get the first page of results\n * const firstPage = await paginator.page(1);\n * \n * // Navigate to the next page\n * const secondPage = await paginator.next();\n * \n * // Get information about the pagination\n * console.log(`Page ${paginator.current} of ${paginator.total}, ${paginator.count} total records`);\n * \n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Paginator\n *   participant Adapter\n *   participant Database\n *   \n *   Client->>Paginator: new Paginator(adapter, query, size, clazz)\n *   Client->>Paginator: page(1)\n *   Paginator->>Paginator: validatePage(1)\n *   Paginator->>Paginator: prepare(query)\n *   Paginator->>Adapter: execute query with pagination\n *   Adapter->>Database: execute query\n *   Database-->>Adapter: return results\n *   Adapter-->>Paginator: return results\n *   Paginator-->>Client: return page results\n *   \n *   Client->>Paginator: next()\n *   Paginator->>Paginator: page(current + 1)\n *   Paginator->>Paginator: validatePage(current + 1)\n *   Paginator->>Adapter: execute query with pagination\n *   Adapter->>Database: execute query\n *   Database-->>Adapter: return results\n *   Adapter-->>Paginator: return results\n *   Paginator-->>Client: return page results\n */\nexport abstract class Paginator<M extends Model, R = M[], Q = any> {\n  protected _currentPage!: number;\n  protected _totalPages!: number;\n  protected _recordCount!: number;\n  protected limit!: number;\n\n  private _statement?: Q;\n\n  get current() {\n    return this._currentPage;\n  }\n\n  get total() {\n    return this._totalPages;\n  }\n\n  get count(): number {\n    return this._recordCount;\n  }\n\n  protected get statement() {\n    if (!this._statement) this._statement = this.prepare(this.query);\n    return this._statement;\n  }\n\n  protected constructor(\n    protected readonly adapter: Adapter<any, Q, any, any>,\n    protected readonly query: Q,\n    readonly size: number,\n    protected readonly clazz: Constructor<M>\n  ) {}\n\n  protected abstract prepare(rawStatement: Q): Q;\n\n  async next() {\n    return this.page(this.current + 1);\n  }\n\n  async previous() {\n    return this.page(this.current - 1);\n  }\n\n  protected validatePage(page: number) {\n    if (page < 1 || !Number.isInteger(page))\n      throw new PagingError(\n        \"Page number cannot be under 1 and must be an integer\"\n      );\n    if (typeof this._totalPages !== \"undefined\" && page > this._totalPages)\n      throw new PagingError(\n        `Only ${this._totalPages} are available. Cannot go to page ${page}`\n      );\n    return page;\n  }\n\n  abstract page(page?: number): Promise<R[]>;\n}\n","import { type Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport type { Executor, RawExecutor } from \"../interfaces\";\nimport type {\n  FromSelector,\n  GroupBySelector,\n  OrderBySelector,\n  SelectSelector,\n} from \"./selectors\";\nimport { Condition } from \"./Condition\";\nimport { findPrimaryKey, InternalError } from \"@decaf-ts/db-decorators\";\nimport { final } from \"../utils/decorators\";\nimport type {\n  CountOption,\n  DistinctOption,\n  LimitOption,\n  MaxOption,\n  MinOption,\n  OffsetOption,\n  OrderAndGroupOption,\n  SelectOption,\n  WhereOption,\n} from \"./options\";\nimport { Paginatable } from \"../interfaces/Paginatable\";\nimport { Paginator } from \"./Paginator\";\nimport { Adapter } from \"../persistence\";\nimport { QueryError } from \"./errors\";\n\n/**\n * @description Base class for database query statements\n * @summary Provides a foundation for building and executing database queries\n * \n * This abstract class implements the query builder pattern for constructing\n * database queries. It supports various query operations like select, from,\n * where, orderBy, groupBy, limit, and offset. It also provides methods for\n * executing queries and handling pagination.\n * \n * @template Q - The query type specific to the database adapter\n * @template M - The model type this statement operates on\n * @template R - The return type of the query\n * @param {Adapter<any, Q, any, any>} adapter - The database adapter to use for executing queries\n * @class Statement\n * @example\n * // Create a statement to query users\n * const statement = new SQLStatement(adapter);\n * const users = await statement\n *   .select()\n *   .from(User)\n *   .where(Condition.attribute(\"status\").eq(\"active\"))\n *   .orderBy([\"createdAt\", \"DESC\"])\n *   .limit(10)\n *   .execute();\n * \n * // Use pagination\n * const paginator = await statement\n *   .select()\n *   .from(User)\n *   .paginate(20); // 20 users per page\n * \n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Statement\n *   participant Adapter\n *   participant Database\n *   \n *   Client->>Statement: select()\n *   Client->>Statement: from(Model)\n *   Client->>Statement: where(condition)\n *   Client->>Statement: orderBy([field, direction])\n *   Client->>Statement: limit(value)\n *   Client->>Statement: execute()\n *   Statement->>Statement: build()\n *   Statement->>Adapter: raw(query)\n *   Adapter->>Database: execute query\n *   Database-->>Adapter: return results\n *   Adapter-->>Statement: return processed results\n *   Statement-->>Client: return final results\n */\nexport abstract class Statement<Q, M extends Model, R>\n  implements Executor<R>, RawExecutor<Q>, Paginatable<M, R, Q>\n{\n  protected readonly selectSelector?: SelectSelector<M>[];\n  protected distinctSelector?: SelectSelector<M>;\n  protected maxSelector?: SelectSelector<M>;\n  protected minSelector?: SelectSelector<M>;\n  protected countSelector?: SelectSelector<M>;\n  protected fromSelector!: Constructor<M>;\n  protected whereCondition?: Condition<M>;\n  protected orderBySelector?: OrderBySelector<M>;\n  protected groupBySelector?: GroupBySelector<M>;\n  protected limitSelector?: number;\n  protected offsetSelector?: number;\n\n  protected constructor(protected adapter: Adapter<any, Q, any, any>) {}\n\n  select<\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    S extends readonly SelectSelector<M>[],\n  >(): SelectOption<M, M[]>;\n  select<S extends readonly SelectSelector<M>[]>(\n    selector: readonly [...S]\n  ): SelectOption<M, Pick<M, S[number]>[]>;\n\n  @final()\n  select<S extends readonly SelectSelector<M>[]>(\n    selector?: readonly [...S]\n  ): SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]> {\n    Object.defineProperty(this, \"selectSelector\", {\n      value: selector,\n      writable: false,\n    });\n    return this as SelectOption<M, M[]> | SelectOption<M, Pick<M, S[number]>[]>;\n  }\n\n  @final()\n  distinct<S extends SelectSelector<M>>(\n    selector: S\n  ): DistinctOption<M, M[S][]> {\n    this.distinctSelector = selector;\n    return this as DistinctOption<M, M[S][]>;\n  }\n\n  @final()\n  max<S extends SelectSelector<M>>(selector: S): MaxOption<M, M[S]> {\n    this.maxSelector = selector;\n    return this as MaxOption<M, M[S]>;\n  }\n\n  @final()\n  min<S extends SelectSelector<M>>(selector: S): MinOption<M, M[S]> {\n    this.minSelector = selector;\n    return this as MinOption<M, M[S]>;\n  }\n\n  @final()\n  count<S extends SelectSelector<M>>(selector?: S): CountOption<M, number> {\n    this.countSelector = selector;\n    return this as CountOption<M, number>;\n  }\n\n  @final()\n  public from(selector: FromSelector<M>): WhereOption<M, R> {\n    this.fromSelector = (\n      typeof selector === \"string\" ? Model.get(selector) : selector\n    ) as Constructor<M>;\n    if (!this.fromSelector)\n      throw new QueryError(`Could not find selector model: ${selector}`);\n    return this;\n  }\n\n  @final()\n  public where(condition: Condition<M>): OrderAndGroupOption<M, R> {\n    this.whereCondition = condition;\n    return this;\n  }\n\n  @final()\n  public orderBy(\n    selector: OrderBySelector<M>\n  ): LimitOption<M, R> & OffsetOption<R> {\n    this.orderBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public groupBy(selector: GroupBySelector<M>): LimitOption<M, R> {\n    this.groupBySelector = selector;\n    return this;\n  }\n\n  @final()\n  public limit(value: number): OffsetOption<R> {\n    this.limitSelector = value;\n    return this;\n  }\n\n  @final()\n  public offset(value: number): Executor<R> {\n    this.offsetSelector = value;\n    return this;\n  }\n\n  @final()\n  async execute(): Promise<R> {\n    try {\n      const query: Q = this.build();\n      return (await this.raw(query)) as R;\n    } catch (e: unknown) {\n      throw new InternalError(e as Error);\n    }\n  }\n\n  async raw<R>(rawInput: Q): Promise<R> {\n    const results = await this.adapter.raw<R>(rawInput);\n    if (!this.selectSelector) return results;\n    const pkAttr = findPrimaryKey(\n      new (this.fromSelector as Constructor<M>)()\n    ).id;\n\n    const processor = function recordProcessor(\n      this: Statement<Q, M, R>,\n      r: any\n    ) {\n      const id = r[pkAttr];\n      return this.adapter.revert(\n        r,\n        this.fromSelector as Constructor<any>,\n        pkAttr,\n        id\n      ) as any;\n    }.bind(this as any);\n\n    if (Array.isArray(results)) return results.map(processor) as R;\n    return processor(results) as R;\n  }\n\n  protected abstract build(): Q;\n  protected abstract parseCondition(condition: Condition<M>): Q;\n  abstract paginate(size: number): Promise<Paginator<M, R, Q>>;\n}\n","/**\n * @module core\n * @description Core module for the Decaf TypeScript framework\n * @summary This module provides the foundational components of the Decaf framework, including identity management, \n * model definitions, repository patterns, persistence layer, query building, and utility functions.\n * It exports functionality from various submodules and sets up the injectable registry for repository decorators.\n */\n\nimport { InjectablesRegistry } from \"./repository\";\nimport { Injectables } from \"@decaf-ts/injectable-decorators\";\n\n// overrides the previous Injectables registry to enable the @repository decorator\nInjectables.setRegistry(new InjectablesRegistry());\n\nexport * from \"./identity\";\nexport * from \"./interfaces\";\nexport * from \"./model\";\nexport * from \"./query\";\nexport * from \"./repository\";\nexport * from \"./utils\";\n//left to last on purpose\nexport * from \"./persistence\";\n\n/**\n * @description Stores the current package version\n * @summary A constant representing the version of the core package\n * @const VERSION\n * @memberOf module:core\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["Rep","populate","pop"],"mappings":"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"}