@codefast/di 0.12.0 → 0.13.0

package/dist/resolution/resolver.js

@@ -9,7 +9,7 @@ import { ActivationNeedCache } from "#resolution/cache/activation-need";
 import { ClassIntrospector } from "#resolution/cache/class-introspector";
 import { BindingLookupCache } from "#resolution/cache/lookup";
 import { AsyncLevelContext, DefaultConstraintContext, DefaultResolutionContext } from "#resolution/context";
-import { branchDepthOf, buildResolutionFrame, cycleNamesOf, enterSyncPath, extendResolutionBranch, leaveSyncPath, ROOT_BRANCH, UNOWNED_BRANCH, } from "#resolution/path";
+import { branchDepthOf, buildResolutionFrame, cycleNamesOf, enterSyncPath, extendResolutionBranch, leaveSyncPath, missPathOf, ROOT_BRANCH, UNOWNED_BRANCH, } from "#resolution/path";
 import { InstantiationPlanCompiler, PLAN_RETRY } from "#resolution/plan/compiler";
 import { matchesSlot, selectAllBindings, selectBinding } from "#resolution/select/candidates";
 const EMPTY_FRAME_LIST = [];
@@ -252,10 +252,11 @@ export class DependencyResolver {
             // dominated by that capture. Bindings under the token anywhere in the chain mean the request
             // matched none of them, so a child reports the same miss its parent would.
             const bound = this.#allBindingsFromChain(currentToken);
+            const path = missPathOf(resolutionStack, token, visitedAliasTokens);
             if (bound.length > 0) {
-                throw new NoMatchingBindingError(tokenName(currentToken), options ?? {}, bound.map((binding) => bindingSlotToString(binding.slot)));
+                throw new NoMatchingBindingError(tokenName(currentToken), options ?? {}, bound.map((binding) => bindingSlotToString(binding.slot)), path);
             }
-            throw new TokenNotBoundError(tokenName(currentToken));
+            throw new TokenNotBoundError(tokenName(currentToken), path);
         }
         return found;
     }
@@ -295,6 +296,36 @@ export class DependencyResolver {
     peekCandidateBindingsForValidate(token, options) {
         return this.#candidateBindings(token, options, []);
     }
+    /**
+     * The error `resolve` raises for a request nothing selects, or `undefined` while a `when()` candidate leaves it open.
+     *
+     * @remarks A predicate reads the resolution path, which a static walk does not have, so a slot-matching candidate
+     * that carries one may still be selected when the request is really made.
+     */
+    missForValidate(token, options, path) {
+        const bound = this.#allBindingsFromChain(token);
+        if (bound.length === 0) {
+            return new TokenNotBoundError(tokenName(token), path);
+        }
+        for (const binding of bound) {
+            if (binding.predicate !== undefined && !binding.isMany && matchesSlot(binding.slot, options)) {
+                return undefined;
+            }
+        }
+        return new NoMatchingBindingError(tokenName(token), options ?? {}, bound.map((binding) => bindingSlotToString(binding.slot)), path);
+    }
+    /** The resolver whose chain a binding this one can see resolves its dependencies from, as a singleton does. */
+    ownerForValidate(binding) {
+        return this.#ownerOf(binding);
+    }
+    /** Deactivates a scoped instance of a binding this resolver owns, with its hooks and reader, when it owes a teardown. */
+    deactivateScoped(binding, instance) {
+        const lifecycle = this.#lifecycle;
+        const reader = this.#metadataReader;
+        return lifecycle.owesDeactivation(binding, reader)
+            ? lifecycle.runDeactivation(binding, instance, reader)
+            : undefined;
+    }
     // ── Sync resolve ───────────────────────────────────────────────────────────────────────────────────────────────────
     resolveFromContext(token, resolutionStack) {
         // Hot lane: own-registry fast default. Fall back to the chain-versioned memo
@@ -647,7 +678,7 @@ export class DependencyResolver {
                 this.#scope.setSingleton(binding, activated);
             }
             else if (scope === "scoped") {
-                this.#scope.setScoped(binding, activated);
+                this.#scope.setScoped(binding, activated, owner);
             }
             return activated;
         }
@@ -1117,13 +1148,13 @@ export class DependencyResolver {
             return activated;
         }
         if (isPending(activated)) {
-            return this.#publishInFlight(binding, activated, scope);
+            return this.#publishInFlight(binding, activated, scope, owner);
         }
         if (scope === "singleton") {
             this.#scope.setSingleton(binding, activated);
         }
         else {
-            this.#scope.setScoped(binding, activated);
+            this.#scope.setScoped(binding, activated, owner);
         }
         return activated;
     }
@@ -1131,13 +1162,13 @@ export class DependencyResolver {
      * Publishes a pending singleton or scoped materialisation so concurrent callers dedup onto it,
      * and caches what it settles to; the creator, like every joiner, is handed a promise of its own.
      */
-    #publishInFlight(binding, pending, scope) {
+    #publishInFlight(binding, pending, scope, owner) {
         const published = pending.then((activated) => {
             if (scope === "singleton") {
                 this.#scope.setSingleton(binding, activated);
             }
             else {
-                this.#scope.setScoped(binding, activated);
+                this.#scope.setScoped(binding, activated, owner);
             }
             this.#scope.clearInflight(binding.identifier);
             return activated;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codefast/di",
-  "version": "0.12.0",
-  "description": "Lightweight dependency injection primitives for Codefast",
+  "version": "0.13.0",
+  "description": "Type-safe, zero-dependency dependency injection for TypeScript, on standard decorators",
   "keywords": [
     "codefast",
     "dependency-injection",