refactor: enhance dependency injection system with improved type definitions and async resolution

Author: hasib-devs

src/decorators/Controller.ts

@@ -6,6 +6,6 @@ export function Controller(path: string) {
     return <T extends Constructor>(target: T) => {
         controllerMetadata.set(target, path);
         // Auto-register the controller as a singleton
-        Container.register(target, () => new (target as any)(), "singleton");
+        Container.register(target, () => new target(), "singleton");
     };
 }

src/decorators/Inject.ts

@@ -1,37 +1,57 @@
 import { Container } from "@/di/Container";
+import type { Constructor, Lifetime } from "@/types";
 import { injectionMetadata } from "@/utils/meta-data";
 
-
+type InjectableOptions = {
+    lifetime?: Lifetime;
+    token?: object; // For interface-based DI
+};
 
 export function Inject(token: unknown) {
     return (target: object, _: string | symbol, parameterIndex: number) => {
-        const metadata = injectionMetadata.get(target.constructor) ?? [];
+        const metadata = injectionMetadata.get(target) ?? [];
         metadata[parameterIndex] = token;
-        injectionMetadata.set(target.constructor, metadata);
+        injectionMetadata.set(target, metadata);
     };
 }
 
-export function Injectable() {
-    return (constructor: new (...args: any[]) => any) => {
-        Container.register(constructor, () => createInstance(constructor));
+export function Injectable(options?: InjectableOptions) {
+    return (target: any) => {
+        const token = options?.token ?? target;
+        const lifetime = options?.lifetime ?? "singleton";
+
+        // Register the class in the container
+        Container.register(
+            token,
+            () => {
+                // Use the existing createInstance function for dependency resolution
+                return createInstance(target);
+            },
+            lifetime
+        );
+
+        // Store original constructor for potential edge cases
+        target.__originalConstructor = target.prototype.constructor;
+
     };
 }
 
 
-export function createInstance<T>(constructor: new (...args: any[]) => T): T {
-    const metadata = injectionMetadata.get(constructor) ?? [];
+function createInstance<T>(constructor: Constructor<T>): T {
+    // Use original constructor if available
+    const ctor = constructor.prototype?.__originalConstructor || constructor;
+    const metadata: any[] = injectionMetadata.get(ctor) ?? [];
+
     const args = metadata.map((token) => {
         try {
             return Container.resolve(token);
         } catch (error) {
-            if (error instanceof Error && error.message.startsWith('Circular dependency')) {
-                // Enhance error message with class name
-                throw new Error(
-                    `${error.message} in ${constructor.name} constructor`
-                );
+            if (error instanceof Error) {
+                throw new Error(`Error resolving ${token}: ${error.message}`);
             }
             throw error;
         }
     });
-    return new constructor(...args);
+
+    return new ctor(...args);
 }

src/di/Container.ts

@@ -1,57 +1,58 @@
-type Provider<T = any> = {
-    factory: () => T;
-    lifetime: "singleton" | "transient";
-};
+import type { Factory, Lifetime } from "@/types";
+
+interface Dependency<T = any> {
+    lifetime: Lifetime;
+    factory: Factory<T>;
+    instance?: T;
+}
 
 export class Container {
-    private static registry = new Map<unknown, Provider>();
-    private static instances = new WeakMap<object, unknown>();
-    private static resolutionStack: unknown[] = []; // Track resolution path for circular dependencies
+    private static dependencies = new WeakMap<object, Dependency>();
 
     static register<T>(
-        token: unknown,
-        factory: () => T,
-        lifetime: "singleton" | "transient" = "singleton"
+        token: object,
+        factory: Factory<T>,
+        lifetime: Lifetime = "singleton"
     ) {
-        this.registry.set(token, { factory, lifetime });
+        this.dependencies.set(token, { factory, lifetime });
     }
 
-    static resolve<T>(token: T): T {
-        // Detect circular dependencies
-        if (this.resolutionStack.includes(token)) {
-            const cycleStart = this.resolutionStack.indexOf(token);
-            const cyclePath = [
-                ...this.resolutionStack.slice(cycleStart),
-                token
-            ].map(t => this.getTokenName(t)).join(' -> ');
-
-            throw new Error(`Circular dependency detected: ${cyclePath}`);
-        }
-
+    static resolve<T extends object>(token: T): T {
         try {
-            this.resolutionStack.push(token);
-            const provider = this.registry.get(token);
-            if (!provider) { throw new Error(`No provider for token: ${String(token)}`); };
-
-            // Handle singleton lifetime
-            if (provider.lifetime === "singleton") {
-                if (!this.instances.has(token as object)) {
-                    this.instances.set(token as object, provider.factory());
+            const dep = this.dependencies.get(token);
+            if (!dep) {
+                throw new Error(`Dependency ${token} not registered`);
+            }
+
+            if (dep.lifetime === "singleton") {
+                if (!dep.instance) {
+                    dep.instance = dep.factory();
                 }
-                return this.instances.get(token as object) as T;
+                return dep.instance;
             }
 
-            // Transient lifetime
-            return provider.factory() as T;
-        } finally {
-            // Clean up stack even if errors occur
-            this.resolutionStack.pop();
+            return dep.factory();
+        } catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Error resolving ${token}: ${error.message}`);
+            }
+            throw error;
         }
     }
 
-    private static getTokenName(token: unknown): string {
-        if (typeof token === 'function') { return token.name || 'AnonymousClass'; };
-        if (typeof token === 'symbol') { return token.toString(); };
-        return String(token);
+    static async resolveAsync<T>(token: object): Promise<T> {
+        const dep = this.dependencies.get(token);
+        if (!dep) {
+            throw new Error(`Dependency ${token} not found`);
+        };
+
+        if (dep.lifetime === "singleton") {
+            if (!dep.instance) {
+                dep.instance = await dep.factory();
+            }
+            return dep.instance;
+        }
+
+        return await dep.factory();
     }
 }

src/exp.ts

@@ -0,0 +1,8 @@
+class Cat { }
+
+const cat = new Cat();
+
+console.log({
+    type: typeof Cat,
+    instance: typeof cat,
+});

src/types/index.ts

@@ -1,4 +1,6 @@
 export type Constructor<T = {}> = new (...args: any[]) => T;
+export type Factory<T> = () => T;
+export type Lifetime = "singleton" | "transient";
 
 
 export type ServerOptions = {