@djodjonx/neo-syringe 1.1.5 → 1.2.2

package/tests/analyzer/Scoped.test.ts

@@ -0,0 +1,434 @@
+/**
+ * Tests for scoped: true functionality
+ *
+ * Allows overriding a token from a parent container
+ * without causing a duplicate registration error.
+ */
+import { describe, it, expect } from 'vitest';
+import * as ts from 'typescript';
+import { Analyzer } from '../../src/analyzer/Analyzer';
+import { GraphValidator } from '../../src/generator/GraphValidator';
+import { Generator } from '../../src/generator/Generator';
+
+describe('Scoped Injection', () => {
+  const createProgram = (fileName: string, fileContent: string) => {
+    const compilerHost = ts.createCompilerHost({});
+    const originalGetSourceFile = compilerHost.getSourceFile;
+
+    compilerHost.getSourceFile = (name, languageVersion) => {
+      if (name === fileName) {
+        return ts.createSourceFile(fileName, fileContent, languageVersion);
+      }
+      return originalGetSourceFile(name, languageVersion);
+    };
+
+    return ts.createProgram([fileName], {}, compilerHost);
+  };
+
+  describe('Analyzer - scoped detection', () => {
+    it('should detect scoped: true in injection', () => {
+      const program = createProgram('scoped.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class FileLogger implements ILogger {}
+
+        export const c = defineBuilderConfig({
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+
+      // Find node containing ILogger (may have filename prefix)
+      const node = Array.from(graph.nodes.values()).find(n =>
+        n.service.tokenId.includes('ILogger')
+      );
+      expect(node).toBeDefined();
+      expect(node!.service.isScoped).toBe(true);
+    });
+
+    it('should detect scoped: false (default) when not specified', () => {
+      const program = createProgram('not-scoped.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+
+        export const c = defineBuilderConfig({
+          injections: [
+            { token: useInterface<ILogger>(), provider: ConsoleLogger }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+
+      // Find node containing ILogger (may have filename prefix)
+      const node = Array.from(graph.nodes.values()).find(n =>
+        n.service.tokenId.includes('ILogger')
+      );
+      expect(node).toBeDefined();
+      expect(node!.service.isScoped).toBeFalsy();
+    });
+
+    it('should allow duplicate registration when scoped: true in same container', () => {
+      const program = createProgram('scoped-same.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class FileLogger implements ILogger {}
+
+        export const c = defineBuilderConfig({
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true },
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      // Should not throw - second scoped: true overrides the first
+      expect(() => analyzer.extract()).not.toThrow();
+    });
+  });
+
+  describe('GraphValidator - scoped with parent', () => {
+    it('should throw duplicate error without scoped: true', () => {
+      const program = createProgram('duplicate.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).toThrow(/Duplicate registration.*ILogger.*parent/);
+    });
+
+    it('should NOT throw duplicate error with scoped: true', () => {
+      const program = createProgram('scoped-override.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).not.toThrow();
+    });
+
+    it('should suggest scoped: true in error message', () => {
+      const program = createProgram('suggest-scoped.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ICache {}
+        class RedisCache implements ICache {}
+        class MemoryCache implements ICache {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ICache>(), provider: RedisCache }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ICache>(), provider: MemoryCache }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      try {
+        validator.validate(graph);
+        expect.fail('Should have thrown');
+      } catch (e: any) {
+        expect(e.message).toContain('scoped: true');
+      }
+    });
+  });
+
+  describe('Generator - scoped code generation', () => {
+    it('should generate local factory for scoped token', () => {
+      const program = createProgram('gen-scoped.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        export const c = defineBuilderConfig({
+          name: 'ChildContainer',
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+
+      // Skip validation for this test (it would throw duplicate without scoped handling in validator)
+      // The generator should include the scoped token factory
+      const generator = new Generator(graph);
+      const code = generator.generate();
+
+      // Should have a factory for ILogger (locally) - may have filename prefix
+      expect(code).toMatch(/create_.*ILogger/);
+      expect(code).toContain('FileLogger');
+    });
+
+    it('should resolve scoped token locally before parent', () => {
+      const program = createProgram('resolve-local.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        class UserService {
+          constructor(logger: ILogger) {}
+        }
+
+        export const c = defineBuilderConfig({
+          name: 'ChildContainer',
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true },
+            { token: UserService }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const generator = new Generator(graph);
+      const code = generator.generate();
+
+      // UserService should resolve ILogger from local container
+      expect(code).toContain('create_UserService');
+      expect(code).toContain('container.resolve');
+    });
+  });
+
+  describe('Scoped with different scopes (singleton/transient)', () => {
+    it('should allow scoped + transient', () => {
+      const program = createProgram('scoped-transient.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger, lifecycle: 'singleton' }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            {
+              token: useInterface<ILogger>(),
+              provider: FileLogger,
+              lifecycle: 'transient',  // Different scope than parent!
+              scoped: true
+            }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+
+      // Find node containing ILogger (may have filename prefix)
+      const node = Array.from(graph.nodes.values()).find(n =>
+        n.service.tokenId.includes('ILogger')
+      );
+      expect(node).toBeDefined();
+      expect(node!.service.lifecycle).toBe('transient');
+      expect(node!.service.isScoped).toBe(true);
+    });
+
+    it('should generate transient code for scoped transient token', () => {
+      const program = createProgram('gen-scoped-transient.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface IRequest {}
+        class RequestImpl implements IRequest {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<IRequest>(), provider: RequestImpl, lifecycle: 'singleton' }]
+        });
+
+        export const c = defineBuilderConfig({
+          name: 'RequestScope',
+          useContainer: parent,
+          injections: [
+            {
+              token: useInterface<IRequest>(),
+              provider: RequestImpl,
+              lifecycle: 'transient',
+              scoped: true
+            }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const generator = new Generator(graph);
+      const code = generator.generate();
+
+      // Transient should NOT use instances cache
+      expect(code).toMatch(/create_.*IRequest/);
+      // The transient resolution should return directly without caching
+      expect(code).toMatch(/if \(token === ".*IRequest"\) \{\s*return create_/);
+    });
+  });
+
+  describe('Complex scenarios', () => {
+    it('should work with multi-level hierarchy', () => {
+      const program = createProgram('multi-level.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+        class MockLogger implements ILogger {}
+
+        // Level 1: Infrastructure
+        const infrastructure = defineBuilderConfig({
+          name: 'Infrastructure',
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        // Level 2: Domain (uses parent's logger)
+        const domain = defineBuilderConfig({
+          name: 'Domain',
+          useContainer: infrastructure,
+          injections: []
+        });
+
+        // Level 3: Test (overrides logger)
+        export const testModule = defineBuilderConfig({
+          name: 'TestModule',
+          useContainer: domain,
+          injections: [
+            { token: useInterface<ILogger>(), provider: MockLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).not.toThrow();
+
+      // Find the ILogger node (may have filename prefix)
+      const loggerNode = Array.from(graph.nodes.values()).find(n =>
+        n.service.tokenId.includes('ILogger')
+      );
+      expect(loggerNode?.service.isScoped).toBe(true);
+    });
+
+    it('should work with factory + scoped', () => {
+      const program = createProgram('factory-scoped.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface IConfig { env: string; }
+
+        const parent = defineBuilderConfig({
+          injections: [{
+            token: useInterface<IConfig>(),
+            provider: () => ({ env: 'production' })
+          }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            {
+              token: useInterface<IConfig>(),
+              provider: () => ({ env: 'test' }),
+              scoped: true
+            }
+          ]
+        });
+      `);
+
+const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).not.toThrow();
+
+      // Find the node by checking all nodes for IConfig
+      const configNode = Array.from(graph.nodes.values()).find(n =>
+        n.service.tokenId.includes('IConfig')
+      );
+      expect(configNode).toBeDefined();
+      expect(configNode!.service.isScoped).toBe(true);
+      expect(configNode!.service.isFactory).toBe(true);
+    });
+  });
+});
+

package/tests/cli/cli.test.ts

@@ -225,5 +225,96 @@ describe('CLI - Validation Logic', () => {
       expect(() => validator.validate(graph)).toThrow(/Circular/);
     });
   });
+
+  describe('Scoped Injections', () => {
+    it('should pass validation with scoped: true override', () => {
+      const program = createProgram('scoped-valid.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).not.toThrow();
+    });
+
+    it('should fail validation without scoped: true', () => {
+      const program = createProgram('scoped-invalid.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ILogger>(), provider: ConsoleLogger }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      expect(() => validator.validate(graph)).toThrow(/Duplicate registration.*ILogger/);
+    });
+
+    it('should suggest scoped: true in error message', () => {
+      const program = createProgram('scoped-suggest.ts', `
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ICache {}
+        class RedisCache implements ICache {}
+        class MemoryCache implements ICache {}
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: useInterface<ICache>(), provider: RedisCache }]
+        });
+
+        export const c = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ICache>(), provider: MemoryCache }
+          ]
+        });
+      `);
+
+      const analyzer = new Analyzer(program);
+      const graph = analyzer.extract();
+      const validator = new GraphValidator();
+
+      try {
+        validator.validate(graph);
+        expect.fail('Should have thrown');
+      } catch (e: any) {
+        expect(e.message).toContain("scoped: true");
+      }
+    });
+  });
 });
 

package/tests/e2e/container-integration.test.ts

@@ -22,8 +22,8 @@ describe('E2E - Container Integration', () => {
 
     private factories = new Map<any, (container: NeoContainer) => any>();
 
-    registerFactory(token: any, factory: (container: NeoContainer) => any, scope: 'singleton' | 'transient' = 'singleton') {
-      if (scope === 'transient') {
+    registerFactory(token: any, factory: (container: NeoContainer) => any, lifecycle: 'singleton' | 'transient' = 'singleton') {
+      if (lifecycle === 'transient') {
         this.factories.set(token, (c) => factory(c));
       } else {
         this.factories.set(token, (c) => {
@@ -74,7 +74,7 @@ describe('E2E - Container Integration', () => {
       const container = new NeoContainer();
       container.registerFactory(SimpleService, () => new SimpleService());
 
-      const service = container.resolve(SimpleService);
+      const service = container.resolve<any>(SimpleService);
       expect(service.getValue()).toBe(42);
     });
 
@@ -96,7 +96,7 @@ describe('E2E - Container Integration', () => {
       container.registerFactory(Logger, () => new Logger());
       container.registerFactory(UserService, (c) => new UserService(c.resolve(Logger)));
 
-      const userService = container.resolve(UserService);
+      const userService = container.resolve<any>(UserService);
       expect(userService.greet('World')).toBe('Hello World');
     });
   });
@@ -111,8 +111,8 @@ describe('E2E - Container Integration', () => {
       const container = new NeoContainer();
       container.registerFactory(Counter, () => new Counter(), 'singleton');
 
-      const c1 = container.resolve(Counter);
-      const c2 = container.resolve(Counter);
+      const c1 = container.resolve<any>(Counter);
+      const c2 = container.resolve<any>(Counter);
 
       expect(c1).toBe(c2);
       expect(c1.increment()).toBe(1);
@@ -131,8 +131,8 @@ describe('E2E - Container Integration', () => {
       const container = new NeoContainer();
       container.registerFactory(Transient, () => new Transient(), 'transient');
 
-      const t1 = container.resolve(Transient);
-      const t2 = container.resolve(Transient);
+      const t1 = container.resolve<any>(Transient);
+      const t2 = container.resolve<any>(Transient);
 
       expect(t1).not.toBe(t2);
       expect(t1.id).not.toBe(t2.id);
@@ -163,11 +163,11 @@ describe('E2E - Container Integration', () => {
       container.registerFactory(UserRepo, (c) => new UserRepo(c.resolve(Database)));
       container.registerFactory(UserService, (c) => new UserService(c.resolve(UserRepo), c.resolve(Logger)));
 
-      const userService = container.resolve(UserService);
+      const userService = container.resolve<any>(UserService);
       expect(userService.getDbUrl()).toBe('postgres://localhost');
 
       // Verify singleton behavior
-      const logger1 = container.resolve(Logger);
+      const logger1 = container.resolve<any>(Logger);
       const logger2 = userService.logger;
       expect(logger1).toBe(logger2);
     });
@@ -181,7 +181,7 @@ describe('E2E - Container Integration', () => {
       const container = new NeoContainer(undefined, undefined, 'MyApp');
       container.registerFactory(Registered, () => new Registered());
 
-      expect(() => container.resolve(NotRegistered)).toThrow(/MyApp.*not found/);
+      expect(() => container.resolve<any>(NotRegistered)).toThrow(/MyApp.*not found/);
     });
   });
 
@@ -198,7 +198,7 @@ describe('E2E - Container Integration', () => {
       container.registerFactory(Right, (c) => new Right(c.resolve(Shared)));
       container.registerFactory(Top, (c) => new Top(c.resolve(Left), c.resolve(Right)));
 
-      const top = container.resolve(Top);
+      const top = container.resolve<any>(Top);
 
       // Both Left and Right should share the same Shared instance
       expect(top.left.shared).toBe(top.right.shared);
@@ -217,7 +217,7 @@ describe('E2E - Container Integration', () => {
       const child = new NeoContainer(parent, undefined, 'Child');
       child.registerFactory(ChildService, (c) => new ChildService(c.resolve(SharedService)));
 
-      const service = child.resolve(ChildService);
+      const service = child.resolve<any>(ChildService);
       expect(service.shared.value).toBe('shared');
     });
 
@@ -230,7 +230,7 @@ describe('E2E - Container Integration', () => {
       const child = new NeoContainer(parent);
       child.registerFactory(Service, () => new Service('child'));
 
-      expect(child.resolve(Service).value).toBe('child');
+      expect(child.resolve<any>(Service).value).toBe('child');
     });
   });
 
@@ -248,7 +248,7 @@ describe('E2E - Container Integration', () => {
 
       const container = new NeoContainer(undefined, [legacyContainer], 'App');
 
-      const service = container.resolve(LegacyService);
+      const service = container.resolve<any>(LegacyService);
       expect(service.fromLegacy).toBe(true);
     });
 
@@ -262,7 +262,7 @@ describe('E2E - Container Integration', () => {
       const container = new NeoContainer(undefined, [legacyContainer]);
       container.registerFactory(Service, () => new Service('local'));
 
-      expect(container.resolve(Service).source).toBe('local');
+      expect(container.resolve<any>(Service).source).toBe('local');
     });
   });
 
@@ -291,7 +291,7 @@ describe('E2E - Container Integration', () => {
       container.registerFactory(ILOGGER, () => new ConsoleLogger());
       container.registerFactory(UserService, (c) => new UserService(c.resolve(ILOGGER)));
 
-      const service = container.resolve(UserService);
+      const service = container.resolve<any>(UserService);
       expect(service.logger.log('hi')).toBe('hi');
     });
   });
@@ -305,11 +305,11 @@ describe('E2E - Container Integration', () => {
 
       const API_URL_TOKEN = 'ApiUrl';
       container.registerFactory(API_URL_TOKEN, (c) => {
-        const config = c.resolve(Config);
+        const config = c.resolve<Config>(Config);
         return `https://api.${config.env}.example.com`;
       });
 
-      expect(container.resolve(API_URL_TOKEN)).toBe('https://api.test.example.com');
+      expect(container.resolve<any>(API_URL_TOKEN)).toBe('https://api.test.example.com');
     });
   });
 
@@ -324,7 +324,7 @@ describe('E2E - Container Integration', () => {
 
       const start = Date.now();
       for (let i = 0; i < 100; i++) {
-        container.resolve(HeavyService);
+        container.resolve<any>(HeavyService);
       }
       const duration = Date.now() - start;
 
@@ -348,7 +348,7 @@ describe('E2E - Container Integration', () => {
       }
 
       const start = Date.now();
-      container.resolve(prevClass);
+      container.resolve<any>(prevClass);
       const duration = Date.now() - start;
 
       expect(duration).toBeLessThan(100); // 100ms max for 20 levels