@lppedd/di-wise-neo 0.5.2 → 0.6.0

package/dist/es/index.d.mts

@@ -422,7 +422,7 @@ declare function createContainer(options?: Partial<ContainerOptions>): Container
  *
  * @example
  * ```ts
- * @AutoRegister
+ * @AutoRegister()
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
@@ -431,28 +431,28 @@ declare function createContainer(options?: Partial<ContainerOptions>): Container
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function AutoRegister<Ctor extends Constructor<any>>(Class: Ctor): void;
+declare function AutoRegister(): ClassDecorator;
 
 /**
- * Class decorator that enables eager instantiation of a class when it is registered
- * in the container with `Scope.Container`.
+ * Class decorator that sets the class scope to **Container** and enables
+ * eager instantiation when the class is registered in the container.
  *
  * This causes the container to immediately create and cache the instance of the class,
  * instead of deferring instantiation until the first resolution.
  *
  * @example
  * ```ts
- * @EagerInstantiate
- * @Scoped(Scope.Container)
+ * @EagerInstantiate()
  * class Wizard {}
  *
- * // A Wizard instance is immediately created and cached by the container
+ * // Wizard is registered with Container scope, and an instance
+ * // is immediately created and cached by the container
  * const wizard = container.register(Wizard);
  * ```
  *
  * @__NO_SIDE_EFFECTS__
  */
-declare function EagerInstantiate<Ctor extends Constructor<any>>(Class: Ctor): void;
+declare function EagerInstantiate(): ClassDecorator;
 
 interface TokensRef<Value = any> {
     readonly getRefTokens: () => Set<Token<Value>>;

package/dist/es/index.mjs

@@ -190,6 +190,22 @@ function getMetadata(Class) {
             }
         });
     }
+    if (metadata.provider.useClass !== Class) {
+        // This is part of the class identity mapping API (see setClassIdentityMapping).
+        //
+        // Scenario:
+        // 1. Metadata is created for class A (the original class) because of a parameter decorator.
+        // 2. Later, because of a class decorator that extends the decorated class, a third-party
+        //    registers a class identity mapping from class B to class A, where B is the class
+        //    generated from the class decorator by extending A.
+        //
+        // We must update useClass to be the extender class B so that instances created by the
+        // DI container match the consumer's registered class. Without this update, the DI
+        // system would instantiate the original class A, causing behavior inconsistencies.
+        //
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        metadata.provider.useClass = Class;
+    }
     return metadata;
 }
 const classIdentityMap = new WeakMap();
@@ -518,7 +534,7 @@ function isDisposable(value) {
                 // The provider is of type ClassProvider, initialized by getMetadata
                 provider: metadata.provider,
                 options: {
-                    scope: metadata.scope ?? this.myOptions.defaultScope
+                    scope: metadata.scope?.value ?? this.myOptions.defaultScope
                 },
                 dependencies: metadata.dependencies
             };
@@ -535,7 +551,7 @@ function isDisposable(value) {
             }
             // Eager-instantiate only if the class is container-scoped
             if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                this.resolve(Class);
+                this.resolveProviderValue(registration, registration.provider);
             }
         } else {
             const [token, provider, options] = args;
@@ -546,7 +562,7 @@ function isDisposable(value) {
                     options: {
                         // The explicit registration options override what is specified
                         // via class decorators (e.g., @Scoped)
-                        scope: metadata.scope ?? this.myOptions.defaultScope,
+                        scope: metadata.scope?.value ?? this.myOptions.defaultScope,
                         ...options
                     },
                     dependencies: metadata.dependencies
@@ -554,7 +570,7 @@ function isDisposable(value) {
                 this.myTokenRegistry.set(token, registration);
                 // Eager-instantiate only if the provided class is container-scoped
                 if (metadata.eagerInstantiate && registration.options?.scope === Scope.Container) {
-                    this.resolve(token);
+                    this.resolveProviderValue(registration, registration.provider);
                 }
             } else {
                 if (isExistingProvider(provider)) {
@@ -670,7 +686,7 @@ function isDisposable(value) {
                 metadata.eagerInstantiate = eagerInstantiate;
             }
         }
-        const scope = this.resolveScope(metadata.scope);
+        const scope = this.resolveScope(metadata.scope?.value);
         if (optional && scope === Scope.Container) {
             // It would not be possible to resolve the class in container scope,
             // as that would require prior registration.
@@ -860,7 +876,7 @@ function isDisposable(value) {
  *
  * @example
  * ```ts
- * @AutoRegister
+ * @AutoRegister()
  * class Wizard {}
  *
  * const wizard = container.resolve(Wizard);
@@ -868,32 +884,45 @@ function isDisposable(value) {
  * ```
  *
  * @__NO_SIDE_EFFECTS__
- */ function AutoRegister(Class) {
-    const metadata = getMetadata(Class);
-    metadata.autoRegister = true;
+ */ function AutoRegister() {
+    return function(Class) {
+        const metadata = getMetadata(Class);
+        metadata.autoRegister = true;
+    };
 }
 
 /**
- * Class decorator that enables eager instantiation of a class when it is registered
- * in the container with `Scope.Container`.
+ * Class decorator that sets the class scope to **Container** and enables
+ * eager instantiation when the class is registered in the container.
  *
  * This causes the container to immediately create and cache the instance of the class,
  * instead of deferring instantiation until the first resolution.
  *
  * @example
  * ```ts
- * @EagerInstantiate
- * @Scoped(Scope.Container)
+ * @EagerInstantiate()
  * class Wizard {}
  *
- * // A Wizard instance is immediately created and cached by the container
+ * // Wizard is registered with Container scope, and an instance
+ * // is immediately created and cached by the container
  * const wizard = container.register(Wizard);
  * ```
  *
  * @__NO_SIDE_EFFECTS__
- */ function EagerInstantiate(Class) {
-    const metadata = getMetadata(Class);
-    metadata.eagerInstantiate = true;
+ */ function EagerInstantiate() {
+    return function(Class) {
+        const metadata = getMetadata(Class);
+        const currentScope = metadata.scope;
+        assert(!currentScope || currentScope.value === Scope.Container, ()=>{
+            const { value, appliedBy } = currentScope;
+            return `class ${Class.name}: Scope.${value} was already set by @${appliedBy},\n  ` + `but @EagerInstantiate is trying to set a conflicting Scope.Container.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
+        });
+        metadata.eagerInstantiate = true;
+        metadata.scope = {
+            value: Scope.Container,
+            appliedBy: "EagerInstantiate"
+        };
+    };
 }
 
 function forwardRef(token) {
@@ -1025,7 +1054,16 @@ function OptionalAll(token) {
  */ function Scoped(scope) {
     return function(Class) {
         const metadata = getMetadata(Class);
-        metadata.scope = scope;
+        const currentScope = metadata.scope;
+        assert(!currentScope || currentScope.value === scope, ()=>{
+            const { value, appliedBy } = currentScope;
+            const by = appliedBy === "Scoped" ? `another @${appliedBy} decorator` : `@${appliedBy}`;
+            return `class ${Class.name}: Scope.${value} was already set by ${by},\n  ` + `but @Scoped is trying to set a conflicting Scope.${scope}.\n  ` + `Only one decorator should set the class scope, or all must agree on the same value.`;
+        });
+        metadata.scope = {
+            value: scope,
+            appliedBy: "Scoped"
+        };
     };
 }