@sentzunhat/zacatl 0.0.24 → 0.0.26

package/package.json

@@ -4,7 +4,7 @@
   "main": "build/index.js",
   "module": "build/index.js",
   "types": "build/index.d.ts",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "packageManager": "npm@10.9.0",
   "exports": {
     ".": {

package/src/dependency-injection/container.ts

@@ -1,6 +1,17 @@
 import "reflect-metadata";
 import { container as tsyringeContainer } from "tsyringe";
 import type { DependencyContainer, InjectionToken } from "tsyringe";
+import type { Constructor } from "../service/architecture/architecture";
+
+/**
+ * Track registered classes to avoid requiring decorator metadata
+ */
+const registeredClasses = new Set<Constructor>();
+
+/**
+ * Cache for singleton instances
+ */
+const singletonInstances = new Map<Constructor, object>();
 
 /**
  * Standalone DI container decoupled from microservice architecture.
@@ -83,10 +94,104 @@ export const resolveDependency = <T>(token: InjectionToken<T>): T => {
   return tsyringeContainer.resolve(token);
 };
 
+/**
+ * Register a dependency with explicit dependencies (no decorator metadata required)
+ * Useful for tsx/ts-node/ESM environments where decorator metadata is not available
+ *
+ * @param serviceClass - Class to register
+ * @param dependencies - Array of dependency classes to inject (in constructor order)
+ *
+ * @example
+ * ```typescript
+ * import { registerWithDependencies } from '@sentzunhat/zacatl';
+ *
+ * // Register with no deps
+ * registerWithDependencies(MachineRepository, []);
+ *
+ * // Register with explicit deps
+ * registerWithDependencies(MachineService, [MachineRepository]);
+ * ```
+ */
+export const registerWithDependencies = <T extends object>(
+  serviceClass: Constructor<T>,
+  dependencies: Constructor[] = [],
+): void => {
+  // Track this class as registered
+  registeredClasses.add(serviceClass);
+
+  tsyringeContainer.register(serviceClass, {
+    useFactory: () => {
+      const resolvedDeps = dependencies.map((dep) => {
+        // Check if dependency was registered
+        if (!registeredClasses.has(dep)) {
+          throw new Error(
+            `Dependency ${dep.name} not registered. Register it before ${serviceClass.name}.`,
+          );
+        }
+        // Resolve from container (works because we registered it)
+        return tsyringeContainer.resolve(dep);
+      });
+      return new serviceClass(...resolvedDeps);
+    },
+  } as never);
+};
+
+/**
+ * Register a singleton with explicit dependencies (no decorator metadata required)
+ * Useful for tsx/ts-node/ESM environments where decorator metadata is not available
+ *
+ * @param serviceClass - Class to register as singleton
+ * @param dependencies - Array of dependency classes to inject (in constructor order)
+ *
+ * @example
+ * ```typescript
+ * import { registerSingletonWithDependencies } from '@sentzunhat/zacatl';
+ *
+ * // Register singleton with deps
+ * registerSingletonWithDependencies(MachineService, [MachineRepository]);
+ * ```
+ */
+export const registerSingletonWithDependencies = <T extends object>(
+  serviceClass: Constructor<T>,
+  dependencies: Constructor[] = [],
+): void => {
+  // Track this class as registered
+  registeredClasses.add(serviceClass);
+
+  // Use register() with manual singleton pattern (lifecycle can't be used with factories)
+  tsyringeContainer.register(serviceClass, {
+    useFactory: () => {
+      // Check if we already have a singleton instance
+      if (singletonInstances.has(serviceClass)) {
+        return singletonInstances.get(serviceClass) as T;
+      }
+
+      // Create new instance
+      const resolvedDeps = dependencies.map((dep) => {
+        // Check if dependency was registered
+        if (!registeredClasses.has(dep)) {
+          throw new Error(
+            `Dependency ${dep.name} not registered. Register it before ${serviceClass.name}.`,
+          );
+        }
+        // Resolve from container (works because we registered it)
+        return tsyringeContainer.resolve(dep);
+      });
+      const instance = new serviceClass(...resolvedDeps);
+
+      // Cache the singleton instance
+      singletonInstances.set(serviceClass, instance);
+      return instance;
+    },
+  } as never);
+};
+
 /**
  * Clear all registrations (useful for testing)
  */
 export const clearContainer = (): void => {
   tsyringeContainer.clearInstances();
   tsyringeContainer.reset();
+  singletonInstances.clear();
+  registeredClasses.clear();
 };

package/src/service/architecture/architecture.ts

@@ -1,6 +1,11 @@
 import { container } from "tsyringe";
 
-export type Constructor<T = unknown> = new (...args: unknown[]) => T;
+/**
+ * Constructor type that accepts classes with any parameter signature
+ * Uses contravariant any[] to allow flexibility in DI container
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Constructor<T = object> = new (...args: any[]) => T;
 
 type Architecture = {
   start: () => void;
@@ -13,9 +18,8 @@ export abstract class AbstractArchitecture implements Architecture {
    */
   protected registerDependencies<T>(dependencies: Array<Constructor<T>>): void {
     for (const dependency of dependencies) {
-      const instance = new dependency();
-
-      container.register<typeof instance>(dependency.name, {
+      // Register class directly - tsyringe handles instantiation with DI
+      container.register(dependency.name, {
         useClass: dependency,
       });
     }
@@ -28,7 +32,7 @@ export abstract class AbstractArchitecture implements Architecture {
    */
   protected registerAndStoreDependencies<T>(
     dependencies: Array<new () => T>,
-    storage: Array<T>
+    storage: Array<T>,
   ): void {
     for (const dependency of dependencies) {
       container.register(dependency.name, { useClass: dependency });