@decaf-ts/core 0.5.20 → 0.5.22

package/lib/esm/repository/errors.js

@@ -1,4 +1,4 @@
-import { BaseError } from "@decaf-ts/db-decorators";
+import { InternalError } from "@decaf-ts/db-decorators";
 /**
  * @description Error thrown when observer communication fails.
  * @summary Represents a failure in observer communication between repositories.
@@ -14,9 +14,9 @@ import { BaseError } from "@decaf-ts/db-decorators";
  *   }
  * }
  */
-export class ObserverError extends BaseError {
+export class ObserverError extends InternalError {
     constructor(msg) {
-        super(ObserverError.name, msg, 500);
+        super(msg, ObserverError.name, 500);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcG9zaXRvcnkvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUVwRDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sT0FBTyxhQUFjLFNBQVEsU0FBUztJQUMxQyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUN0QyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlRXJyb3IgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gRXJyb3IgdGhyb3duIHdoZW4gb2JzZXJ2ZXIgY29tbXVuaWNhdGlvbiBmYWlscy5cbiAqIEBzdW1tYXJ5IFJlcHJlc2VudHMgYSBmYWlsdXJlIGluIG9ic2VydmVyIGNvbW11bmljYXRpb24gYmV0d2VlbiByZXBvc2l0b3JpZXMuXG4gKiBAcGFyYW0ge3N0cmluZ3xFcnJvcn0gbXNnIC0gVGhlIGVycm9yIG1lc3NhZ2Ugb3IgRXJyb3Igb2JqZWN0LlxuICogQGNsYXNzIE9ic2VydmVyRXJyb3JcbiAqIEBjYXRlZ29yeSBFcnJvcnNcbiAqIEBleGFtcGxlXG4gKiB0cnkge1xuICogICAvLyBTb21lIHJlcG9zaXRvcnkgb2JzZXJ2ZXIgb3BlcmF0aW9uXG4gKiB9IGNhdGNoIChlcnJvcikge1xuICogICBpZiAoZXJyb3IgaW5zdGFuY2VvZiBPYnNlcnZlckVycm9yKSB7XG4gKiAgICAgY29uc29sZS5lcnJvcignT2JzZXJ2ZXIgY29tbXVuaWNhdGlvbiBmYWlsZWQ6JywgZXJyb3IubWVzc2FnZSk7XG4gKiAgIH1cbiAqIH1cbiAqL1xuZXhwb3J0IGNsYXNzIE9ic2VydmVyRXJyb3IgZXh0ZW5kcyBCYXNlRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZyB8IEVycm9yKSB7XG4gICAgc3VwZXIoT2JzZXJ2ZXJFcnJvci5uYW1lLCBtc2csIDUwMCk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcG9zaXRvcnkvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUV4RDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sT0FBTyxhQUFjLFNBQVEsYUFBYTtJQUM5QyxZQUFZLEdBQW1CO1FBQzdCLEtBQUssQ0FBQyxHQUFHLEVBQUUsYUFBYSxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztJQUN0QyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbnRlcm5hbEVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEVycm9yIHRocm93biB3aGVuIG9ic2VydmVyIGNvbW11bmljYXRpb24gZmFpbHMuXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIGEgZmFpbHVyZSBpbiBvYnNlcnZlciBjb21tdW5pY2F0aW9uIGJldHdlZW4gcmVwb3NpdG9yaWVzLlxuICogQHBhcmFtIHtzdHJpbmd8RXJyb3J9IG1zZyAtIFRoZSBlcnJvciBtZXNzYWdlIG9yIEVycm9yIG9iamVjdC5cbiAqIEBjbGFzcyBPYnNlcnZlckVycm9yXG4gKiBAY2F0ZWdvcnkgRXJyb3JzXG4gKiBAZXhhbXBsZVxuICogdHJ5IHtcbiAqICAgLy8gU29tZSByZXBvc2l0b3J5IG9ic2VydmVyIG9wZXJhdGlvblxuICogfSBjYXRjaCAoZXJyb3IpIHtcbiAqICAgaWYgKGVycm9yIGluc3RhbmNlb2YgT2JzZXJ2ZXJFcnJvcikge1xuICogICAgIGNvbnNvbGUuZXJyb3IoJ09ic2VydmVyIGNvbW11bmljYXRpb24gZmFpbGVkOicsIGVycm9yLm1lc3NhZ2UpO1xuICogICB9XG4gKiB9XG4gKi9cbmV4cG9ydCBjbGFzcyBPYnNlcnZlckVycm9yIGV4dGVuZHMgSW50ZXJuYWxFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihtc2csIE9ic2VydmVyRXJyb3IubmFtZSwgNTAwKTtcbiAgfVxufVxuIl19

package/lib/esm/repository/injectables.d.ts

@@ -1,24 +1,95 @@
 import { InjectableRegistryImp } from "@decaf-ts/injectable-decorators";
 import { Constructor } from "@decaf-ts/decorator-validation";
+import { Logger } from "@decaf-ts/logging";
 /**
- * @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
  */
 export declare class InjectablesRegistry extends InjectableRegistryImp {
+    private logger?;
+    protected get log(): Logger;
     constructor();
     /**
-     * @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<T>(name: symbol | Constructor<T>, flavour?: string): T | undefined;
+    get<T>(name: symbol | Constructor<T> | string, flavour?: string): T | undefined;
 }

package/lib/esm/repository/injectables.js

@@ -4,53 +4,162 @@ import { Model, } from "@decaf-ts/decorator-validation";
 import { generateInjectableNameForRepository } from "./utils.js";
 import { PersistenceKeys } from "./../persistence/constants.js";
 import { Adapter } from "./../persistence/Adapter.js";
+import { Logging } from "@decaf-ts/logging";
 /**
- * @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
  */
 export class InjectablesRegistry extends InjectableRegistryImp {
+    get log() {
+        if (!this.logger)
+            this.logger = 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 = Model.get(name.toString());
+            }
+            if (!modelCtor)
+                return undefined;
+            // Resolve flavour from metadata if not provided
+            const metaKey = Adapter.key(PersistenceKeys.ADAPTER);
+            const resolvedFlavour = flavour ||
+                Reflect.getMetadata(metaKey, modelCtor);
             try {
-                let m = name;
-                if (typeof name === "symbol" || typeof name === "string") {
-                    m = 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(PersistenceKeys.ADAPTER), injectable.constructor) ||
-                            Reflect.getMetadata(Adapter.key(PersistenceKeys.ADAPTER), m);
-                    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);
+                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;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injectables.js","sourceRoot":"","sources":["../../../src/repository/injectables.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,WAAW,GACZ,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAC1C,OAAO,EAEL,KAAK,GAEN,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,mCAAmC,EAAE,mBAAgB;AAC9D,OAAO,EAAE,eAAe,EAAE,sCAAiC;AAC3D,OAAO,EAAE,OAAO,EAAE,oCAA+B;AACjD,OAAO,EAAU,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,OAAO,mBAAoB,SAAQ,qBAAqB;IAG5D,IAAc,GAAG;QACf,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;QACE,KAAK,EAAE,CAAC;IACV,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACM,GAAG,CACV,IAAsC,EACtC,OAAgB;QAEhB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnC,4DAA4D;QAC5D,IAAI,UAAyB,CAAC;QAC9B,IAAI,CAAC;YACH,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;QACtC,CAAC;QAAC,MAAM,CAAC;YACP,iCAAiC;QACnC,CAAC;QAED,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,IAAI,SAAuC,CAAC;YAC5C,IAAI,OAAO,IAAI,KAAK,UAAU;gBAAE,SAAS,GAAG,IAAwB,CAAC;iBAChE,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC9D,SAAS,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAA0B,CAAC;YAClE,CAAC;YAED,IAAI,CAAC,SAAS;gBAAE,OAAO,SAAS,CAAC;YAEjC,gDAAgD;YAChD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YACrD,MAAM,eAAe,GACnB,OAAO;gBACN,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAwB,CAAC;YAElE,IAAI,CAAC;gBACH,qGAAqG;gBACrG,0FAA0F;gBAC1F,IAAI,UAAU,GAAG,eAAe,CAAC;gBACjC,IAAI,CAAC;oBACH,IAAI,eAAe;wBAAE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBACpD,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,OAAO,GAAG,OAAO,CAAC,OAAc,CAAC;oBACvC,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,KAAK,eAAe;wBAChD,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC;gBAC/B,CAAC;gBAED,UAAU,GAAG,UAAU,CAAC,QAAQ,CAC9B,SAA6B,EAC7B,UAAU,CACN,CAAC;gBACP,IAAI,UAAU,YAAY,UAAU;oBAAE,OAAO,UAAe,CAAC;gBAE7D,uEAAuE;gBACvE,MAAM,CAAC,GACL,eAAe;oBACd,OAAO,CAAC,WAAW,CAAC,OAAO,EAAG,UAAkB,CAAC,WAAW,CAE/C;oBACb,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAwB,CAAC;gBAClE,WAAW,CAAC,QAAQ,CAClB,UAAU,EACV,mCAAmC,CACjC,SAAkC,EAClC,CAAW,CACZ,CACF,CAAC;YACJ,CAAC;YAAC,OAAO,CAAU,EAAE,CAAC;gBACpB,GAAG,CAAC,KAAK,CACP,4EAA4E,CAC7E,CAAC;gBACF,MAAM,QAAQ,GAAI,UAAkB,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;gBACxE,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;oBACnC,MAAM,OAAO,GAAG,eAAe;wBAC7B,CAAC,CAAE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAS;wBACvC,CAAC,CAAE,OAAO,CAAC,OAAe,CAAC;oBAC7B,IAAI,CAAC,OAAO;wBAAE,OAAO,SAAS,CAAC;oBAC/B,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;oBAClD,OAAO,QAAa,CAAC;gBACvB,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,UAA2B,CAAC;IACrC,CAAC;CACF","sourcesContent":["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"]}

package/lib/esm/repository/utils.d.ts

@@ -2,13 +2,35 @@ import { Constructor } from "@decaf-ts/decorator-validation";
 import { Model } from "@decaf-ts/decorator-validation";
 /**
  * @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.
+ * @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 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
+ *   U->>S: sf(INJECTABLE, flavour, Repository.table(model))
+ *   S-->>C: token string
  * @memberOf module:core
  */
 export declare function generateInjectableNameForRepository<T extends Model>(model: Constructor<T> | T, flavour?: string): string;

package/lib/esm/repository/utils.js

@@ -6,13 +6,35 @@ import { Model } from "@decaf-ts/decorator-validation";
 import { Repository } from "./Repository.js";
 /**
  * @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.
+ * @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 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
+ *   U->>S: sf(INJECTABLE, flavour, Repository.table(model))
+ *   S-->>C: token string
  * @memberOf module:core
  */
 export function generateInjectableNameForRepository(model, flavour) {
@@ -24,4 +46,4 @@ export function generateInjectableNameForRepository(model, flavour) {
     }
     return sf(PersistenceKeys.INJECTABLE, flavour, Repository.table(model));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from "@decaf-ts/db-decorators";
+import { BadRequestError, InternalError } from "@decaf-ts/db-decorators";
 /**
  * @description Error thrown when a user is not authorized to perform an action
  * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication
@@ -13,8 +13,8 @@ import { BaseError } from "@decaf-ts/db-decorators";
  * }
  * ```
  */
-export declare class AuthorizationError extends BaseError {
-    constructor(msg: string | Error);
+export declare class AuthorizationError extends BadRequestError {
+    constructor(msg: string | Error, name?: string, code?: number);
 }
 /**
  * @description Error thrown when a user is forbidden from accessing a resource
@@ -31,7 +31,7 @@ export declare class AuthorizationError extends BaseError {
  * }
  * ```
  */
-export declare class ForbiddenError extends BaseError {
+export declare class ForbiddenError extends AuthorizationError {
     constructor(msg: string | Error);
 }
 /**
@@ -51,6 +51,6 @@ export declare class ForbiddenError extends BaseError {
  * }
  * ```
  */
-export declare class ConnectionError extends BaseError {
+export declare class ConnectionError extends InternalError {
     constructor(msg: string | Error);
 }

package/lib/esm/utils/errors.js

@@ -1,4 +1,4 @@
-import { BaseError } from "@decaf-ts/db-decorators";
+import { BadRequestError, InternalError } from "@decaf-ts/db-decorators";
 /**
  * @description Error thrown when a user is not authorized to perform an action
  * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication
@@ -13,9 +13,9 @@ import { BaseError } from "@decaf-ts/db-decorators";
  * }
  * ```
  */
-export class AuthorizationError extends BaseError {
-    constructor(msg) {
-        super(AuthorizationError.name, msg, 401);
+export class AuthorizationError extends BadRequestError {
+    constructor(msg, name = AuthorizationError.name, code = 401) {
+        super(msg, name, code);
     }
 }
 /**
@@ -33,9 +33,9 @@ export class AuthorizationError extends BaseError {
  * }
  * ```
  */
-export class ForbiddenError extends BaseError {
+export class ForbiddenError extends AuthorizationError {
     constructor(msg) {
-        super(ForbiddenError.name, msg, 403);
+        super(msg, ForbiddenError.name, 403);
     }
 }
 /**
@@ -55,9 +55,9 @@ export class ForbiddenError extends BaseError {
  * }
  * ```
  */
-export class ConnectionError extends BaseError {
+export class ConnectionError extends InternalError {
     constructor(msg) {
-        super(ConnectionError.name, msg, 503);
+        super(msg, ConnectionError.name, 503);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/identity/decorators.cjs

@@ -109,4 +109,4 @@ function pk(opts = SequenceOptions_1.DefaultSequenceOptions) {
     })
         .apply();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/identity/decorators.ts"],"names":[],"mappings":";;AA8DA,gCA0CC;AAsBD,gBAgCC;AA9JD,yEAMwC;AACxC,yEAGuC;AACvC,2DAMiC;AACjC,+DAA4D;AAC5D,0DAA4C;AAC5C,uCAA+C;AAG/C,0DAA+C;AAC/C,qDAA6C;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACI,KAAK,UAAU,UAAU,CAQ9B,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAChD,OAAO;IACT,CAAC;IAED,MAAM,kBAAkB,GAAG,UACzB,MAAS,EACT,WAAmB,EACnB,KAA+B;QAE/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,CAAC,IAAI,GAAG,IAAA,4BAAoB,EAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,QAAkB,CAAC;IACvB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,IAAI,6BAAa,CACrB,kCAAkC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,kBAAkB,CAAC,KAAK,EAAE,GAAa,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,EAAE,CAChB,OAGI,wCAAsB;IAE1B,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,wCAAsB,EAAE,IAAI,EAAE;QACrD,SAAS,EACP,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,WAAW;YAChD,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,wCAAsB,CAAC,SAAS;KACzD,CAAoB,CAAC;IAEtB,MAAM,GAAG,GAAG,uBAAU,CAAC,GAAG,CAAC,sBAAM,CAAC,EAAE,CAAC,CAAC;IACtC,SAAS,KAAK,CAAC,OAAwB;QACrC,OAAO,SAAS,KAAK,CAAC,GAAQ,EAAE,IAAS;YACvC,OAAO,IAAA,kBAAK,EACV,IAAA,kBAAK,EAAC,CAAC,2BAAc,CAAC,GAAG,EAAE,2BAAc,CAAC,GAAG,CAAC,CAAC,EAC/C,IAAA,+BAAQ,GAAE,EACV,IAAA,wBAAQ,GAAE,EACV,IAAA,mCAAY,EAAC,GAAG,EAAE,OAAO,CAAC,EAC1B,IAAA,wBAAQ,EAAC,UAAU,EAAE,OAAO,CAAC,EAC7B,IAAA,mCAAY,EAAC,sBAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAC9B,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IACD,OAAO,iCAAU,CAAC,GAAG,CAAC,GAAG,CAAC;SACvB,MAAM,CAAC;QACN,SAAS,EAAE,KAAK;QAChB,IAAI,EAAE,CAAC,IAAI,CAAC;KACb,CAAC;SACD,KAAK,EAAE,CAAC;AACb,CAAC","sourcesContent":["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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/identity/decorators.ts"],"names":[],"mappings":";;AA6DA,gCA0CC;AAsBD,gBAgCC;AA7JD,yEAKwC;AACxC,yEAGuC;AACvC,2DAMiC;AACjC,+DAA4D;AAC5D,0DAA4C;AAC5C,uCAA+C;AAG/C,0DAA+C;AAC/C,qDAA6C;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACI,KAAK,UAAU,UAAU,CAQ9B,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAChD,OAAO;IACT,CAAC;IAED,MAAM,kBAAkB,GAAG,UACzB,MAAS,EACT,WAAmB,EACnB,KAA+B;QAE/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,CAAC,IAAI,GAAG,IAAA,4BAAoB,EAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,QAAkB,CAAC;IACvB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,IAAI,6BAAa,CACrB,kCAAkC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,kBAAkB,CAAC,KAAK,EAAE,GAAa,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,EAAE,CAChB,OAGI,wCAAsB;IAE1B,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,wCAAsB,EAAE,IAAI,EAAE;QACrD,SAAS,EACP,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,WAAW;YAChD,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,wCAAsB,CAAC,SAAS;KACzD,CAAoB,CAAC;IAEtB,MAAM,GAAG,GAAG,uBAAU,CAAC,GAAG,CAAC,sBAAM,CAAC,EAAE,CAAC,CAAC;IACtC,SAAS,KAAK,CAAC,OAAwB;QACrC,OAAO,SAAS,KAAK,CAAC,GAAQ,EAAE,IAAS;YACvC,OAAO,IAAA,kBAAK,EACV,IAAA,kBAAK,EAAC,CAAC,2BAAc,CAAC,GAAG,EAAE,2BAAc,CAAC,GAAG,CAAC,CAAC,EAC/C,IAAA,+BAAQ,GAAE,EACV,IAAA,wBAAQ,GAAE,EACV,IAAA,mCAAY,EAAC,GAAG,EAAE,OAAO,CAAC,EAC1B,IAAA,wBAAQ,EAAC,UAAU,EAAE,OAAO,CAAC,EAC7B,IAAA,mCAAY,EAAC,sBAAM,CAAC,EAAE,EAAE,IAAI,CAAC,CAC9B,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IACD,OAAO,iCAAU,CAAC,GAAG,CAAC,GAAG,CAAC;SACvB,MAAM,CAAC;QACN,SAAS,EAAE,KAAK;QAChB,IAAI,EAAE,CAAC,IAAI,CAAC;KACb,CAAC;SACD,KAAK,EAAE,CAAC;AACb,CAAC","sourcesContent":["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"]}

package/lib/index.cjs

@@ -40,5 +40,5 @@ __exportStar(require("./persistence/index.cjs"), exports);
  * @const VERSION
  * @memberOf module:core
  */
-exports.VERSION = "0.5.20";
+exports.VERSION = "0.5.22";
 //# sourceMappingURL=data:application/json;base64,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