@lppedd/di-wise-neo 0.5.1 → 0.5.3

package/dist/cjs/index.d.ts

@@ -792,6 +792,24 @@ interface Injector {
  */
 declare const Injector: Type<Injector>;
 
+/**
+ * Registers a mapping between a generated (e.g., decorated or proxied) constructor
+ * and its original, underlying constructor.
+ *
+ * This allows libraries or consumers that manipulate constructors, such as through
+ * class decorators, to inform the DI system about the real "identity" of a class.
+ *
+ * @param transformedClass The constructor function returned by a class decorator or factory.
+ * @param originalClass The original constructor function.
+ *
+ * @remarks
+ * This API affects the core class identity resolution mechanism of the DI system.
+ * Incorrect usage may cause metadata to be misassociated, leading to subtle errors.
+ * Use only when manipulating constructors (e.g., via decorators or proxies),
+ * and ensure the mapping is correct.
+ */
+declare function setClassIdentityMapping<T extends object>(transformedClass: Constructor<T>, originalClass: Constructor<T>): void;
+
 /**
  * Composer API for middleware functions.
  */
@@ -847,5 +865,5 @@ interface Middleware {
  */
 declare function applyMiddleware(container: Container, middlewares: Middleware[]): Container;
 
-export { AutoRegister, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, applyMiddleware, build, createContainer, createType, forwardRef, inject, injectAll, injectBy };
+export { AutoRegister, EagerInstantiate, Inject, InjectAll, Injectable, Injector, Optional, OptionalAll, Scope, Scoped, applyMiddleware, build, createContainer, createType, forwardRef, inject, injectAll, injectBy, setClassIdentityMapping };
 export type { ClassProvider, Constructor, Container, ContainerOptions, ExistingProvider, FactoryProvider, Middleware, MiddlewareComposer, Provider, RegistrationOptions, Token, TokenRef, Tokens, TokensRef, Type, ValueProvider };

package/dist/cjs/index.js

@@ -156,16 +156,35 @@ function injectAll(token) {
     return context.container.resolveAll(token);
 }
 
+/**
+ * Registers a mapping between a generated (e.g., decorated or proxied) constructor
+ * and its original, underlying constructor.
+ *
+ * This allows libraries or consumers that manipulate constructors, such as through
+ * class decorators, to inform the DI system about the real "identity" of a class.
+ *
+ * @param transformedClass The constructor function returned by a class decorator or factory.
+ * @param originalClass The original constructor function.
+ *
+ * @remarks
+ * This API affects the core class identity resolution mechanism of the DI system.
+ * Incorrect usage may cause metadata to be misassociated, leading to subtle errors.
+ * Use only when manipulating constructors (e.g., via decorators or proxies),
+ * and ensure the mapping is correct.
+ */ function setClassIdentityMapping(transformedClass, originalClass) {
+    classIdentityMap.set(transformedClass, originalClass);
+}
 // @internal
 function getMetadata(Class) {
-    let metadata = metadataMap.get(Class);
+    const originalClass = classIdentityMap.get(Class) ?? Class;
+    let metadata = metadataMap.get(originalClass);
     if (!metadata) {
-        metadataMap.set(Class, metadata = {
+        metadataMap.set(originalClass, metadata = {
             tokensRef: {
                 getRefTokens: ()=>new Set()
             },
             provider: {
-                useClass: Class
+                useClass: originalClass
             },
             dependencies: {
                 constructor: [],
@@ -173,8 +192,25 @@ 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();
 const metadataMap = new WeakMap();
 
 function optional(token) {
@@ -1120,4 +1156,5 @@ exports.forwardRef = forwardRef;
 exports.inject = inject;
 exports.injectAll = injectAll;
 exports.injectBy = injectBy;
+exports.setClassIdentityMapping = setClassIdentityMapping;
 //# sourceMappingURL=index.js.map