@stitchem/core 0.0.3 → 0.0.7

package/dist/context/context.d.ts

@@ -170,12 +170,12 @@ export declare class Context implements AsyncDisposable {
     private resolveSingletons;
     /** Instantiates component classes from registered component keys. */
     private resolveComponents;
-    /** Calls onReady() on all singleton providers, module classes, and components. */
-    private fireOnReady;
     /** Disposes injectables in reverse module order, before component disposal. */
     private disposeInjectables;
     /** Disposes components in reverse module order, before provider disposal. */
     private disposeComponents;
+    /** Calls onDispose() on module class instances in reverse module order. */
+    private disposeModuleInstances;
     private ensureInitialized;
 }
 //# sourceMappingURL=context.d.ts.map

package/dist/context/context.js

@@ -57,7 +57,7 @@ import { ModuleGraph } from '../module/module.graph.js';
 import { ModuleRef } from '../module/module.ref.js';
 import { Injector } from '../injector/injector.js';
 import { CoreError } from '../errors/core.error.js';
-import { hasOnReady } from '../core/core.lifecycle.js';
+import { hasOnDispose } from '../core/core.lifecycle.js';
 import { ConsoleLogger, NoopLogger } from '../logger/console.logger.js';
 import { LOGGER } from '../logger/logger.token.js';
 import { Scope } from './scope.js';
@@ -163,9 +163,6 @@ export class Context {
             return cached;
         const scope = Scope.current() ?? Scope.STATIC;
         const instance = await this.injector.instantiateClassGlobal(ctor, scope);
-        if (hasOnReady(instance)) {
-            await instance.onReady();
-        }
         this.rootModule.setInjectable(ctor, instance);
         return instance;
     }
@@ -263,6 +260,7 @@ export class Context {
         }
         await this.container.dispose(scope);
         if (!scope) {
+            await this.disposeModuleInstances();
             this.initialized = false;
         }
     }
@@ -274,7 +272,6 @@ export class Context {
         this.container.buildGlobalExports();
         await this.resolveSingletons();
         await this.resolveComponents();
-        await this.fireOnReady();
         this.initialized = true;
     }
     /** Registers a ModuleRef factory provider for each module. */
@@ -346,30 +343,6 @@ export class Context {
             }
         }
     }
-    /** Calls onReady() on all singleton providers, module classes, and components. */
-    async fireOnReady() {
-        for (const id of this.moduleGraph.sortedIds) {
-            const module = this.container.getModule(id);
-            for (const [, wrapper] of module.providers) {
-                if (!wrapper.isSingleton)
-                    continue;
-                const instance = wrapper.getInstance(Scope.STATIC);
-                if (instance !== undefined && hasOnReady(instance)) {
-                    await instance.onReady();
-                }
-            }
-            if (module.instance !== undefined && hasOnReady(module.instance)) {
-                await module.instance.onReady();
-            }
-            for (const key of this.componentKeys) {
-                for (const entry of module.getComponents(key)) {
-                    if (hasOnReady(entry.instance)) {
-                        await entry.instance.onReady();
-                    }
-                }
-            }
-        }
-    }
     /** Disposes injectables in reverse module order, before component disposal. */
     async disposeInjectables() {
         const moduleIds = [...this.moduleGraph.sortedIds].reverse();
@@ -386,6 +359,16 @@ export class Context {
             await module.disposeComponents();
         }
     }
+    /** Calls onDispose() on module class instances in reverse module order. */
+    async disposeModuleInstances() {
+        const moduleIds = [...this.moduleGraph.sortedIds].reverse();
+        for (const id of moduleIds) {
+            const module = this.container.getModule(id);
+            if (module.instance !== undefined && hasOnDispose(module.instance)) {
+                await module.instance.onDispose();
+            }
+        }
+    }
     ensureInitialized() {
         if (!this.initialized) {
             throw new Error('Context is not initialized. Call Context.create() first.');

package/dist/core/core.lifecycle.d.ts

@@ -10,13 +10,6 @@ export interface OnInit {
 export interface OnDispose {
     onDispose(): void | Promise<void>;
 }
-/**
- * Interface for providers that need to run logic after all modules are initialized.
- * Fires after every singleton provider has been created and onInit() has completed.
- */
-export interface OnReady {
-    onReady(): void | Promise<void>;
-}
 /**
  * Type guard for OnInit.
  *
@@ -31,11 +24,4 @@ export declare function hasOnInit(instance: unknown): instance is OnInit;
  * @returns True if the instance implements the OnDispose interface.
  */
 export declare function hasOnDispose(instance: unknown): instance is OnDispose;
-/**
- * Type guard for OnReady.
- *
- * @param instance - The value to check for OnReady conformance.
- * @returns True if the instance implements the OnReady interface.
- */
-export declare function hasOnReady(instance: unknown): instance is OnReady;
 //# sourceMappingURL=core.lifecycle.d.ts.map

package/dist/core/core.lifecycle.js

@@ -22,16 +22,4 @@ export function hasOnDispose(instance) {
         'onDispose' in instance &&
         typeof instance.onDispose === 'function');
 }
-/**
- * Type guard for OnReady.
- *
- * @param instance - The value to check for OnReady conformance.
- * @returns True if the instance implements the OnReady interface.
- */
-export function hasOnReady(instance) {
-    return (typeof instance === 'object' &&
-        instance !== null &&
-        'onReady' in instance &&
-        typeof instance.onReady === 'function');
-}
 //# sourceMappingURL=core.lifecycle.js.map

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export type { Token } from './token/token.types.js';
 export { Lifetime } from './core/core.lifetime.js';
 export { lazy } from './token/lazy.token.js';
 export { isConstructor } from './core/core.utils.js';
-export type { OnInit, OnDispose, OnReady } from './core/core.lifecycle.js';
+export type { OnInit, OnDispose } from './core/core.lifecycle.js';
 export type { Provider, ClassProvider, ValueProvider, FactoryProvider, ExistingProvider, } from './provider/provider.interface.js';
 export type { ModuleMetadata, DynamicModule, ModuleImport, } from './module/module.types.js';
 export { Context } from './context/context.js';

package/dist/injector/injector.d.ts

@@ -10,8 +10,15 @@ import { Container } from '../container/container.js';
  */
 export declare class Injector {
     private readonly container;
-    /** Tracks tokens currently being resolved (circular dependency detection). */
-    private readonly resolutionStack;
+    /**
+     * Per-scope resolution stack for circular dependency detection.
+     * Each scope (e.g. per HTTP request) gets its own stack, preventing
+     * false circular dependency errors under concurrency.
+     * WeakMap ensures stacks are GC'd when their scope is disposed.
+     */
+    private readonly resolutionStacks;
+    /** Returns or creates the resolution stack for the given scope. */
+    private getResolutionStack;
     constructor(container: Container);
     /**
      * Resolves an instance from a wrapper (async).

package/dist/injector/injector.js

@@ -12,8 +12,22 @@ import { isValueProvider, isFactoryProvider, isExistingProvider, isClassProvider
  */
 export class Injector {
     container;
-    /** Tracks tokens currently being resolved (circular dependency detection). */
-    resolutionStack = new Set();
+    /**
+     * Per-scope resolution stack for circular dependency detection.
+     * Each scope (e.g. per HTTP request) gets its own stack, preventing
+     * false circular dependency errors under concurrency.
+     * WeakMap ensures stacks are GC'd when their scope is disposed.
+     */
+    resolutionStacks = new WeakMap();
+    /** Returns or creates the resolution stack for the given scope. */
+    getResolutionStack(scope) {
+        let stack = this.resolutionStacks.get(scope);
+        if (!stack) {
+            stack = new Set();
+            this.resolutionStacks.set(scope, stack);
+        }
+        return stack;
+    }
     constructor(container) {
         this.container = container;
     }
@@ -28,7 +42,7 @@ export class Injector {
         const cached = this.guardResolution(wrapper, scope);
         if (cached !== null)
             return cached;
-        this.resolutionStack.add(wrapper.token);
+        this.getResolutionStack(scope).add(wrapper.token);
         try {
             const resolver = this.moduleResolver(module);
             const instance = await this.createInstance(wrapper, resolver, scope);
@@ -39,7 +53,7 @@ export class Injector {
             return instance;
         }
         finally {
-            this.resolutionStack.delete(wrapper.token);
+            this.getResolutionStack(scope).delete(wrapper.token);
         }
     }
     /**
@@ -53,7 +67,7 @@ export class Injector {
         const cached = this.guardResolution(wrapper, scope);
         if (cached !== null)
             return cached;
-        this.resolutionStack.add(wrapper.token);
+        this.getResolutionStack(scope).add(wrapper.token);
         try {
             const resolver = this.moduleResolver(module);
             const instance = this.createInstanceSync(wrapper, resolver, scope);
@@ -67,7 +81,7 @@ export class Injector {
             return instance;
         }
         finally {
-            this.resolutionStack.delete(wrapper.token);
+            this.getResolutionStack(scope).delete(wrapper.token);
         }
     }
     /**
@@ -77,13 +91,13 @@ export class Injector {
      * @throws CoreError (CIRCULAR_DEPENDENCY) if a circular dependency is detected
      */
     async createUncached(wrapper, module, scope = Scope.STATIC) {
-        if (this.resolutionStack.has(wrapper.token)) {
+        if (this.getResolutionStack(scope).has(wrapper.token)) {
             throw CoreError.circularDependency([
-                ...this.resolutionStack,
+                ...this.getResolutionStack(scope),
                 wrapper.token,
             ]);
         }
-        this.resolutionStack.add(wrapper.token);
+        this.getResolutionStack(scope).add(wrapper.token);
         try {
             const resolver = this.moduleResolver(module);
             const instance = await this.createInstance(wrapper, resolver, scope);
@@ -93,7 +107,7 @@ export class Injector {
             return instance;
         }
         finally {
-            this.resolutionStack.delete(wrapper.token);
+            this.getResolutionStack(scope).delete(wrapper.token);
         }
     }
     /**
@@ -142,9 +156,9 @@ export class Injector {
         if (wrapper.isResolved(scope)) {
             return wrapper.getInstance(scope);
         }
-        if (this.resolutionStack.has(wrapper.token)) {
+        if (this.getResolutionStack(scope).has(wrapper.token)) {
             throw CoreError.circularDependency([
-                ...this.resolutionStack,
+                ...this.getResolutionStack(scope),
                 wrapper.token,
             ]);
         }

package/dist/module/module.ref.js

@@ -1,5 +1,4 @@
 import { Scope } from '../context/scope.js';
-import { hasOnReady } from '../core/core.lifecycle.js';
 import { CoreError } from '../errors/core.error.js';
 /**
  * Reference to a module, injectable into providers.
@@ -47,14 +46,16 @@ export class ModuleRef {
      * Resolves a dependency from this module's context.
      * Respects module visibility (can only resolve visible tokens).
      */
-    async resolve(token, scope = Scope.STATIC) {
+    async resolve(token, scope) {
+        const resolvedScope = scope ?? Scope.current() ?? Scope.STATIC;
         const { wrapper, module } = this.container.getProviderByToken(token, this.module);
-        return this.injector.loadInstance(wrapper, module, scope);
+        return this.injector.loadInstance(wrapper, module, resolvedScope);
     }
     /** Synchronously resolves a dependency from this module's context. */
-    resolveSync(token, scope = Scope.STATIC) {
+    resolveSync(token, scope) {
+        const resolvedScope = scope ?? Scope.current() ?? Scope.STATIC;
         const { wrapper, module } = this.container.getProviderByToken(token, this.module);
-        return this.injector.loadInstanceSync(wrapper, module, scope);
+        return this.injector.loadInstanceSync(wrapper, module, resolvedScope);
     }
     /**
      * Creates a new instance of a registered provider, bypassing cache.
@@ -62,10 +63,11 @@ export class ModuleRef {
      *
      * @throws CoreError (PROVIDER_NOT_FOUND) if the class is not registered
      */
-    async create(ctor, scope = Scope.STATIC) {
+    async create(ctor, scope) {
+        const resolvedScope = scope ?? Scope.current() ?? Scope.STATIC;
         const wrapper = this.module.getProvider(ctor);
         if (wrapper) {
-            return this.injector.createUncached(wrapper, this.module, scope);
+            return this.injector.createUncached(wrapper, this.module, resolvedScope);
         }
         throw CoreError.providerNotFound(ctor, this.module.id);
     }
@@ -73,8 +75,9 @@ export class ModuleRef {
      * Instantiates any class by resolving its dependencies.
      * The class does not need to be registered as a provider.
      */
-    async constructClass(ctor, scope = Scope.STATIC) {
-        return this.injector.instantiateClass(ctor, this.module, scope);
+    async constructClass(ctor, scope) {
+        const resolvedScope = scope ?? Scope.current() ?? Scope.STATIC;
+        return this.injector.instantiateClass(ctor, this.module, resolvedScope);
     }
     /**
      * Resolves an injectable class instance with caching and lifecycle hooks.
@@ -97,9 +100,6 @@ export class ModuleRef {
         const instance = await (options?.strict === false
             ? this.injector.instantiateClassGlobal(ctor, scope)
             : this.injector.instantiateClass(ctor, this.module, scope));
-        if (hasOnReady(instance)) {
-            await instance.onReady();
-        }
         this.module.setInjectable(ctor, instance);
         return instance;
     }

package/dist/test/test.d.ts

@@ -5,7 +5,7 @@ import { TestModuleBuilder } from './test.module-builder.js';
  *
  * @example
  * ```ts
- * const module = await Test.createModule({
+ * await using module = await Test.createModule({
  *   imports: [UserModule],
  *   providers: [UserService],
  * })
@@ -13,7 +13,6 @@ import { TestModuleBuilder } from './test.module-builder.js';
  * .compile();
  *
  * const userService = await module.resolve(UserService);
- * await module.close();
  * ```
  */
 export declare class Test {

package/dist/test/test.js

@@ -4,7 +4,7 @@ import { TestModuleBuilder } from './test.module-builder.js';
  *
  * @example
  * ```ts
- * const module = await Test.createModule({
+ * await using module = await Test.createModule({
  *   imports: [UserModule],
  *   providers: [UserService],
  * })
@@ -12,7 +12,6 @@ import { TestModuleBuilder } from './test.module-builder.js';
  * .compile();
  *
  * const userService = await module.resolve(UserService);
- * await module.close();
  * ```
  */
 export class Test {

package/dist/test/test.module-builder.js

@@ -38,7 +38,6 @@ import { ModuleGraph } from '../module/module.graph.js';
 import { ModuleRef } from '../module/module.ref.js';
 import { Injector } from '../injector/injector.js';
 import { Scope } from '../context/scope.js';
-import { hasOnReady } from '../core/core.lifecycle.js';
 import { getProviderToken } from '../provider/provider.guards.js';
 import { TestModule } from './test.module.js';
 // ---------------------------------------------------------------------------
@@ -178,9 +177,6 @@ export class TestModuleBuilder {
                 const result = override.factory(...deps);
                 instance = result instanceof Promise ? await result : result;
             }
-            if (hasOnReady(instance)) {
-                await instance.onReady();
-            }
             for (const id of moduleGraph.sortedIds) {
                 const mod = container.getModule(id);
                 mod.setInjectable(override.ctor, instance);
@@ -215,28 +211,6 @@ export class TestModuleBuilder {
                 }
             }
         }
-        // Fire onReady lifecycle.
-        for (const id of moduleGraph.sortedIds) {
-            const mod = container.getModule(id);
-            for (const [, wrapper] of mod.providers) {
-                if (!wrapper.isSingleton)
-                    continue;
-                const instance = wrapper.getInstance(Scope.STATIC);
-                if (instance !== undefined && hasOnReady(instance)) {
-                    await instance.onReady();
-                }
-            }
-            if (mod.instance !== undefined && hasOnReady(mod.instance)) {
-                await mod.instance.onReady();
-            }
-            for (const key of componentKeys) {
-                for (const entry of mod.getComponents(key)) {
-                    if (hasOnReady(entry.instance)) {
-                        await entry.instance.onReady();
-                    }
-                }
-            }
-        }
         return new TestModule(container, injector, rootModule, moduleGraph.sortedIds);
     }
     /** @internal */

package/dist/test/test.module.d.ts

@@ -61,11 +61,8 @@ export declare class TestModule implements AsyncDisposable {
     /** Creates a new disposable scope for scoped resolution. */
     createScope(): Scope;
     [Symbol.asyncDispose](): Promise<void>;
-    /**
-     * Disposes the test module.
-     * Call in afterEach/afterAll to clean up.
-     */
-    close(scope?: Scope): Promise<void>;
+    /** Disposes a single scope's instances. */
+    private disposeScope;
     private ensureNotDisposed;
 }
 //# sourceMappingURL=test.module.d.ts.map

package/dist/test/test.module.js

@@ -1,6 +1,6 @@
 import { Scope } from '../context/scope.js';
 import { ModuleRef } from '../module/module.ref.js';
-import { hasOnReady } from '../core/core.lifecycle.js';
+import { hasOnDispose } from '../core/core.lifecycle.js';
 /**
  * A compiled test module.
  * Provides resolution and lifecycle management for test scenarios.
@@ -83,9 +83,6 @@ export class TestModule {
             return cached;
         const scope = Scope.current() ?? Scope.STATIC;
         const instance = await this.injector.instantiateClassGlobal(ctor, scope);
-        if (hasOnReady(instance)) {
-            await instance.onReady();
-        }
         this.rootModule.setInjectable(ctor, instance);
         return instance;
     }
@@ -111,36 +108,35 @@ export class TestModule {
     /** Creates a new disposable scope for scoped resolution. */
     createScope() {
         this.ensureNotDisposed();
-        return Scope.create((scope) => this.close(scope));
+        return Scope.create((scope) => this.disposeScope(scope));
     }
     async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-    /**
-     * Disposes the test module.
-     * Call in afterEach/afterAll to clean up.
-     */
-    async close(scope) {
-        if (this.disposed && !scope)
+        if (this.disposed)
             return;
-        if (!scope) {
-            // Dispose injectables → components → providers.
-            const moduleIds = [...this.sortedIds].reverse();
-            for (const id of moduleIds) {
-                const module = this.container.getModule(id);
-                if (module)
-                    await module.disposeInjectables();
-            }
-            for (const id of moduleIds) {
-                const module = this.container.getModule(id);
-                if (module)
-                    await module.disposeComponents();
+        // Dispose injectables → components → providers → module instances.
+        const moduleIds = [...this.sortedIds].reverse();
+        for (const id of moduleIds) {
+            const module = this.container.getModule(id);
+            if (module)
+                await module.disposeInjectables();
+        }
+        for (const id of moduleIds) {
+            const module = this.container.getModule(id);
+            if (module)
+                await module.disposeComponents();
+        }
+        await this.container.dispose();
+        for (const id of moduleIds) {
+            const module = this.container.getModule(id);
+            if (module?.instance !== undefined && hasOnDispose(module.instance)) {
+                await module.instance.onDispose();
             }
         }
+        this.disposed = true;
+    }
+    /** Disposes a single scope's instances. */
+    async disposeScope(scope) {
         await this.container.dispose(scope);
-        if (!scope) {
-            this.disposed = true;
-        }
     }
     ensureNotDisposed() {
         if (this.disposed) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stitchem/core",
-  "version": "0.0.3",
-  "description": "Extensible modular dependency injection for TypeScript",
+  "version": "0.0.7",
+  "description": "",
   "author": {
     "name": "hexac",
     "url": "https://existin.space",