@martel/calyx 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.4.0](https://github.com/bmartel/calyx/compare/v1.3.0...v1.4.0) (2026-07-01)
+
+
+### Features
+
+* **di:** implement JIT request-scoped DI factory compiler at bootstrap ([339c069](https://github.com/bmartel/calyx/commit/339c0693bdf2afe64f89648012da4fad55d91444))
+
 # [1.3.0](https://github.com/bmartel/calyx/compare/v1.2.4...v1.3.0) (2026-07-01)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martel/calyx",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "High-performance Bun-native NestJS-compatible framework",
   "main": "src/index.ts",
   "bin": {

package/src/core/container.ts

@@ -64,6 +64,7 @@ export class CalyxContainer {
   private resolvingStack: { moduleClass: any; token: InjectionToken }[] = [];
   private providerScopes = new Map<InjectionToken, Scope>();
   private controllerScopes = new Map<any, Scope>();
+  private compiledControllerFactories = new Map<any, (requestContext: Map<any, any>) => any>();
 
   getModuleRecord(moduleClass: any): ModuleRecord | undefined {
     return this.modules.get(resolveForwardRef(moduleClass));
@@ -447,6 +448,8 @@ export class CalyxContainer {
         record.instances.set(moduleClass, instance);
       }
     }
+
+    this.compileControllerFactories();
   }
 
   private resolveController(moduleClass: any, controllerClass: any): any {
@@ -478,6 +481,12 @@ export class CalyxContainer {
       if (requestContext.has(controllerClass)) {
         return requestContext.get(controllerClass);
       }
+      const factory = this.compiledControllerFactories.get(controllerClass);
+      if (factory) {
+        const instance = factory(requestContext);
+        requestContext.set(controllerClass, instance);
+        return instance;
+      }
       const instance = this.instantiateClass(controllerClass, moduleClass, requestContext);
       requestContext.set(controllerClass, instance);
       return instance;
@@ -609,4 +618,215 @@ export class CalyxContainer {
       }
     }
   }
+
+  private compileControllerFactories() {
+    for (const [moduleClass, record] of this.modules.entries()) {
+      for (const controllerClass of record.controllers) {
+        const scope = this.controllerScopes.get(controllerClass) ?? Scope.DEFAULT;
+        if (scope === Scope.REQUEST) {
+          const closureValues: any[] = [];
+          const getClosureIdx = (val: any): number => {
+            let idx = closureValues.indexOf(val);
+            if (idx === -1) {
+              idx = closureValues.length;
+              closureValues.push(val);
+            }
+            return idx;
+          };
+
+          const instantiations: string[] = [];
+          const compiledTokens = new Set<string>();
+
+          const compileToken = (token: any, currentModuleClass: any): string => {
+            if (token === REQUEST) {
+              return `requestContext.get(c[${getClosureIdx(REQUEST)}])`;
+            }
+            if (token === ModuleRef) {
+              const record = this.modules.get(currentModuleClass)!;
+              return `c[${getClosureIdx(record.instances.get(ModuleRef))}]`;
+            }
+
+            const scope = this.providerScopes.get(token) ?? Scope.DEFAULT;
+            if (scope === Scope.DEFAULT) {
+              const instance = this.resolveTokenInModuleContext(currentModuleClass, token);
+              return `c[${getClosureIdx(instance)}]`;
+            }
+
+            const tokenKey = `${currentModuleClass.name || currentModuleClass}::${String(token.name || token)}`;
+            if (compiledTokens.has(tokenKey)) {
+              return `requestContext.get(c[${getClosureIdx(token)}])`;
+            }
+
+            const resolution = this.findProviderDefinition(currentModuleClass, token);
+            if (!resolution) {
+              const optional = this.isTokenOptional(token, currentModuleClass);
+              return optional ? `undefined` : `(() => { throw new Error('calyx JIT DI: Cannot resolve dependency ' + String(c[${getClosureIdx(token)}])); })()`;
+            }
+
+            const { targetModuleClass, provider } = resolution;
+            
+            let valExpr = '';
+            if (typeof provider !== 'function' && 'useValue' in provider) {
+              valExpr = `c[${getClosureIdx(provider.useValue)}]`;
+            } else {
+              const ClassToInstantiate = typeof provider === 'function'
+                ? provider
+                : ('useClass' in provider ? provider.useClass : null);
+
+              if (ClassToInstantiate) {
+                const paramTypes: any[] = Reflect.getMetadata('design:paramtypes', ClassToInstantiate) || [];
+                const injectTokens: Map<number, any> = Reflect.getMetadata(METADATA_KEYS.INJECT_TOKENS, ClassToInstantiate) || new Map();
+                const optionalParams: Set<number> = Reflect.getMetadata(METADATA_KEYS.OPTIONAL_PARAMS, ClassToInstantiate) || new Set();
+
+                const argsExprs = paramTypes.map((paramType, i) => {
+                  const depToken = injectTokens.get(i) ?? paramType;
+                  const resolvedDepToken = resolveForwardRef(depToken);
+                  try {
+                    return compileToken(resolvedDepToken, targetModuleClass);
+                  } catch (err) {
+                    if (optionalParams.has(i)) {
+                      return `undefined`;
+                    }
+                    throw err;
+                  }
+                });
+
+                const propertyInjects: Map<string | symbol, any> =
+                  Reflect.getOwnMetadata(METADATA_KEYS.PROPERTY_INJECTS, ClassToInstantiate) || new Map();
+                
+                const propAssignments: string[] = [];
+                for (const [propKey, propToken] of propertyInjects.entries()) {
+                  const resolvedPropToken = resolveForwardRef(propToken);
+                  const propValExpr = compileToken(resolvedPropToken, targetModuleClass);
+                  propAssignments.push(`inst.${String(propKey)} = ${propValExpr};`);
+                }
+
+                const classIdx = getClosureIdx(ClassToInstantiate);
+                const instantiateExpr = `new c[${classIdx}](${argsExprs.join(', ')})`;
+
+                if (scope === Scope.REQUEST) {
+                  compiledTokens.add(tokenKey);
+                  const tokenIdx = getClosureIdx(token);
+                  instantiations.push(`
+                    if (!requestContext.has(c[${tokenIdx}])) {
+                      const inst = ${instantiateExpr};
+                      ${propAssignments.join('\n')}
+                      requestContext.set(c[${tokenIdx}], inst);
+                    }
+                  `);
+                  valExpr = `requestContext.get(c[${tokenIdx}])`;
+                } else {
+                  if (propAssignments.length > 0) {
+                    const tempVar = `transient_${compiledTokens.size}`;
+                    compiledTokens.add(tempVar);
+                    instantiations.push(`
+                      const ${tempVar} = ${instantiateExpr};
+                      ${propAssignments.map(line => line.replace('inst.', `${tempVar}.`)).join('\n')}
+                    `);
+                    valExpr = tempVar;
+                  } else {
+                    valExpr = instantiateExpr;
+                  }
+                }
+              } else if (provider && typeof provider === 'object' && 'useFactory' in provider) {
+                const injectTokens = provider.inject || [];
+                const argsExprs = injectTokens.map((t) => compileToken(resolveForwardRef(t), targetModuleClass));
+                
+                const factoryIdx = getClosureIdx(provider.useFactory);
+                const factoryCallExpr = `c[${factoryIdx}](${argsExprs.join(', ')})`;
+
+                if (scope === Scope.REQUEST) {
+                  compiledTokens.add(tokenKey);
+                  const tokenIdx = getClosureIdx(token);
+                  instantiations.push(`
+                    if (!requestContext.has(c[${tokenIdx}])) {
+                      requestContext.set(c[${tokenIdx}], ${factoryCallExpr});
+                    }
+                  `);
+                  valExpr = `requestContext.get(c[${tokenIdx}])`;
+                } else {
+                  valExpr = factoryCallExpr;
+                }
+              }
+            }
+
+            return valExpr;
+          };
+
+          const paramTypes: any[] = Reflect.getMetadata('design:paramtypes', controllerClass) || [];
+          const injectTokens: Map<number, any> = Reflect.getMetadata(METADATA_KEYS.INJECT_TOKENS, controllerClass) || new Map();
+          const optionalParams: Set<number> = Reflect.getMetadata(METADATA_KEYS.OPTIONAL_PARAMS, controllerClass) || new Set();
+
+          const argsExprs = paramTypes.map((paramType, i) => {
+            const depToken = injectTokens.get(i) ?? paramType;
+            const resolvedDepToken = resolveForwardRef(depToken);
+            try {
+              return compileToken(resolvedDepToken, moduleClass);
+            } catch (err) {
+              if (optionalParams.has(i)) {
+                return `undefined`;
+              }
+              throw err;
+            }
+          });
+
+          const propertyInjects: Map<string | symbol, any> =
+            Reflect.getOwnMetadata(METADATA_KEYS.PROPERTY_INJECTS, controllerClass) || new Map();
+          
+          const propAssignments: string[] = [];
+          for (const [propKey, propToken] of propertyInjects.entries()) {
+            const resolvedPropToken = resolveForwardRef(propToken);
+            const propValExpr = compileToken(resolvedPropToken, moduleClass);
+            propAssignments.push(`inst.${String(propKey)} = ${propValExpr};`);
+          }
+
+          const controllerClassIdx = getClosureIdx(controllerClass);
+          const instantiateControllerExpr = `new c[${controllerClassIdx}](${argsExprs.join(', ')})`;
+
+          const factoryBody = `
+            ${instantiations.join('\n')}
+            const inst = ${instantiateControllerExpr};
+            ${propAssignments.join('\n')}
+            return inst;
+          `;
+
+          try {
+            const factoryFn = new Function('c', `
+              return function resolve(requestContext) {
+                ${factoryBody}
+              }
+            `)(closureValues);
+            this.compiledControllerFactories.set(controllerClass, factoryFn);
+          } catch (err) {
+            console.error('Failed to compile JIT DI Factory for controller:', controllerClass.name || controllerClass);
+            console.error('Factory body was:', factoryBody);
+            throw err;
+          }
+        }
+      }
+    }
+  }
+
+  private isTokenOptional(token: any, moduleClass: any): boolean {
+    for (const record of this.modules.values()) {
+      for (const provider of record.providers.values()) {
+        const Class = typeof provider === 'function'
+          ? provider
+          : ('useClass' in provider ? provider.useClass : null);
+        if (Class) {
+          const paramTypes = Reflect.getMetadata('design:paramtypes', Class) || [];
+          const injectTokens = Reflect.getMetadata(METADATA_KEYS.INJECT_TOKENS, Class) || new Map();
+          const optionalParams = Reflect.getMetadata(METADATA_KEYS.OPTIONAL_PARAMS, Class) || new Set();
+          for (let i = 0; i < paramTypes.length; i++) {
+            const pToken = injectTokens.get(i) ?? paramTypes[i];
+            if (resolveForwardRef(pToken) === token && optionalParams.has(i)) {
+              return true;
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
 }
+