@xeno-js/core 0.1.9 → 0.1.11

package/dist/index.cjs

@@ -1509,47 +1509,31 @@ var init_logger_utils = __esm({
        */
       async addLogger(container, opts) {
         const loggerDependencies = [];
-        const { Guards: Guards47, LOG_LEVEL: LOG_LEVEL7, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        if (!Guards47.isDefined(opts) || opts.console) {
+        const { Guards: Guards46, LOG_LEVEL: LOG_LEVEL7, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
+        if (!Guards46.isDefined(opts) || opts.console) {
           const { ConsoleLogger: ConsoleLogger2 } = await Promise.resolve().then(() => (init_console_logger(), console_logger_exports));
-          container.addSingleton(TOKENS4.CONSOLE_LOGGER, () => new ConsoleLogger2(opts?.level));
-          loggerDependencies.push(TOKENS4.CONSOLE_LOGGER);
+          loggerDependencies.push(new ConsoleLogger2(opts?.level));
         }
-        const customLoggerFactories = [];
-        if (Guards47.isDefined(opts)) {
-          if (Guards47.isDefined(opts.sentry.config)) {
+        if (Guards46.isDefined(opts)) {
+          if (Guards46.isDefined(opts.sentry.config)) {
             const { SentryLoggerFactory: SentryLoggerFactory2 } = await Promise.resolve().then(() => (init_sentry_logger_factory(), sentry_logger_factory_exports));
-            container.addSingleton(TOKENS4.SENTRY_LOGGER, () => {
-              const factory = new SentryLoggerFactory2();
-              return factory.create(opts);
-            });
-            loggerDependencies.push(TOKENS4.SENTRY_LOGGER);
+            loggerDependencies.push(new SentryLoggerFactory2().create(opts));
           }
-          if (Guards47.isDefined(opts.pino.config)) {
+          if (Guards46.isDefined(opts.pino.config)) {
             const { PinoLoggerFactory: PinoLoggerFactory2 } = await Promise.resolve().then(() => (init_pino_logger_factory(), pino_logger_factory_exports));
-            container.addSingleton(TOKENS4.PINO_LOGGER, () => {
-              const factory = new PinoLoggerFactory2();
-              return factory.create(opts);
-            });
-            loggerDependencies.push(TOKENS4.PINO_LOGGER);
+            loggerDependencies.push(new PinoLoggerFactory2().create(opts));
           }
-          if (!Guards47.isNullOrEmpty(opts.customLoggers)) {
+          if (!Guards46.isNullOrEmpty(opts.customLoggers)) {
             const customLoggers = opts.customLoggers;
-            customLoggers.forEach((f) => {
-              if (Guards47.isDefined(f)) {
-                customLoggerFactories.push(f);
-              }
+            customLoggers.forEach((fn) => {
+              if (Guards46.isDefined(fn)) loggerDependencies.push(fn(container));
             });
           }
         }
         const { BaseLogger } = await import("@xeno-js/shared");
         container.addSingleton(TOKENS4.LOGGER, (c) => {
           const context = c.resolve(TOKENS4.CONTEXT_ACCESSOR);
-          const resolvedDependencies = [
-            ...loggerDependencies.map((token) => c.resolve(token)),
-            ...customLoggerFactories.map((factory) => factory(c))
-          ];
-          return new BaseLogger(context, opts?.level ?? LOG_LEVEL7.DEBUG, resolvedDependencies);
+          return new BaseLogger(context, opts?.level ?? LOG_LEVEL7.DEBUG, loggerDependencies);
         });
       }
     });
@@ -1709,8 +1693,8 @@ var init_cache_utils = __esm({
        * @link https://github.com/xeno-js/xeno-js
        */
       async addCache(container, opts) {
-        const { Guards: Guards47, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        if (!opts.inMemory && !Guards47.isDefined(opts.redis)) {
+        const { Guards: Guards46, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
+        if (!opts.inMemory && !Guards46.isDefined(opts.redis)) {
           throw new Error(
             "No cache strategies are configured. Please provide at least one cache strategy."
           );
@@ -1720,12 +1704,12 @@ var init_cache_utils = __esm({
           TOKENS4.CACHE_KEY_BUILDER,
           (c) => new CacheKeyBuilder(c.resolve(TOKENS4.IDENTITY_ACCESSOR))
         );
-        if (opts.inMemory || !Guards47.isDefined(opts.redis)) {
+        if (opts.inMemory || !Guards46.isDefined(opts.redis)) {
           const { InMemoryCacheExtended: InMemoryCacheExtended2 } = await Promise.resolve().then(() => (init_inmemory_cache(), inmemory_cache_exports));
           container.addSingleton(TOKENS4.CACHE, () => new InMemoryCacheExtended2());
           return;
         }
-        if (Guards47.isDefined(opts.redis)) {
+        if (Guards46.isDefined(opts.redis)) {
           const { RedisCacheFactory: RedisCacheFactory2 } = await Promise.resolve().then(() => (init_redis_cache_factory(), redis_cache_factory_exports));
           container.addSingleton(TOKENS4.CACHE, () => {
             const config = opts.redis;
@@ -2634,7 +2618,9 @@ var init_supabase_factory = __esm({
         container
       }) {
         if (!import_shared55.Guards.isDefined(config.ssrOpts)) {
-          throw new Error("ISsrCookieHandler is required for @supabase/ssr initialization.");
+          throw new Error(
+            "ISsrCookieHandler is required for @supabase/ssr initialization., Please provide it in the config object."
+          );
         }
         const cookieService = config.ssrOpts(container);
         const client = (0, import_ssr.createServerClient)(config.url, config.key, {
@@ -2697,10 +2683,6 @@ var init_user_context_factory = __esm({
 });
 
 // src/infrastructure/factories/zod-validator.factory.ts
-var zod_validator_factory_exports = {};
-__export(zod_validator_factory_exports, {
-  ZodValidatorFactory: () => ZodValidatorFactory
-});
 var import_shared57, ZodValidatorFactory;
 var init_zod_validator_factory = __esm({
   "src/infrastructure/factories/zod-validator.factory.ts"() {
@@ -2777,97 +2759,57 @@ var init_auth_utils = __esm({
        */
       async addAuthZ(container, opts) {
         const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        const pipelines = [];
         const strategies = [];
-        const { Guards: Guards47 } = await import("@xeno-js/shared");
-        if (Guards47.isDefined(opts.policies)) {
+        const { Guards: Guards46 } = await import("@xeno-js/shared");
+        if (Guards46.isDefined(opts.policies)) {
           const { PolicyRegistry: PolicyRegistry2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-          container.addSingleton(TOKENS4.POLICY_REGISTRY, () => new PolicyRegistry2());
           const policyRegistry = opts.policies;
-          const registryInstance = container.resolve(TOKENS4.POLICY_REGISTRY);
+          const registryInstance = new PolicyRegistry2();
+          const ctxAccessor = container.resolve(TOKENS4.CONTEXT_ACCESSOR);
           const Policies = /* @__PURE__ */ new Set();
           for (const [intent, policy] of Object.entries(policyRegistry)) {
             const intentLower = intent.toLowerCase();
             registryInstance.addPolicy(intentLower, policy);
-            if (!Guards47.isNullOrEmpty(policy.roles)) {
+            if (!Guards46.isNullOrEmpty(policy.roles)) {
               Policies.add("roles");
             }
-            if (!Guards47.isNullOrEmpty(policy.permissions)) {
+            if (!Guards46.isNullOrEmpty(policy.permissions)) {
               Policies.add("permissions");
             }
-            if (!Guards47.isNullOrEmpty(policy.userId)) {
+            if (!Guards46.isNullOrEmpty(policy.userId)) {
               Policies.add("userId");
             }
-            if (!Guards47.isNullOrEmpty(policy.tenantId)) {
+            if (!Guards46.isNullOrEmpty(policy.tenantId)) {
               Policies.add("tenantId");
             }
           }
           if (Policies.has("roles")) {
             const { RoleAuthorizationStrategy: RoleAuthorizationStrategy2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-            container.addSingleton(
-              TOKENS4.ROLE_AUTHORIZATION_PIPELINE,
-              (c) => new RoleAuthorizationStrategy2(
-                c.resolve(TOKENS4.POLICY_REGISTRY),
-                c.resolve(TOKENS4.CONTEXT_ACCESSOR)
-              )
-            );
-            strategies.push(TOKENS4.ROLE_AUTHORIZATION_PIPELINE);
+            strategies.push(new RoleAuthorizationStrategy2(registryInstance, ctxAccessor));
           }
           if (Policies.has("permissions")) {
             const { PermissionAuthorizationStrategy: PermissionAuthorizationStrategy2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-            container.addSingleton(
-              TOKENS4.PERMISSION_AUTHORIZATION_PIPELINE,
-              (c) => new PermissionAuthorizationStrategy2(
-                c.resolve(TOKENS4.POLICY_REGISTRY),
-                c.resolve(TOKENS4.CONTEXT_ACCESSOR)
-              )
-            );
-            strategies.push(TOKENS4.PERMISSION_AUTHORIZATION_PIPELINE);
+            strategies.push(new PermissionAuthorizationStrategy2(registryInstance, ctxAccessor));
           }
           if (Policies.has("userId")) {
             const { UserAuthorizationStrategy: UserAuthorizationStrategy2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-            container.addSingleton(
-              TOKENS4.USER_AUTHORIZATION_PIPELINE,
-              (c) => new UserAuthorizationStrategy2(
-                c.resolve(TOKENS4.POLICY_REGISTRY),
-                c.resolve(TOKENS4.CONTEXT_ACCESSOR)
-              )
-            );
-            strategies.push(TOKENS4.USER_AUTHORIZATION_PIPELINE);
+            strategies.push(new UserAuthorizationStrategy2(registryInstance, ctxAccessor));
           }
           if (Policies.has("tenantId")) {
             const { TenantAuthorizationStrategy: TenantAuthorizationStrategy2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-            container.addSingleton(
-              TOKENS4.TENANT_AUTHORIZATION_PIPELINE,
-              (c) => new TenantAuthorizationStrategy2(
-                c.resolve(TOKENS4.POLICY_REGISTRY),
-                c.resolve(TOKENS4.CONTEXT_ACCESSOR)
-              )
-            );
-            strategies.push(TOKENS4.TENANT_AUTHORIZATION_PIPELINE);
+            strategies.push(new TenantAuthorizationStrategy2(registryInstance, ctxAccessor));
           }
         }
-        if (!Guards47.isNullOrEmpty(opts.customAuthorizationStrategy)) {
+        if (!Guards46.isNullOrEmpty(opts.customAuthorizationStrategy)) {
           const customStrategies = opts.customAuthorizationStrategy;
-          customStrategies.forEach((strategyToken, index) => {
-            if (Guards47.isDefined(strategyToken)) {
-              const token = `CUSTOM_AUTHORIZATION_STRATEGY_${index}`;
-              container.addSingleton(token, (c) => {
-                return strategyToken(c);
-              });
-              strategies.push(token);
+          customStrategies.forEach((strategyToken) => {
+            if (Guards46.isDefined(strategyToken)) {
+              strategies.push(strategyToken(container));
             }
           });
         }
         const { AuthorizationPipeline: AuthorizationPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.AUTHORIZATION_PIPELINE, (c) => {
-          const resolvedStrategies = strategies.map(
-            (strategy) => c.resolve(strategy)
-          );
-          return new AuthorizationPipeline2(resolvedStrategies);
-        });
-        pipelines.push(TOKENS4.AUTHORIZATION_PIPELINE);
-        return pipelines;
+        return new AuthorizationPipeline2(strategies);
       },
       /**
        * @description Configures the authentication service and gatekeeper in the service container.
@@ -2884,22 +2826,13 @@ var init_auth_utils = __esm({
         const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
         const _t = opts;
         const { SupabaseServerAuthFactory: SupabaseServerAuthFactory2 } = await Promise.resolve().then(() => (init_factories(), factories_exports));
+        const factory = new SupabaseServerAuthFactory2();
+        const supabase = factory.create({ config: opts, container });
         container.addScoped(TOKENS4.AUTH_SERVICE, () => {
-          const factory = new SupabaseServerAuthFactory2();
-          return factory.create({ config: opts, container });
+          return supabase;
         });
         container.addSingleton(TOKENS4.BASE_AUTH_SERVICE, () => {
-          const factory = new SupabaseServerAuthFactory2();
-          return factory.create({ config: opts, container });
-        });
-        const { ClaimsIdentityMapper: ClaimsIdentityMapper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.CLAIMS_IDENTITY_MAPPER, () => new ClaimsIdentityMapper2());
-        const { GateKeeper: GateKeeper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.GATE_KEEPER, (c) => {
-          return new GateKeeper2(
-            c.resolve(TOKENS4.BASE_AUTH_SERVICE),
-            c.resolve(TOKENS4.CLAIMS_IDENTITY_MAPPER)
-          );
+          return supabase;
         });
       }
     });
@@ -3053,24 +2986,24 @@ var init_db_module = __esm({
     "use strict";
     DbModule = class {
       async configure(container, opts) {
-        const { Guards: Guards47, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
+        const { Guards: Guards46, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
         const { DbUtils: DbUtils2 } = await Promise.resolve().then(() => (init_db_utils(), db_utils_exports));
         const db = opts.enableSqlLite ? await DbUtils2.addSqlLite(opts) : await DbUtils2.addDbClient(opts);
         const { TransactionState: TransactionState2 } = await Promise.resolve().then(() => (init_transaction_state(), transaction_state_exports));
-        container.addScoped(TOKENS4.TRANSACTION_STATE, () => {
+        container.addScoped("TRANSACTION_STATE", () => {
           return new TransactionState2();
         });
         const { UnitOfWork: UnitOfWork2 } = await Promise.resolve().then(() => (init_unit_of_work(), unit_of_work_exports));
         container.addScoped(TOKENS4.UNIT_OF_WORK, (c) => {
-          const ttx = c.resolve(TOKENS4.TRANSACTION_STATE);
+          const ttx = c.resolve("TRANSACTION_STATE");
           return new UnitOfWork2(db, ttx);
         });
         container.addScoped(TOKENS4.DB_CONTEXT, (c) => {
-          const ttx = c.resolve(TOKENS4.TRANSACTION_STATE);
+          const ttx = c.resolve("TRANSACTION_STATE");
           return new Proxy(db, {
             get(_target, prop, receiver) {
               const activeState = ttx.state;
-              if (Guards47.isDefined(activeState)) {
+              if (Guards46.isDefined(activeState)) {
                 if (prop === "transaction") {
                   return activeState.transaction.bind(activeState);
                 }
@@ -3107,14 +3040,14 @@ var init_http_utils = __esm({
        */
       async addAxios(container, opts) {
         const { NodeAxiosFactory: NodeAxiosFactory2 } = await Promise.resolve().then(() => (init_factories(), factories_exports));
-        const { Guards: Guards47 } = await import("@xeno-js/shared");
-        if (!Guards47.isDefined(opts.token)) {
+        const { Guards: Guards46 } = await import("@xeno-js/shared");
+        if (!Guards46.isDefined(opts.token)) {
           throw new Error("HttpConfig.token is required and must be defined.");
         }
         container.addSingleton(opts.token, () => {
           const factory = new NodeAxiosFactory2();
           const instance = factory.create(opts.client);
-          if (!Guards47.hasMethod(instance, "get") || !Guards47.hasMethod(instance, "post") || !Guards47.hasMethod(instance, "put") || !Guards47.hasMethod(instance, "patch") || !Guards47.hasMethod(instance, "delete")) {
+          if (!Guards46.hasMethod(instance, "get") || !Guards46.hasMethod(instance, "post") || !Guards46.hasMethod(instance, "put") || !Guards46.hasMethod(instance, "patch") || !Guards46.hasMethod(instance, "delete")) {
             throw new Error(
               "The created HTTP client instance does not implement the required methods of IHttpClient."
             );
@@ -3139,17 +3072,6 @@ var init_http_utils = __esm({
           const factory = new CockatielResilienceFactory2();
           return factory.create(opts);
         });
-      },
-      async addAllowOrigin(container, opts) {
-        const { Guards: Guards47 } = await import("@xeno-js/shared");
-        if (Guards47.isNullOrEmpty(opts)) throw new Error("At least an allow origin must be passed");
-        const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        const { AllowOrigin: AllowOrigin2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-        const allowOrigin = [];
-        opts.forEach((x) => {
-          allowOrigin.push(x.trim().toLowerCase());
-        });
-        container.addSingleton(TOKENS4.ALLOW_ORIGIN, () => new AllowOrigin2(allowOrigin));
       }
     });
   }
@@ -3158,10 +3080,9 @@ var init_http_utils = __esm({
 // src/infrastructure/modules/http-core.module.ts
 var http_core_module_exports = {};
 __export(http_core_module_exports, {
-  HttpCoreModule: () => HttpCoreModule,
-  HttpOriginModule: () => HttpOriginModule
+  HttpCoreModule: () => HttpCoreModule
 });
-var HttpCoreModule, HttpOriginModule;
+var HttpCoreModule;
 var init_http_core_module = __esm({
   "src/infrastructure/modules/http-core.module.ts"() {
     "use strict";
@@ -3172,12 +3093,6 @@ var init_http_core_module = __esm({
         await HttpUtils2.addResilience(container, opts.resilience);
       }
     };
-    HttpOriginModule = class {
-      async configure(container, opts) {
-        const { HttpUtils: HttpUtils2 } = await Promise.resolve().then(() => (init_http_utils(), http_utils_exports));
-        await HttpUtils2.addAllowOrigin(container, opts);
-      }
-    };
   }
 });
 
@@ -3202,53 +3117,32 @@ var init_validation_utils = __esm({
        * @link https://github.com/xeno-js/xeno-js
        */
       async addValidation(container, opts, logger) {
-        const { Guards: Guards47, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        if (!Guards47.isDefined(opts.zod) && Guards47.isNullOrEmpty(opts.customValidationStrategy)) {
-          return [];
+        const { Guards: Guards46, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
+        if (!Guards46.isDefined(opts.zod) && Guards46.isNullOrEmpty(opts.customValidationStrategy)) {
+          return;
         }
-        const pipelines = [];
         const validationStrategies = [];
-        if (Guards47.isDefined(opts.zod)) {
+        if (Guards46.isDefined(opts.zod)) {
           const config = opts.zod;
-          const { ZodValidatorFactory: ZodValidatorFactory2 } = await Promise.resolve().then(() => (init_zod_validator_factory(), zod_validator_factory_exports));
-          container.addSingleton(TOKENS4.ZOD_VALIDATOR, () => {
-            return new ZodValidatorFactory2().create({ ...config, logger });
-          });
+          const { ZodValidatorFactory: ZodValidatorFactory2 } = await Promise.resolve().then(() => (init_factories(), factories_exports));
           const { SchemaValidationStrategy: SchemaValidationStrategy2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-          container.addSingleton(
-            TOKENS4.SCHEMA_VALIDATION_STRATEGY,
-            (c) => new SchemaValidationStrategy2(c.resolve(TOKENS4.ZOD_VALIDATOR))
-          );
-          validationStrategies.push(TOKENS4.SCHEMA_VALIDATION_STRATEGY);
+          const validatorService = new ZodValidatorFactory2().create({ ...config, logger });
+          container.addSingleton(TOKENS4.VALIDATOR_SERVICE, () => validatorService);
+          validationStrategies.push(new SchemaValidationStrategy2(validatorService));
         }
-        const customValidationFactory = [];
-        if (!Guards47.isNullOrEmpty(opts.customValidationStrategy)) {
+        if (!Guards46.isNullOrEmpty(opts.customValidationStrategy)) {
           for (const strategyToken of opts.customValidationStrategy) {
-            if (Guards47.isDefined(strategyToken)) {
-              customValidationFactory.push(strategyToken);
-            }
+            if (Guards46.isDefined(strategyToken)) validationStrategies.push(strategyToken(container));
           }
         }
         const { ValidationPipeline: ValidationPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.VALIDATION_PIPELINE, (c) => {
-          const resolvedStrategies = [
-            ...validationStrategies.map((token) => c.resolve(token)),
-            ...customValidationFactory.map((factory) => factory(c))
-          ];
-          return new ValidationPipeline2(resolvedStrategies);
-        });
-        pipelines.push(TOKENS4.VALIDATION_PIPELINE);
-        return pipelines;
+        return new ValidationPipeline2(validationStrategies);
       }
     });
   }
 });
 
 // src/infrastructure/idempotency/idempotency-store.ts
-var idempotency_store_exports = {};
-__export(idempotency_store_exports, {
-  IdempotencyStore: () => IdempotencyStore
-});
 var import_shared60, IdempotencyStore;
 var init_idempotency_store = __esm({
   "src/infrastructure/idempotency/idempotency-store.ts"() {
@@ -3305,6 +3199,18 @@ var init_idempotency_store = __esm({
   }
 });
 
+// src/infrastructure/idempotency/index.ts
+var idempotency_exports = {};
+__export(idempotency_exports, {
+  IdempotencyStore: () => IdempotencyStore
+});
+var init_idempotency = __esm({
+  "src/infrastructure/idempotency/index.ts"() {
+    "use strict";
+    init_idempotency_store();
+  }
+});
+
 // src/infrastructure/modules/utils/pipeline.utils.ts
 var pipeline_utils_exports = {};
 __export(pipeline_utils_exports, {
@@ -3326,35 +3232,30 @@ var init_pipeline_utils = __esm({
        * @link https://github.com/xeno-js/xeno-js
        */
       async addCommand(container, opts) {
+        const { Guards: Guards46, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
         const pipelines = [];
-        const { Guards: Guards47, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        if (Guards47.isDefined(opts.idempotency)) {
-          const { IdempotencyStore: IdempotencyStore2 } = await Promise.resolve().then(() => (init_idempotency_store(), idempotency_store_exports));
-          container.addSingleton(
-            TOKENS4.IDEMPOTENCY_STORE,
-            (c) => new IdempotencyStore2(c.resolve(TOKENS4.CACHE), c.resolve(TOKENS4.CACHE_KEY_BUILDER))
+        if (Guards46.isDefined(opts.idempotency)) {
+          const { IdempotencyStore: IdempotencyStore2 } = await Promise.resolve().then(() => (init_idempotency(), idempotency_exports));
+          const imdStore = new IdempotencyStore2(
+            container.resolve(TOKENS4.CACHE),
+            container.resolve(TOKENS4.CACHE_KEY_BUILDER)
           );
           const { IdempotencyPipeline: IdempotencyPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-          container.addSingleton(TOKENS4.IDEMPOTENCY_PIPELINE, (c) => {
-            const requestContext = c.resolve(TOKENS4.NETWORK_CONTEXT_ACCESSOR);
-            const idempotencyStore = c.resolve(TOKENS4.IDEMPOTENCY_STORE);
-            const config = opts.idempotency;
-            return new IdempotencyPipeline2(
+          const requestContext = container.resolve(TOKENS4.NETWORK_CONTEXT_ACCESSOR);
+          const config = opts.idempotency;
+          pipelines.push(
+            new IdempotencyPipeline2(
               requestContext,
-              idempotencyStore,
+              imdStore,
               config?.lockTtlSeconds,
               config?.processedTtlSeconds
-            );
-          });
-          pipelines.push(TOKENS4.IDEMPOTENCY_PIPELINE);
+            )
+          );
         }
-        if (Guards47.isDefined(opts.concurrency)) {
+        if (Guards46.isDefined(opts.concurrency)) {
           const { ConcurrencyRetryPipeline: ConcurrencyRetryPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-          container.addSingleton(TOKENS4.CONCURRENCY_RETRY_PIPELINE, () => {
-            const config = opts.concurrency;
-            return new ConcurrencyRetryPipeline2(config?.maxRetries, config?.delayConfig);
-          });
-          pipelines.push(TOKENS4.CONCURRENCY_RETRY_PIPELINE);
+          const config = opts.concurrency;
+          pipelines.push(new ConcurrencyRetryPipeline2(config?.maxRetries, config?.delayConfig));
         }
         return pipelines;
       },
@@ -3368,24 +3269,14 @@ var init_pipeline_utils = __esm({
        * @since 2025-09-30
        * @link https://github.com/xeno-js/xeno-js
        */
-      async addQuery(container, opts) {
+      async addQuery(container) {
         const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        const pipelines = [];
-        if (!opts.isCache) {
-          const { CacheUtils: CacheUtils2 } = await Promise.resolve().then(() => (init_cache_utils(), cache_utils_exports));
-          await CacheUtils2.addCache(container, { inMemory: true, redis: void 0 });
-        }
         const { QueryCachingPipeline: QueryCachingPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(
-          TOKENS4.QUERY_CACHING_PIPELINE,
-          (c) => new QueryCachingPipeline2(
-            c.resolve(TOKENS4.CACHE),
-            c.resolve(TOKENS4.CACHE_KEY_BUILDER),
-            c.resolve(TOKENS4.LOGGER)
-          )
+        return new QueryCachingPipeline2(
+          container.resolve(TOKENS4.CACHE),
+          container.resolve(TOKENS4.CACHE_KEY_BUILDER),
+          container.resolve(TOKENS4.LOGGER)
         );
-        pipelines.push(TOKENS4.QUERY_CACHING_PIPELINE);
-        return pipelines;
       }
     });
   }
@@ -3403,79 +3294,54 @@ var init_cqrs_module = __esm({
     CqrsModule = class {
       async configure(container, opts) {
         const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        let isCache = opts.isCache;
+        const logger = container.resolve(TOKENS4.LOGGER);
         const { Mediator: Mediator2 } = await Promise.resolve().then(() => (init_application(), application_exports));
         container.addSingleton(TOKENS4.MEDIATOR, (c) => {
           const serviceScopeAccessor = c.resolve(TOKENS4.SERVICE_SCOPE_ACCESSOR);
           return new Mediator2(serviceScopeAccessor);
         });
         const { ExceptionPipeline: ExceptionPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.EXCEPTION_PIPELINE, () => new ExceptionPipeline2());
-        if (!opts.isLogger) {
-          const { LoggerUtils: LoggerUtils2 } = await Promise.resolve().then(() => (init_logger_utils(), logger_utils_exports));
-          await LoggerUtils2.addLogger(container, void 0);
-        }
         const { LoggingPipeline: LoggingPipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(
-          TOKENS4.LOGGING_PIPELINE,
-          (c) => new LoggingPipeline2(c.resolve(TOKENS4.LOGGER))
-        );
-        const pipelines = [TOKENS4.EXCEPTION_PIPELINE, TOKENS4.LOGGING_PIPELINE];
         const { PerformancePipeline: PerformancePipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.PERFORMANCE_PIPELINE, (c) => {
-          const logger = c.resolve(TOKENS4.LOGGER);
-          const thresholdMs = opts.performance?.thresholdMs;
-          return new PerformancePipeline2(logger, thresholdMs);
-        });
-        pipelines.push(TOKENS4.PERFORMANCE_PIPELINE);
-        const { Guards: Guards47 } = await import("@xeno-js/shared");
-        if (Guards47.isDefined(opts.authorization.policies) || Guards47.isDefined(opts.authorization.customAuthorizationStrategy)) {
+        const thresholdMs = opts.performance?.thresholdMs;
+        const pipelines = [
+          new ExceptionPipeline2(),
+          new LoggingPipeline2(logger),
+          new PerformancePipeline2(logger, thresholdMs)
+        ];
+        const { Guards: Guards46 } = await import("@xeno-js/shared");
+        if (Guards46.isDefined(opts.authorization.policies) || Guards46.isDefined(opts.authorization.customAuthorizationStrategy)) {
           const { AuthUtils: AuthUtils2 } = await Promise.resolve().then(() => (init_auth_utils(), auth_utils_exports));
           const authPipelines = await AuthUtils2.addAuthZ(container, opts.authorization);
-          pipelines.push(...authPipelines);
+          pipelines.push(authPipelines);
         }
-        if (Guards47.isDefined(opts.validation.zod) || Guards47.isDefined(opts.validation.customValidationStrategy)) {
+        if (Guards46.isDefined(opts.validation.zod) || Guards46.isDefined(opts.validation.customValidationStrategy)) {
           const { ValidationUtils: ValidationUtils2 } = await Promise.resolve().then(() => (init_validation_utils(), validation_utils_exports));
-          const logger = container.resolve(TOKENS4.LOGGER);
           const validationPipelines = await ValidationUtils2.addValidation(
             container,
             opts.validation,
             logger
           );
-          pipelines.push(...validationPipelines);
+          if (Guards46.isDefined(validationPipelines)) pipelines.push(validationPipelines);
         }
         const commandPipelines = pipelines;
         const queryPipelines = pipelines;
-        if ((Guards47.isDefined(opts.commandBus.idempotency) || opts.queryBus.isEnabled) && opts.isCache) {
-          const { CacheUtils: CacheUtils2 } = await Promise.resolve().then(() => (init_cache_utils(), cache_utils_exports));
-          await CacheUtils2.addCache(container, { inMemory: true, redis: void 0 });
-        }
-        if (Guards47.isDefined(opts.commandBus.idempotency) || Guards47.isDefined(opts.commandBus.concurrency)) {
+        if (Guards46.isDefined(opts.commandBus.idempotency) || Guards46.isDefined(opts.commandBus.concurrency)) {
           const { PipelineUtils: PipelineUtils2 } = await Promise.resolve().then(() => (init_pipeline_utils(), pipeline_utils_exports));
-          const newCommandPipelines = await PipelineUtils2.addCommand(container, {
-            ...opts.commandBus,
-            isCache
-          });
-          isCache = true;
+          const newCommandPipelines = await PipelineUtils2.addCommand(container, opts.commandBus);
           commandPipelines.push(...newCommandPipelines);
         }
         if (opts.queryBus.isEnabled) {
           const { PipelineUtils: PipelineUtils2 } = await Promise.resolve().then(() => (init_pipeline_utils(), pipeline_utils_exports));
-          const newQueryPipelines = await PipelineUtils2.addQuery(container, { isCache });
-          queryPipelines.push(...newQueryPipelines);
+          const newQueryPipelines = await PipelineUtils2.addQuery(container);
+          queryPipelines.push(newQueryPipelines);
         }
         const { CompositePipeline: CompositePipeline2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-        container.addSingleton(TOKENS4.COMMAND_PIPELINES_BEHAVIOR, (c) => {
-          const resolvedCommandPipelines = commandPipelines.map((token) => {
-            return c.resolve(token);
-          });
-          return new CompositePipeline2(resolvedCommandPipelines);
+        container.addSingleton(TOKENS4.COMMAND_PIPELINES_BEHAVIOR, () => {
+          return new CompositePipeline2(commandPipelines);
         });
-        container.addSingleton(TOKENS4.QUERY_PIPELINES_BEHAVIOR, (c) => {
-          const resolvedQueryPipelines = queryPipelines.map(
-            (token) => c.resolve(token)
-          );
-          return new CompositePipeline2(resolvedQueryPipelines);
+        container.addSingleton(TOKENS4.QUERY_PIPELINES_BEHAVIOR, () => {
+          return new CompositePipeline2(queryPipelines);
         });
       }
     };
@@ -4259,150 +4125,111 @@ var middleware_module_exports = {};
 __export(middleware_module_exports, {
   MiddlewareModule: () => MiddlewareModule
 });
-var import_shared73, MiddlewareModule;
+var MiddlewareModule;
 var init_middleware_module = __esm({
   "src/infrastructure/modules/middleware.module.ts"() {
     "use strict";
-    import_shared73 = require("@xeno-js/shared");
     MiddlewareModule = class {
       async configure(container, opts) {
-        const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
-        if (!opts.isAuth) {
-          const { NoAuthGateKeeper: NoAuthGateKeeper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
-          container.addSingleton(TOKENS4.GATE_KEEPER, () => new NoAuthGateKeeper2());
-        }
-        if (opts.isSSR) {
-          const { SupabaseSsrTokenExtractor: SupabaseSsrTokenExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-          container.addSingleton(TOKENS4.BEARER_TOKEN_EXTRACTOR, () => new SupabaseSsrTokenExtractor2());
-        } else {
-          const { BearerTokenExtractor: BearerTokenExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-          container.addSingleton(TOKENS4.BEARER_TOKEN_EXTRACTOR, () => new BearerTokenExtractor2());
-        }
+        const { Guards: Guards46, TOKENS: TOKENS4 } = await import("@xeno-js/shared");
         const { HttpCookieExtractor: HttpCookieExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-        container.addSingleton("COOKIE_EXTRACTOR", () => new HttpCookieExtractor2());
         const { HttpHeaderExtractor: HttpHeaderExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
+        const tokenExtractor = await this._getTokenExtractor(opts.isSSR);
         container.addSingleton(
           TOKENS4.SERVICE_EXTRACTOR,
-          (c) => new HttpHeaderExtractor2(
-            c.resolve(TOKENS4.BEARER_TOKEN_EXTRACTOR),
-            c.resolve("COOKIE_EXTRACTOR"),
+          () => new HttpHeaderExtractor2(
+            tokenExtractor,
+            new HttpCookieExtractor2(),
             opts.trustedIpHeader,
             opts.csrf?.cookieName ?? "__Host-xeno-csrf"
           )
         );
-        if (!opts.isLogger) {
-          const { LoggerUtils: LoggerUtils2 } = await Promise.resolve().then(() => (init_logger_utils(), logger_utils_exports));
-          await LoggerUtils2.addLogger(container, void 0);
-        }
         const { ClientIpResolver: ClientIpResolver2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-        container.addSingleton("IP_RESOLVER", () => new ClientIpResolver2(opts.trustedProxies));
-        const middlewares = [TOKENS4.REQUEST_CONTEXT_MIDDLEWARE];
+        const middlewares = [];
+        const requestContext = container.resolve(TOKENS4.REQUEST_CONTEXT);
+        const logger = container.resolve(TOKENS4.LOGGER);
         const { RequestContextMiddleware: RequestContextMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-        container.addSingleton(
-          TOKENS4.REQUEST_CONTEXT_MIDDLEWARE,
-          (c) => new RequestContextMiddleware2(
-            c.resolve(TOKENS4.REQUEST_CONTEXT),
-            c.resolve(TOKENS4.SERVICE_EXTRACTOR),
-            c.resolve("IP_RESOLVER"),
-            c.resolve(TOKENS4.LOGGER)
+        middlewares.push(
+          new RequestContextMiddleware2(
+            requestContext,
+            container.resolve(TOKENS4.SERVICE_EXTRACTOR),
+            new ClientIpResolver2(opts.trustedProxies),
+            logger
           )
         );
-        if (!import_shared73.Guards.isNullOrEmpty(opts.allowOrigins)) {
+        if (!Guards46.isNullOrEmpty(opts.allowOrigins)) {
           if (opts.withCredentials && opts.allowOrigins.includes("*"))
             throw new Error(
               "Wildcard CORS origin is not allowed when withCredentials is set to true in addHttpCore"
             );
           const { AllowOrigin: AllowOrigin2 } = await Promise.resolve().then(() => (init_services(), services_exports));
-          container.addSingleton("ALLOW_ORIGIN", () => {
-            return new AllowOrigin2(opts.allowOrigins);
-          });
           const { AllowOriginMiddleware: AllowOriginMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(TOKENS4.ALLOW_ORIGIN_MIDDLEWARE, (c) => {
-            return new AllowOriginMiddleware2(
-              c.resolve(TOKENS4.ALLOW_ORIGIN),
-              c.resolve(TOKENS4.CONTEXT_ACCESSOR),
-              c.resolve(TOKENS4.LOGGER)
-            );
-          });
-          middlewares.push(TOKENS4.ALLOW_ORIGIN_MIDDLEWARE);
+          middlewares.push(
+            new AllowOriginMiddleware2(new AllowOrigin2(opts.allowOrigins), requestContext, logger)
+          );
         }
         const withCredentials = opts.withCredentials ? "true" : "false";
+        const allowMethod = await this._getAllowMethod(
+          opts.optionsMiddleware || opts.cors,
+          opts.routeRegistry
+        );
         if (opts.optionsMiddleware) {
           const { OptionsMiddleware: OptionsMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(
-            TOKENS4.OPTIONS_MIDDLEWARE,
-            (c) => new OptionsMiddleware2(
-              c.resolve(TOKENS4.NETWORK_CONTEXT_ACCESSOR),
-              c.resolve(TOKENS4.ALLOW_METHOD),
-              opts.allowHeaders,
-              withCredentials
-            )
+          middlewares.push(
+            new OptionsMiddleware2(requestContext, allowMethod, opts.allowHeaders, withCredentials)
           );
-          middlewares.push(TOKENS4.OPTIONS_MIDDLEWARE);
         }
         if (opts.cors) {
           const { CORSMiddleware: CORSMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(TOKENS4.CORS_MIDDLEWARE, (c) => {
-            return new CORSMiddleware2(c.resolve(TOKENS4.CONTEXT_ACCESSOR), withCredentials);
-          });
-          middlewares.push(TOKENS4.CORS_MIDDLEWARE);
+          middlewares.push(new CORSMiddleware2(requestContext, withCredentials));
         }
-        if (import_shared73.Guards.isDefined(opts.routeRegistry)) {
-          const registry = opts.routeRegistry;
-          const { AllowMethodFactory: AllowMethodFactory2 } = await Promise.resolve().then(() => (init_factories(), factories_exports));
-          container.addSingleton(TOKENS4.ALLOW_METHOD, () => new AllowMethodFactory2().create(registry));
+        if (Guards46.isDefined(opts.routeRegistry)) {
           const { MethodCheckMiddleware: MethodCheckMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(
-            TOKENS4.METHOD_CHECK_MIDDLEWARE,
-            (c) => new MethodCheckMiddleware2(
-              c.resolve(TOKENS4.REQUEST_CONTEXT),
-              c.resolve(TOKENS4.ALLOW_METHOD)
-            )
-          );
-          middlewares.push(TOKENS4.METHOD_CHECK_MIDDLEWARE);
+          middlewares.push(new MethodCheckMiddleware2(requestContext, allowMethod));
         }
         const { AuthenticationMiddleware: AuthenticationMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-        container.addSingleton(TOKENS4.AUTH_MIDDLEWARE, (c) => {
-          return new AuthenticationMiddleware2(
-            c.resolve(TOKENS4.REQUEST_CONTEXT),
-            c.resolve(TOKENS4.BEARER_TOKEN_EXTRACTOR),
-            c.resolve(TOKENS4.GATE_KEEPER),
-            c.resolve(TOKENS4.LOGGER)
+        if (!opts.isAuth) {
+          const { NoAuthGateKeeper: NoAuthGateKeeper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
+          middlewares.push(
+            new AuthenticationMiddleware2(
+              requestContext,
+              tokenExtractor,
+              new NoAuthGateKeeper2(),
+              logger
+            )
           );
-        });
-        middlewares.push(TOKENS4.AUTH_MIDDLEWARE);
-        if (import_shared73.Guards.isDefined(opts.rateLimite.maxRequests) || import_shared73.Guards.isDefined(opts.rateLimite.windowSeconds)) {
+        } else {
+          const { ClaimsIdentityMapper: ClaimsIdentityMapper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
+          const { GateKeeper: GateKeeper2 } = await Promise.resolve().then(() => (init_application(), application_exports));
+          middlewares.push(
+            new AuthenticationMiddleware2(
+              requestContext,
+              tokenExtractor,
+              new GateKeeper2(container.resolve(TOKENS4.BASE_AUTH_SERVICE), new ClaimsIdentityMapper2()),
+              logger
+            )
+          );
+        }
+        if (Guards46.isDefined(opts.rateLimite.maxRequests) || Guards46.isDefined(opts.rateLimite.windowSeconds)) {
           const maxRequests = opts.rateLimite.maxRequests ?? 30;
-          import_shared73.Guards.throwIfNegative(maxRequests, "MaxRequests must be positive");
-          import_shared73.Guards.throwIfNotInteger(maxRequests, "MaxRequests must be an integer");
+          Guards46.throwIfNegative(maxRequests, "MaxRequests must be positive");
+          Guards46.throwIfNotInteger(maxRequests, "MaxRequests must be an integer");
           const windowSeconds = opts.rateLimite.windowSeconds ?? 30;
-          import_shared73.Guards.throwIfNegative(windowSeconds, "WindowSeconds must be positive");
-          import_shared73.Guards.throwIfNotInteger(windowSeconds, "WindowSeconds must be an integer");
-          if (!opts.isCache) {
-            const { CacheUtils: CacheUtils2 } = await Promise.resolve().then(() => (init_cache_utils(), cache_utils_exports));
-            await CacheUtils2.addCache(container, { inMemory: true, redis: void 0 });
-          }
+          Guards46.throwIfNegative(windowSeconds, "WindowSeconds must be positive");
+          Guards46.throwIfNotInteger(windowSeconds, "WindowSeconds must be an integer");
           const { RateLimitKeyBuilder: RateLimitKeyBuilder2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-          container.addSingleton(
-            "RATE_LIMIT_KEY_BUILDER",
-            (c) => new RateLimitKeyBuilder2(c.resolve(TOKENS4.REQUEST_CONTEXT))
-          );
           const { RateLimitMiddleware: RateLimitMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(TOKENS4.RATE_LIMITER_MIDDLEWARE, (c) => {
-            return new RateLimitMiddleware2(
-              c.resolve(TOKENS4.CONTEXT_ACCESSOR),
-              c.resolve(TOKENS4.CACHE),
-              c.resolve("RATE_LIMIT_KEY_BUILDER"),
-              c.resolve(TOKENS4.LOGGER),
-              {
-                maxRequests,
-                windowSeconds
-              }
-            );
-          });
-          middlewares.push(TOKENS4.RATE_LIMITER_MIDDLEWARE);
+          middlewares.push(
+            new RateLimitMiddleware2(
+              requestContext,
+              container.resolve(TOKENS4.CACHE),
+              new RateLimitKeyBuilder2(requestContext),
+              logger,
+              { maxRequests, windowSeconds }
+            )
+          );
         }
-        if (import_shared73.Guards.isDefined(opts.csrf)) {
+        if (Guards46.isDefined(opts.csrf)) {
           const csrf = opts.csrf;
           const { EdgeCryptoService: EdgeCryptoService2 } = await Promise.resolve().then(() => (init_services(), services_exports));
           container.addSingleton("CRYPTO_SERVICE", () => new EdgeCryptoService2());
@@ -4411,31 +4238,36 @@ var init_middleware_module = __esm({
             return new CsrfTokenService2(csrf.secret, c.resolve("CRYPTO_SERVICE"));
           });
           const { CsrfCookieMiddleware: CsrfCookieMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton("CSRF_COOKIE_MIDDLEWARE", (c) => {
-            return new CsrfCookieMiddleware2(
-              c.resolve(TOKENS4.REQUEST_CONTEXT),
-              c.resolve("CSRF_TOKEN_SERVICE"),
-              csrf
-            );
-          });
-          middlewares.push("CSRF_COOKIE_MIDDLEWARE");
+          middlewares.push(
+            new CsrfCookieMiddleware2(
+              requestContext,
+              container.resolve("CSRF_TOKEN_SERVICE"),
+              opts.csrf
+            )
+          );
           const { CsrfMiddleware: CsrfMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-          container.addSingleton(TOKENS4.CSRF_MIDDLEWARE, (c) => {
-            return new CsrfMiddleware2(
-              c.resolve(TOKENS4.REQUEST_CONTEXT),
-              c.resolve("CSRF_TOKEN_SERVICE")
-            );
-          });
-          middlewares.push(TOKENS4.CSRF_MIDDLEWARE);
+          middlewares.push(new CsrfMiddleware2(requestContext, container.resolve("CSRF_TOKEN_SERVICE")));
         }
         const { CompositeMiddleware: CompositeMiddleware2 } = await Promise.resolve().then(() => (init_presentation(), presentation_exports));
-        container.addSingleton(TOKENS4.MIDDLEWARE, (c) => {
-          const resolvedMiddleware = middlewares.map(
-            (token) => c.resolve(token)
-          );
-          return new CompositeMiddleware2(resolvedMiddleware);
+        container.addSingleton(TOKENS4.MIDDLEWARE, () => {
+          return new CompositeMiddleware2(middlewares);
         });
       }
+      async _getTokenExtractor(isSSR) {
+        if (isSSR) {
+          const { SupabaseSsrTokenExtractor: SupabaseSsrTokenExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
+          return new SupabaseSsrTokenExtractor2();
+        } else {
+          const { BearerTokenExtractor: BearerTokenExtractor2 } = await Promise.resolve().then(() => (init_services(), services_exports));
+          return new BearerTokenExtractor2();
+        }
+      }
+      async _getAllowMethod(configure, opts) {
+        const { Guards: Guards46 } = await import("@xeno-js/shared");
+        if (!configure || !Guards46.isDefined(opts)) return void 0;
+        const { AllowMethodFactory: AllowMethodFactory2 } = await Promise.resolve().then(() => (init_factories(), factories_exports));
+        return new AllowMethodFactory2().create(opts);
+      }
     };
   }
 });
@@ -4453,26 +4285,17 @@ var init_context_module = __esm({
       async configure(container) {
         const { TOKENS: TOKENS4 } = await import("@xeno-js/shared");
         const { ServiceScopeFactory: ServiceScopeFactory2 } = await Promise.resolve().then(() => (init_service_scope_factory(), service_scope_factory_exports));
-        container.addSingleton(TOKENS4.SERVICE_SCOPE_FACTORY, () => {
-          const factory = new ServiceScopeFactory2(container);
-          return factory;
-        });
         const { NodeRequestContextFactory: NodeRequestContextFactory2 } = await Promise.resolve().then(() => (init_request_context_factory(), request_context_factory_exports));
-        container.addSingleton(TOKENS4.REQUEST_CONTEXT, (c) => {
-          return new NodeRequestContextFactory2(
-            c.resolve(TOKENS4.SERVICE_SCOPE_FACTORY)
-          ).create();
-        });
-        container.addSingleton(TOKENS4.CONTEXT_ACCESSOR, (c) => c.resolve(TOKENS4.REQUEST_CONTEXT));
-        container.addSingleton(TOKENS4.IDENTITY_ACCESSOR, (c) => c.resolve(TOKENS4.REQUEST_CONTEXT));
-        container.addSingleton(TOKENS4.SERVICE_SCOPE_ACCESSOR, (c) => c.resolve(TOKENS4.REQUEST_CONTEXT));
-        container.addSingleton(
-          TOKENS4.NETWORK_CONTEXT_ACCESSOR,
-          (c) => c.resolve(TOKENS4.REQUEST_CONTEXT)
-        );
+        const requestContext = new NodeRequestContextFactory2(
+          new ServiceScopeFactory2(container)
+        ).create();
+        container.addSingleton(TOKENS4.REQUEST_CONTEXT, () => requestContext);
+        container.addSingleton(TOKENS4.CONTEXT_ACCESSOR, () => requestContext);
+        container.addSingleton(TOKENS4.IDENTITY_ACCESSOR, () => requestContext);
+        container.addSingleton(TOKENS4.SERVICE_SCOPE_ACCESSOR, () => requestContext);
+        container.addSingleton(TOKENS4.NETWORK_CONTEXT_ACCESSOR, () => requestContext);
         const { UserContextFactory: UserContextFactory2 } = await Promise.resolve().then(() => (init_user_context_factory(), user_context_factory_exports));
-        container.addSingleton(TOKENS4.USER_CONTEXT_FACTORY, (c) => {
-          const requestContext = c.resolve(TOKENS4.REQUEST_CONTEXT);
+        container.addSingleton("USER_CONTEXT_FACTORY", () => {
           return new UserContextFactory2(requestContext);
         });
       }
@@ -4488,7 +4311,7 @@ __export(index_exports, {
   BaseController: () => BaseController,
   BaseHandler: () => BaseHandler,
   BasePostgresSqlDataSource: () => BasePostgresSqlDataSource,
-  BaseQuery: () => import_shared80.Query,
+  BaseQuery: () => import_shared79.Query,
   BaseSqliteSqlDataSource: () => BaseSqliteSqlDataSource,
   ContainerUtils: () => ContainerUtils,
   ReadDao: () => ReadDao,
@@ -4500,7 +4323,7 @@ module.exports = __toCommonJS(index_exports);
 init_application();
 
 // src/infrastructure/builder/app.builder.ts
-var import_shared74 = require("@xeno-js/shared");
+var import_shared73 = require("@xeno-js/shared");
 
 // src/infrastructure/configuration/configuration.ts
 var import_shared32 = require("@xeno-js/shared");
@@ -4650,6 +4473,12 @@ var ServiceContainer = class {
     this.registrations.set(token, { token, lifetime, factory });
   }
   resolve(token) {
+    const registration = this.registrations.get(token);
+    if (registration?.lifetime === "scoped") {
+      throw new Error(
+        `[DI Container Error]: Scoped service '${String(token)}' requires an active scope.`
+      );
+    }
     return this.internalExecuteInContext(() => this.rootScope.resolve(token));
   }
   createScope() {
@@ -4772,10 +4601,10 @@ var AppBuilder = class {
   constructor(container) {
     this._container = container ?? new ServiceContainer();
     this._container.addSingleton(
-      import_shared74.TOKENS.CONFIGURATION_SERVICE,
+      import_shared73.TOKENS.CONFIGURATION_SERVICE,
       () => new EnvironmentConfigurationService()
     );
-    this._configuration = this._container.resolve(import_shared74.TOKENS.CONFIGURATION_SERVICE);
+    this._configuration = this._container.resolve(import_shared73.TOKENS.CONFIGURATION_SERVICE);
     this._middlewareConfig.allowOrigins?.push(
       this._configuration.get("APP_URL") ?? `http://localhost:${this._configuration.getNumber("PORT", 3e3)}`
     );
@@ -4834,6 +4663,13 @@ var AppBuilder = class {
     },
     resilience: { retry: {}, circuitBreaker: {}, bulkhead: {} }
   };
+  _loggerConfig = {
+    level: import_shared73.LOG_LEVEL.DEBUG,
+    console: true,
+    sentry: { config: void 0 },
+    pino: { config: void 0 },
+    customLoggers: void 0
+  };
   // --- Module Queuing Flags ---
   _isContextModuleQueued = false;
   _isMiddlewareModuleQueued = false;
@@ -4879,31 +4715,22 @@ var AppBuilder = class {
    * @description Configures the logger for the application. This method allows you to set up logging options such as log level, console logging, and integration with external logging services like Sentry or Pino.
    * @param setupAction A callback function that receives a LoggerConfig object to configure the logger settings.
    * @returns The current instance of AppBuilder for method chaining.
-  
-   * 
+   *
    * @author Xeno
    * @version 1.0.0
    * @since 2025-09-30
-   * @link https://github.com/xeno-js/xeno-js 
+   * @link https://github.com/xeno-js/xeno-js
    */
   addLogger(setupAction) {
+    if (import_shared73.Guards.isDefined(setupAction)) setupAction(this._loggerConfig, this._configuration);
     if (this._isLoggerModuleQueued) return this;
     this._isLoggerModuleQueued = true;
-    const config = {
-      level: import_shared74.LOG_LEVEL.DEBUG,
-      console: true,
-      sentry: { config: void 0 },
-      pino: { config: void 0 },
-      customLoggers: void 0
-    };
-    if (import_shared74.Guards.isDefined(setupAction) && import_shared74.Guards.isDefined(config))
-      setupAction(config, this._configuration);
     this._modules.push({
-      priority: 3,
+      priority: 1,
       name: "LoggerModule",
       action: async () => {
         const { LoggerUtils: LoggerUtils2 } = await Promise.resolve().then(() => (init_logger_utils(), logger_utils_exports));
-        await LoggerUtils2.addLogger(this._container, config);
+        await LoggerUtils2.addLogger(this._container, this._loggerConfig);
       }
     });
     return this;
@@ -4920,11 +4747,11 @@ var AppBuilder = class {
    * @link https://github.com/xeno-js/xeno-js 
    */
   addCache(setupAction) {
+    if (import_shared73.Guards.isDefined(setupAction)) setupAction(this._config, this._configuration);
     if (this._isCacheModuleQueued) return this;
     this._isCacheModuleQueued = true;
-    if (import_shared74.Guards.isDefined(setupAction)) setupAction(this._config, this._configuration);
     this._modules.push({
-      priority: 3,
+      priority: 2,
       name: "CacheModule",
       action: async () => {
         const { CacheUtils: CacheUtils2 } = await Promise.resolve().then(() => (init_cache_utils(), cache_utils_exports));
@@ -4957,7 +4784,7 @@ var AppBuilder = class {
     };
     setupAction(config, this._configuration);
     this._modules.push({
-      priority: 2,
+      priority: 3,
       name: "AuthModule",
       action: async () => {
         const { AuthUtils: AuthUtils2 } = await Promise.resolve().then(() => (init_auth_utils(), auth_utils_exports));
@@ -5031,7 +4858,7 @@ var AppBuilder = class {
    * @link https://github.com/xeno-js/xeno-js 
    */
   addPipeline(setupAction) {
-    if (import_shared74.Guards.isDefined(setupAction)) {
+    if (import_shared73.Guards.isDefined(setupAction)) {
       setupAction(this._pipelineConfig, this._configuration);
     }
     this._queuePipelineModule();
@@ -5064,20 +4891,6 @@ var AppBuilder = class {
     });
     return this;
   }
-  addAllowOrigin(setupAction) {
-    const config = [];
-    setupAction(config, this._configuration);
-    this._modules.push({
-      priority: 30,
-      name: "HttpCoreModule",
-      action: async () => {
-        const { HttpOriginModule: HttpOriginModule2 } = await Promise.resolve().then(() => (init_http_core_module(), http_core_module_exports));
-        const httpOriginModule = new HttpOriginModule2();
-        await httpOriginModule.configure(this._container, config);
-      }
-    });
-    return this;
-  }
   // ─────────────────────────────────────────────────────────────────────────────
   // Dependency Injection Pass-through Methods
   // ─────────────────────────────────────────────────────────────────────────────
@@ -5165,7 +4978,7 @@ var AppBuilder = class {
         console.error(`\u{1F449} Module: **${queued.name}**`);
         console.error(`\u{1F4DD} Reason: ${errorMessage}
 `);
-        if (error instanceof Error && import_shared74.Guards.isDefined(error.stack)) {
+        if (error instanceof Error && import_shared73.Guards.isDefined(error.stack)) {
           console.error(error.stack);
         }
         throw new Error(`Bootstrap failed at [${queued.name}]: ${errorMessage}`, { cause: error });
@@ -5190,17 +5003,15 @@ var AppBuilder = class {
     if (this._isPipelineModuleQueued) return;
     this._isPipelineModuleQueued = true;
     this._queueContextModule();
+    if (!this._isLoggerModuleQueued) this.addLogger();
+    if (!this._isCacheModuleQueued) this.addCache();
     this._modules.push({
       priority: 5,
       name: "CqrsModule",
       action: async () => {
         const { CqrsModule: CqrsModule2 } = await Promise.resolve().then(() => (init_cqrs_module(), cqrs_module_exports));
         const pipelineModule = new CqrsModule2();
-        await pipelineModule.configure(this._container, {
-          ...this._pipelineConfig,
-          isLogger: this._isLoggerModuleQueued || this._isMiddlewareModuleQueued,
-          isCache: !this._isCacheModuleQueued
-        });
+        await pipelineModule.configure(this._container, this._pipelineConfig);
       }
     });
   }
@@ -5217,17 +5028,17 @@ var AppBuilder = class {
     if (this._isMiddlewareModuleQueued) return;
     this._isMiddlewareModuleQueued = true;
     this._queueContextModule();
+    if (!this._isLoggerModuleQueued) this.addLogger();
+    if (!this._isCacheModuleQueued) this.addCache();
     this._modules.push({
-      priority: 3,
+      priority: 4,
       name: "MiddlewareModule",
       action: async () => {
         const { MiddlewareModule: MiddlewareModule2 } = await Promise.resolve().then(() => (init_middleware_module(), middleware_module_exports));
         const middlewareModule = new MiddlewareModule2();
         await middlewareModule.configure(this._container, {
           ...this._middlewareConfig,
-          isAuth: this._isAuthModuleQueued,
-          isLogger: this._isLoggerModuleQueued,
-          isCache: this._isCacheModuleQueued || this._isPipelineModuleQueued
+          isAuth: this._isAuthModuleQueued
         });
       }
     });
@@ -5293,13 +5104,11 @@ var BaseSqliteSqlDataSource = class {
 };
 
 // src/infrastructure/datasources/remote.datasource.ts
-var import_shared75 = require("@xeno-js/shared");
+var import_shared74 = require("@xeno-js/shared");
 
 // src/infrastructure/index.ts
 init_factories();
-
-// src/infrastructure/idempotency/index.ts
-init_idempotency_store();
+init_idempotency();
 
 // src/infrastructure/loggers/index.ts
 init_console_logger();
@@ -5323,8 +5132,8 @@ init_pipeline_utils();
 init_validation_utils();
 
 // src/infrastructure/repositories/read-dao.ts
+var import_shared75 = require("@xeno-js/shared");
 var import_shared76 = require("@xeno-js/shared");
-var import_shared77 = require("@xeno-js/shared");
 var ReadDao = class {
   /**
    * Constructs a new ReadDao instance.
@@ -5344,23 +5153,23 @@ var ReadDao = class {
   _dataSource;
   _mapper;
   async findById(id, ctx, signal) {
-    import_shared76.AppError.throwIfAborted(signal, "ReadDao.findById");
+    import_shared75.AppError.throwIfAborted(signal, "ReadDao.findById");
     const result = await this._dataSource.findById(id, ctx, signal);
-    if (import_shared77.Guards.isNullOrEmpty(result)) return import_shared76.Result.ok();
+    if (import_shared76.Guards.isNullOrEmpty(result)) return import_shared75.Result.ok();
     const entity = this._mapper.toEntity(result);
-    return import_shared76.Result.ok(entity);
+    return import_shared75.Result.ok(entity);
   }
   async findAll(ctx, signal) {
-    import_shared76.AppError.throwIfAborted(signal, "ReadDao.findAll");
+    import_shared75.AppError.throwIfAborted(signal, "ReadDao.findAll");
     const results = await this._dataSource.findAll(ctx, signal);
     const entities = results.map((result) => this._mapper.toEntity(result));
-    return import_shared76.Result.ok(entities);
+    return import_shared75.Result.ok(entities);
   }
 };
 
 // src/infrastructure/repositories/repository.ts
+var import_shared77 = require("@xeno-js/shared");
 var import_shared78 = require("@xeno-js/shared");
-var import_shared79 = require("@xeno-js/shared");
 var Repository = class {
   /**
    * Constructs a new Repository instance.
@@ -5380,35 +5189,35 @@ var Repository = class {
   _dataSource;
   _mapper;
   async findById(id, ctx, signal) {
-    import_shared78.AppError.throwIfAborted(signal, "Repository.findById");
+    import_shared77.AppError.throwIfAborted(signal, "Repository.findById");
     const result = await this._dataSource.findById(id, ctx, signal);
-    if (import_shared79.Guards.isNullOrEmpty(result)) return import_shared78.Result.ok();
+    if (import_shared78.Guards.isNullOrEmpty(result)) return import_shared77.Result.ok();
     const entity = this._mapper.toEntity(result);
-    return import_shared78.Result.ok(entity);
+    return import_shared77.Result.ok(entity);
   }
   async findAll(ctx, signal) {
-    import_shared78.AppError.throwIfAborted(signal, "Repository.findAll");
+    import_shared77.AppError.throwIfAborted(signal, "Repository.findAll");
     const results = await this._dataSource.findAll(ctx, signal);
     const entities = results.map((result) => this._mapper.toEntity(result));
-    return import_shared78.Result.ok(entities);
+    return import_shared77.Result.ok(entities);
   }
   async save(entity, signal) {
     const dto = this._mapper.toDto(entity);
-    import_shared78.AppError.throwIfAborted(signal, "Repository.save");
+    import_shared77.AppError.throwIfAborted(signal, "Repository.save");
     await this._dataSource.insert(dto, signal);
-    return import_shared78.Result.ok();
+    return import_shared77.Result.ok();
   }
   async delete(entity, ctx, signal) {
     const dto = this._mapper.toDto(entity);
-    import_shared78.AppError.throwIfAborted(signal, "Repository.delete");
+    import_shared77.AppError.throwIfAborted(signal, "Repository.delete");
     await this._dataSource.delete(dto, ctx, signal);
-    return import_shared78.Result.ok();
+    return import_shared77.Result.ok();
   }
   async update(id, entity, ctx, signal) {
     const dto = this._mapper.toPartialDto(entity);
-    import_shared78.AppError.throwIfAborted(signal, "Repository.update");
+    import_shared77.AppError.throwIfAborted(signal, "Repository.update");
     await this._dataSource.update(id, dto, ctx, signal);
-    return import_shared78.Result.ok();
+    return import_shared77.Result.ok();
   }
 };
 
@@ -5426,7 +5235,7 @@ __reExport(drizzle_types_exports, require("drizzle-orm"));
 __reExport(index_exports, drizzle_types_exports, module.exports);
 init_presentation();
 __reExport(index_exports, require("@xeno-js/shared"), module.exports);
-var import_shared80 = require("@xeno-js/shared");
+var import_shared79 = require("@xeno-js/shared");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppBuilder,