@decaf-ts/core 0.5.21 → 0.5.23

package/dist/core.cjs

@@ -1,48 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/injectable-decorators'), require('@decaf-ts/db-decorators'), require('@decaf-ts/reflection'), require('@decaf-ts/decorator-validation'), require('tslib'), require('@decaf-ts/logging')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/injectable-decorators', '@decaf-ts/db-decorators', '@decaf-ts/reflection', '@decaf-ts/decorator-validation', 'tslib', '@decaf-ts/logging'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.core = {}, global.injectableDecorators, global.dbDecorators, global.reflection, global.decoratorValidation, global.tslib, global.logging));
-})(this, (function (exports, injectableDecorators, dbDecorators, reflection, decoratorValidation, tslib, logging) { 'use strict';
-
-    /**
-     * @description Enumeration of possible sort directions.
-     * @summary Defines the available sort directions for ordering query results.
-     * @enum {string}
-     * @readonly
-     * @memberOf module:core
-     */
-    exports.OrderDirection = void 0;
-    (function (OrderDirection) {
-        /** Ascending order (A to Z, 0 to 9) */
-        OrderDirection["ASC"] = "asc";
-        /** Descending order (Z to A, 9 to 0) */
-        OrderDirection["DSC"] = "desc";
-    })(exports.OrderDirection || (exports.OrderDirection = {}));
-    /**
-     * @description Enumeration of cascade operation types.
-     * @summary Defines the available cascade behaviors for entity relationships.
-     * @enum {string}
-     * @readonly
-     * @memberOf module:core
-     */
-    exports.Cascade = void 0;
-    (function (Cascade) {
-        /** Perform cascade operation on related entities */
-        Cascade["CASCADE"] = "cascade";
-        /** Do not perform cascade operation on related entities */
-        Cascade["NONE"] = "none";
-    })(exports.Cascade || (exports.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: exports.Cascade.CASCADE,
-        delete: exports.Cascade.NONE,
-    };
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/injectable-decorators'), require('tslib'), require('@decaf-ts/db-decorators'), require('@decaf-ts/decorator-validation'), require('@decaf-ts/logging'), require('@decaf-ts/reflection')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/injectable-decorators', 'tslib', '@decaf-ts/db-decorators', '@decaf-ts/decorator-validation', '@decaf-ts/logging', '@decaf-ts/reflection'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.core = {}, global.injectableDecorators, global.tslib, global.dbDecorators, global.decoratorValidation, global.logging, global.reflection));
+})(this, (function (exports, injectableDecorators, tslib, dbDecorators, decoratorValidation, logging, reflection) { 'use strict';
 
     /**
      * @description Persistence-related constant keys
@@ -124,9 +84,9 @@
      * }
      * ```
      */
-    class AuthorizationError extends dbDecorators.BaseError {
-        constructor(msg) {
-            super(AuthorizationError.name, msg, 401);
+    class AuthorizationError extends dbDecorators.BadRequestError {
+        constructor(msg, name = AuthorizationError.name, code = 401) {
+            super(msg, name, code);
         }
     }
     /**
@@ -144,9 +104,9 @@
      * }
      * ```
      */
-    class ForbiddenError extends dbDecorators.BaseError {
+    class ForbiddenError extends AuthorizationError {
         constructor(msg) {
-            super(ForbiddenError.name, msg, 403);
+            super(msg, ForbiddenError.name, 403);
         }
     }
     /**
@@ -166,9 +126,9 @@
      * }
      * ```
      */
-    class ConnectionError extends dbDecorators.BaseError {
+    class ConnectionError extends dbDecorators.InternalError {
         constructor(msg) {
-            super(ConnectionError.name, msg, 503);
+            super(msg, ConnectionError.name, 503);
         }
     }
 
@@ -195,9 +155,9 @@
      * }
      * ```
      */
-    class UnsupportedError extends dbDecorators.BaseError {
+    class UnsupportedError extends dbDecorators.InternalError {
         constructor(msg) {
-            super(UnsupportedError.name, msg, 500);
+            super(msg, UnsupportedError.name, 500);
         }
     }
 
@@ -227,22 +187,14 @@
      * 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.Logging.for(this).for(this.adapter);
-            return this.logger;
-        }
+    class Dispatch extends logging.LoggedClass {
         /**
          * @description Creates a new Dispatch instance
          * @summary Initializes a new Dispatch instance without any adapter
          */
-        constructor() { }
+        constructor() {
+            super();
+        }
         /**
          * @description Initializes the dispatch by proxying adapter methods
          * @summary Sets up proxies on the adapter's CRUD methods to intercept operations and notify observers.
@@ -349,7 +301,7 @@
             if (!(observer instanceof Adapter))
                 throw new UnsupportedError("Only Adapters can be observed by dispatch");
             this.adapter = observer;
-            this.native = observer.native;
+            this.native = observer.config;
             this.models = Adapter.models(this.adapter.alias);
             this.initialize().then(() => this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`));
         }
@@ -541,24 +493,24 @@
         }
     });
     /**
-     * @description Abstract base class for database adapters
+     * @description Abstract Facade class for persistence 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
+     * @template CONFIG - The underlying persistence driver config
+     * @template QUERY - The query object type used by the adapter
+     * @template FLAGS - The repository flags type
+     * @template CONTEXT - The context type
+     * @param {CONFIG} _config - The underlying persistence driver config
      * @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) {
+     * class PostgresAdapter extends Adapter<pg.PoolConfig, pg.Query, PostgresFlags, PostgresContext> {
+     *   constructor(client: pg.PoolConfig) {
      *     super(client, 'postgres');
      *   }
      *
@@ -632,25 +584,16 @@
      *   Adapter --|> Observer
      *   Adapter --|> ErrorParser
      */
-    class Adapter {
+    class Adapter extends logging.LoggedClass {
         static { this._cache = {}; }
         /**
-         * @description Logger accessor
-         * @summary Gets or initializes the logger for this adapter instance
-         * @return {Logger} The logger instance
+         * @description Gets the native persistence config
+         * @summary Provides access to the underlying persistence driver config
+         * @template CONF
+         * @return {CONF} The native persistence driver config
          */
-        get log() {
-            if (!this.logger)
-                this.logger = logging.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;
+        get config() {
+            return this._config;
         }
         /**
          * @description Gets the adapter's alias or flavor name
@@ -664,17 +607,56 @@
          * @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
+         * @return {Constructor<Repository<M, QUERY, Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>, FLAGS, CONTEXT>>} The repository constructor
          */
         repository() {
             return Repository;
         }
+        async shutdownProxies(k) {
+            if (!this.proxies)
+                return;
+            if (k && !(k in this.proxies))
+                throw new dbDecorators.InternalError(`No proxy found for ${k}`);
+            if (!k) {
+                for (const key in this.proxies) {
+                    try {
+                        await this.proxies[key].shutdown();
+                    }
+                    catch (e) {
+                        this.log.error(`Failed to shutdown proxied adapter ${key}: ${e}`);
+                        continue;
+                    }
+                    delete this.proxies[key];
+                }
+            }
+            else {
+                try {
+                    await this.proxies[k].shutdown();
+                    delete this.proxies[k];
+                }
+                catch (e) {
+                    this.log.error(`Failed to shutdown proxied adapter ${k}: ${e}`);
+                }
+            }
+        }
+        /**
+         * @description Shuts down the adapter
+         * @summary Performs any necessary cleanup tasks, such as closing connections
+         * When overriding this method, ensure to call the base method first
+         * @return {Promise<void>} A promise that resolves when shutdown is complete
+         */
+        async shutdown() {
+            await this.shutdownProxies();
+            if (this.dispatch)
+                await this.dispatch.close();
+        }
         /**
          * @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;
+        constructor(_config, flavour, _alias) {
+            super();
+            this._config = _config;
             this.flavour = flavour;
             this._alias = _alias;
             /**
@@ -682,7 +664,7 @@
              * @summary Reference to the context class constructor used by this adapter
              */
             this.Context = (dbDecorators.Context);
-            if (this.flavour in Adapter._cache)
+            if (this.alias in Adapter._cache)
                 throw new dbDecorators.InternalError(`${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : ""} already registered`);
             Adapter._cache[this.alias] = this;
             this.log.info(`Created ${this.alias} persistence adapter ${this._alias ? `(${this.flavour}) ` : ""} persistence adapter`);
@@ -716,6 +698,14 @@
         isReserved(attr) {
             return !attr;
         }
+        /**
+         * @description Initializes the adapter
+         * @summary Performs any necessary setup for the adapter, such as establishing connections
+         * @param {...any[]} args - Initialization arguments
+         * @return {Promise<void>} A promise that resolves when initialization is complete
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        async initialize(...args) { }
         /**
          * @description Creates repository flags for an operation
          * @summary Generates a set of flags that describe a database operation, combining default flags with overrides
@@ -998,12 +988,13 @@
         /**
          * @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
+         * @template CONF - The database driver config
+         * @template CONN - The database driver instance
+         * @template QUERY - The query type
+         * @template CCONTEXT - The context type
+         * @template FLAGS - 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
+         * @return {Adapter<CONF, CONN, QUERY, CONTEXT, FLAGS> | undefined} The adapter instance or undefined if not found
          */
         static get(flavour) {
             if (!flavour)
@@ -1063,19 +1054,49 @@
             }
         }
         static decoration() { }
-        /**
-         * @description Creates a child Adapter with specific congigurations
-         * @summary Returns a new Adapter instance with specific congigurations
-         * @param {string | Function} config - The method name or function to create a logger for
-         * @param {Partial<LoggingConfig>} config - Optional configuration to override settings
-         * @param {...any} args - Additional arguments to pass to the logger factory
-         * @return {Logger} A new logger instance for the specified method
-         */
+        get client() {
+            if (!this._client) {
+                this._client = this.getClient();
+            }
+            return this._client;
+        }
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        for(...args) {
-            throw new UnsupportedError("Method not supported by default");
+        for(config, ...args) {
+            if (!this.proxies)
+                this.proxies = {};
+            const key = `${this.alias} - ${decoratorValidation.hashObj(config)}`;
+            if (key in this.proxies)
+                return this.proxies[key];
+            let client;
+            const proxy = new Proxy(this, {
+                get: (target, p, receiver) => {
+                    if (p === "_config") {
+                        const originalConf = Reflect.get(target, p, receiver);
+                        return Object.assign({}, originalConf, config);
+                    }
+                    if (p === "_client") {
+                        return client;
+                    }
+                    return Reflect.get(target, p, receiver);
+                },
+                set: (target, p, value, receiver) => {
+                    if (p === "_client") {
+                        client = value;
+                        return true;
+                    }
+                    return Reflect.set(target, p, value, receiver);
+                },
+            });
+            this.proxies[key] = proxy;
+            return proxy;
         }
     }
+    tslib.__decorate([
+        final(),
+        tslib.__metadata("design:type", Function),
+        tslib.__metadata("design:paramtypes", [String]),
+        tslib.__metadata("design:returntype", Promise)
+    ], Adapter.prototype, "shutdownProxies", null);
     tslib.__decorate([
         final(),
         tslib.__metadata("design:type", Function),
@@ -1094,6 +1115,52 @@
         tslib.__metadata("design:paramtypes", [Object]),
         tslib.__metadata("design:returntype", void 0)
     ], Adapter.prototype, "unObserve", null);
+    tslib.__decorate([
+        final(),
+        tslib.__metadata("design:type", Object),
+        tslib.__metadata("design:paramtypes", [])
+    ], Adapter.prototype, "client", null);
+
+    /**
+     * @description Enumeration of possible sort directions.
+     * @summary Defines the available sort directions for ordering query results.
+     * @enum {string}
+     * @readonly
+     * @memberOf module:core
+     */
+    exports.OrderDirection = void 0;
+    (function (OrderDirection) {
+        /** Ascending order (A to Z, 0 to 9) */
+        OrderDirection["ASC"] = "asc";
+        /** Descending order (Z to A, 9 to 0) */
+        OrderDirection["DSC"] = "desc";
+    })(exports.OrderDirection || (exports.OrderDirection = {}));
+    /**
+     * @description Enumeration of cascade operation types.
+     * @summary Defines the available cascade behaviors for entity relationships.
+     * @enum {string}
+     * @readonly
+     * @memberOf module:core
+     */
+    exports.Cascade = void 0;
+    (function (Cascade) {
+        /** Perform cascade operation on related entities */
+        Cascade["CASCADE"] = "cascade";
+        /** Do not perform cascade operation on related entities */
+        Cascade["NONE"] = "none";
+    })(exports.Cascade || (exports.Cascade = {}));
+    /**
+     * @description Shape of the default cascade configuration object used in repositories.
+     * @summary Documents the structure of the cascade configuration with explicit update and delete behaviors.
+     * @property {'cascade'|'none'} update - Determines whether updates cascade to related entities.
+     * @property {'cascade'|'none'} delete - Determines whether deletes cascade to related entities.
+     * @typeDef DefaultCascadeConfig
+     * @memberOf module:core
+     */
+    const DefaultCascade = {
+        update: exports.Cascade.CASCADE,
+        delete: exports.Cascade.NONE,
+    };
 
     /**
      * @description Gets the table name for a model
@@ -1306,7 +1373,7 @@
          */
         get log() {
             if (!this.logger)
-                this.logger = logging.Logging.for(this);
+                this.logger = this.adapter["log"].for(this.toString());
             return this.logger;
         }
         /**
@@ -1379,23 +1446,23 @@
             });
         }
         /**
-         * Creates a new instance of the Repository class with a specific adapter and arguments.
+         * @description Creates a new instance of the Repository class with a specific adapter and arguments.
          *
          * @template A - The type of the adapter.
          * @template Q - The type of the query builder.
          * @template F - The type of the filter.
          * @template C - The type of the context.
          *
-         * @param adapter - The adapter to be used for the new instance.
-         * @param args - Additional arguments to be passed to the new instance.
+         * @param {Partial<InferredAdapterConfig<A>>} conf - adapter configurations to override.
+         * @param [args] - Additional arguments to be passed to the new instance.
          *
          * @return A new instance of the Repository class with the specified adapter and arguments.
          */
-        for(...args) {
+        for(conf, ...args) {
             return new Proxy(this, {
                 get: (target, p, receiver) => {
                     if (p === "adapter") {
-                        return this.adapter.for(...args);
+                        return this.adapter.for(conf, ...args);
                     }
                     return Reflect.get(target, p, receiver);
                 },
@@ -1884,6 +1951,7 @@
          * @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.
+         * @param {string} [alias] the adapter alias/flavour.
          * @throws {InternalError} If a repository is already registered for the model.
          */
         static register(model, repo, alias) {
@@ -2026,85 +2094,36 @@
     ], 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} [flavour] - the required adapter's flavour/alias. If not provided, it will be retrieved from the model metadata..
-     * @return {any} - The decorator function.
-     * @function repository
+     * @description Generates a unique injectable name for a repository.
+     * @summary Creates a standardized injectable token for repositories using the adapter flavour and model table name.
+     * This helps the DI system register and resolve repository instances consistently across adapters.
+     * @template T The model type that extends Model.
+     * @param {Constructor<T> | T} model The model constructor or instance from which to derive the table name.
+     * @param {string} [flavour] Optional adapter flavour/alias. If omitted, it is read from model metadata.
+     * @return {string} A namespaced injectable token for the repository (e.g., "db:repo:ram:users").
+     * @throws {InternalError} If the flavour cannot be determined from arguments or metadata.
+     * @function generateInjectableNameForRepository
      * @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
+     *   participant C as Caller
+     *   participant U as generateInjectableNameForRepository
+     *   participant R as Reflect Metadata
+     *   participant A as Adapter
+     *   participant S as String Formatter
+     *   C->>U: call(model, flavour?)
+     *   alt flavour provided
+     *     U-->>U: use provided flavour
+     *   else flavour not provided
+     *     U->>A: Adapter.key(ADAPTER)
+     *     U->>R: getMetadata(key, model|model.ctor)
+     *     alt metadata present
+     *       R-->>U: flavour
+     *     else missing
+     *       U-->>C: throw InternalError
+     *     end
      *   end
-     * @category Decorators
-     */
-    function repository(model, flavour) {
-        return ((original, propertyKey) => {
-            if (propertyKey) {
-                return injectableDecorators.inject(model[decoratorValidation.ModelKeys.ANCHOR] || model)(original, propertyKey);
-            }
-            reflection.metadata(Repository.key(dbDecorators.DBKeys.REPOSITORY), original.name)(model);
-            flavour =
-                flavour ||
-                    Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), original);
-            Repository.register(model[decoratorValidation.ModelKeys.ANCHOR] || model, original, flavour);
-            return injectableDecorators.injectable(model[decoratorValidation.ModelKeys.ANCHOR] || model, {
-                callback: (instance) => {
-                    Object.defineProperty(instance, dbDecorators.DBKeys.CLASS, {
-                        enumerable: false,
-                        configurable: false,
-                        writable: false,
-                        value: model,
-                    });
-                },
-            })(original);
-        });
-    }
-
-    /**
-     * @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
-     * @category Errors
-     * @example
-     * try {
-     *   // Some repository observer operation
-     * } catch (error) {
-     *   if (error instanceof ObserverError) {
-     *     console.error('Observer communication failed:', error.message);
-     *   }
-     * }
-     */
-    class ObserverError extends dbDecorators.BaseError {
-        constructor(msg) {
-            super(ObserverError.name, msg, 500);
-        }
-    }
-
-    /**
-     * @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
+     *   U->>S: sf(INJECTABLE, flavour, Repository.table(model))
+     *   S-->>C: token string
      * @memberOf module:core
      */
     function generateInjectableNameForRepository(model, flavour) {
@@ -2118,51 +2137,159 @@
     }
 
     /**
-     * @description Registry for injectable repositories.
-     * @summary Extends the base injectable registry to provide automatic repository resolution for models.
-     * @param {void} - No constructor parameters required.
+     * @description Registry for injectable repositories with auto-resolution.
+     * @summary Provides an InjectableRegistry implementation that resolves repositories by model name or constructor. If a repository
+     * is not explicitly registered, it attempts to infer the correct repository using model metadata and the active or specified adapter flavour.
+     * @param {void} [constructor] No constructor parameters required; the superclass handles internal state.
      * @class InjectablesRegistry
      * @example
+     * // Basic usage: retrieve a repository by model name
      * 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
+     * // If UserRepository is registered, it will be returned. Otherwise, a repository will be created if a User model exists.
+     *
+     * // Retrieve by constructor and specify adapter flavour
+     * const repoByCtor = registry.get<UserRepository>(UserModel, 'ram');
+     *
+     * // Retrieve by symbol (e.g., injectable token)
+     * const token = Symbol.for('UserRepository');
+     * const byToken = registry.get<UserRepository>(token);
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Consumer
+     *   participant R as InjectablesRegistry
+     *   participant B as BaseRegistry
+     *   participant M as Model
+     *   participant A as Adapter
+     *   participant RP as Repository
+     *   C->>R: get(name, flavour?)
+     *   activate R
+     *   R->>B: super.get(name)
+     *   alt Found in base registry
+     *     B-->>R: injectable
+     *     R-->>C: injectable
+     *   else Not found
+     *     R->>M: Model.get(name)
+     *     alt Model found
+     *       R->>A: resolve flavour (from arg/metadata/current)
+     *       R->>RP: Repository.forModel(modelCtor, alias)
+     *       alt Repository instance
+     *         RP-->>R: repository instance
+     *         R-->>C: repository instance
+     *       else Repository ctor
+     *         R->>A: Adapter.get(resolvedFlavour) or Adapter.current
+     *         A-->>R: adapter instance
+     *         R->>RP: new repoCtor(adapter, modelCtor)
+     *         R-->>C: repository instance
+     *       end
+     *     else Model not found
+     *       R-->>C: undefined
+     *     end
+     *   end
      */
     class InjectablesRegistry extends injectableDecorators.InjectableRegistryImp {
+        get log() {
+            if (!this.logger)
+                this.logger = logging.Logging.for(this);
+            return this.logger;
+        }
         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.
+         * @description Retrieve an injectable with repository auto-resolution.
+         * @summary Attempts to get an injectable from the base registry; if not found and the name refers to a known model, it
+         * resolves the appropriate repository using the specified flavour or model metadata, falling back to the current adapter when needed.
+         * @template T The injectable type to be returned.
+         * @param {string | symbol | Constructor<T>} name Token, model name, or constructor associated with the injectable or model.
+         * @param {string} [flavour] Optional adapter flavour (e.g., "ram"). If omitted, derives from metadata or current adapter.
+         * @return {T | undefined} The located or auto-created injectable instance; otherwise undefined if it cannot be resolved.
+         * @mermaid
+         * sequenceDiagram
+         *   participant G as get(name, flavour?)
+         *   participant BR as BaseRegistry
+         *   participant M as Model
+         *   participant A as Adapter
+         *   participant RP as Repository
+         *   G->>BR: super.get(name)
+         *   alt Found
+         *     BR-->>G: injectable
+         *   else Not found
+         *     G->>M: derive modelCtor from name
+         *     alt modelCtor resolved
+         *       G->>A: resolve flavour (arg | metadata | current)
+         *       G->>RP: Repository.forModel(modelCtor, alias)
+         *       alt returns instance
+         *         RP-->>G: Repository instance
+         *       else returns ctor
+         *         G->>A: Adapter.get(flavour) | Adapter.current
+         *         A-->>G: adapter instance
+         *         G->>RP: new repoCtor(adapter, modelCtor)
+         *       end
+         *     else no modelCtor
+         *       G-->>G: return undefined
+         *     end
+         *   end
          */
         get(name, flavour) {
-            let injectable = super.get(name);
-            if (!injectable)
+            const log = this.log.for(this.get);
+            // First, try base registry, but guard against thrown errors
+            let injectable;
+            try {
+                injectable = super.get(name);
+            }
+            catch {
+                // do nothing. we handle it later
+            }
+            if (!injectable) {
+                let modelCtor;
+                if (typeof name === "function")
+                    modelCtor = name;
+                else if (typeof name === "symbol" || typeof name === "string") {
+                    modelCtor = decoratorValidation.Model.get(name.toString());
+                }
+                if (!modelCtor)
+                    return undefined;
+                // Resolve flavour from metadata if not provided
+                const metaKey = Adapter.key(exports.PersistenceKeys.ADAPTER);
+                const resolvedFlavour = flavour ||
+                    Reflect.getMetadata(metaKey, modelCtor);
                 try {
-                    let m = name;
-                    if (typeof name === "symbol" || typeof name === "string") {
-                        m = decoratorValidation.Model.get(name.toString());
+                    // Determine an alias to use: prefer a directly registered adapter; otherwise, if the current adapter
+                    // has the same flavour, use its alias to satisfy Repository.forModel/Adapter.get lookups.
+                    let aliasToUse = resolvedFlavour;
+                    try {
+                        if (resolvedFlavour)
+                            Adapter.get(resolvedFlavour);
                     }
-                    if (m)
-                        injectable = Repository.forModel(m, flavour);
-                    if (injectable) {
-                        if (injectable instanceof Repository)
-                            return injectable;
-                        flavour =
-                            flavour ||
-                                Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), injectable.constructor) ||
-                                Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), m);
-                        injectableDecorators.Injectables.register(injectable, generateInjectableNameForRepository(m, flavour));
+                    catch {
+                        const current = Adapter.current;
+                        if (current && current.flavour === resolvedFlavour)
+                            aliasToUse = current.alias;
                     }
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    injectable = Repository.forModel(modelCtor, aliasToUse);
+                    if (injectable instanceof Repository)
+                        return injectable;
+                    // Otherwise, register the resolved injectable name for later retrieval
+                    const f = resolvedFlavour ||
+                        Reflect.getMetadata(metaKey, injectable.constructor) ||
+                        Reflect.getMetadata(metaKey, modelCtor);
+                    injectableDecorators.Injectables.register(injectable, generateInjectableNameForRepository(modelCtor, f));
                 }
                 catch (e) {
-                    return undefined;
+                    log.debug(`No registered repository or adapter found. falling back to default adapter`);
+                    const repoCtor = Repository["get"](modelCtor, resolvedFlavour);
+                    if (typeof repoCtor === "function") {
+                        const adapter = resolvedFlavour
+                            ? Adapter.get(resolvedFlavour)
+                            : Adapter.current;
+                        if (!adapter)
+                            return undefined;
+                        const instance = new repoCtor(adapter, modelCtor);
+                        return instance;
+                    }
                 }
+            }
             return injectable;
         }
     }
@@ -2262,9 +2389,9 @@
      * @class QueryError
      * @category Errors
      */
-    class QueryError extends dbDecorators.BaseError {
+    class QueryError extends dbDecorators.InternalError {
         constructor(msg) {
-            super(QueryError.name, msg, 500);
+            super(msg, QueryError.name, 500);
         }
     }
     /**
@@ -2274,9 +2401,9 @@
      * @class PagingError
      * @category Errors
      */
-    class PagingError extends dbDecorators.BaseError {
+    class PagingError extends dbDecorators.InternalError {
         constructor(msg) {
-            super(PagingError.name, msg, 500);
+            super(msg, PagingError.name, 500);
         }
     }
 
@@ -2302,6 +2429,14 @@
      * const userQuery = Condition.builder()
      *   .attribute("email").regexp(".*@example.com")
      *   .and(Condition.attribute("lastLogin").gt(new Date("2023-01-01")));
+     * @mermaid
+     * sequenceDiagram
+     *   participant Dev
+     *   participant Condition
+     *   Dev->>Condition: builder().attribute("age").gt(18)
+     *   Condition-->>Dev: Condition(age > 18)
+     *   Dev->>Condition: .and(attribute("status").eq("active"))
+     *   Condition-->>Dev: Condition((age > 18) AND (status = "active"))
      */
     class Condition extends decoratorValidation.Model {
         constructor(attr1, operator, comparison) {
@@ -3659,6 +3794,78 @@
             .apply();
     }
 
+    /**
+     * @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} [flavour] - the required adapter's flavour/alias. If not provided, it will be retrieved from the model metadata..
+     * @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, flavour) {
+        return ((original, propertyKey) => {
+            if (propertyKey) {
+                return injectableDecorators.inject(model[decoratorValidation.ModelKeys.ANCHOR] || model)(original, propertyKey);
+            }
+            reflection.metadata(Repository.key(dbDecorators.DBKeys.REPOSITORY), original.name)(model);
+            flavour =
+                flavour ||
+                    Reflect.getMetadata(Adapter.key(exports.PersistenceKeys.ADAPTER), original);
+            Repository.register(model[decoratorValidation.ModelKeys.ANCHOR] || model, original, flavour);
+            return injectableDecorators.injectable(model[decoratorValidation.ModelKeys.ANCHOR] || model, {
+                callback: (instance) => {
+                    Object.defineProperty(instance, dbDecorators.DBKeys.CLASS, {
+                        enumerable: false,
+                        configurable: false,
+                        writable: false,
+                        value: model,
+                    });
+                    return instance;
+                },
+            })(original);
+        });
+    }
+
+    /**
+     * @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
+     * @category Errors
+     * @example
+     * try {
+     *   // Some repository observer operation
+     * } catch (error) {
+     *   if (error instanceof ObserverError) {
+     *     console.error('Observer communication failed:', error.message);
+     *   }
+     * }
+     */
+    class ObserverError extends dbDecorators.InternalError {
+        constructor(msg) {
+            super(msg, ObserverError.name, 500);
+        }
+    }
+
     /**
      * @description Callback function for primary key creation
      * @summary Handles the creation of primary key values for models using sequences
@@ -3940,8 +4147,9 @@
      *   Adapter-->>Statement: return processed results
      *   Statement-->>Client: return final results
      */
-    class Statement {
+    class Statement extends logging.LoggedClass {
         constructor(adapter) {
+            super();
             this.adapter = adapter;
         }
         get log() {
@@ -4107,7 +4315,7 @@
      * @const VERSION
      * @memberOf module:core
      */
-    const VERSION = "0.5.21";
+    const VERSION = "0.5.23";
 
     exports.Adapter = Adapter;
     exports.AuthorizationError = AuthorizationError;
@@ -4167,4 +4375,4 @@
     exports.uses = uses;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.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  // Ownership\n  /** @description Key for created-by ownership metadata */\n  OWNERSHIP = \"ownership\",\n\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\n  /** @description Key for relations metadata storage */\n  RELATIONS = \"__relations\",\n\n  /** @description Key for relations metadata storage */\n  RELATION = \"relation\",\n\n  /** @description Key for one-to-one relation metadata */\n  ONE_TO_ONE = `${RELATION}.one-to-one`,\n\n  /** @description Key for one-to-many relation metadata */\n  ONE_TO_MANY = `${RELATION}.one-to-many`,\n\n  /** @description Key for many-to-one relation metadata */\n  MANY_TO_ONE = `${RELATION}.many-to-one`,\n  /** @description Key for many-to-one relation metadata */\n  MANY_TO_MANY = `${RELATION}.many-to-many`,\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) => {\n          o.observer.refresh(table, event, id, ...args);\n        })\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  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\";\nimport { UnsupportedError } from \"./errors\";\n\nDecoration.setFlavourResolver((obj: object) => {\n  try {\n    return (\n      Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : (obj as any)) ||\n      Adapter.currentFlavour ||\n      DefaultFlavour\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    // return DefaultFlavour;\n  }\n  try {\n    return Adapter.currentFlavour || DefaultFlavour;\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 _currentFlavour: string;\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<true | false>>(): 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._currentFlavour) {\n      this.log.verbose(`Defined ${this.alias} persistence adapter as current`);\n      Adapter._currentFlavour = this.alias;\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(): 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): boolean {\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 {Promise<F>} The complete set of flags\n   */\n  protected async 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  ): Promise<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    const log = this.log.for(this.context);\n    log.debug(\n      `Creating new context for ${operation} operation on ${model.name} model with flag overrides: ${JSON.stringify(overrides)}`\n    );\n    const flags = await this.flags(operation, model, overrides, ...args);\n    return new this.Context().accumulate(flags) 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    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  static get currentFlavour() {\n    if (!Adapter._currentFlavour)\n      throw new InternalError(\n        `No persistence flavour set. Please initialize your adapter`\n      );\n    return Adapter._currentFlavour;\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(): Adapter<any, any, any, any> | undefined {\n    return Adapter.get(this.currentFlavour);\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) return Adapter.get(this._currentFlavour);\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    this._currentFlavour = flavour;\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  static decoration(): void {}\n\n  /**\n   * @description Creates a child Adapter with specific congigurations\n   * @summary Returns a new Adapter instance with specific congigurations\n   * @param {string | Function} config - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} config - Optional configuration to override settings\n   * @param {...any} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified method\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  for(...args: any[]): Adapter<Y, Q, F, C> {\n    throw new UnsupportedError(\"Method not supported by default\");\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\";\nimport { UnsupportedError } from \"./errors\";\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(): Logger {\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\" | string | 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      case undefined:\n        return value;\n      default:\n        throw new UnsupportedError(\n          `Unsupported sequence type: ${type} for adapter ${this}`\n        );\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 function uses(original: any) {\n    return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour))(\n      original\n    );\n  };\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<true | false>,\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<true | false>,\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  protected _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   * Creates a new instance of the Repository class with a specific adapter and arguments.\n   *\n   * @template A - The type of the adapter.\n   * @template Q - The type of the query builder.\n   * @template F - The type of the filter.\n   * @template C - The type of the context.\n   *\n   * @param adapter - The adapter to be used for the new instance.\n   * @param args - Additional arguments to be passed to the new instance.\n   *\n   * @return A new instance of the Repository class with the specified adapter and arguments.\n   */\n  for(...args: any[]): Repository<M, Q, A, F, C> {\n    return new Proxy(this, {\n      get: (target: any, p: string | symbol, receiver: any) => {\n        if (p === \"adapter\") {\n          return this.adapter.for(...args);\n        }\n        return Reflect.get(target, p, receiver);\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 = await Promise.resolve(\n      model.hasErrors(\n        ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n      )\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    } else {\n      ids = models.map((m, i) => {\n        if (typeof m[this.pk] === \"undefined\")\n          throw new InternalError(\n            `Primary key is not defined for model in position ${i}`\n          );\n        return m[this.pk] as string;\n      });\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        if (opts.type) 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\n    const ignoredProps =\n      contextArgs.context.get(\"ignoredValidationProperties\") || [];\n\n    const errors = await Promise.all(\n      models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps)))\n    );\n\n    const errorMessages = errors.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\n    if (errorMessages) throw new ValidationError(errorMessages);\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 = await Promise.resolve(\n      model.hasErrors(\n        oldModel,\n        ...Repository.relations(this.class),\n        ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n      )\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 ignoredProps =\n      contextArgs.context.get(\"ignoredValidationProperties\") || [];\n\n    const errors = await Promise.all(\n      models.map((m, i) =>\n        Promise.resolve(m.hasErrors(oldModels[i], m, ...ignoredProps))\n      )\n    );\n\n    const errorMessages = errors.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\n    if (errorMessages) throw new ValidationError(errorMessages);\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} [alias] - 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 =\n      alias ||\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||\n      Adapter.currentFlavour;\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      Adapter.currentFlavour;\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   * @param {string} [alias] - The adapter alias.\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, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\nimport { Adapter, PersistenceKeys } from \"../persistence\";\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} [flavour] - the required adapter's flavour/alias. If not provided, it will be retrieved from the model metadata..\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  flavour?: string\n): any {\n  return ((original: any, propertyKey?: any) => {\n    if (propertyKey) {\n      return inject(model[ModelKeys.ANCHOR as keyof typeof model] || model)(\n        original,\n        propertyKey\n      );\n    }\n\n    metadata(Repository.key(DBKeys.REPOSITORY), original.name)(model);\n    flavour =\n      flavour ||\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), original);\n    Repository.register(\n      model[ModelKeys.ANCHOR as keyof typeof model] || model,\n      original,\n      flavour\n    );\n    return injectable(model[ModelKeys.ANCHOR as keyof typeof model] || model, {\n      callback: (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 {\n  Constructor,\n  Model,\n  ModelConstructor,\n} 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>(\n    name: symbol | Constructor<T>,\n    flavour?: string\n  ): T | undefined {\n    let injectable = super.get(name);\n    if (!injectable)\n      try {\n        let m = name;\n        if (typeof name === \"symbol\" || typeof name === \"string\") {\n          m = Model.get(name.toString()) as ModelConstructor<any>;\n        }\n        if (m)\n          injectable = Repository.forModel(m as Constructor<any>, flavour) as T;\n        if (injectable) {\n          if (injectable instanceof Repository) return injectable as T;\n          flavour =\n            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  TYPE = \"Number\" | \"BigInt\" | string | undefined,\n> {\n  /**\n   * @description Optional name for the sequence\n   * @summary A unique identifier for the sequence\n   */\n  name?: string;\n\n  generated?: boolean;\n\n  /**\n   * @description The data type of the sequence\n   * @summary Specifies whether the sequence generates Number or BigInt values\n   */\n  type: TYPE;\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 NoneSequenceOptions\n * @memberOf module:core\n */\nexport const NoneSequenceOptions: SequenceOptions = {\n  type: undefined,\n  generated: false,\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\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 = NoneSequenceOptions;\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  generated: true,\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 = Object.assign(\n  {},\n  NumericSequence,\n  {\n    type: \"BigInt\",\n  }\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  ConditionalAsync,\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\ntype InferAsync<M> = M extends Model<infer A> ? A : false;\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<any>> extends Model<InferAsync<M>> {\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  ): ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined> {\n    const conditionCheck = (): ModelErrorDefinition | undefined => {\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:\n                \"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(\n            this.operator as GroupOperator\n          ) === -1 &&\n          this.operator !== Operator.NOT\n        )\n          return {\n            operator: {\n              condition: invalidOpMessage,\n            },\n          } as ModelErrorDefinition;\n      }\n    };\n\n    const errors = super.hasErrors(...exceptions);\n    if (!this.isAsync())\n      return (\n        (errors as ModelErrorDefinition | undefined) ??\n        (conditionCheck() as any)\n      );\n\n    return (async () => {\n      const resolved = await Promise.resolve(\n        errors as unknown as Promise<ModelErrorDefinition | undefined>\n      );\n      return resolved ?? conditionCheck();\n    })() as ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined>;\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  alias?: string,\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      alias\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(\n      model,\n      key,\n      this.adapter.alias\n    );\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  data.class =\n    typeof data.class === \"string\" ? data.class : (data.class as any)().name;\n\n  const constructor = Model.get(data.class as string);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor, this.adapter.alias);\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(\n      model,\n      key,\n      this.adapter.alias\n    );\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(\n    model[key] as M,\n    context,\n    this.adapter.alias\n  );\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(\n    model,\n    key,\n    this.adapter.alias\n  );\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, this.adapter.alias);\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, this.adapter.alias);\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, this.adapter.alias);\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    alias?: string\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, alias);\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    this.adapter.alias\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  alias?: string\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[] = (\n    Array.isArray(customTypes) ? [...customTypes] : [customTypes]\n  ).map((t) => (typeof t === \"function\" ? t() : t));\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, alias);\n}\n\n","import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n  timestamp,\n  OperationKeys,\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 {\n  JoinColumnOptions,\n  JoinTableMultipleColumnsOptions,\n  JoinTableOptions,\n  RelationsMetadata,\n} 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} opts - 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<OPTS = string>(opts: OPTS) {\n  const key = Adapter.key(PersistenceKeys.TABLE);\n  return Decoration.for(key)\n    .define({\n      decorator: metadata,\n      args: [key, opts],\n    })\n    .apply();\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<OPTS = string>(columnName?: OPTS) {\n  const key = Adapter.key(PersistenceKeys.COLUMN);\n  return Decoration.for(key)\n    .define({\n      decorator: function column(k, c) {\n        return function column(obj: any, attr: any) {\n          return propMetadata(k, c || attr)(obj, attr);\n        };\n      },\n      args: [key, columnName],\n    })\n    .apply();\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(): ReturnType<typeof propMetadata>;\nexport function index(name: string): ReturnType<typeof propMetadata>;\nexport function index(\n  directions: OrderDirection[]\n): ReturnType<typeof propMetadata>;\nexport function index(\n  directions: OrderDirection[],\n  name: string\n): ReturnType<typeof propMetadata>;\nexport function index(compositions: string[]): ReturnType<typeof propMetadata>;\nexport function index(\n  compositions: string[],\n  name: string\n): ReturnType<typeof propMetadata>;\nexport function index(\n  directions?: OrderDirection[] | string[] | string,\n  compositions?: string[] | string,\n  name?: string\n) {\n  function index(\n    directions?: OrderDirection[] | string[] | string,\n    compositions?: string[] | string,\n    name?: string\n  ) {\n    if (typeof directions === \"string\") {\n      name = directions;\n      directions = undefined;\n      compositions = undefined;\n    }\n    if (typeof compositions === \"string\") {\n      name = compositions;\n      compositions = undefined;\n    }\n    if (!compositions && directions) {\n      if (\n        directions.find(\n          (d) => ![OrderDirection.ASC, OrderDirection.DSC].includes(d as any)\n        )\n      ) {\n        compositions = directions as string[];\n        directions = undefined;\n      }\n    }\n\n    return propMetadata(\n      Repository.key(\n        `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n      ),\n      {\n        directions: directions,\n        compositions: compositions,\n        name: name,\n      } as IndexMetadata\n    );\n  }\n\n  return Decoration.for(PersistenceKeys.INDEX)\n    .define({\n      decorator: index,\n      args: [directions, compositions, name],\n    })\n    .apply();\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  const key = Repository.key(PersistenceKeys.UNIQUE);\n  return Decoration.for(key)\n    .define(onCreateUpdate(uniqueOnCreateUpdate), propMetadata(key, {}))\n    .apply();\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\nexport function createdAt() {\n  return timestamp([OperationKeys.CREATE]);\n}\n\nexport function updatedAt() {\n  return timestamp();\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true,\n  joinColumnOpts?: JoinColumnOptions,\n  fk?: string\n) {\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  // Model.register(clazz as Constructor<M>);\n\n  function oneToOneDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinColumnOpts?: JoinColumnOptions,\n    fk?: string\n  ) {\n    const meta: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinColumnOpts) meta.joinTable = joinColumnOpts;\n    if (fk) meta.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      type([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      onCreate(oneToOneOnCreate, meta),\n      onUpdate(oneToOneOnUpdate, meta),\n      onDelete(oneToOneOnDelete, meta),\n      afterAny(pop, meta),\n      propMetadata(key, meta)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: oneToOneDec,\n      args: [clazz, cascadeOptions, populate, joinColumnOpts, fk],\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n\n  function oneToManyDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      list([\n        clazz as Constructor<M>,\n        String,\n        Number,\n        // @ts-expect-error Bigint is not a constructor\n        BigInt,\n      ]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: oneToManyDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  // Model.register(clazz as Constructor<M>);\n\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n\n  function manyToOneDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    if (!clazz.name)\n      clazz = (clazz as () => Constructor<M>)() as Constructor<M>;\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      type([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: manyToOneDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\n    })\n    .apply();\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 manyToMany<M extends Model>(\n  clazz: Constructor<M> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  // Model.register(clazz as Constructor<M>);\n  const key = Repository.key(PersistenceKeys.MANY_TO_MANY);\n\n  function manyToManyDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      list([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: manyToManyDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\n    })\n    .apply();\n}\n","import {\n  Decoration,\n  Model,\n  prop,\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\";\nimport { apply } from \"@decaf-ts/reflection\";\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 || !data.generated || 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\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, {\n    generated:\n      opts.type && typeof opts.generated === \"undefined\"\n        ? true\n        : opts.generated || DefaultSequenceOptions.generated,\n  }) as SequenceOptions;\n\n  const key = Repository.key(DBKeys.ID);\n  function pkDec(options: SequenceOptions) {\n    return function pkDec(obj: any, attr: any) {\n      return apply(\n        index([OrderDirection.ASC, OrderDirection.DSC]),\n        required(),\n        readonly(),\n        propMetadata(key, options),\n        onCreate(pkOnCreate, options),\n        propMetadata(DBKeys.ID, attr)\n      )(obj, attr);\n    };\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: pkDec,\n      args: [opts],\n    })\n    .apply();\n}\n","import { DBOperations, timestamp } from \"@decaf-ts/db-decorators\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { createdAt, updatedAt } from \"./decorators\";\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  @createdAt()\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  @updatedAt()\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\";\nimport { Logger } from \"@decaf-ts/logging\";\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  protected get log(): Logger {\n    return (this.adapter as any).log.for(Statement);\n  }\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>, ...args: any[]): 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":["OrderDirection","Cascade","PersistenceKeys","BaseError","Logging","InternalError","OperationKeys","BulkCrudOperationKeys","Decoration","Model","DefaultFlavour","Context","DefaultRepositoryFlags","modelToTransient","DBKeys","__decorate","apply","metadata","Rep","wrapMethodWithContext","enforceDBDecorators","ValidationError","DefaultSeparator","findPrimaryKey","Reflection","inject","ModelKeys","injectable","sf","InjectableRegistryImp","Injectables","Operator","GroupOperator","required","NotFoundError","Validation","ValidationKeys","propMetadata","ConflictError","onCreateUpdate","onCreate","timestamp","populate","prop","type","onUpdate","onDelete","afterAny","pop","list","readonly","__metadata"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"core.cjs","sources":["../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/repository/constants.ts","../src/identity/utils.ts","../src/persistence/Sequence.ts","../src/persistence/decorators.ts","../src/repository/Repository.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/repository/decorators.ts","../src/repository/errors.ts","../src/identity/decorators.ts","../src/model/BaseModel.ts","../src/query/Paginator.ts","../src/query/Statement.ts","../src/index.ts"],"sourcesContent":["/**\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  // Ownership\n  /** @description Key for created-by ownership metadata */\n  OWNERSHIP = \"ownership\",\n\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\n  /** @description Key for relations metadata storage */\n  RELATIONS = \"__relations\",\n\n  /** @description Key for relations metadata storage */\n  RELATION = \"relation\",\n\n  /** @description Key for one-to-one relation metadata */\n  ONE_TO_ONE = `${RELATION}.one-to-one`,\n\n  /** @description Key for one-to-many relation metadata */\n  ONE_TO_MANY = `${RELATION}.one-to-many`,\n\n  /** @description Key for many-to-one relation metadata */\n  MANY_TO_ONE = `${RELATION}.many-to-one`,\n  /** @description Key for many-to-one relation metadata */\n  MANY_TO_MANY = `${RELATION}.many-to-many`,\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 { BadRequestError, InternalError } 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 BadRequestError {\n  constructor(msg: string | Error, name = AuthorizationError.name, code = 401) {\n    super(msg, name, code);\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 AuthorizationError {\n  constructor(msg: string | Error) {\n    super(msg, ForbiddenError.name, 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 InternalError {\n  constructor(msg: string | Error) {\n    super(msg, ConnectionError.name, 503);\n  }\n}\n","import { InternalError } 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 InternalError {\n  constructor(msg: string | Error) {\n    super(msg, UnsupportedError.name, 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 { EventIds } from \"./types\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\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> extends LoggedClass 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 Creates a new Dispatch instance\n   * @summary Initializes a new Dispatch instance without any adapter\n   */\n  constructor() {\n    super();\n  }\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.config;\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) => {\n          o.observer.refresh(table, event, id, ...args);\n        })\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  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  hashObj,\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 { final } from \"../utils\";\nimport { Dispatch } from \"./Dispatch\";\nimport { type EventIds, type ObserverFilter } from \"./types\";\nimport { ObserverHandler } from \"./ObserverHandler\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\n\nDecoration.setFlavourResolver((obj: object) => {\n  try {\n    return (\n      Adapter.flavourOf(Model.isModel(obj) ? obj.constructor : (obj as any)) ||\n      Adapter.currentFlavour ||\n      DefaultFlavour\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    // return DefaultFlavour;\n  }\n  try {\n    return Adapter.currentFlavour || DefaultFlavour;\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    return DefaultFlavour;\n  }\n});\n\n/**\n * @description Abstract Facade class for persistence 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 CONFIG - The underlying persistence driver config\n * @template QUERY - The query object type used by the adapter\n * @template FLAGS - The repository flags type\n * @template CONTEXT - The context type\n * @param {CONFIG} _config - The underlying persistence driver config\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.PoolConfig, pg.Query, PostgresFlags, PostgresContext> {\n *   constructor(client: pg.PoolConfig) {\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    CONF,\n    CONN,\n    QUERY,\n    FLAGS extends RepositoryFlags = RepositoryFlags,\n    CONTEXT extends Context<FLAGS> = Context<FLAGS>,\n  >\n  extends LoggedClass\n  implements\n    RawExecutor<QUERY>,\n    Contextual<FLAGS, CONTEXT>,\n    Observable,\n    Observer,\n    ErrorParser\n{\n  private static _currentFlavour: string;\n  private static _cache: Record<string, Adapter<any, any, any, any, any>> = {};\n\n  protected dispatch?: Dispatch<CONF>;\n\n  protected readonly observerHandler?: ObserverHandler;\n\n  protected _client?: CONN;\n\n  /**\n   * @description Gets the native persistence config\n   * @summary Provides access to the underlying persistence driver config\n   * @template CONF\n   * @return {CONF} The native persistence driver config\n   */\n  get config(): CONF {\n    return this._config;\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(): string {\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, QUERY, Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>, FLAGS, CONTEXT>>} The repository constructor\n   */\n  repository<M extends Model<boolean>>(): Constructor<\n    Repository<\n      M,\n      QUERY,\n      Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>,\n      FLAGS,\n      CONTEXT\n    >\n  > {\n    return Repository;\n  }\n\n  @final()\n  protected async shutdownProxies(k?: string) {\n    if (!this.proxies) return;\n    if (k && !(k in this.proxies))\n      throw new InternalError(`No proxy found for ${k}`);\n    if (!k) {\n      for (const key in this.proxies) {\n        try {\n          await this.proxies[key].shutdown();\n        } catch (e: unknown) {\n          this.log.error(`Failed to shutdown proxied adapter ${key}: ${e}`);\n          continue;\n        }\n        delete this.proxies[key];\n      }\n    } else {\n      try {\n        await this.proxies[k].shutdown();\n        delete this.proxies[k];\n      } catch (e: unknown) {\n        this.log.error(`Failed to shutdown proxied adapter ${k}: ${e}`);\n      }\n    }\n  }\n\n  /**\n   * @description Shuts down the adapter\n   * @summary Performs any necessary cleanup tasks, such as closing connections\n   * When overriding this method, ensure to call the base method first\n   * @return {Promise<void>} A promise that resolves when shutdown is complete\n   */\n  async shutdown(): Promise<void> {\n    await this.shutdownProxies();\n    if (this.dispatch) await this.dispatch.close();\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 _config: CONF,\n    readonly flavour: string,\n    private readonly _alias?: string\n  ) {\n    super();\n    if (this.alias 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._currentFlavour) {\n      this.log.verbose(`Defined ${this.alias} persistence adapter as current`);\n      Adapter._currentFlavour = this.alias;\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<QUERY, 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<CONF> {\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(): 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): boolean {\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  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async 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 {Promise<F>} The complete set of flags\n   */\n  protected async flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<FLAGS>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<FLAGS> {\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 FLAGS;\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<FLAGS>;\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<FLAGS>,\n    model: Constructor<M>,\n    ...args: any[]\n  ): Promise<CONTEXT> {\n    const log = this.log.for(this.context);\n    log.debug(\n      `Creating new context for ${operation} operation on ${model.name} model with flag overrides: ${JSON.stringify(overrides)}`\n    );\n    const flags = await this.flags(operation, model, overrides, ...args);\n    return new this.Context().accumulate(flags) as unknown as CONTEXT;\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    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: QUERY, ...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  override 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  static get currentFlavour() {\n    if (!Adapter._currentFlavour)\n      throw new InternalError(\n        `No persistence flavour set. Please initialize your adapter`\n      );\n    return Adapter._currentFlavour;\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(): Adapter<any, any, any, any> | undefined {\n    return Adapter.get(this.currentFlavour);\n  }\n\n  /**\n   * @description Gets an adapter by flavor\n   * @summary Retrieves a registered adapter by its flavor name\n   * @template CONF - The database driver config\n   * @template CONN - The database driver instance\n   * @template QUERY - The query type\n   * @template CCONTEXT - The context type\n   * @template FLAGS - The repository flags type\n   * @param {string} flavour - The flavor name of the adapter to retrieve\n   * @return {Adapter<CONF, CONN, QUERY, CONTEXT, FLAGS> | undefined} The adapter instance or undefined if not found\n   */\n  static get<\n    CONF,\n    CONN,\n    QUERY,\n    CONTEXT extends Context<FLAGS>,\n    FLAGS extends RepositoryFlags,\n  >(flavour?: any): Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT> | undefined {\n    if (!flavour) return Adapter.get(this._currentFlavour);\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): void {\n    this._currentFlavour = flavour;\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  static decoration(): void {}\n\n  protected proxies?: Record<string, typeof this>;\n\n  /**\n   * @description Returns the client instance for the adapter\n   * @summary This method should be overridden by subclasses to return the client instance for the adapter.\n   * @template CON - The type of the client instance\n   * @return {CON} The client instance for the adapter\n   * @abstract\n   * @function getClient\n   * @memberOf module:core\n   * @instance\n   * @protected\n   */\n  protected abstract getClient(): CONN;\n\n  @final()\n  get client(): CONN {\n    if (!this._client) {\n      this._client = this.getClient();\n    }\n    return this._client;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  for(config: Partial<CONF>, ...args: any[]): typeof this {\n    if (!this.proxies) this.proxies = {};\n    const key = `${this.alias} - ${hashObj(config)}`;\n    if (key in this.proxies) return this.proxies[key] as typeof this;\n\n    let client: any;\n    const proxy = new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        if (p === \"_config\") {\n          const originalConf: CONF = Reflect.get(target, p, receiver);\n          return Object.assign({}, originalConf, config);\n        }\n        if (p === \"_client\") {\n          return client;\n        }\n        return Reflect.get(target, p, receiver);\n      },\n      set: (target: any, p: string | symbol, value: any, receiver: any) => {\n        if (p === \"_client\") {\n          client = value;\n          return true;\n        }\n        return Reflect.set(target, p, value, receiver);\n      },\n    });\n    this.proxies[key] = proxy;\n    return proxy;\n  }\n}\n","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 Shape of the default cascade configuration object used in repositories.\n * @summary Documents the structure of the cascade configuration with explicit update and delete behaviors.\n * @property {'cascade'|'none'} update - Determines whether updates cascade to related entities.\n * @property {'cascade'|'none'} delete - Determines whether deletes cascade to related entities.\n * @typeDef DefaultCascadeConfig\n * @memberOf module:core\n */\nexport const DefaultCascade: CascadeMetadata = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\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\";\nimport { UnsupportedError } from \"./errors\";\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(): Logger {\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\" | string | 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      case undefined:\n        return value;\n      default:\n        throw new UnsupportedError(\n          `Unsupported sequence type: ${type} for adapter ${this}`\n        );\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 function uses(original: any) {\n    return apply(metadata(Adapter.key(PersistenceKeys.ADAPTER), flavour))(\n      original\n    );\n  };\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 } from \"@decaf-ts/logging\";\nimport { ObserverHandler } from \"../persistence/ObserverHandler\";\nimport { final } from \"../utils\";\nimport {\n  EventIds,\n  InferredAdapterConfig,\n  type ObserverFilter,\n} 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<boolean>,\n  F extends RepositoryFlags = any,\n  C extends Context<F> = any,\n  Q = any,\n  A extends Adapter<any, 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<boolean>,\n    Q,\n    A extends Adapter<any, 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  protected _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)\n      this.logger = (\n        this.adapter[\"log\" as keyof typeof this.adapter] as Logger\n      ).for(this.toString());\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 instance of the Repository class with a specific adapter and arguments.\n   *\n   * @template A - The type of the adapter.\n   * @template Q - The type of the query builder.\n   * @template F - The type of the filter.\n   * @template C - The type of the context.\n   *\n   * @param {Partial<InferredAdapterConfig<A>>} conf - adapter configurations to override.\n   * @param [args] - Additional arguments to be passed to the new instance.\n   *\n   * @return A new instance of the Repository class with the specified adapter and arguments.\n   */\n  for(\n    conf: Partial<InferredAdapterConfig<A>>,\n    ...args: any[]\n  ): Repository<M, Q, A, F, C> {\n    return new Proxy(this, {\n      get: (target: any, p: string | symbol, receiver: any) => {\n        if (p === \"adapter\") {\n          return this.adapter.for(conf, ...args);\n        }\n        return Reflect.get(target, p, receiver);\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 = await Promise.resolve(\n      model.hasErrors(\n        ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n      )\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    } else {\n      ids = models.map((m, i) => {\n        if (typeof m[this.pk] === \"undefined\")\n          throw new InternalError(\n            `Primary key is not defined for model in position ${i}`\n          );\n        return m[this.pk] as string;\n      });\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        if (opts.type) 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\n    const ignoredProps =\n      contextArgs.context.get(\"ignoredValidationProperties\") || [];\n\n    const errors = await Promise.all(\n      models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps)))\n    );\n\n    const errorMessages = errors.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\n    if (errorMessages) throw new ValidationError(errorMessages);\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 = await Promise.resolve(\n      model.hasErrors(\n        oldModel,\n        ...Repository.relations(this.class),\n        ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n      )\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 ignoredProps =\n      contextArgs.context.get(\"ignoredValidationProperties\") || [];\n\n    const errors = await Promise.all(\n      models.map((m, i) =>\n        Promise.resolve(m.hasErrors(oldModels[i], m, ...ignoredProps))\n      )\n    );\n\n    const errorMessages = errors.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\n    if (errorMessages) throw new ValidationError(errorMessages);\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} [alias] - 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 =\n      alias ||\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), model) ||\n      Adapter.currentFlavour;\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      Adapter.currentFlavour;\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   * @param {string} [alias] - The adapter alias.\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   * @param {string} [alias] the adapter alias/flavour.\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 { 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 injectable token for repositories using the adapter flavour and model table name.\n * This helps the DI system register and resolve repository instances consistently across adapters.\n * @template T The model type that extends Model.\n * @param {Constructor<T> | T} model The model constructor or instance from which to derive the table name.\n * @param {string} [flavour] Optional adapter flavour/alias. If omitted, it is read from model metadata.\n * @return {string} A namespaced injectable token for the repository (e.g., \"db:repo:ram:users\").\n * @throws {InternalError} If the flavour cannot be determined from arguments or metadata.\n * @function generateInjectableNameForRepository\n * @mermaid\n * sequenceDiagram\n *   participant C as Caller\n *   participant U as generateInjectableNameForRepository\n *   participant R as Reflect Metadata\n *   participant A as Adapter\n *   participant S as String Formatter\n *   C->>U: call(model, flavour?)\n *   alt flavour provided\n *     U-->>U: use provided flavour\n *   else flavour not provided\n *     U->>A: Adapter.key(ADAPTER)\n *     U->>R: getMetadata(key, model|model.ctor)\n *     alt metadata present\n *       R-->>U: flavour\n *     else missing\n *       U-->>C: throw InternalError\n *     end\n *   end\n *   U->>S: sf(INJECTABLE, flavour, Repository.table(model))\n *   S-->>C: token string\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 {\n  Constructor,\n  Model,\n  ModelConstructor,\n} from \"@decaf-ts/decorator-validation\";\nimport { generateInjectableNameForRepository } from \"./utils\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Registry for injectable repositories with auto-resolution.\n * @summary Provides an InjectableRegistry implementation that resolves repositories by model name or constructor. If a repository\n * is not explicitly registered, it attempts to infer the correct repository using model metadata and the active or specified adapter flavour.\n * @param {void} [constructor] No constructor parameters required; the superclass handles internal state.\n * @class InjectablesRegistry\n * @example\n * // Basic usage: retrieve a repository by model name\n * const registry = new InjectablesRegistry();\n * const userRepo = registry.get<UserRepository>('User');\n * // If UserRepository is registered, it will be returned. Otherwise, a repository will be created if a User model exists.\n *\n * // Retrieve by constructor and specify adapter flavour\n * const repoByCtor = registry.get<UserRepository>(UserModel, 'ram');\n *\n * // Retrieve by symbol (e.g., injectable token)\n * const token = Symbol.for('UserRepository');\n * const byToken = registry.get<UserRepository>(token);\n * @mermaid\n * sequenceDiagram\n *   participant C as Consumer\n *   participant R as InjectablesRegistry\n *   participant B as BaseRegistry\n *   participant M as Model\n *   participant A as Adapter\n *   participant RP as Repository\n *   C->>R: get(name, flavour?)\n *   activate R\n *   R->>B: super.get(name)\n *   alt Found in base registry\n *     B-->>R: injectable\n *     R-->>C: injectable\n *   else Not found\n *     R->>M: Model.get(name)\n *     alt Model found\n *       R->>A: resolve flavour (from arg/metadata/current)\n *       R->>RP: Repository.forModel(modelCtor, alias)\n *       alt Repository instance\n *         RP-->>R: repository instance\n *         R-->>C: repository instance\n *       else Repository ctor\n *         R->>A: Adapter.get(resolvedFlavour) or Adapter.current\n *         A-->>R: adapter instance\n *         R->>RP: new repoCtor(adapter, modelCtor)\n *         R-->>C: repository instance\n *       end\n *     else Model not found\n *       R-->>C: undefined\n *     end\n *   end\n */\nexport class InjectablesRegistry extends InjectableRegistryImp {\n  private logger?: Logger;\n\n  protected get log(): Logger {\n    if (!this.logger) this.logger = Logging.for(this as any);\n    return this.logger;\n  }\n\n  constructor() {\n    super();\n  }\n\n  /**\n   * @description Retrieve an injectable with repository auto-resolution.\n   * @summary Attempts to get an injectable from the base registry; if not found and the name refers to a known model, it\n   * resolves the appropriate repository using the specified flavour or model metadata, falling back to the current adapter when needed.\n   * @template T The injectable type to be returned.\n   * @param {string | symbol | Constructor<T>} name Token, model name, or constructor associated with the injectable or model.\n   * @param {string} [flavour] Optional adapter flavour (e.g., \"ram\"). If omitted, derives from metadata or current adapter.\n   * @return {T | undefined} The located or auto-created injectable instance; otherwise undefined if it cannot be resolved.\n   * @mermaid\n   * sequenceDiagram\n   *   participant G as get(name, flavour?)\n   *   participant BR as BaseRegistry\n   *   participant M as Model\n   *   participant A as Adapter\n   *   participant RP as Repository\n   *   G->>BR: super.get(name)\n   *   alt Found\n   *     BR-->>G: injectable\n   *   else Not found\n   *     G->>M: derive modelCtor from name\n   *     alt modelCtor resolved\n   *       G->>A: resolve flavour (arg | metadata | current)\n   *       G->>RP: Repository.forModel(modelCtor, alias)\n   *       alt returns instance\n   *         RP-->>G: Repository instance\n   *       else returns ctor\n   *         G->>A: Adapter.get(flavour) | Adapter.current\n   *         A-->>G: adapter instance\n   *         G->>RP: new repoCtor(adapter, modelCtor)\n   *       end\n   *     else no modelCtor\n   *       G-->>G: return undefined\n   *     end\n   *   end\n   */\n  override get<T>(\n    name: symbol | Constructor<T> | string,\n    flavour?: string\n  ): T | undefined {\n    const log = this.log.for(this.get);\n    // First, try base registry, but guard against thrown errors\n    let injectable: T | undefined;\n    try {\n      injectable = super.get(name as any);\n    } catch {\n      // do nothing. we handle it later\n    }\n\n    if (!injectable) {\n      let modelCtor: Constructor<any> | undefined;\n      if (typeof name === \"function\") modelCtor = name as Constructor<any>;\n      else if (typeof name === \"symbol\" || typeof name === \"string\") {\n        modelCtor = Model.get(name.toString()) as ModelConstructor<any>;\n      }\n\n      if (!modelCtor) return undefined;\n\n      // Resolve flavour from metadata if not provided\n      const metaKey = Adapter.key(PersistenceKeys.ADAPTER);\n      const resolvedFlavour =\n        flavour ||\n        (Reflect.getMetadata(metaKey, modelCtor) as string | undefined);\n\n      try {\n        // Determine an alias to use: prefer a directly registered adapter; otherwise, if the current adapter\n        // has the same flavour, use its alias to satisfy Repository.forModel/Adapter.get lookups.\n        let aliasToUse = resolvedFlavour;\n        try {\n          if (resolvedFlavour) Adapter.get(resolvedFlavour);\n        } catch {\n          const current = Adapter.current as any;\n          if (current && current.flavour === resolvedFlavour)\n            aliasToUse = current.alias;\n        }\n\n        injectable = Repository.forModel(\n          modelCtor as Constructor<any>,\n          aliasToUse\n        ) as T;\n        if (injectable instanceof Repository) return injectable as T;\n\n        // Otherwise, register the resolved injectable name for later retrieval\n        const f =\n          resolvedFlavour ||\n          (Reflect.getMetadata(metaKey, (injectable as any).constructor) as\n            | string\n            | undefined) ||\n          (Reflect.getMetadata(metaKey, modelCtor) as string | undefined);\n        Injectables.register(\n          injectable,\n          generateInjectableNameForRepository(\n            modelCtor as ModelConstructor<any>,\n            f as string\n          )\n        );\n      } catch (e: unknown) {\n        log.debug(\n          `No registered repository or adapter found. falling back to default adapter`\n        );\n        const repoCtor = (Repository as any)[\"get\"](modelCtor, resolvedFlavour);\n        if (typeof repoCtor === \"function\") {\n          const adapter = resolvedFlavour\n            ? (Adapter.get(resolvedFlavour) as any)\n            : (Adapter.current as any);\n          if (!adapter) return undefined;\n          const instance = new repoCtor(adapter, modelCtor);\n          return instance as T;\n        }\n      }\n    }\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  TYPE = \"Number\" | \"BigInt\" | string | undefined,\n> {\n  /**\n   * @description Optional name for the sequence\n   * @summary A unique identifier for the sequence\n   */\n  name?: string;\n\n  generated?: boolean;\n\n  /**\n   * @description The data type of the sequence\n   * @summary Specifies whether the sequence generates Number or BigInt values\n   */\n  type: TYPE;\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 NoneSequenceOptions\n * @memberOf module:core\n */\nexport const NoneSequenceOptions: SequenceOptions = {\n  type: undefined,\n  generated: false,\n  startWith: 0,\n  incrementBy: 1,\n  cycle: false,\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 = NoneSequenceOptions;\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  generated: true,\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 = Object.assign(\n  {},\n  NumericSequence,\n  {\n    type: \"BigInt\",\n  }\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 { InternalError } 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 InternalError {\n  constructor(msg: string | Error) {\n    super(msg, QueryError.name, 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 InternalError {\n  constructor(msg: string | Error) {\n    super(msg, PagingError.name, 500);\n  }\n}\n","import { AttributeOption, ConditionBuilderOption } from \"./options\";\nimport {\n  ConditionalAsync,\n  Model,\n  ModelErrorDefinition,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { GroupOperator, Operator } from \"./constants\";\nimport { QueryError } from \"./errors\";\n\ntype InferAsync<M> = M extends Model<infer A> ? A : false;\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 * @mermaid\n * sequenceDiagram\n *   participant Dev\n *   participant Condition\n *   Dev->>Condition: builder().attribute(\"age\").gt(18)\n *   Condition-->>Dev: Condition(age > 18)\n *   Dev->>Condition: .and(attribute(\"status\").eq(\"active\"))\n *   Condition-->>Dev: Condition((age > 18) AND (status = \"active\"))\n */\nexport class Condition<M extends Model<any>> extends Model<InferAsync<M>> {\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  ): ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined> {\n    const conditionCheck = (): ModelErrorDefinition | undefined => {\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:\n                \"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(\n            this.operator as GroupOperator\n          ) === -1 &&\n          this.operator !== Operator.NOT\n        )\n          return {\n            operator: {\n              condition: invalidOpMessage,\n            },\n          } as ModelErrorDefinition;\n      }\n    };\n\n    const errors = super.hasErrors(...exceptions);\n    if (!this.isAsync())\n      return (\n        (errors as ModelErrorDefinition | undefined) ??\n        (conditionCheck() as any)\n      );\n\n    return (async () => {\n      const resolved = await Promise.resolve(\n        errors as unknown as Promise<ModelErrorDefinition | undefined>\n      );\n      return resolved ?? conditionCheck();\n    })() as ConditionalAsync<InferAsync<M>, ModelErrorDefinition | undefined>;\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  alias?: string,\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      alias\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(\n      model,\n      key,\n      this.adapter.alias\n    );\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  data.class =\n    typeof data.class === \"string\" ? data.class : (data.class as any)().name;\n\n  const constructor = Model.get(data.class as string);\n  if (!constructor)\n    throw new InternalError(`Could not find model ${data.class}`);\n  const repo: Repo<any> = Repository.forModel(constructor, this.adapter.alias);\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(\n      model,\n      key,\n      this.adapter.alias\n    );\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(\n    model[key] as M,\n    context,\n    this.adapter.alias\n  );\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(\n    model,\n    key,\n    this.adapter.alias\n  );\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, this.adapter.alias);\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, this.adapter.alias);\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, this.adapter.alias);\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    alias?: string\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, alias);\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    this.adapter.alias\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  alias?: string\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[] = (\n    Array.isArray(customTypes) ? [...customTypes] : [customTypes]\n  ).map((t) => (typeof t === \"function\" ? t() : t));\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, alias);\n}\n\n","import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n  timestamp,\n  OperationKeys,\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 {\n  JoinColumnOptions,\n  JoinTableMultipleColumnsOptions,\n  JoinTableOptions,\n  RelationsMetadata,\n} 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} opts - 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<OPTS = string>(opts: OPTS) {\n  const key = Adapter.key(PersistenceKeys.TABLE);\n  return Decoration.for(key)\n    .define({\n      decorator: metadata,\n      args: [key, opts],\n    })\n    .apply();\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<OPTS = string>(columnName?: OPTS) {\n  const key = Adapter.key(PersistenceKeys.COLUMN);\n  return Decoration.for(key)\n    .define({\n      decorator: function column(k, c) {\n        return function column(obj: any, attr: any) {\n          return propMetadata(k, c || attr)(obj, attr);\n        };\n      },\n      args: [key, columnName],\n    })\n    .apply();\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(): ReturnType<typeof propMetadata>;\nexport function index(name: string): ReturnType<typeof propMetadata>;\nexport function index(\n  directions: OrderDirection[]\n): ReturnType<typeof propMetadata>;\nexport function index(\n  directions: OrderDirection[],\n  name: string\n): ReturnType<typeof propMetadata>;\nexport function index(compositions: string[]): ReturnType<typeof propMetadata>;\nexport function index(\n  compositions: string[],\n  name: string\n): ReturnType<typeof propMetadata>;\nexport function index(\n  directions?: OrderDirection[] | string[] | string,\n  compositions?: string[] | string,\n  name?: string\n) {\n  function index(\n    directions?: OrderDirection[] | string[] | string,\n    compositions?: string[] | string,\n    name?: string\n  ) {\n    if (typeof directions === \"string\") {\n      name = directions;\n      directions = undefined;\n      compositions = undefined;\n    }\n    if (typeof compositions === \"string\") {\n      name = compositions;\n      compositions = undefined;\n    }\n    if (!compositions && directions) {\n      if (\n        directions.find(\n          (d) => ![OrderDirection.ASC, OrderDirection.DSC].includes(d as any)\n        )\n      ) {\n        compositions = directions as string[];\n        directions = undefined;\n      }\n    }\n\n    return propMetadata(\n      Repository.key(\n        `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n      ),\n      {\n        directions: directions,\n        compositions: compositions,\n        name: name,\n      } as IndexMetadata\n    );\n  }\n\n  return Decoration.for(PersistenceKeys.INDEX)\n    .define({\n      decorator: index,\n      args: [directions, compositions, name],\n    })\n    .apply();\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  const key = Repository.key(PersistenceKeys.UNIQUE);\n  return Decoration.for(key)\n    .define(onCreateUpdate(uniqueOnCreateUpdate), propMetadata(key, {}))\n    .apply();\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\nexport function createdAt() {\n  return timestamp([OperationKeys.CREATE]);\n}\n\nexport function updatedAt() {\n  return timestamp();\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true,\n  joinColumnOpts?: JoinColumnOptions,\n  fk?: string\n) {\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  // Model.register(clazz as Constructor<M>);\n\n  function oneToOneDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinColumnOpts?: JoinColumnOptions,\n    fk?: string\n  ) {\n    const meta: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinColumnOpts) meta.joinTable = joinColumnOpts;\n    if (fk) meta.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      type([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      onCreate(oneToOneOnCreate, meta),\n      onUpdate(oneToOneOnUpdate, meta),\n      onDelete(oneToOneOnDelete, meta),\n      afterAny(pop, meta),\n      propMetadata(key, meta)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: oneToOneDec,\n      args: [clazz, cascadeOptions, populate, joinColumnOpts, fk],\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n\n  function oneToManyDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      list([\n        clazz as Constructor<M>,\n        String,\n        Number,\n        // @ts-expect-error Bigint is not a constructor\n        BigInt,\n      ]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: oneToManyDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\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> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  // Model.register(clazz as Constructor<M>);\n\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n\n  function manyToOneDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    if (!clazz.name)\n      clazz = (clazz as () => Constructor<M>)() as Constructor<M>;\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      type([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: manyToOneDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\n    })\n    .apply();\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 manyToMany<M extends Model>(\n  clazz: Constructor<M> | (() => Constructor<M>),\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true,\n  joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n  fk?: string\n) {\n  // Model.register(clazz as Constructor<M>);\n  const key = Repository.key(PersistenceKeys.MANY_TO_MANY);\n\n  function manyToManyDec(\n    clazz: Constructor<M> | (() => Constructor<M>),\n    cascade: CascadeMetadata,\n    populate: boolean,\n    joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n    fk?: string\n  ) {\n    const metadata: RelationsMetadata = {\n      class: clazz.name ? clazz.name : (clazz as any),\n      cascade: cascade,\n      populate: populate,\n    };\n    if (joinTableOpts) metadata.joinTable = joinTableOpts;\n    if (fk) metadata.name = fk;\n    return apply(\n      prop(PersistenceKeys.RELATIONS),\n      list([\n        clazz.name ? clazz.name : (clazz as any),\n        String.name,\n        Number.name,\n        BigInt.name,\n      ]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    );\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: manyToManyDec,\n      args: [clazz, cascadeOptions, populate, joinTableOpts, fk],\n    })\n    .apply();\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, ModelKeys } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"./Repository\";\nimport { Adapter, PersistenceKeys } from \"../persistence\";\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} [flavour] - the required adapter's flavour/alias. If not provided, it will be retrieved from the model metadata..\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  flavour?: string\n): any {\n  return ((original: any, propertyKey?: any) => {\n    if (propertyKey) {\n      return inject(model[ModelKeys.ANCHOR as keyof typeof model] || model)(\n        original,\n        propertyKey\n      );\n    }\n\n    metadata(Repository.key(DBKeys.REPOSITORY), original.name)(model);\n    flavour =\n      flavour ||\n      Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), original);\n    Repository.register(\n      model[ModelKeys.ANCHOR as keyof typeof model] || model,\n      original,\n      flavour\n    );\n    return injectable(model[ModelKeys.ANCHOR as keyof typeof model] || model, {\n      callback: (instance: IRepository<T>) => {\n        Object.defineProperty(instance, DBKeys.CLASS, {\n          enumerable: false,\n          configurable: false,\n          writable: false,\n          value: model,\n        });\n        return instance;\n      },\n    })(original);\n  }) as any;\n}\n","import { InternalError } 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 InternalError {\n  constructor(msg: string | Error) {\n    super(msg, ObserverError.name, 500);\n  }\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\";\nimport { apply } from \"@decaf-ts/reflection\";\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 || !data.generated || 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\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, {\n    generated:\n      opts.type && typeof opts.generated === \"undefined\"\n        ? true\n        : opts.generated || DefaultSequenceOptions.generated,\n  }) as SequenceOptions;\n\n  const key = Repository.key(DBKeys.ID);\n  function pkDec(options: SequenceOptions) {\n    return function pkDec(obj: any, attr: any) {\n      return apply(\n        index([OrderDirection.ASC, OrderDirection.DSC]),\n        required(),\n        readonly(),\n        propMetadata(key, options),\n        onCreate(pkOnCreate, options),\n        propMetadata(DBKeys.ID, attr)\n      )(obj, attr);\n    };\n  }\n  return Decoration.for(key)\n    .define({\n      decorator: pkDec,\n      args: [opts],\n    })\n    .apply();\n}\n","import { DBOperations, timestamp } from \"@decaf-ts/db-decorators\";\nimport { ModelArg, Model } from \"@decaf-ts/decorator-validation\";\nimport { createdAt, updatedAt } from \"./decorators\";\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  @createdAt()\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  @updatedAt()\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, 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\";\nimport { Logger } from \"@decaf-ts/logging\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\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  extends LoggedClass\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, any, Q, any, any>) {\n    super();\n  }\n\n  protected override get log(): Logger {\n    return (this.adapter as any).log.for(Statement);\n  }\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>, ...args: any[]): 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/injectables\";\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":["PersistenceKeys","BadRequestError","InternalError","LoggedClass","OperationKeys","BulkCrudOperationKeys","Decoration","Model","DefaultFlavour","Context","DefaultRepositoryFlags","modelToTransient","DBKeys","hashObj","__decorate","OrderDirection","Cascade","Logging","apply","metadata","Rep","wrapMethodWithContext","enforceDBDecorators","ValidationError","DefaultSeparator","findPrimaryKey","Reflection","sf","InjectableRegistryImp","Injectables","Operator","GroupOperator","required","NotFoundError","Validation","ValidationKeys","propMetadata","ConflictError","onCreateUpdate","onCreate","timestamp","populate","prop","type","onUpdate","onDelete","afterAny","pop","list","inject","ModelKeys","injectable","readonly","__metadata"],"mappings":"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"}