meteorjs-decorators 1.0.2 → 1.0.3

package/dist/decorators/controller.decorator.js

@@ -3,21 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Controller = Controller;
 require("reflect-metadata");
 const container_1 = require("../utils/container");
+const forward_ref_1 = require("../utils/forward-ref");
+const inject_decorator_1 = require("./inject.decorator");
 function Controller() {
     return function (constructor) {
         const methods = constructor.prototype.__methods || [];
         // Get the constructor parameters
         const paramTypes = Reflect.getMetadata('design:paramtypes', constructor) || [];
+        const injectTokens = (0, inject_decorator_1.getInjectTokens)(constructor);
         // Create a factory function that will create instances with dependencies (services)
         const factory = () => {
-            const args = paramTypes.map((type) => {
+            const args = paramTypes.map((type, index) => {
                 // Get the module's container from the prototype chain
                 let current = constructor;
                 while (current && !current.__container) {
                     current = Object.getPrototypeOf(current);
                 }
                 const container = current?.__container || container_1.Container;
-                return container.get(type.name);
+                const injectionToken = resolveInjectionToken(type, injectTokens[index], constructor.name, index);
+                return container.get(injectionToken);
             });
             return new constructor(...args);
         };
@@ -27,7 +31,7 @@ function Controller() {
             current = Object.getPrototypeOf(current);
         }
         const container = current?.__container || container_1.Container;
-        container.register(constructor.name, factory);
+        container.register(constructor, factory);
         methods.forEach(({ name, method }) => {
             console.log('registering method: ', name);
             Meteor.methods({
@@ -38,7 +42,7 @@ function Controller() {
                         current = Object.getPrototypeOf(current);
                     }
                     const container = current?.__container || container_1.Container;
-                    const instance = container.get(constructor.name);
+                    const instance = container.get(constructor);
                     // Merge the Meteor method context into the instance
                     instance.__context = this; // __context now is the meteor context for methods
                     // Call the method with the merged context
@@ -48,3 +52,22 @@ function Controller() {
         });
     };
 }
+function resolveInjectionToken(reflectedType, customToken, targetName, index) {
+    if (customToken) {
+        return unwrapToken(customToken);
+    }
+    if (!reflectedType) {
+        throw new Error(`Cannot resolve dependency for ${targetName}. Parameter at index ${index} is undefined. ` +
+            'Consider using @Inject with forwardRef to resolve circular dependencies.');
+    }
+    return reflectedType;
+}
+function unwrapToken(token) {
+    if (typeof token === 'string') {
+        return token;
+    }
+    if (token instanceof forward_ref_1.ForwardRef) {
+        return token.get();
+    }
+    return token();
+}

package/dist/decorators/injectable.decorator.js

@@ -30,7 +30,7 @@ function Injectable() {
             current = Object.getPrototypeOf(current);
         }
         const container = current?.__container || container_1.Container;
-        container.register(target.name, factory);
+        container.register(target, factory);
         return target;
     };
 }
@@ -42,14 +42,14 @@ function resolveInjectionToken(reflectedType, customToken, targetName, index) {
         throw new Error(`Cannot resolve dependency for ${targetName}. Parameter at index ${index} is undefined. ` +
             'Consider using @Inject with forwardRef to resolve circular dependencies.');
     }
-    return reflectedType.name;
+    return reflectedType;
 }
 function unwrapToken(token) {
     if (typeof token === 'string') {
         return token;
     }
     if (token instanceof forward_ref_1.ForwardRef) {
-        return token.get().name;
+        return token.get();
     }
-    return token().name;
+    return token();
 }

package/dist/decorators/publication.decorator.js

@@ -41,14 +41,14 @@ function resolveInjectionToken(reflectedType, customToken, targetName, index) {
         throw new Error(`Cannot resolve dependency for ${targetName}. Parameter at index ${index} is undefined. ` +
             'Consider using @Inject with forwardRef to resolve circular dependencies.');
     }
-    return reflectedType.name;
+    return reflectedType;
 }
 function unwrapToken(token) {
     if (typeof token === 'string') {
         return token;
     }
     if (token instanceof forward_ref_1.ForwardRef) {
-        return token.get().name;
+        return token.get();
     }
-    return token().name;
+    return token();
 }

package/dist/utils/container.d.ts

@@ -2,6 +2,7 @@ import { ForwardRef } from './forward-ref';
 export interface ContainerAware {
     __container?: ModuleContainer;
 }
+export type ContainerToken<T = any> = string | symbol | (new (...args: any[]) => T);
 export declare class ModuleContainer {
     private instances;
     private factories;
@@ -9,18 +10,19 @@ export declare class ModuleContainer {
     private resolving;
     private parent?;
     constructor(parent?: ModuleContainer);
-    set<T>(token: string, value: T | ForwardRef<T>): void;
-    register<T>(token: string, factory: () => T): void;
-    get<T>(token: string): T;
-    has(token: string): boolean;
+    set<T>(token: ContainerToken<T>, value: T | ForwardRef<T>): void;
+    register<T>(token: ContainerToken<T>, factory: () => T): void;
+    get<T>(token: ContainerToken<T>): T;
+    has(token: ContainerToken): boolean;
     clear(): void;
     private getProxy;
+    private tokenLabel;
 }
 export declare class Container {
     private static rootContainer;
-    static set<T>(token: string, value: T | ForwardRef<T>): void;
-    static register<T>(token: string, factory: () => T): void;
-    static get<T>(token: string): T;
-    static has(token: string): boolean;
+    static set<T>(token: ContainerToken<T>, value: T | ForwardRef<T>): void;
+    static register<T>(token: ContainerToken<T>, factory: () => T): void;
+    static get<T>(token: ContainerToken<T>): T;
+    static has(token: ContainerToken): boolean;
     static createChildContainer(): ModuleContainer;
 }

package/dist/utils/container.js

@@ -54,7 +54,7 @@ class ModuleContainer {
                 get: (_target, prop) => {
                     const instance = this.instances.get(token);
                     if (!instance) {
-                        throw new Error(`Circular dependency detected for token ${token}.`);
+                        throw new Error(`Circular dependency detected for token ${this.tokenLabel(token)}.`);
                     }
                     const value = instance[prop];
                     return typeof value === 'function' ? value.bind(instance) : value;
@@ -62,7 +62,7 @@ class ModuleContainer {
                 set: (_target, prop, value) => {
                     const instance = this.instances.get(token);
                     if (!instance) {
-                        throw new Error(`Circular dependency detected for token ${token}.`);
+                        throw new Error(`Circular dependency detected for token ${this.tokenLabel(token)}.`);
                     }
                     instance[prop] = value;
                     return true;
@@ -72,6 +72,15 @@ class ModuleContainer {
         }
         return this.proxies.get(token);
     }
+    tokenLabel(token) {
+        if (typeof token === 'string') {
+            return token;
+        }
+        if (typeof token === 'symbol') {
+            return token.toString();
+        }
+        return token.name || '<anonymous>';
+    }
 }
 exports.ModuleContainer = ModuleContainer;
 // Global container for backward compatibility

package/dist/utils/module.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Module = Module;
 require("reflect-metadata");
 const container_1 = require("./container");
+const forward_ref_1 = require("./forward-ref");
+const inject_decorator_1 = require("../decorators/inject.decorator");
 function Module(config) {
     return function (target) {
         // Create a container for this module
@@ -12,22 +14,20 @@ function Module(config) {
             config.imports.forEach(importedModule => {
                 // Don't instantiate modules directly, just register them
                 if (importedModule.forwardRef) {
-                    console.log('importedModule4: ', importedModule.forwardRef.get());
-                    moduleContainer.set(importedModule.forwardRef.get().name, importedModule.forwardRef.get());
+                    moduleContainer.set(importedModule.forwardRef.get(), importedModule.forwardRef.get());
                 }
                 else {
-                    moduleContainer.set(importedModule.name, importedModule);
+                    moduleContainer.set(importedModule, importedModule);
                 }
             });
         }
         const resolveProvider = (providerClass) => {
-            if (container_1.Container.has(providerClass.name)) {
-                moduleContainer.set(providerClass.name, container_1.Container.get(providerClass.name));
+            if (container_1.Container.has(providerClass)) {
+                moduleContainer.set(providerClass, container_1.Container.get(providerClass));
                 return;
             }
-            const paramTypes = Reflect.getMetadata('design:paramtypes', providerClass) || [];
-            const args = paramTypes.map((type) => moduleContainer.get(type.name));
-            moduleContainer.set(providerClass.name, new providerClass(...args));
+            const args = resolveArguments(providerClass, moduleContainer);
+            moduleContainer.set(providerClass, new providerClass(...args));
         };
         // Then handle providers
         if (config.providers) {
@@ -45,15 +45,14 @@ function Module(config) {
             config.controllers.forEach(controller => {
                 if (typeof controller === 'function') {
                     let instance;
-                    if (container_1.Container.has(controller.name)) {
-                        instance = container_1.Container.get(controller.name);
+                    if (container_1.Container.has(controller)) {
+                        instance = container_1.Container.get(controller);
                     }
                     else {
-                        const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
-                        const args = paramTypes.map((type) => moduleContainer.get(type.name));
+                        const args = resolveArguments(controller, moduleContainer);
                         instance = new controller(...args);
                     }
-                    moduleContainer.set(controller.name, instance);
+                    moduleContainer.set(controller, instance);
                     controller.__container = moduleContainer;
                 }
             });
@@ -62,3 +61,30 @@ function Module(config) {
         target.__container = moduleContainer;
     };
 }
+function resolveArguments(targetClass, container) {
+    const paramTypes = Reflect.getMetadata('design:paramtypes', targetClass) || [];
+    const injectTokens = (0, inject_decorator_1.getInjectTokens)(targetClass);
+    return paramTypes.map((type, index) => {
+        const token = resolveInjectionToken(type, injectTokens[index], targetClass.name, index);
+        return container.get(token);
+    });
+}
+function resolveInjectionToken(reflectedType, customToken, targetName, index) {
+    if (customToken) {
+        return unwrapToken(customToken);
+    }
+    if (!reflectedType) {
+        throw new Error(`Cannot resolve dependency for ${targetName}. Parameter at index ${index} is undefined. ` +
+            'Consider using @Inject with forwardRef to resolve circular dependencies.');
+    }
+    return reflectedType;
+}
+function unwrapToken(token) {
+    if (typeof token === 'string') {
+        return token;
+    }
+    if (token instanceof forward_ref_1.ForwardRef) {
+        return token.get();
+    }
+    return token();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meteorjs-decorators",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Meteor decorators to make your Meteor app with NestJS-style pattern.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,4 +23,4 @@
     "mongodb": "^6.13.1",
     "typescript": "^5.4.5"
   }
-}
+}