@codefast/di 0.3.14-canary.0 → 0.3.14-canary.2

package/dist/dependency-graph.d.mts

@@ -1,58 +1,28 @@
-import { RegistryKey } from "./registry.mjs";
-import { Binding, BindingIdentifier, ResolveHint } from "./binding.mjs";
+import { BindingScope } from "./types.mjs";
+import { BindingRegistry } from "./registry.mjs";
 import { MetadataReader } from "./metadata/metadata-types.mjs";
 
 //#region src/dependency-graph.d.ts
-/**
- * A directed edge in the static dependency graph produced by {@link collectStaticDependencyEdges}.
- */
-type StaticDependencyEdge = {
-  readonly fromBindingId: BindingIdentifier;
-  readonly toBindingId: BindingIdentifier;
-  readonly resolutionPath: readonly string[];
-  readonly edgeKind: "sync" | "async";
-  /**
-   * True when the resolved target binding carries a {@link BindingBuilder.when} predicate (runtime may skip this edge).
-   */
-  readonly toBindingConditional: boolean;
-  /**
-   * Constructor inject hint for this edge (named / tagged), when known statically.
-   */
-  readonly injectHintLabel?: string;
-  /**
-   * True when the consumer binding is an alias (rebind to another token).
-   */
-  readonly isAliasEdge: boolean;
-};
-/**
- * A single resolved dependency entry produced by {@link listResolvedDependencies}.
- */
-type ResolvedDependency = {
-  readonly binding: Binding<unknown>;
-  readonly path: readonly string[];
-  readonly injectHintLabel?: string;
-};
-/**
- * Converts a {@link ResolveHint} to a human-readable edge label for graph output (`name: x` / `tag: k=v`).
- */
-declare function injectHintLabelFromResolveHint(hint: ResolveHint | undefined): string | undefined;
-/**
- * Lists the direct static dependencies of `consumer` by inspecting binding metadata.
- *
- * - `constant` / `dynamic` / `async-dynamic` — no enumerable deps (empty array).
- * - `alias` — single dependency on the alias target (chased through alias chains).
- * - `resolved` — one dependency per entry in `dependencyTokens`; a missing binding
- *   always throws {@link InternalError} (there is no optional concept for `resolved`).
- * - `class` — one dependency per `@injectable()` constructor parameter
- *   (requires a {@link MetadataReader}). Parameters marked `optional` whose token
- *   has no binding are silently skipped; non-optional missing tokens throw
- *   {@link InternalError}.
- */
-declare function listResolvedDependencies(consumer: Binding<unknown>, lookup: (key: RegistryKey) => readonly Binding<unknown>[] | undefined, reader: MetadataReader | undefined, pathPrefix: readonly string[]): readonly ResolvedDependency[];
-/**
- * Flattens the direct dependencies of `consumer` into typed graph edges.
- * Used by {@link ContainerInspector} to build DOT and JSON outputs.
- */
-declare function collectStaticDependencyEdges(consumer: Binding<unknown>, lookup: (key: RegistryKey) => readonly Binding<unknown>[] | undefined, reader: MetadataReader | undefined, pathPrefix: readonly string[]): readonly StaticDependencyEdge[];
+interface GraphNode {
+  readonly id: string;
+  readonly tokenName: string;
+  readonly kind: string;
+  readonly scope: BindingScope;
+  readonly fromParent: boolean;
+}
+interface GraphEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly label?: string;
+}
+interface ContainerGraphJson {
+  readonly nodes: readonly GraphNode[];
+  readonly edges: readonly GraphEdge[];
+  readonly includesParent: boolean;
+}
+interface GraphOptions {
+  readonly includeParent?: boolean;
+}
+declare function buildDependencyGraph(registry: BindingRegistry, metadataReader: MetadataReader, options: GraphOptions | undefined, parentRegistry?: BindingRegistry): ContainerGraphJson;
 //#endregion
-export { ResolvedDependency, StaticDependencyEdge, collectStaticDependencyEdges, injectHintLabelFromResolveHint, listResolvedDependencies };
+export { ContainerGraphJson, GraphEdge, GraphNode, GraphOptions, buildDependencyGraph };

package/dist/dependency-graph.mjs

@@ -1,160 +1,58 @@
-import { InternalError } from "./errors.mjs";
-import { filterMatchingBindings, registryKeyLabel, selectBindingForRegistry } from "./binding-select.mjs";
+import { effectiveBindingScope } from "./binding-scope.mjs";
+import { tokenName } from "./token.mjs";
 //#region src/dependency-graph.ts
-/**
-* Converts a tag value to a printable string for graph edge labels.
-*/
-function formatTagValueForGraph(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-}
-/**
-* Converts a {@link ResolveHint} to a human-readable edge label for graph output (`name: x` / `tag: k=v`).
-*/
-function injectHintLabelFromResolveHint(hint) {
-	if (hint === void 0) return;
-	if (hint.name !== void 0) return `name: ${hint.name}`;
-	if (hint.tag !== void 0) {
-		const [tagKey, tagValue] = hint.tag;
-		return `tag: ${tagKey}=${formatTagValueForGraph(tagValue)}`;
-	}
-}
-/**
-* Returns `"async"` when either the consumer or dependency binding is an `async-dynamic` factory.
-*/
-function edgeKindFor(consumer, dependency) {
-	if (consumer.kind === "async-dynamic" || dependency.kind === "async-dynamic") return "async";
-	return "sync";
-}
-/**
-* Resolves the default (first matching, no hint) binding for `depKey`.
-* Returns `undefined` when the key has no registered bindings.
-*/
-function resolveDefaultBinding(lookup, depKey, pathPrefix) {
-	const label = registryKeyLabel(depKey);
-	const nextPath = [...pathPrefix, label];
-	const list = lookup(depKey);
-	if (list === void 0 || list.length === 0) return;
-	return selectBindingForRegistry(list, void 0, label, nextPath, void 0);
-}
-/**
-* Follows alias bindings until a non-alias binding is reached.
-* Returns the last reachable binding; stops early if an alias target is unregistered.
-*
-* **Warning:** This is a static walk with no cycle detection (`visiting` set). If the
-* registry contains a cyclic alias chain (A → B → A), this function will loop
-* indefinitely. The runtime resolver prevents such cycles via its own `visiting`
-* guard, but callers invoking `expandAliasChain` on a manually-constructed or
-* corrupted registry must ensure alias chains are acyclic.
-*/
-function expandAliasChain(lookup, start, pathPrefix) {
-	let current = start;
-	let path = pathPrefix;
-	while (current.kind === "alias") {
-		const next = resolveDefaultBinding(lookup, current.targetToken, path);
-		if (next === void 0) return current;
-		const label = registryKeyLabel(current.targetToken);
-		path = [...path, label];
-		current = next;
-	}
-	return current;
-}
-/**
-* Lists the direct static dependencies of `consumer` by inspecting binding metadata.
-*
-* - `constant` / `dynamic` / `async-dynamic` — no enumerable deps (empty array).
-* - `alias` — single dependency on the alias target (chased through alias chains).
-* - `resolved` — one dependency per entry in `dependencyTokens`; a missing binding
-*   always throws {@link InternalError} (there is no optional concept for `resolved`).
-* - `class` — one dependency per `@injectable()` constructor parameter
-*   (requires a {@link MetadataReader}). Parameters marked `optional` whose token
-*   has no binding are silently skipped; non-optional missing tokens throw
-*   {@link InternalError}.
-*/
-function listResolvedDependencies(consumer, lookup, reader, pathPrefix) {
-	switch (consumer.kind) {
-		case "constant":
-		case "dynamic":
-		case "async-dynamic": return [];
-		case "alias": {
-			const binding = resolveDefaultBinding(lookup, consumer.targetToken, pathPrefix);
-			if (binding === void 0) return [];
-			const label = registryKeyLabel(consumer.targetToken);
-			const nextPath = [...pathPrefix, label];
-			return [{
-				binding: expandAliasChain(lookup, binding, nextPath),
-				path: nextPath,
-				injectHintLabel: void 0
-			}];
-		}
-		case "resolved": return consumer.dependencyTokens.map((tok) => {
-			const label = registryKeyLabel(tok);
-			const nextPath = [...pathPrefix, label];
-			const binding = resolveDefaultBinding(lookup, tok, pathPrefix);
-			if (binding === void 0) throw new InternalError(`Missing binding for dependency "${label}" while building dependency graph (resolution path: ${nextPath.join(" -> ")})`);
-			return {
-				binding: expandAliasChain(lookup, binding, nextPath),
-				path: nextPath,
-				injectHintLabel: void 0
-			};
-		});
-		case "class": {
-			if (reader === void 0) return [];
-			const meta = reader.getConstructorMetadata(consumer.implementationClass);
-			if (meta === void 0 || meta.params.length === 0) return [];
-			return meta.params.flatMap((param) => {
-				const tok = param.token;
-				const label = registryKeyLabel(tok);
-				const nextPath = [...pathPrefix, label];
-				const paramHint = param.name !== void 0 ? { name: param.name } : param.tag !== void 0 ? { tag: param.tag } : void 0;
-				if (param.all === true) {
-					const bindings = lookup(tok);
-					if (bindings === void 0 || bindings.length === 0) return [];
-					const candidates = filterMatchingBindings(bindings, paramHint, void 0);
-					if (candidates.length === 0) return [];
-					return candidates.map((binding) => {
-						return {
-							binding: expandAliasChain(lookup, binding, nextPath),
-							path: nextPath,
-							injectHintLabel: injectHintLabelFromResolveHint(paramHint)
-						};
+function buildDependencyGraph(registry, metadataReader, options, parentRegistry) {
+	const nodes = [];
+	const edges = [];
+	const includesParent = options?.includeParent === true;
+	const addBindings = (reg, fromParent) => {
+		for (const binding of reg.allBindings()) {
+			const scope = effectiveBindingScope(binding);
+			nodes.push({
+				id: binding.id,
+				tokenName: tokenName(binding.token),
+				kind: binding.kind,
+				scope,
+				fromParent
+			});
+			if (binding.kind === "class") {
+				const meta = metadataReader.getConstructorMetadata(binding.target);
+				if (meta !== void 0) meta.params.forEach((param, idx) => {
+					const depBinding = reg.getAll(param.token)[0];
+					if (depBinding !== void 0) edges.push({
+						from: binding.id,
+						to: depBinding.id,
+						label: `[${idx}]`
+					});
+				});
+			} else if (binding.kind === "resolved" || binding.kind === "resolved-async") binding.deps.forEach((dep, idx) => {
+				const depBindings = reg.getAll(dep.token);
+				if (depBindings.length > 0 && depBindings[0] !== void 0) {
+					const label = dep.name !== void 0 ? `name:${dep.name}` : dep.tags !== void 0 && dep.tags.length > 0 ? `tag:${dep.tags[0]?.[0]}=${String(dep.tags[0]?.[1])}` : `[${idx}]`;
+					edges.push({
+						from: binding.id,
+						to: depBindings[0].id,
+						label
 					});
 				}
-				const binding = resolveDefaultBinding(lookup, tok, pathPrefix);
-				if (binding === void 0) {
-					if (param.optional) return [];
-					throw new InternalError(`Missing binding for constructor parameter "${label}" while building dependency graph (resolution path: ${nextPath.join(" -> ")})`);
-				}
-				return [{
-					binding: expandAliasChain(lookup, binding, nextPath),
-					path: nextPath,
-					injectHintLabel: injectHintLabelFromResolveHint(paramHint)
-				}];
 			});
+			else if (binding.kind === "alias") {
+				const targetBindings = reg.getAll(binding.target);
+				if (targetBindings.length > 0 && targetBindings[0] !== void 0) edges.push({
+					from: binding.id,
+					to: targetBindings[0].id,
+					label: "alias"
+				});
+			}
 		}
-		default: return consumer;
-	}
-}
-/**
-* Flattens the direct dependencies of `consumer` into typed graph edges.
-* Used by {@link ContainerInspector} to build DOT and JSON outputs.
-*/
-function collectStaticDependencyEdges(consumer, lookup, reader, pathPrefix) {
-	const deps = listResolvedDependencies(consumer, lookup, reader, pathPrefix);
-	const isAliasEdge = consumer.kind === "alias";
-	return deps.map((dep) => ({
-		fromBindingId: consumer.id,
-		toBindingId: dep.binding.id,
-		resolutionPath: dep.path,
-		edgeKind: edgeKindFor(consumer, dep.binding),
-		toBindingConditional: dep.binding.constraint !== void 0,
-		injectHintLabel: dep.injectHintLabel,
-		isAliasEdge
-	}));
+	};
+	addBindings(registry, false);
+	if (includesParent && parentRegistry !== void 0) addBindings(parentRegistry, true);
+	return {
+		nodes,
+		edges,
+		includesParent
+	};
 }
 //#endregion
-export { collectStaticDependencyEdges, injectHintLabelFromResolveHint, listResolvedDependencies };
+export { buildDependencyGraph };

package/dist/environment.d.mts

@@ -1,14 +1,40 @@
+import { Constructor } from "./constructor-type.mjs";
+import { Token } from "./token.mjs";
+import { BindingIdentifier, BindingKind, BindingScope, ConstraintContext, MaterializationFrame, ResolutionContext, ResolveOptions } from "./types.mjs";
+import { Container } from "./container.mjs";
+
 //#region src/environment.d.ts
-/**
- * Node-style production gate using `process.env.NODE_ENV`.
- * When `process` is unavailable, this returns false (not treated as production).
- */
-declare function isProductionEnvironment(): boolean;
-/**
- * True when not in production: `development`, `test`, unset `NODE_ENV`, or any value other than `"production"`.
- * The container uses this to run one-time static scope validation after load/resolve so graph issues surface
- * during local work and CI tests (e.g. Vitest).
- */
-declare function isDevelopmentOrTestEnvironment(): boolean;
+declare function runWithContainer<Result>(container: Container, fn: () => Result): Result;
+declare function getActiveContainer(): Container | undefined;
+interface ResolverCallbacks {
+  resolveFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: string[], stack: MaterializationFrame[]): Value;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value;
+  resolveAsyncFromContext<const Value>(token: Token<Value> | Constructor<Value>, path: string[], stack: MaterializationFrame[]): Promise<Value>;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Value[];
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint: ResolveOptions | undefined, path: string[], stack: MaterializationFrame[]): Promise<Value[]>;
+}
+declare class DefaultResolutionContext implements ResolutionContext {
+  private _resolver;
+  private _resolutionPath;
+  private _materializationStack;
+  private _currentHint;
+  constructor(resolver: ResolverCallbacks, resolutionPath: string[], materializationStack: MaterializationFrame[], currentHint: ResolveOptions | undefined);
+  private _graph;
+  get graph(): ConstraintContext;
+  reset(resolver: ResolverCallbacks, resolutionPath: string[], materializationStack: MaterializationFrame[], currentHint: ResolveOptions | undefined): void;
+  resolve<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value;
+  resolveAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value>;
+  resolveOptional<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value | undefined;
+  resolveOptionalAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value | undefined>;
+  resolveAll<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Value[];
+  resolveAllAsync<const Value>(token: Token<Value> | Constructor<Value>, hint?: ResolveOptions): Promise<Value[]>;
+}
+declare function buildMaterializationFrame(tokenName: string, scope: BindingScope, bindingId: BindingIdentifier, kind: BindingKind, slot: {
+  name: string | undefined;
+  tags: ReadonlyArray<readonly [string, unknown]>;
+}): MaterializationFrame;
 //#endregion
-export { isDevelopmentOrTestEnvironment, isProductionEnvironment };
+export { DefaultResolutionContext, ResolverCallbacks, buildMaterializationFrame, getActiveContainer, runWithContainer };

package/dist/environment.mjs

@@ -1,20 +1,86 @@
 //#region src/environment.ts
-/**
-* Node-style production gate using `process.env.NODE_ENV`.
-* When `process` is unavailable, this returns false (not treated as production).
-*/
-function isProductionEnvironment() {
-	const processRef = globalThis.process;
-	if (processRef === void 0 || processRef === null) return false;
-	return processRef.env.NODE_ENV === "production";
+let _activeContainer;
+function runWithContainer(container, fn) {
+	const prev = _activeContainer;
+	_activeContainer = container;
+	try {
+		return fn();
+	} finally {
+		_activeContainer = prev;
+	}
 }
-/**
-* True when not in production: `development`, `test`, unset `NODE_ENV`, or any value other than `"production"`.
-* The container uses this to run one-time static scope validation after load/resolve so graph issues surface
-* during local work and CI tests (e.g. Vitest).
-*/
-function isDevelopmentOrTestEnvironment() {
-	return !isProductionEnvironment();
+function getActiveContainer() {
+	return _activeContainer;
+}
+var DefaultResolutionContext = class {
+	_resolver;
+	_resolutionPath;
+	_materializationStack;
+	_currentHint;
+	constructor(resolver, resolutionPath, materializationStack, currentHint) {
+		this._resolver = resolver;
+		this._resolutionPath = resolutionPath;
+		this._materializationStack = materializationStack;
+		this._currentHint = currentHint;
+	}
+	_graph;
+	get graph() {
+		if (this._graph === void 0) this._graph = new DefaultConstraintContext(this._resolutionPath, this._materializationStack, this._currentHint);
+		return this._graph;
+	}
+	reset(resolver, resolutionPath, materializationStack, currentHint) {
+		this._resolver = resolver;
+		this._resolutionPath = resolutionPath;
+		this._materializationStack = materializationStack;
+		this._currentHint = currentHint;
+		this._graph = void 0;
+	}
+	resolve(token, hint) {
+		if (hint === void 0) return this._resolver.resolveFromContext(token, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolve(token, hint, this._resolutionPath, this._materializationStack);
+	}
+	resolveAsync(token, hint) {
+		if (hint === void 0) return this._resolver.resolveAsyncFromContext(token, this._resolutionPath, this._materializationStack);
+		return this._resolver.resolveAsync(token, hint, this._resolutionPath, this._materializationStack);
+	}
+	resolveOptional(token, hint) {
+		return this._resolver.resolveOptional(token, hint, this._resolutionPath, this._materializationStack);
+	}
+	resolveOptionalAsync(token, hint) {
+		return this._resolver.resolveOptionalAsync(token, hint, this._resolutionPath, this._materializationStack);
+	}
+	resolveAll(token, hint) {
+		return this._resolver.resolveAll(token, hint, this._resolutionPath, this._materializationStack);
+	}
+	resolveAllAsync(token, hint) {
+		return this._resolver.resolveAllAsync(token, hint, this._resolutionPath, this._materializationStack);
+	}
+};
+var DefaultConstraintContext = class {
+	resolutionPath;
+	materializationStack;
+	parent;
+	currentResolveHint;
+	constructor(resolutionPath, materializationStack, currentResolveHint) {
+		this.resolutionPath = resolutionPath;
+		this.materializationStack = materializationStack;
+		this.parent = materializationStack.at(-1);
+		this.currentResolveHint = currentResolveHint;
+	}
+	_ancestors;
+	get ancestors() {
+		if (this._ancestors === void 0) this._ancestors = this.materializationStack.length > 1 ? this.materializationStack.slice(0, -1) : [];
+		return this._ancestors;
+	}
+};
+function buildMaterializationFrame(tokenName, scope, bindingId, kind, slot) {
+	return {
+		tokenName,
+		scope,
+		bindingId,
+		kind,
+		slot
+	};
 }
 //#endregion
-export { isDevelopmentOrTestEnvironment, isProductionEnvironment };
+export { DefaultResolutionContext, buildMaterializationFrame, getActiveContainer, runWithContainer };