@decaf-ts/core 0.5.21 → 0.5.23

package/lib/repository/Repository.d.ts

@@ -12,7 +12,7 @@ import { WhereOption } from "../query/options";
 import { SelectSelector } from "../query/selectors";
 import { Logger } from "@decaf-ts/logging";
 import { ObserverHandler } from "../persistence/ObserverHandler";
-import type { EventIds, ObserverFilter } from "../persistence";
+import { EventIds, InferredAdapterConfig, type ObserverFilter } from "../persistence";
 /**
  * @description Type alias for Repository class with simplified generic parameters.
  * @summary Provides a more concise way to reference the Repository class with its generic parameters.
@@ -24,7 +24,7 @@ import type { EventIds, ObserverFilter } from "../persistence";
  * @typedef Repo
  * @memberOf module:core
  */
-export type Repo<M extends Model<true | false>, F extends RepositoryFlags = any, C extends Context<F> = any, Q = any, A extends Adapter<any, Q, F, C> = any> = Repository<M, Q, A, F, C>;
+export type Repo<M extends Model<boolean>, F extends RepositoryFlags = any, C extends Context<F> = any, Q = any, A extends Adapter<any, any, Q, F, C> = any> = Repository<M, Q, A, F, C>;
 /**
  * @description Core repository implementation for database operations on models on a table by table way.
  * @summary Provides CRUD operations, querying capabilities, and observer pattern implementation for model persistence.
@@ -78,7 +78,7 @@ export type Repo<M extends Model<true | false>, F extends RepositoryFlags = any,
  *   O-->>-R: Notification complete
  *   R-->>-C: created model
  */
-export declare class Repository<M extends Model<true | false>, Q, A extends Adapter<any, Q, F, C>, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> extends Rep<M, F, C> implements Observable, Observer, Queriable<M>, IRepository<M, F, C> {
+export declare class Repository<M extends Model<boolean>, Q, A extends Adapter<any, any, Q, F, C>, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> extends Rep<M, F, C> implements Observable, Observer, Queriable<M>, IRepository<M, F, C> {
     private static _cache;
     protected observers: Observer[];
     protected observerHandler?: ObserverHandler;
@@ -121,19 +121,19 @@ export declare class Repository<M extends Model<true | false>, Q, A extends Adap
      */
     override(flags: Partial<F>): Repository<M, Q, A, F, C>;
     /**
-     * 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: any[]): Repository<M, Q, A, F, C>;
+    for(conf: Partial<InferredAdapterConfig<A>>, ...args: any[]): Repository<M, Q, A, F, C>;
     /**
      * @description Creates a new observer handler.
      * @summary Factory method for creating an observer handler instance.
@@ -376,6 +376,7 @@ export declare class Repository<M extends Model<true | false>, Q, A extends Adap
      * @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<M extends Model>(model: Constructor<M>, repo: Constructor<Repo<M>> | Repo<M>, alias?: string): void;

package/lib/repository/constants.cjs

@@ -30,14 +30,15 @@ var Cascade;
     Cascade["NONE"] = "none";
 })(Cascade || (exports.Cascade = Cascade = {}));
 /**
- * @description Default cascade configuration for entity relationships.
- * @summary Provides the default cascade behavior where updates cascade but deletes do not.
- * @type {CascadeMetadata}
- * @const DefaultCascade
+ * @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
  */
 exports.DefaultCascade = {
     update: Cascade.CASCADE,
     delete: Cascade.NONE,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/repository/constants.d.ts

@@ -26,10 +26,11 @@ export declare enum Cascade {
     NONE = "none"
 }
 /**
- * @description Default cascade configuration for entity relationships.
- * @summary Provides the default cascade behavior where updates cascade but deletes do not.
- * @type {CascadeMetadata}
- * @const DefaultCascade
+ * @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
  */
 export declare const DefaultCascade: CascadeMetadata;

package/lib/repository/decorators.cjs

@@ -52,8 +52,9 @@ function repository(model, flavour) {
                     writable: false,
                     value: model,
                 });
+                return instance;
             },
         })(original);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/repository/errors.cjs

@@ -17,10 +17,10 @@ const db_decorators_1 = require("@decaf-ts/db-decorators");
  *   }
  * }
  */
-class ObserverError extends db_decorators_1.BaseError {
+class ObserverError extends db_decorators_1.InternalError {
     constructor(msg) {
-        super(ObserverError.name, msg, 500);
+        super(msg, ObserverError.name, 500);
     }
 }
 exports.ObserverError = ObserverError;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcG9zaXRvcnkvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJEQUFvRDtBQUVwRDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQWEsYUFBYyxTQUFRLHlCQUFTO0lBQzFDLFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLGFBQWEsQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRjtBQUpELHNDQUlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEVycm9yIHRocm93biB3aGVuIG9ic2VydmVyIGNvbW11bmljYXRpb24gZmFpbHMuXG4gKiBAc3VtbWFyeSBSZXByZXNlbnRzIGEgZmFpbHVyZSBpbiBvYnNlcnZlciBjb21tdW5pY2F0aW9uIGJldHdlZW4gcmVwb3NpdG9yaWVzLlxuICogQHBhcmFtIHtzdHJpbmd8RXJyb3J9IG1zZyAtIFRoZSBlcnJvciBtZXNzYWdlIG9yIEVycm9yIG9iamVjdC5cbiAqIEBjbGFzcyBPYnNlcnZlckVycm9yXG4gKiBAY2F0ZWdvcnkgRXJyb3JzXG4gKiBAZXhhbXBsZVxuICogdHJ5IHtcbiAqICAgLy8gU29tZSByZXBvc2l0b3J5IG9ic2VydmVyIG9wZXJhdGlvblxuICogfSBjYXRjaCAoZXJyb3IpIHtcbiAqICAgaWYgKGVycm9yIGluc3RhbmNlb2YgT2JzZXJ2ZXJFcnJvcikge1xuICogICAgIGNvbnNvbGUuZXJyb3IoJ09ic2VydmVyIGNvbW11bmljYXRpb24gZmFpbGVkOicsIGVycm9yLm1lc3NhZ2UpO1xuICogICB9XG4gKiB9XG4gKi9cbmV4cG9ydCBjbGFzcyBPYnNlcnZlckVycm9yIGV4dGVuZHMgQmFzZUVycm9yIHtcbiAgY29uc3RydWN0b3IobXNnOiBzdHJpbmcgfCBFcnJvcikge1xuICAgIHN1cGVyKE9ic2VydmVyRXJyb3IubmFtZSwgbXNnLCA1MDApO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcG9zaXRvcnkvZXJyb3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDJEQUF3RDtBQUV4RDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQWEsYUFBYyxTQUFRLDZCQUFhO0lBQzlDLFlBQVksR0FBbUI7UUFDN0IsS0FBSyxDQUFDLEdBQUcsRUFBRSxhQUFhLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRjtBQUpELHNDQUlDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW50ZXJuYWxFcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBFcnJvciB0aHJvd24gd2hlbiBvYnNlcnZlciBjb21tdW5pY2F0aW9uIGZhaWxzLlxuICogQHN1bW1hcnkgUmVwcmVzZW50cyBhIGZhaWx1cmUgaW4gb2JzZXJ2ZXIgY29tbXVuaWNhdGlvbiBiZXR3ZWVuIHJlcG9zaXRvcmllcy5cbiAqIEBwYXJhbSB7c3RyaW5nfEVycm9yfSBtc2cgLSBUaGUgZXJyb3IgbWVzc2FnZSBvciBFcnJvciBvYmplY3QuXG4gKiBAY2xhc3MgT2JzZXJ2ZXJFcnJvclxuICogQGNhdGVnb3J5IEVycm9yc1xuICogQGV4YW1wbGVcbiAqIHRyeSB7XG4gKiAgIC8vIFNvbWUgcmVwb3NpdG9yeSBvYnNlcnZlciBvcGVyYXRpb25cbiAqIH0gY2F0Y2ggKGVycm9yKSB7XG4gKiAgIGlmIChlcnJvciBpbnN0YW5jZW9mIE9ic2VydmVyRXJyb3IpIHtcbiAqICAgICBjb25zb2xlLmVycm9yKCdPYnNlcnZlciBjb21tdW5pY2F0aW9uIGZhaWxlZDonLCBlcnJvci5tZXNzYWdlKTtcbiAqICAgfVxuICogfVxuICovXG5leHBvcnQgY2xhc3MgT2JzZXJ2ZXJFcnJvciBleHRlbmRzIEludGVybmFsRXJyb3Ige1xuICBjb25zdHJ1Y3Rvcihtc2c6IHN0cmluZyB8IEVycm9yKSB7XG4gICAgc3VwZXIobXNnLCBPYnNlcnZlckVycm9yLm5hbWUsIDUwMCk7XG4gIH1cbn1cbiJdfQ==

package/lib/repository/errors.d.ts

@@ -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,6 +14,6 @@ import { BaseError } from "@decaf-ts/db-decorators";
  *   }
  * }
  */
-export declare class ObserverError extends BaseError {
+export declare class ObserverError extends InternalError {
     constructor(msg: string | Error);
 }

package/lib/repository/injectables.cjs

@@ -7,54 +7,163 @@ const decorator_validation_1 = require("@decaf-ts/decorator-validation");
 const utils_1 = require("./utils.cjs");
 const constants_1 = require("./../persistence/constants.cjs");
 const Adapter_1 = require("./../persistence/Adapter.cjs");
+const logging_1 = require("@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
  */
 class InjectablesRegistry extends injectable_decorators_1.InjectableRegistryImp {
+    get log() {
+        if (!this.logger)
+            this.logger = logging_1.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 = decorator_validation_1.Model.get(name.toString());
+            }
+            if (!modelCtor)
+                return undefined;
+            // Resolve flavour from metadata if not provided
+            const metaKey = Adapter_1.Adapter.key(constants_1.PersistenceKeys.ADAPTER);
+            const resolvedFlavour = flavour ||
+                Reflect.getMetadata(metaKey, modelCtor);
             try {
-                let m = name;
-                if (typeof name === "symbol" || typeof name === "string") {
-                    m = decorator_validation_1.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_1.Adapter.get(resolvedFlavour);
                 }
-                if (m)
-                    injectable = Repository_1.Repository.forModel(m, flavour);
-                if (injectable) {
-                    if (injectable instanceof Repository_1.Repository)
-                        return injectable;
-                    flavour =
-                        flavour ||
-                            Reflect.getMetadata(Adapter_1.Adapter.key(constants_1.PersistenceKeys.ADAPTER), injectable.constructor) ||
-                            Reflect.getMetadata(Adapter_1.Adapter.key(constants_1.PersistenceKeys.ADAPTER), m);
-                    injectable_decorators_1.Injectables.register(injectable, (0, utils_1.generateInjectableNameForRepository)(m, flavour));
+                catch {
+                    const current = Adapter_1.Adapter.current;
+                    if (current && current.flavour === resolvedFlavour)
+                        aliasToUse = current.alias;
                 }
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                injectable = Repository_1.Repository.forModel(modelCtor, aliasToUse);
+                if (injectable instanceof Repository_1.Repository)
+                    return injectable;
+                // Otherwise, register the resolved injectable name for later retrieval
+                const f = resolvedFlavour ||
+                    Reflect.getMetadata(metaKey, injectable.constructor) ||
+                    Reflect.getMetadata(metaKey, modelCtor);
+                injectable_decorators_1.Injectables.register(injectable, (0, utils_1.generateInjectableNameForRepository)(modelCtor, f));
             }
             catch (e) {
-                return undefined;
+                log.debug(`No registered repository or adapter found. falling back to default adapter`);
+                const repoCtor = Repository_1.Repository["get"](modelCtor, resolvedFlavour);
+                if (typeof repoCtor === "function") {
+                    const adapter = resolvedFlavour
+                        ? Adapter_1.Adapter.get(resolvedFlavour)
+                        : Adapter_1.Adapter.current;
+                    if (!adapter)
+                        return undefined;
+                    const instance = new repoCtor(adapter, modelCtor);
+                    return instance;
+                }
             }
+        }
         return injectable;
     }
 }
 exports.InjectablesRegistry = InjectablesRegistry;
-//# 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,2EAGyC;AACzC,iDAA0C;AAC1C,yEAIwC;AACxC,uCAA8D;AAC9D,8DAA2D;AAC3D,0DAAiD;AACjD,+CAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAa,mBAAoB,SAAQ,6CAAqB;IAG5D,IAAc,GAAG;QACf,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,MAAM,GAAG,iBAAO,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;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,4BAAK,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,iBAAO,CAAC,GAAG,CAAC,2BAAe,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,iBAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gBACpD,CAAC;gBAAC,MAAM,CAAC;oBACP,MAAM,OAAO,GAAG,iBAAO,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,uBAAU,CAAC,QAAQ,CAC9B,SAA6B,EAC7B,UAAU,CACN,CAAC;gBACP,IAAI,UAAU,YAAY,uBAAU;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,mCAAW,CAAC,QAAQ,CAClB,UAAU,EACV,IAAA,2CAAmC,EACjC,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,uBAAkB,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,iBAAO,CAAC,GAAG,CAAC,eAAe,CAAS;wBACvC,CAAC,CAAE,iBAAO,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;AA7HD,kDA6HC","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/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/repository/utils.cjs

@@ -9,13 +9,35 @@ const decorator_validation_2 = require("@decaf-ts/decorator-validation");
 const Repository_1 = require("./Repository.cjs");
 /**
  * @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
  */
 function generateInjectableNameForRepository(model, flavour) {
@@ -27,4 +49,4 @@ function generateInjectableNameForRepository(model, flavour) {
     }
     return (0, decorator_validation_1.sf)(constants_1.PersistenceKeys.INJECTABLE, flavour, Repository_1.Repository.table(model));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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;