@nexus-ioc/core 0.6.2 → 0.7.0

package/dist/esm/core/resolver/resolver.js

@@ -1,160 +1,584 @@
-import { EdgeTypeEnum, Scope, } from "../../interfaces/index.js";
+import { CircularInjectionError } from "../../errors/injection-errors.js";
+import { AsyncFactoryError, ContainerClosedError, ProviderNotFoundError, ProviderNotInstantiatedError, ProviderUnloadedError, } from "../../errors/provider-errors.js";
+import { EdgeTypeEnum, NodeTypeEnum, Scope, } from "../../interfaces/index.js";
 import { isClassProvider, isFactoryProvider, isValueProvider, } from "../../utils/helpers.js";
+import { withInjectionContext, } from "../injection/injection-context.js";
 import { ProvidersContainer } from "./providers-container.js";
+import { ResolutionContext } from "./resolution-context.js";
 function isCircularDependencyFn(fn) {
     // @ts-expect-error
     return !!(typeof fn === "function" && fn.dependencyName);
 }
+function isThenable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value.then === "function");
+}
 export class Resolver {
-    constructor(graph) {
+    /**
+     * @param link - The parent chain of a child container. Edges marked
+     *   `external` resolve through it; their results are never cached here.
+     */
+    constructor(graph, link = null) {
         this.graph = graph;
+        this.link = link;
         this.providersContainer = new ProvidersContainer();
+        this.initializationOrder = [];
+        /** `lateBoundVisible` results, valid while the graph version matches. */
+        this.lateBoundMemo = new WeakMap();
+        /**
+         * Singletons created by inject() whose onModuleInit (or the wait on
+         * inits queued before them) has not settled yet. Other resolution trees
+         * that hit such a cached singleton wait on this promise, so they never
+         * see it half-initialised or keep it after a failed init evicted it.
+         */
+        this.inFlightInits = new Map();
+        /**
+         * Singletons that resolveProvider is creating (construction through
+         * onModuleInit), not yet in the cache. Concurrent callers await the same
+         * promise, so each singleton is created once. An entry is removed when
+         * its creation settles: after the commit on success, so a token is always
+         * in the cache or here; on failure, so the next resolve retries.
+         */
+        this.inFlightCreations = new Map();
+        /**
+         * Set once close() starts. From then on nothing new is created or
+         * cached: creations still in flight are destroyed when they finish
+         * (close() does not wait for them, see commitCreation), and inject()
+         * in a resolution tree that outlived close() throws instead of creating.
+         */
+        this.closed = false;
+    }
+    /**
+     * The link that satisfies an external edge. The graph marks an edge
+     * external only when a link can provide its target, so a missing link
+     * is an internal error, reported as not found rather than `undefined`.
+     */
+    linkFor(edge) {
+        if (!this.link) {
+            throw new ProviderNotFoundError(edge.target, edge.source);
+        }
+        return this.link;
+    }
+    /** Cached singleton lookup; never creates. Uses has() so falsy values count. */
+    getInstantiated(token) {
+        // A singleton inject() created is cached before its async init settles;
+        // like the async path, it counts as instantiated only after the init.
+        if (!this.providersContainer.has(token) || this.inFlightInits.has(token)) {
+            return { found: false };
+        }
+        return { found: true, instance: this.providersContainer.get(token) };
+    }
+    /**
+     * Marks the resolver closed without destroying anything; used when the
+     * container was closed before this resolver existed.
+     */
+    markClosed() {
+        this.closed = true;
+        // Every creation still in flight is now stale (see commitCreation).
+        this.inFlightCreations.clear();
+    }
+    async close() {
+        // Before the first await: a creation that finishes while the hooks
+        // below run must not be cached behind the destroy pass.
+        this.markClosed();
+        const errors = [];
+        for (const token of [...this.initializationOrder].reverse()) {
+            const instance = this.providersContainer.get(token);
+            if (instance?.onModuleDestroy) {
+                try {
+                    await instance.onModuleDestroy();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+        }
+        this.providersContainer.clear();
+        this.initializationOrder.length = 0;
+        this.inFlightInits.clear();
+        this.inFlightCreations.clear();
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "One or more onModuleDestroy hooks failed");
+        }
+    }
+    /**
+     * Destroys exactly the given singletons: `onModuleDestroy` in reverse
+     * initialization order, then removed from the cache and from
+     * `initializationOrder`. A token that was never instantiated (never
+     * resolved, or `Transient`/non-singleton scope) is silently skipped.
+     * Like `close()`, every hook runs even if some throw, the cleanup always
+     * completes, and the failures are thrown afterwards as one
+     * `AggregateError`.
+     */
+    async destroy(tokens) {
+        const dead = new Set(tokens);
+        // Before the first await: a creation of a dead token still in flight
+        // is stale from now on and is destroyed, not cached, when it finishes.
+        for (const token of dead) {
+            this.inFlightInits.delete(token);
+            this.inFlightCreations.delete(token);
+        }
+        const orderedDead = this.initializationOrder.filter((token) => dead.has(token));
+        const errors = [];
+        for (const token of [...orderedDead].reverse()) {
+            const instance = this.providersContainer.get(token);
+            if (instance?.onModuleDestroy) {
+                try {
+                    await instance.onModuleDestroy();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            this.providersContainer.delete(token);
+        }
+        const survivors = this.initializationOrder.filter((token) => !dead.has(token));
+        this.initializationOrder.length = 0;
+        this.initializationOrder.push(...survivors);
+        if (errors.length > 0) {
+            throw new AggregateError(errors, "One or more onModuleDestroy hooks failed");
+        }
     }
-    async resolveProvider(token, resolveCache = new ProvidersContainer(), isCircularDependency = false) {
+    async resolveProvider(token, ctx = new ResolutionContext(), isCircularDependency = false) {
+        if (this.closed) {
+            throw new ContainerClosedError();
+        }
         const node = this.graph.getNode(token);
         if (!node) {
             return undefined;
         }
+        // Module and LAZY placeholder nodes share the token space with providers
+        // but carry no instance, so they resolve to undefined instead of failing.
+        if (node.type !== NodeTypeEnum.PROVIDER) {
+            return undefined;
+        }
         // Get the scope of the provider
         const scope = node.scope;
         // For Transient scope, always create a new instance (no caching at all)
         if (scope === Scope.Transient) {
-            const [instance] = await this.createInstance(node, resolveCache, isCircularDependency);
-            return instance;
+            return (await this.createInstance(node, ctx, isCircularDependency));
         }
         // For Singleton scope, check global cache first
         if (scope === Scope.Singleton && this.providersContainer.has(token)) {
-            return this.providersContainer.get(token);
+            const cached = this.providersContainer.get(token);
+            const inFlight = this.inFlightInits.get(token);
+            if (inFlight) {
+                // Created by inject() in another tree; its init is still running.
+                // On failure it was evicted, so the error propagates.
+                await inFlight;
+            }
+            return cached;
+        }
+        const inFlight = this.inFlightCreations.get(token);
+        if (inFlight) {
+            // Defensive: this tree is creating the token itself, so awaiting its
+            // own creation would never settle. Static cycles are marked circular
+            // by the graph and never get here.
+            if (ctx.isConstructing(token)) {
+                throw new CircularInjectionError([...ctx.path, token]);
+            }
+            return (await inFlight);
         }
-        // For Request and Singleton scopes, check resolve cache (within current resolution tree)
-        if (resolveCache.has(token)) {
-            return resolveCache.get(token);
+        const creation = this.createInstance(node, ctx, isCircularDependency).then((instance) => this.commitCreation(node, creation, instance));
+        this.inFlightCreations.set(token, creation);
+        const clear = () => {
+            // close()/destroy() may have dropped it, or a retry replaced it.
+            if (this.inFlightCreations.get(token) === creation) {
+                this.inFlightCreations.delete(token);
+            }
+        };
+        creation.then(clear, clear);
+        return (await creation);
+    }
+    /**
+     * Caches what `creation` produced, unless the creation went stale while
+     * it ran: close() or destroy() (an unload) dropped its in-flight entry.
+     * A stale instance is never cached. Its onModuleDestroy is called (best
+     * effort: a failure there is ignored, since the caller already gets the
+     * rejection below and nothing else holds the instance), and the caller
+     * gets ContainerClosedError after a close, ProviderUnloadedError after
+     * an unload.
+     */
+    async commitCreation(node, creation, instance) {
+        if (this.inFlightCreations.get(node.id) === creation) {
+            this.commitInstance(node, instance);
+            return instance;
         }
-        const [instance, saveInCache] = await this.createInstance(node, resolveCache, isCircularDependency);
-        // Add to resolve cache for current resolution context (for Request and Singleton)
-        // This ensures same instance is used within a single dependency resolution tree
-        if (scope === Scope.Singleton || scope === Scope.Request) {
-            resolveCache.set(token, instance);
+        const stale = instance;
+        try {
+            await stale?.onModuleDestroy?.();
         }
-        // Only save to global cache for Singleton scope
-        if (saveInCache) {
-            this.providersContainer.set(token, instance);
+        catch {
+            // Best effort; see above.
+        }
+        throw this.closed
+            ? new ContainerClosedError()
+            : new ProviderUnloadedError(node.id);
+    }
+    /**
+     * Caching rules shared by the async and sync paths: Singletons go into the
+     * global cache and the destroy order. Nothing else is cached.
+     */
+    commitInstance(node, instance) {
+        if (node.scope !== Scope.Singleton) {
+            return;
+        }
+        // First writer wins if concurrent creations race for the same token.
+        if (!this.providersContainer.has(node.id)) {
+            this.providersContainer.set(node.id, instance);
+            this.initializationOrder.push(node.id);
+        }
+    }
+    /** Undoes commitInstance for `instance`, if it is still the cached one. */
+    evictInstance(node, instance) {
+        const token = node.id;
+        if (this.providersContainer.has(token) &&
+            this.providersContainer.get(token) === instance) {
+            this.providersContainer.delete(token);
+            const index = this.initializationOrder.lastIndexOf(token);
+            if (index !== -1) {
+                this.initializationOrder.splice(index, 1);
+            }
+        }
+    }
+    async createInstance(node, ctx, isCircularDependency = false) {
+        ctx.enter(node.id);
+        try {
+            return await this.createInstanceInContext(node, ctx, isCircularDependency);
+        }
+        finally {
+            ctx.leave(node.id);
         }
-        return instance;
     }
-    async createInstance(node, resolveCache, isCircularDependency = false) {
+    async createInstanceInContext(node, ctx, isCircularDependency) {
         const provider = node.metatype;
-        const dependencies = this.graph
-            .getEdge(node.id)
-            .filter((edge) => edge.type === EdgeTypeEnum.DEPENDENCY &&
-            edge.metadata.inject === "constructor" &&
-            edge.metadata.unreached === false)
-            .map((edge) => {
+        const dependencyEdges = this.constructorEdges(node).filter((edge) => edge.metadata.unreached === false);
+        const resolvedDependencies = [];
+        for (const edge of dependencyEdges) {
+            // An external target lives in the parent chain. Branch before any
+            // local lookup: the child graph may have no node for it (which would
+            // read as undefined) or a hidden one the requester must not get.
+            if (edge.metadata.external) {
+                resolvedDependencies.push(await this.linkFor(edge).resolve(edge.target));
+                continue;
+            }
+            if (edge.metadata.lateBound && !this.lateBoundVisible(edge, node)) {
+                resolvedDependencies.push(undefined);
+                continue;
+            }
             if (edge.metadata.isCircular) {
-                const circularResolver = () => new Proxy({}, {
-                    get: (_, prop) => {
-                        const instance = resolveCache.get(edge.target);
-                        return instance?.[prop];
-                    },
-                });
-                circularResolver.dependencyName = edge.target;
-                return circularResolver;
-            }
-            return edge.target;
-        });
-        const depsChunks = dependencies.reduce((prev, depToken) => {
-            if (isCircularDependencyFn(depToken)) {
-                prev[0].push(depToken);
-                prev[1].push(null);
-                return prev;
-            }
-            prev[0].push(null);
-            prev[1].push(depToken);
-            return prev;
-        }, [[], []]);
-        // biome-ignore lint/suspicious/noExplicitAny: dependency resolution
-        let resolvedDependencies = [];
-        for (const depToken of dependencies) {
-            if (isCircularDependencyFn(depToken)) {
-                if (isCircularDependency) {
-                    resolvedDependencies.push(depToken);
+                // A circular target that another tree is creating gets the proxy
+                // too: awaiting it could deadlock, since that tree may be waiting
+                // on this one through the same cycle.
+                if (isCircularDependency ||
+                    (this.inFlightCreations.has(edge.target) &&
+                        !this.providersContainer.has(edge.target))) {
+                    const circularResolver = () => new Proxy({}, {
+                        get: (_, prop) => {
+                            const instance = this.providersContainer.get(edge.target);
+                            return instance?.[prop];
+                        },
+                    });
+                    circularResolver.dependencyName = edge.target;
+                    resolvedDependencies.push(circularResolver);
                     continue;
                 }
-                const instance = await this.resolveProvider(
-                // @ts-expect-error
-                depToken.dependencyName, resolveCache, true);
-                resolvedDependencies.push(instance);
+                resolvedDependencies.push(await this.resolveProvider(edge.target, ctx, true));
                 continue;
             }
-            const instance = await this.resolveProvider(depToken, resolveCache);
-            resolvedDependencies.push(instance);
+            resolvedDependencies.push(await this.resolveProvider(edge.target, ctx));
         }
-        resolvedDependencies = resolvedDependencies.map((dependency, index) => {
-            if (depsChunks[0]?.[index]) {
-                return depsChunks[0]?.[index];
-            }
-            return dependency;
-        });
+        const deps = resolvedDependencies.map((dep) => isCircularDependencyFn(dep)
+            ? dep()
+            : dep);
         // biome-ignore lint/suspicious/noExplicitAny: instance creation
         let instance;
-        let saveInCache = true;
-        const deps = resolvedDependencies.map((depToken) => isCircularDependencyFn(depToken) ? depToken() : depToken);
+        const injectionContext = this.contextFor(node, ctx);
         if (isClassProvider(provider)) {
-            instance = new provider.useClass(...deps);
-            await this.injectPropertyDependencies(instance, node, resolveCache);
-            // Determine caching strategy based on scope
-            const scope = node.scope;
-            saveInCache = scope === Scope.Singleton;
+            instance = withInjectionContext(injectionContext, () => new provider.useClass(...deps));
+            await this.injectPropertyDependencies(instance, node, ctx);
         }
         else if (isValueProvider(provider)) {
             instance = provider.useValue;
-            // Value providers are always singleton
-            saveInCache = true;
         }
         else if (isFactoryProvider(provider)) {
-            instance = await provider.useFactory(...deps);
-            // Check scope for factory providers
-            const scope = node.scope;
-            saveInCache = scope === Scope.Singleton;
+            instance = this.callFactory(node, provider, deps, injectionContext);
         }
         else {
-            instance = new provider(...deps);
-            await this.injectPropertyDependencies(instance, node, resolveCache);
-            // Check scope for function providers
-            const scope = node.scope;
-            saveInCache = scope === Scope.Singleton;
+            instance = withInjectionContext(injectionContext, () => new provider(...deps));
+            await this.injectPropertyDependencies(instance, node, ctx);
         }
-        // Call lifecycle hook with error handling
+        // onModuleInit of providers created via inject() must finish before
+        // this instance's own onModuleInit runs.
+        await ctx.drainPendingInits();
         if (instance?.onModuleInit) {
             try {
                 await instance.onModuleInit();
             }
             catch (error) {
-                // Re-throw with additional context about which provider failed
-                const providerName = typeof provider === "function"
-                    ? provider.name
-                    : provider.provide?.toString() ||
-                        "Unknown";
-                const errorMessage = `Failed to initialize provider "${providerName}": ${error instanceof Error ? error.message : String(error)}`;
-                const wrappedError = new Error(errorMessage);
-                // Preserve original error stack if available
-                if (error instanceof Error && error.stack) {
-                    wrappedError.stack = `${wrappedError.stack}\nCaused by: ${error.stack}`;
-                }
-                throw wrappedError;
+                throw this.wrapInitError(provider, error);
+            }
+        }
+        return instance;
+    }
+    /**
+     * inject() entry point: resolves `token` synchronously for `requester`.
+     * The token must be visible from the requester's module, the same rule
+     * as `@Inject`.
+     */
+    resolveSync(token, ctx, requester, options) {
+        const node = this.graph.getNode(token);
+        const visible = node?.type === NodeTypeEnum.PROVIDER &&
+            this.graph.isProviderVisible(requester.moduleContainer, token);
+        if (!visible) {
+            // Not visible locally: the parent chain may provide it. `link.get`
+            // returns only an existing parent singleton (never creates one) and
+            // throws for a parent Transient, a not-yet-created singleton or a
+            // closed parent, even with `optional`. The dependency crosses
+            // containers, so no runtime edge is recorded and nothing is cached.
+            if (this.link?.canProvide(token)) {
+                return this.link.get(token);
+            }
+            if (options.optional) {
+                return undefined;
+            }
+            throw new ProviderNotFoundError(token, requester.id);
+        }
+        const instance = this.resolveProviderSync(node, ctx);
+        // Idempotent; covers cached and freshly created instances alike.
+        this.graph.addRuntimeDependency(requester.id, node.id);
+        return instance;
+    }
+    /**
+     * Synchronous counterpart of resolveProvider for a provider node whose
+     * reachability was already established (visibility check or graph edge).
+     */
+    resolveProviderSync(node, ctx) {
+        const token = node.id;
+        if (ctx.isConstructing(token)) {
+            throw new CircularInjectionError([...ctx.path, token]);
+        }
+        if (node.scope === Scope.Singleton && this.providersContainer.has(token)) {
+            const inFlight = this.inFlightInits.get(token);
+            if (inFlight) {
+                // The requester's own init and eviction chain wait on it.
+                ctx.addPendingInit(inFlight);
+            }
+            return this.providersContainer.get(token);
+        }
+        if (node.scope === Scope.Singleton && this.inFlightCreations.has(token)) {
+            // resolveProvider is creating it in another tree. This path is
+            // synchronous and cannot wait, and creating it here would make a
+            // second instance.
+            throw new ProviderNotInstantiatedError(token, "creation-in-flight");
+        }
+        return this.createInstanceSync(node, ctx);
+    }
+    /** Resolves a static @Inject edge of `requester` on the synchronous path. */
+    resolveEdgeSync(edge, requester, ctx) {
+        // External first, before any node lookup (see createInstanceInContext).
+        if (edge.metadata.external) {
+            return this.linkFor(edge).get(edge.target);
+        }
+        if (edge.metadata.isCircular) {
+            throw new CircularInjectionError([...ctx.path, edge.target]);
+        }
+        // Unreached edges resolve to undefined, as on the async path. Reached
+        // edges were checked by the graph, so there is no second visibility
+        // check, except for a late-bound one (see lateBoundVisible); a missing
+        // (@Optional) node resolves to undefined.
+        if (edge.metadata.unreached) {
+            return undefined;
+        }
+        if (edge.metadata.lateBound && !this.lateBoundVisible(edge, requester)) {
+            return undefined;
+        }
+        const target = this.graph.getNode(edge.target);
+        if (!target || target.type !== NodeTypeEnum.PROVIDER) {
+            return undefined;
+        }
+        return this.resolveProviderSync(target, ctx);
+    }
+    /**
+     * Synchronous mirror of createInstance + resolveProvider caching, used
+     * when inject() reaches a provider that does not exist yet.
+     */
+    createInstanceSync(node, ctx) {
+        // A resolution tree that outlived close() (it was awaiting something
+        // when close() ran) must not create and cache anything: the destroy
+        // pass is over. Refused before construction, so there is nothing to
+        // destroy. No unload counterpart is needed: this path always reads
+        // the live graph, so it never creates an instance of an unloaded node.
+        if (this.closed) {
+            throw new ContainerClosedError();
+        }
+        ctx.enter(node.id);
+        try {
+            const provider = node.metatype;
+            const deps = this.constructorEdges(node).map((edge) => this.resolveEdgeSync(edge, node, ctx));
+            const injectionContext = this.contextFor(node, ctx);
+            // biome-ignore lint/suspicious/noExplicitAny: instance creation
+            let instance;
+            if (isValueProvider(provider)) {
+                instance = provider.useValue;
+            }
+            else if (isFactoryProvider(provider)) {
+                instance = this.callFactory(node, provider, deps, injectionContext);
+            }
+            else {
+                const Class = isClassProvider(provider)
+                    ? provider.useClass
+                    : provider;
+                instance = withInjectionContext(injectionContext, () => new Class(...deps));
+                this.injectPropertyDependenciesSync(instance, node, ctx);
+            }
+            // onModuleInit is not part of creation: it runs with no injection
+            // context, so inject() there throws InjectionContextError.
+            const runInit = () => withInjectionContext(null, () => this.callInitSync(provider, instance));
+            // Conservatively wait on every init queued before this instance (it
+            // may hold some of those instances, created here or via cache hits),
+            // even without its own onModuleInit, so a failure there evicts this
+            // instance too. No deadlock: each entry only waits on earlier ones.
+            const earlier = [...ctx.pendingInits];
+            let pendingInit;
+            if (earlier.length > 0) {
+                const afterEarlier = Promise.all(earlier);
+                pendingInit = instance?.onModuleInit
+                    ? afterEarlier.then(runInit)
+                    : afterEarlier;
             }
+            else if (instance?.onModuleInit) {
+                pendingInit = runInit();
+            }
+            this.commitInstance(node, instance);
+            if (pendingInit) {
+                // A failed init (own or earlier) must not leave a broken cached
+                // instance. The eviction is chained here, not in a drain, so it
+                // also happens when the requester's constructor throws later.
+                const settled = pendingInit.catch((error) => {
+                    this.evictInstance(node, instance);
+                    throw error;
+                });
+                ctx.addPendingInit(settled);
+                this.trackInFlightInit(node.id, instance, settled);
+            }
+            return instance;
+        }
+        finally {
+            ctx.leave(node.id);
+        }
+    }
+    /** Runs a factory; factories must be synchronous. */
+    callFactory(node, provider, deps, injectionContext) {
+        const result = withInjectionContext(injectionContext, () => provider.useFactory(...deps));
+        if (isThenable(result)) {
+            // Never leave a rejected promise unhandled. A foreign thenable's
+            // then() is user code with unknown effects, so it is not called.
+            if (result instanceof Promise) {
+                result.catch(() => { });
+            }
+            throw new AsyncFactoryError(node.id);
+        }
+        return result;
+    }
+    /** Registers `init` as the in-flight init of a just-committed singleton. */
+    trackInFlightInit(token, instance, init) {
+        if (!this.providersContainer.has(token) ||
+            this.providersContainer.get(token) !== instance) {
+            return; // not the global singleton (lost a race)
+        }
+        this.inFlightInits.set(token, init);
+        const clear = () => {
+            if (this.inFlightInits.get(token) === init) {
+                this.inFlightInits.delete(token);
+            }
+        };
+        init.then(clear, clear);
+    }
+    /**
+     * Calls onModuleInit synchronously. A synchronous throw is wrapped and
+     * rethrown; an async result is returned with its rejection wrapped.
+     */
+    callInitSync(provider, instance) {
+        let result;
+        try {
+            result = instance.onModuleInit();
         }
-        return [instance, saveInCache];
+        catch (error) {
+            throw this.wrapInitError(provider, error);
+        }
+        if (isThenable(result)) {
+            return Promise.resolve(result).catch((error) => {
+                throw this.wrapInitError(provider, error);
+            });
+        }
+        return undefined;
+    }
+    wrapInitError(provider, error) {
+        const providerName = typeof provider === "function"
+            ? provider.name
+            : (provider.provide?.toString() ??
+                "Unknown");
+        const errorMessage = `Failed to initialize provider "${providerName}": ${error instanceof Error ? error.message : String(error)}`;
+        const wrappedError = new Error(errorMessage);
+        // Assigned rather than passed as ErrorOptions: the build targets ES2021.
+        wrappedError.cause = error;
+        if (error instanceof Error && error.stack) {
+            wrappedError.stack = `${wrappedError.stack}\nCaused by: ${error.stack}`;
+        }
+        return wrappedError;
+    }
+    contextFor(node, ctx) {
+        return {
+            inject: (token, options) => this.resolveSync(token, ctx, node, options),
+        };
+    }
+    /**
+     * Whether a late-bound edge's target may be injected into `requester`:
+     * it exists now and is visible from the requester's module. The graph
+     * records the referrer (keeping the target's module alive) under the
+     * same rule, so injection and unload bookkeeping agree.
+     */
+    lateBoundVisible(edge, requester) {
+        const version = this.graph.version;
+        const memo = this.lateBoundMemo.get(edge);
+        if (memo?.version === version) {
+            return memo.visible;
+        }
+        const visible = this.graph.getNode(edge.target)?.type === NodeTypeEnum.PROVIDER &&
+            this.graph.isProviderVisible(requester.moduleContainer, edge.target);
+        this.lateBoundMemo.set(edge, { version, visible });
+        return visible;
     }
-    async injectPropertyDependencies(instance, node, resolveCache) {
-        const dependencies = this.graph
+    constructorEdges(node) {
+        return this.graph
+            .getEdge(node.id)
+            .filter((edge) => edge.type === EdgeTypeEnum.DEPENDENCY &&
+            edge.metadata.inject === "constructor");
+    }
+    propertyEdges(node) {
+        return this.graph
             .getEdge(node.id)
             .filter((edge) => edge.type === EdgeTypeEnum.DEPENDENCY &&
             edge.metadata.inject === "property" &&
             edge.metadata.unreached === false &&
             edge.metadata.isCircular === false);
-        for (const edge of dependencies) {
-            instance[edge.metadata.key] = await this.resolveProvider(edge.target, resolveCache);
+    }
+    injectPropertyDependenciesSync(instance, node, ctx) {
+        for (const edge of this.propertyEdges(node)) {
+            instance[edge.metadata.key] = this.resolveEdgeSync(edge, node, ctx);
+        }
+    }
+    async injectPropertyDependencies(instance, node, ctx) {
+        for (const edge of this.propertyEdges(node)) {
+            // External first, before resolveProvider's node lookup.
+            instance[edge.metadata.key] = edge.metadata.external
+                ? await this.linkFor(edge).resolve(edge.target)
+                : edge.metadata.lateBound &&
+                    !this.lateBoundVisible(edge, node)
+                    ? undefined
+                    : await this.resolveProvider(edge.target, ctx);
         }
     }
 }