feat: add circular dependency detection

README.md

@@ -293,3 +293,30 @@ container.runInScope(() => {
 ```
 
 Note: If you try to resolve a scoped dependency outside a scope, an error will be thrown.
+
+### Circular dependencies
+
+IOctopus can detect circular dependencies. 
+An error will be thrown if a circular dependency is detected.
+
+```typescript
+const container = createContainer();
+
+const A_TOKEN = Symbol('A');
+const B_TOKEN = Symbol('B');
+
+class A {
+    constructor(public b: B) {}
+}
+
+class B {
+    constructor(public a: A) {}
+}
+
+container.bind(A_TOKEN).toClass(A, [B_TOKEN]);
+container.bind(B_TOKEN).toClass(B, [A_TOKEN]);
+
+container.get(A_TOKEN); // Will throw: "Circular dependency detected: Symbol(A) -> Symbol(B) -> Symbol(A)"
+```
+
+This way you can avoid infinite loops and stack overflow errors.

specs/container.spec.ts

@@ -223,4 +223,30 @@ describe('Container', () => {
                 .toThrowError(`No binding found for key: ${DI.NOT_REGISTERED_VALUE.toString()}`);
         });
     });
+
+    describe('When circular dependency is detected', () => {
+        it('should throw an error when a circular dependency is detected', () => {
+            // Arrange
+            const container = createContainer();
+
+            const A_TOKEN = Symbol('A');
+            const B_TOKEN = Symbol('B');
+
+            class A {
+                constructor(public b: B) {}
+            }
+
+            class B {
+                constructor(public a: A) {}
+            }
+
+            container.bind(A_TOKEN).toClass(A, [B_TOKEN]);
+            container.bind(B_TOKEN).toClass(B, [A_TOKEN]);
+
+            // Act & Assert
+            expect(() => {
+                container.get(A_TOKEN);
+            }).toThrowError(/Circular dependency detected: Symbol\(A\) -> Symbol\(B\) -> Symbol\(A\)/);
+        });
+    });
 });

src/container.ts

@@ -1,13 +1,14 @@
-import { Binding, Container, Module } from "./types";
-import { createModule } from "./module";
+import { Binding, Container, Module } from './types';
+import { createModule } from './module';
 
 export function createContainer(): Container {
     const modules = new Map<symbol, Module>();
     const singletonInstances = new Map<symbol, unknown>();
     const scopedInstances = new Map<symbol, Map<symbol, unknown>>();
+    const resolutionStack: symbol[] = [];
     let currentScopeId: symbol | undefined;
 
-    const DEFAULT_MODULE_KEY = Symbol("DEFAULT");
+    const DEFAULT_MODULE_KEY = Symbol('DEFAULT');
     const defaultModule = createModule();
     modules.set(DEFAULT_MODULE_KEY, defaultModule);
 
@@ -33,37 +34,49 @@ export function createContainer(): Container {
     };
 
     const get = <T>(key: symbol): T => {
-        const binding = findLastBinding(key);
-        if (!binding) throw new Error(`No binding found for key: ${key.toString()}`);
+        if (resolutionStack.includes(key)) {
+            const cycle = [...resolutionStack, key].map((k) => k.toString()).join(' -> ');
+            throw new Error(`Circular dependency detected: ${cycle}`);
+        }
 
-        const { factory, scope } = binding;
+        resolutionStack.push(key);
 
-        if (scope === "singleton") {
-            if (!singletonInstances.has(key)) {
-                singletonInstances.set(key, factory(resolveDependency));
-            }
-            return singletonInstances.get(key) as T;
-        }
+        try {
+            const binding = findLastBinding(key);
+            if (!binding) throw new Error(`No binding found for key: ${key.toString()}`);
 
-        if (scope === "transient") {
-            return factory(resolveDependency) as T;
-        }
+            const { factory, scope } = binding;
 
-        if (scope === "scoped") {
-            if (!currentScopeId) throw new Error(`Cannot resolve scoped binding outside of a scope: ${key.toString()}`);
+            if (scope === 'singleton') {
+                if (!singletonInstances.has(key)) {
+                    singletonInstances.set(key, factory(resolveDependency));
+                }
+                return singletonInstances.get(key) as T;
+            }
 
-            if (!scopedInstances.has(currentScopeId)) {
-                scopedInstances.set(currentScopeId, new Map<symbol, unknown>());
+            if (scope === 'transient') {
+                return factory(resolveDependency) as T;
             }
-            const scopeMap = scopedInstances.get(currentScopeId)!;
-            if (!scopeMap.has(key)) {
-                scopeMap.set(key, factory(resolveDependency));
+
+            if (scope === 'scoped') {
+                if (!currentScopeId)
+                    throw new Error(`Cannot resolve scoped binding outside of a scope: ${key.toString()}`);
+
+                if (!scopedInstances.has(currentScopeId)) {
+                    scopedInstances.set(currentScopeId, new Map<symbol, unknown>());
+                }
+                const scopeMap = scopedInstances.get(currentScopeId)!;
+                if (!scopeMap.has(key)) {
+                    scopeMap.set(key, factory(resolveDependency));
+                }
+
+                return scopeMap.get(key) as T;
             }
 
-            return scopeMap.get(key) as T;
+            throw new Error(`Unknown scope: ${scope}`);
+        } finally {
+            resolutionStack.pop();
         }
-
-        throw new Error(`Unknown scope: ${scope}`);
     };
 
     const resolveDependency = (depKey: symbol): unknown => {
@@ -72,7 +85,7 @@ export function createContainer(): Container {
 
     const runInScope = <T>(callback: () => T): T => {
         const previousScopeId = currentScopeId;
-        currentScopeId = Symbol("scope");
+        currentScopeId = Symbol('scope');
         try {
             return callback();
         } finally {