@djodjonx/neo-syringe 1.1.5 → 1.2.2

package/tests/e2e/generated-code.test.ts

@@ -202,7 +202,7 @@ it('should resolve class dependencies on interfaces', () => {
         function defineBuilderConfig(config: any) { return config; }
         class SingletonService {}
         export const c = defineBuilderConfig({
-          injections: [{ token: SingletonService, scope: 'singleton' }]
+          injections: [{ token: SingletonService, lifecycle: 'singleton' }]
         });
       `);
 
@@ -217,7 +217,7 @@ it('should resolve class dependencies on interfaces', () => {
         function defineBuilderConfig(config: any) { return config; }
         class TransientService {}
         export const c = defineBuilderConfig({
-          injections: [{ token: TransientService, scope: 'transient' }]
+          injections: [{ token: TransientService, lifecycle: 'transient' }]
         });
       `);
 
@@ -652,10 +652,10 @@ it('should generate PropertyToken resolution', () => {
 
         export const c = defineBuilderConfig({
           injections: [
-            { token: SingletonA, scope: 'singleton' },
+            { token: SingletonA, lifecycle: 'singleton' },
             { token: SingletonB },  // Default singleton
-            { token: TransientA, scope: 'transient' },
-            { token: TransientB, scope: 'transient' }
+            { token: TransientA, lifecycle: 'transient' },
+            { token: TransientB, lifecycle: 'transient' }
           ]
         });
       `);
@@ -926,7 +926,7 @@ it('should generate PropertyToken resolution', () => {
       );
 
       // Should parse without syntax errors
-      const syntaxErrors = sourceFile.parseDiagnostics || [];
+      const syntaxErrors = (sourceFile as any).parseDiagnostics || [];
       expect(syntaxErrors.length).toBe(0);
     });
 
@@ -948,7 +948,7 @@ it('should generate PropertyToken resolution', () => {
         ts.ScriptTarget.Latest,
         true
       );
-      const syntaxErrors = sourceFile.parseDiagnostics || [];
+      const syntaxErrors = (sourceFile as any).parseDiagnostics || [];
       expect(syntaxErrors.length).toBe(0);
     });
   });

package/tests/e2e/scoped.test.ts

@@ -0,0 +1,370 @@
+/**
+ * E2E Tests for scoped: true functionality
+ *
+ * Tests the complete flow from configuration to generated code
+ * for scoped token overrides.
+ */
+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('E2E - Scoped Injections', () => {
+  const compileAndGenerate = (fileContent: string): string => {
+    const fileName = 'scoped-e2e.ts';
+    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);
+    };
+
+    const program = ts.createProgram([fileName], {}, compilerHost);
+    const analyzer = new Analyzer(program);
+    const graph = analyzer.extract();
+
+    const validator = new GraphValidator();
+    validator.validate(graph);
+
+    const generator = new Generator(graph);
+    return generator.generate();
+  };
+
+  describe('Basic scoped override', () => {
+    it('should compile and generate code for scoped token', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger { log(msg: string): void; }
+        class ConsoleLogger implements ILogger { log(msg: string) {} }
+        class FileLogger implements ILogger { log(msg: string) {} }
+
+        const sharedKernel = defineBuilderConfig({
+          name: 'SharedKernel',
+          injections: [
+            { token: useInterface<ILogger>(), provider: ConsoleLogger }
+          ]
+        });
+
+        class UserService {
+          constructor(private logger: ILogger) {}
+        }
+
+        export const userModule = defineBuilderConfig({
+          name: 'UserModule',
+          useContainer: sharedKernel,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true },
+            { token: UserService }
+          ]
+        });
+      `);
+
+// Container should be generated
+      expect(code).toContain('class NeoContainer');
+
+      // FileLogger (scoped) should be used, not ConsoleLogger
+      expect(code).toContain('FileLogger');
+
+      // Should have factory for ILogger (may have filename prefix)
+      expect(code).toMatch(/create_.*ILogger/);
+
+      // UserService should depend on ILogger
+      expect(code).toContain('UserService');
+    });
+
+    it('should fail without scoped: true when overriding parent', () => {
+      expect(() => compileAndGenerate(`
+        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 child = defineBuilderConfig({
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger }  // Missing scoped: true
+          ]
+        });
+      `)).toThrow(/Duplicate registration.*ILogger/);
+    });
+  });
+
+  describe('Scoped with scopes (singleton/transient)', () => {
+    it('should generate singleton for scoped singleton', () => {
+      const code = compileAndGenerate(`
+        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, lifecycle: 'singleton', scoped: true }
+          ]
+        });
+      `);
+
+      // Should use instances cache for singleton
+      expect(code).toContain('this.instances.has');
+      expect(code).toContain('this.instances.set');
+      expect(code).toContain('MemoryCache');
+    });
+
+    it('should generate transient for scoped transient', () => {
+      const code = compileAndGenerate(`
+        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 }
+          ]
+        });
+      `);
+
+      // Transient should return directly without caching
+      expect(code).toMatch(/if \(token === ".*IRequest"\) \{\s*return create_/);
+    });
+  });
+
+  describe('Scoped with factory', () => {
+    it('should work with factory provider + scoped', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface IConfig { apiUrl: string; }
+
+        const parent = defineBuilderConfig({
+          injections: [{
+            token: useInterface<IConfig>(),
+            provider: () => ({ apiUrl: 'https://prod.api.com' })
+          }]
+        });
+
+        export const testModule = defineBuilderConfig({
+          name: 'TestModule',
+          useContainer: parent,
+          injections: [
+            {
+              token: useInterface<IConfig>(),
+              provider: () => ({ apiUrl: 'http://localhost:3000' }),
+              scoped: true
+            }
+          ]
+        });
+      `);
+
+      expect(code).toContain('localhost:3000');
+      expect(code).toMatch(/create_.*IConfig/);
+    });
+  });
+
+  describe('Multi-level hierarchy', () => {
+    it('should work with 3-level container hierarchy', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        interface IDatabase {}
+
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+        class PostgresDB implements IDatabase {}
+
+        // Level 1: Infrastructure
+        const infrastructure = defineBuilderConfig({
+          name: 'Infrastructure',
+          injections: [
+            { token: useInterface<ILogger>(), provider: ConsoleLogger },
+            { token: useInterface<IDatabase>(), provider: PostgresDB }
+          ]
+        });
+
+        // Level 2: Domain (inherits all from infrastructure)
+        const domain = defineBuilderConfig({
+          name: 'Domain',
+          useContainer: infrastructure,
+          injections: []
+        });
+
+        // Level 3: TestModule (overrides ILogger only)
+        class TestService {
+          constructor(private logger: ILogger, private db: IDatabase) {}
+        }
+
+        export const testModule = defineBuilderConfig({
+          name: 'TestModule',
+          useContainer: domain,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true },
+            { token: TestService }
+          ]
+        });
+      `);
+
+      // Should have local ILogger (FileLogger)
+      expect(code).toContain('FileLogger');
+
+      // Should NOT have local IDatabase (comes from parent)
+      expect(code).not.toContain('create_IDatabase');
+
+      // TestService should exist
+      expect(code).toContain('TestService');
+    });
+  });
+
+  describe('Class token scoped', () => {
+    it('should work with class token (not just interfaces)', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+
+        class Logger {
+          log(msg: string) { console.log(msg); }
+        }
+
+        class MockLogger extends Logger {
+          log(msg: string) { /* noop */ }
+        }
+
+        const parent = defineBuilderConfig({
+          injections: [{ token: Logger }]
+        });
+
+        export const testModule = defineBuilderConfig({
+          name: 'TestModule',
+          useContainer: parent,
+          injections: [
+            { token: Logger, provider: MockLogger, scoped: true }
+          ]
+        });
+      `);
+
+      expect(code).toContain('MockLogger');
+      expect(code).toContain('create_Logger');
+    });
+  });
+
+  describe('Multiple scoped tokens', () => {
+    it('should handle multiple scoped overrides', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        interface ICache {}
+        interface IConfig {}
+
+        class ConsoleLogger implements ILogger {}
+        class RedisCache implements ICache {}
+        class ProdConfig implements IConfig {}
+
+        class MockLogger implements ILogger {}
+        class MemoryCache implements ICache {}
+        class TestConfig implements IConfig {}
+
+        const production = defineBuilderConfig({
+          name: 'Production',
+          injections: [
+            { token: useInterface<ILogger>(), provider: ConsoleLogger },
+            { token: useInterface<ICache>(), provider: RedisCache },
+            { token: useInterface<IConfig>(), provider: ProdConfig }
+          ]
+        });
+
+        export const testing = defineBuilderConfig({
+          name: 'Testing',
+          useContainer: production,
+          injections: [
+            { token: useInterface<ILogger>(), provider: MockLogger, scoped: true },
+            { token: useInterface<ICache>(), provider: MemoryCache, scoped: true },
+            { token: useInterface<IConfig>(), provider: TestConfig, scoped: true }
+          ]
+        });
+      `);
+
+// All 3 mock implementations should be present
+      expect(code).toContain('MockLogger');
+      expect(code).toContain('MemoryCache');
+      expect(code).toContain('TestConfig');
+
+      // Should have factories for all 3 (may have filename prefix)
+      expect(code).toMatch(/create_.*ILogger/);
+      expect(code).toMatch(/create_.*ICache/);
+      expect(code).toMatch(/create_.*IConfig/);
+    });
+  });
+
+  describe('Scoped with dependencies', () => {
+    it('should resolve scoped dependencies correctly', () => {
+      const code = compileAndGenerate(`
+        function defineBuilderConfig(config: any) { return config; }
+        function useInterface<T>(): any { return null; }
+
+        interface ILogger {}
+        class ConsoleLogger implements ILogger {}
+        class FileLogger implements ILogger {}
+
+        class UserRepository {
+          constructor(private logger: ILogger) {}
+        }
+
+        class UserService {
+          constructor(private repo: UserRepository, private logger: ILogger) {}
+        }
+
+        const parent = defineBuilderConfig({
+          name: 'Parent',
+          injections: [
+            { token: useInterface<ILogger>(), provider: ConsoleLogger }
+          ]
+        });
+
+        export const child = defineBuilderConfig({
+          name: 'Child',
+          useContainer: parent,
+          injections: [
+            { token: useInterface<ILogger>(), provider: FileLogger, scoped: true },
+            { token: UserRepository },
+            { token: UserService }
+          ]
+        });
+      `);
+
+      // Both UserRepository and UserService should use local ILogger
+      expect(code).toContain('create_UserRepository');
+      expect(code).toContain('create_UserService');
+      expect(code).toContain('FileLogger');
+    });
+  });
+});
+

package/tests/e2e/snapshots.test.ts

@@ -91,8 +91,8 @@ describe('Generated Code Snapshots', () => {
       export const c = defineBuilderConfig({
         name: 'ScopesApp',
         injections: [
-          { token: SingletonService, scope: 'singleton' },
-          { token: TransientService, scope: 'transient' }
+          { token: SingletonService, lifecycle: 'singleton' },
+          { token: TransientService, lifecycle: 'transient' }
         ]
       });
     `);

package/tests/e2e/standalone.test.ts

@@ -130,8 +130,8 @@ describe('E2E - Neo-Syringe Standalone', () => {
 
       export const container = defineBuilderConfig({
         injections: [
-          { token: SingletonService, scope: 'singleton' },
-          { token: TransientService, scope: 'transient' }
+          { token: SingletonService, lifecycle: 'singleton' },
+          { token: TransientService, lifecycle: 'transient' }
         ]
       });
     `);

package/tests/generator/ExternalGenerator.test.ts

@@ -29,7 +29,7 @@ function createMockNode(
       implementationSymbol: createMockSymbol(implName, filePath),
       registrationNode: {} as ts.Node,
       type: type,
-      scope: 'singleton',
+      lifecycle: 'singleton',
     } as ServiceDefinition,
     dependencies,
   };

package/tests/generator/FactoryGenerator.test.ts

@@ -18,7 +18,7 @@ describe('Generator - Factory Support', () => {
             tokenId: 'IConfig',
             registrationNode: {} as any,
             type: 'factory',
-            scope: 'singleton',
+            lifecycle: 'singleton',
             isInterfaceToken: true,
             isFactory: true,
             factorySource: '(container) => ({ apiUrl: "http://example.com" })'
@@ -50,7 +50,7 @@ describe('Generator - Factory Support', () => {
             tokenId: 'IDatabase',
             registrationNode: {} as any,
             type: 'factory',
-            scope: 'singleton',
+            lifecycle: 'singleton',
             isInterfaceToken: true,
             isFactory: true,
             factorySource: '() => ({ query: () => [] })'
@@ -78,7 +78,7 @@ describe('Generator - Factory Support', () => {
             tokenId: 'IRequest',
             registrationNode: {} as any,
             type: 'factory',
-            scope: 'transient',
+            lifecycle: 'transient',
             isInterfaceToken: true,
             isFactory: true,
             factorySource: '() => ({ id: Math.random() })'
@@ -107,7 +107,7 @@ describe('Generator - Factory Support', () => {
             tokenSymbol: createMockSymbol('UserService'),
             registrationNode: {} as any,
             type: 'autowire',
-            scope: 'singleton',
+            lifecycle: 'singleton',
             isFactory: false
           },
           dependencies: []
@@ -131,7 +131,7 @@ describe('Generator - Factory Support', () => {
             tokenId: 'IConfig',
             registrationNode: {} as any,
             type: 'factory',
-            scope: 'singleton',
+            lifecycle: 'singleton',
             isInterfaceToken: true,
             isFactory: true,
             factorySource: '() => ({ env: "prod" })'
@@ -145,7 +145,7 @@ describe('Generator - Factory Support', () => {
             tokenSymbol: createMockSymbol('AppService'),
             registrationNode: {} as any,
             type: 'autowire',
-            scope: 'singleton',
+            lifecycle: 'singleton',
             isFactory: false
           },
           dependencies: ['IConfig']

package/tests/generator/Generator.test.ts

@@ -16,14 +16,14 @@ function createMockSymbol(name: string, filePath: string): ts.Symbol {
 }
 
 // Helper to create a mock node
-function createMockNode(id: TokenId, dependencies: TokenId[], implName: string, filePath: string, scope: 'singleton' | 'transient' = 'singleton'): DependencyNode {
+function createMockNode(id: TokenId, dependencies: TokenId[], implName: string, filePath: string, lifecycle: 'singleton' | 'transient' = 'singleton'): DependencyNode {
   return {
     service: {
       tokenId: id,
       implementationSymbol: createMockSymbol(implName, filePath),
       registrationNode: {} as ts.Node,
       type: 'explicit',
-      scope: scope,
+      lifecycle: lifecycle,
     } as ServiceDefinition,
     dependencies,
   };

package/tests/generator/GeneratorDeclarative.test.ts

@@ -24,7 +24,7 @@ function createNode(
       tokenId: id,
       implementationSymbol: createMockSymbol(implName, '/src/file.ts'),
       type: 'explicit',
-      scope: 'singleton',
+      lifecycle: 'singleton',
       isInterfaceToken: isInterface
     } as ServiceDefinition,
     dependencies: deps

package/tests/generator/GraphValidator.test.ts

@@ -11,7 +11,7 @@ function createMockNode(id: TokenId, dependencies: TokenId[]): DependencyNode {
       implementationSymbol: {} as ts.Symbol, // Mock
       registrationNode: {} as ts.Node, // Mock
       type: 'autowire',
-      scope: 'singleton',
+      lifecycle: 'singleton',
     } as ServiceDefinition,
     dependencies,
   };

package/tsconfig.json

@@ -10,5 +10,6 @@
     "declaration": true,
     "outDir": "./dist"
   },
-  "include": ["src"]
+  "include": ["src", "tests"],
+  "exclude": ["docs"]
 }

package/typedoc.json

@@ -1,5 +0,0 @@
-{
-  "entryPoints": ["src/index.ts"],
-  "out": "docs",
-  "hideGenerator": true
-}