@nextrush/di 3.0.6 → 4.0.0-beta.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { container as container$1, singleton, injectable, inject as inject$1, delay as delay$1 } from 'tsyringe';
+import { Lifecycle, singleton, injectable, inject as inject$1, delay as delay$1, container as container$1 } from 'tsyringe';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -66,42 +66,6 @@ Strategies to break the cycle:
     this.cycle = cycle;
   }
 };
-var TypeInferenceError = class extends DIError {
-  static {
-    __name(this, "TypeInferenceError");
-  }
-  className;
-  parameterIndex;
-  constructor(className, parameterIndex) {
-    super(`
-\u274C Cannot Resolve Constructor Parameter
-
-${className} constructor parameter at index ${parameterIndex} has no type information.
-
-This usually means:
-  1. Missing type annotation on the parameter
-  2. emitDecoratorMetadata is not enabled in tsconfig.json
-
-Fix option 1 - Add explicit type annotation:
-  constructor(private service: ServiceClass) {}
-                              ^^^^^^^^^^^^
-
-Fix option 2 - Update tsconfig.json:
-  {
-    "compilerOptions": {
-      "experimentalDecorators": true,
-      "emitDecoratorMetadata": true
-    }
-  }
-
-Fix option 3 - Use explicit @inject():
-  constructor(@inject(ServiceClass) private service: ServiceClass) {}
-`);
-    this.name = "TypeInferenceError";
-    this.className = className;
-    this.parameterIndex = parameterIndex;
-  }
-};
 var InvalidProviderError = class extends DIError {
   static {
     __name(this, "InvalidProviderError");
@@ -120,51 +84,130 @@ A provider must have one of:
 
 Example:
   container.register(MyService, { useClass: MyService });
-  container.register('CONFIG', { useValue: { port: 3000 } });
+  container.register('CONFIG', { useValue: { port: 8080 } });
   container.register(Logger, { useFactory: () => new Logger() });
 `);
     this.name = "InvalidProviderError";
     this.token = token;
   }
 };
-var ContainerDisposedError = class extends DIError {
-  static {
-    __name(this, "ContainerDisposedError");
-  }
-  constructor() {
-    super(`
-\u274C Container Has Been Disposed
-
-The container has been reset or disposed and cannot resolve dependencies.
 
-If you're in a test environment, ensure you're creating a fresh container
-for each test or using container.clearInstances() between tests.
-`);
-    this.name = "ContainerDisposedError";
-  }
+// src/types.ts
+var METADATA_KEYS = {
+  SERVICE_TYPE: "di:type",
+  SERVICE_SCOPE: "di:scope",
+  INJECT_TOKEN: "di:inject",
+  PARAM_TYPES: "design:paramtypes",
+  CONFIG_PREFIX: "di:config:prefix",
+  OPTIONAL_PARAMS: "di:optional"
 };
-var MissingDependencyError = class extends DIError {
-  static {
-    __name(this, "MissingDependencyError");
-  }
-  token;
-  constructor(token) {
-    super(`
-\u274C Missing Required Dependency
-
-Token: "${token}"
 
-The requested dependency is not registered in the container.
-
-Make sure to:
-  1. Register the dependency before resolving
-  2. Check spelling of the token
-  3. Verify the service has @Service() or @Repository() decorator
-`);
-    this.name = "MissingDependencyError";
-    this.token = token;
+// src/service-decorators.ts
+function Service(options = {}) {
+  const scope = options.scope ?? "singleton";
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "service", target);
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, scope, target);
+    if (scope === "singleton") {
+      singleton()(target);
+    } else {
+      injectable()(target);
+    }
+  };
+}
+__name(Service, "Service");
+function Repository(options = {}) {
+  const scope = options.scope ?? "singleton";
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "repository", target);
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, scope, target);
+    if (scope === "singleton") {
+      singleton()(target);
+    } else {
+      injectable()(target);
+    }
+  };
+}
+__name(Repository, "Repository");
+function Config(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "config", target);
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, "singleton", target);
+    if (options.prefix) {
+      Reflect.defineMetadata(METADATA_KEYS.CONFIG_PREFIX, options.prefix, target);
+    }
+    singleton()(target);
+  };
+}
+__name(Config, "Config");
+function inject(token) {
+  return inject$1(token);
+}
+__name(inject, "inject");
+function delay(tokenFactory) {
+  return delay$1(tokenFactory);
+}
+__name(delay, "delay");
+function Injectable() {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "service", target);
+    injectable()(target);
+  };
+}
+__name(Injectable, "Injectable");
+function markInjectable(target) {
+  injectable()(target);
+}
+__name(markInjectable, "markInjectable");
+function markTsyringeParamOptional(target, parameterIndex) {
+  const TSYRINGE_INJECTION_KEY = "injectionTokens";
+  try {
+    const descriptors = Reflect.getOwnMetadata(TSYRINGE_INJECTION_KEY, target) ?? {};
+    const descriptor = descriptors[parameterIndex];
+    if (descriptor && typeof descriptor === "object" && "token" in descriptor) {
+      descriptor.isOptional = true;
+      Reflect.defineMetadata(TSYRINGE_INJECTION_KEY, descriptors, target);
+    }
+  } catch {
   }
-};
+}
+__name(markTsyringeParamOptional, "markTsyringeParamOptional");
+function Optional() {
+  return (target, _propertyKey, parameterIndex) => {
+    const existing = Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target) ?? /* @__PURE__ */ new Set();
+    existing.add(parameterIndex);
+    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL_PARAMS, existing, target);
+    markTsyringeParamOptional(target, parameterIndex);
+  };
+}
+__name(Optional, "Optional");
+function isParameterOptional(target, parameterIndex) {
+  const optional = Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target);
+  return optional?.has(parameterIndex) ?? false;
+}
+__name(isParameterOptional, "isParameterOptional");
+function getOptionalParams(target) {
+  return Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target) ?? /* @__PURE__ */ new Set();
+}
+__name(getOptionalParams, "getOptionalParams");
+
+// src/service-metadata.ts
+function hasServiceMetadata(target) {
+  return Reflect.hasMetadata(METADATA_KEYS.SERVICE_TYPE, target);
+}
+__name(hasServiceMetadata, "hasServiceMetadata");
+function getServiceType(target) {
+  return Reflect.getMetadata(METADATA_KEYS.SERVICE_TYPE, target);
+}
+__name(getServiceType, "getServiceType");
+function getServiceScope(target) {
+  return Reflect.getMetadata(METADATA_KEYS.SERVICE_SCOPE, target) ?? "singleton";
+}
+__name(getServiceScope, "getServiceScope");
+function getConfigPrefix(target) {
+  return Reflect.getMetadata(METADATA_KEYS.CONFIG_PREFIX, target);
+}
+__name(getConfigPrefix, "getConfigPrefix");
 
 // src/container.ts
 function getTokenName(token) {
@@ -186,23 +229,55 @@ function isFactoryProvider(provider) {
   return "useFactory" in provider && typeof provider.useFactory === "function";
 }
 __name(isFactoryProvider, "isFactoryProvider");
-function createContainerWrapper(tsyInstance) {
-  const resolutionStack = /* @__PURE__ */ new Set();
-  const factoryTokens = /* @__PURE__ */ new Set();
-  const bootstrappedValues = /* @__PURE__ */ new Map();
+function createContainerWrapper(tsyInstance, sharedState) {
+  const resolutionStack = sharedState?.resolutionStack ?? /* @__PURE__ */ new Set();
+  const factoryTokens = sharedState?.factoryTokens ?? /* @__PURE__ */ new Set();
+  const bootstrappedValues = sharedState?.bootstrappedValues ?? /* @__PURE__ */ new Map();
+  const guardedTokens = sharedState?.guardedTokens ?? /* @__PURE__ */ new Set();
+  function registerCycleGuard(token, tsyToken) {
+    if (guardedTokens.has(token)) return;
+    guardedTokens.add(token);
+    const tokenName = getTokenName(token);
+    tsyInstance.beforeResolution(tsyToken, () => {
+      if (resolutionStack.has(tokenName)) {
+        const cycle = [
+          ...resolutionStack,
+          tokenName
+        ];
+        throw new CircularDependencyError(cycle);
+      }
+      resolutionStack.add(tokenName);
+    }, {
+      frequency: "Always"
+    });
+    tsyInstance.afterResolution(tsyToken, () => {
+      resolutionStack.delete(tokenName);
+    }, {
+      frequency: "Always"
+    });
+  }
+  __name(registerCycleGuard, "registerCycleGuard");
   const wrapper = {
     register(token, provider, options) {
       const tokenName = getTokenName(token);
       const tsyToken = token;
       bootstrappedValues.delete(token);
       if (isClassProvider(provider)) {
-        if (options?.scope === "singleton") {
+        const scope = options?.scope ?? getServiceScope(provider.useClass);
+        if (scope === "singleton") {
           tsyInstance.registerSingleton(tsyToken, provider.useClass);
+        } else if (scope === "request") {
+          tsyInstance.register(tsyToken, {
+            useClass: provider.useClass
+          }, {
+            lifecycle: Lifecycle.ContainerScoped
+          });
         } else {
           tsyInstance.register(tsyToken, {
             useClass: provider.useClass
           });
         }
+        registerCycleGuard(token, tsyToken);
       } else if (isValueProvider(provider)) {
         tsyInstance.register(tsyToken, {
           useValue: provider.useValue
@@ -236,46 +311,44 @@ function createContainerWrapper(tsyInstance) {
       }
       const tokenName = getTokenName(token);
       const tsyToken = token;
-      if (resolutionStack.has(tokenName)) {
-        const cycle = [
-          ...resolutionStack,
-          tokenName
-        ];
-        throw new CircularDependencyError(cycle);
+      const guardedByInterceptor = guardedTokens.has(token);
+      const stackSnapshot = [
+        ...resolutionStack
+      ];
+      if (!guardedByInterceptor) {
+        if (resolutionStack.has(tokenName)) {
+          const cycle = [
+            ...resolutionStack,
+            tokenName
+          ];
+          throw new CircularDependencyError(cycle);
+        }
+        resolutionStack.add(tokenName);
       }
-      resolutionStack.add(tokenName);
       try {
-        const instance = tsyInstance.resolve(tsyToken);
-        resolutionStack.delete(tokenName);
-        return instance;
+        return tsyInstance.resolve(tsyToken);
       } catch (error) {
-        resolutionStack.delete(tokenName);
         if (error instanceof CircularDependencyError) {
           throw error;
         }
-        if (error instanceof RangeError && error.message.includes("Maximum call stack")) {
-          const cycle = [
-            ...resolutionStack,
-            tokenName
-          ];
-          throw new CircularDependencyError(cycle);
+        const message = error instanceof Error ? error.message.toLowerCase() : "";
+        if (error instanceof Error && (message.includes("not registered") || message.includes("cannot resolve") || message.includes("unregistered"))) {
+          throw new DependencyResolutionError([
+            ...resolutionStack
+          ], tokenName);
         }
-        if (error instanceof Error && error.message.includes("Cannot inject the dependency")) {
+        const isStackOverflow = error instanceof RangeError && error.message.includes("Maximum call stack") || message.includes("maximum call stack");
+        if (isStackOverflow || message.includes("circular") || message.includes("cyclic") || message.includes("cannot inject the dependency")) {
           const cycle = [
             ...resolutionStack,
             tokenName
           ];
           throw new CircularDependencyError(cycle);
         }
-        if (error instanceof Error) {
-          const message = error.message.toLowerCase();
-          if (message.includes("not registered") || message.includes("cannot resolve") || message.includes("unregistered dependency")) {
-            throw new DependencyResolutionError([
-              ...resolutionStack
-            ], tokenName);
-          }
-        }
         throw error;
+      } finally {
+        resolutionStack.clear();
+        for (const name of stackSnapshot) resolutionStack.add(name);
       }
     },
     async resolveAsync(token) {
@@ -283,16 +356,17 @@ function createContainerWrapper(tsyInstance) {
         return bootstrappedValues.get(token);
       }
       const result = wrapper.resolve(token);
-      return result instanceof Promise ? result : result;
+      return await result;
     },
     async bootstrap() {
-      for (const token of factoryTokens) {
+      for (const token of [
+        ...factoryTokens
+      ]) {
         if (bootstrappedValues.has(token)) continue;
         const result = wrapper.resolve(token);
         const value = result instanceof Promise ? await result : result;
         bootstrappedValues.set(token, value);
       }
-      factoryTokens.clear();
     },
     resolveAll(token) {
       const tsyToken = token;
@@ -319,10 +393,16 @@ function createContainerWrapper(tsyInstance) {
       bootstrappedValues.clear();
       factoryTokens.clear();
       resolutionStack.clear();
+      guardedTokens.clear();
     },
     createChild() {
       const childTsy = tsyInstance.createChildContainer();
-      return createContainerWrapper(childTsy);
+      return createContainerWrapper(childTsy, {
+        resolutionStack,
+        factoryTokens,
+        bootstrappedValues,
+        guardedTokens
+      });
     }
   };
   return wrapper;
@@ -336,115 +416,6 @@ function createContainer() {
 }
 __name(createContainer, "createContainer");
 
-// src/types.ts
-var METADATA_KEYS = {
-  SERVICE_TYPE: "di:type",
-  SERVICE_SCOPE: "di:scope",
-  INJECT_TOKEN: "di:inject",
-  PARAM_TYPES: "design:paramtypes",
-  CONFIG_PREFIX: "di:config:prefix",
-  OPTIONAL_PARAMS: "di:optional"
-};
-
-// src/decorators.ts
-function Service(options = {}) {
-  const scope = options.scope ?? "singleton";
-  return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "service", target);
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, scope, target);
-    if (scope === "singleton") {
-      singleton()(target);
-    } else {
-      injectable()(target);
-    }
-  };
-}
-__name(Service, "Service");
-function Repository(options = {}) {
-  const scope = options.scope ?? "singleton";
-  return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "repository", target);
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, scope, target);
-    if (scope === "singleton") {
-      singleton()(target);
-    } else {
-      injectable()(target);
-    }
-  };
-}
-__name(Repository, "Repository");
-function inject(token) {
-  return inject$1(token);
-}
-__name(inject, "inject");
-function Injectable() {
-  return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "service", target);
-    injectable()(target);
-  };
-}
-__name(Injectable, "Injectable");
-var AutoInjectable = Injectable;
-function markInjectable(target) {
-  injectable()(target);
-}
-__name(markInjectable, "markInjectable");
-function delay(tokenFactory) {
-  return delay$1(tokenFactory);
-}
-__name(delay, "delay");
-function hasServiceMetadata(target) {
-  return Reflect.hasMetadata(METADATA_KEYS.SERVICE_TYPE, target);
-}
-__name(hasServiceMetadata, "hasServiceMetadata");
-function getServiceType(target) {
-  return Reflect.getMetadata(METADATA_KEYS.SERVICE_TYPE, target);
-}
-__name(getServiceType, "getServiceType");
-function getServiceScope(target) {
-  return Reflect.getMetadata(METADATA_KEYS.SERVICE_SCOPE, target);
-}
-__name(getServiceScope, "getServiceScope");
-function Config(options = {}) {
-  return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_TYPE, "config", target);
-    Reflect.defineMetadata(METADATA_KEYS.SERVICE_SCOPE, "singleton", target);
-    if (options.prefix) {
-      Reflect.defineMetadata(METADATA_KEYS.CONFIG_PREFIX, options.prefix, target);
-    }
-    singleton()(target);
-  };
-}
-__name(Config, "Config");
-function getConfigPrefix(target) {
-  return Reflect.getMetadata(METADATA_KEYS.CONFIG_PREFIX, target);
-}
-__name(getConfigPrefix, "getConfigPrefix");
-function Optional() {
-  return (target, _propertyKey, parameterIndex) => {
-    const existing = Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target) ?? /* @__PURE__ */ new Set();
-    existing.add(parameterIndex);
-    Reflect.defineMetadata(METADATA_KEYS.OPTIONAL_PARAMS, existing, target);
-    const TSYRINGE_INJECTION_KEY = "injectionTokens";
-    const descriptors = Reflect.getOwnMetadata(TSYRINGE_INJECTION_KEY, target) ?? {};
-    const descriptor = descriptors[parameterIndex];
-    if (descriptor && typeof descriptor === "object" && "token" in descriptor) {
-      descriptor.isOptional = true;
-    }
-    Reflect.defineMetadata(TSYRINGE_INJECTION_KEY, descriptors, target);
-  };
-}
-__name(Optional, "Optional");
-function isParameterOptional(target, parameterIndex) {
-  const optional = Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target);
-  return optional?.has(parameterIndex) ?? false;
-}
-__name(isParameterOptional, "isParameterOptional");
-function getOptionalParams(target) {
-  return Reflect.getOwnMetadata(METADATA_KEYS.OPTIONAL_PARAMS, target) ?? /* @__PURE__ */ new Set();
-}
-__name(getOptionalParams, "getOptionalParams");
-
-export { AutoInjectable, CircularDependencyError, Config, ContainerDisposedError, DIError, DependencyResolutionError, Injectable, InvalidProviderError, METADATA_KEYS, MissingDependencyError, Optional, Repository, Service, TypeInferenceError, container, createContainer, delay, getConfigPrefix, getOptionalParams, getServiceScope, getServiceType, hasServiceMetadata, inject, isParameterOptional, markInjectable };
+export { CircularDependencyError, Config, DIError, DependencyResolutionError, Injectable, InvalidProviderError, METADATA_KEYS, Optional, Repository, Service, container, createContainer, delay, getConfigPrefix, getOptionalParams, getServiceScope, getServiceType, hasServiceMetadata, inject, isParameterOptional, markInjectable };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map