refactor: simplify error handling

exuanbo · Oct 19, 2024 · 093259b · 093259b
1 parent 0886a13
commit 093259b
Show file tree

Hide file tree

Showing 6 changed files with 39 additions and 26 deletions.
diff --git a/src/container.ts b/src/container.ts
@@ -185,10 +185,8 @@ export class Container {
 
     if (context.resolution.stack.has(provider)) {
       const dependentRef = context.resolution.dependents.get(provider);
-      if (dependentRef) {
-        return dependentRef.current;
-      }
-      assert(false, ErrorMessage.CircularDependency);
+      assert(dependentRef, ErrorMessage.CircularDependency);
+      return dependentRef.current;
     }
 
     let resolvedScope = options?.scope || this.defaultScope;
@@ -203,8 +201,9 @@ export class Container {
     });
     try {
       if (resolvedScope == Scope.Container) {
-        if (registration.instance) {
-          return registration.instance.current;
+        const instanceRef = registration.instance;
+        if (instanceRef) {
+          return instanceRef.current;
         }
         const instance = instantiate();
         registration.instance = {current: instance};

diff --git a/src/errors.ts b/src/errors.ts
@@ -2,7 +2,6 @@ export const ErrorMessage = {
   ReservedToken: "reserved token",
   UnresolvableToken: "unresolvable token",
   CircularDependency: "circular dependency",
-  InvariantViolation: "invariant violation",
   InjectOutsideOfContext: "inject outside of context",
 } as const;
 

diff --git a/src/inject.ts b/src/inject.ts
@@ -1,21 +1,19 @@
-import {assert, ErrorMessage} from "./errors";
-import {useInjectionContext} from "./injection-context";
+import {ensureInjectionContext} from "./injection-context";
 import type {Token, TokenList} from "./token";
+import {invariant} from "./utils/invariant";
 
 export function inject<Values extends unknown[]>(...tokens: TokenList<Values>): Values[number];
 export function inject<Value>(...tokens: Token<Value>[]): Value {
-  const context = useInjectionContext();
-  assert(context, ErrorMessage.InjectOutsideOfContext);
+  const context = ensureInjectionContext();
   return context.container.resolve(...tokens);
 }
 
 export namespace inject {
   export function by<Values extends unknown[]>(thisArg: any, ...tokens: TokenList<Values>): Values[number];
   export function by<Value>(thisArg: any, ...tokens: Token<Value>[]): Value {
-    const context = useInjectionContext();
-    assert(context, ErrorMessage.InjectOutsideOfContext);
+    const context = ensureInjectionContext();
     const currentFrame = context.resolution.stack.peek();
-    assert(currentFrame, ErrorMessage.InvariantViolation);
+    invariant(currentFrame);
     const provider = currentFrame.provider;
     context.resolution.dependents.set(provider, {current: thisArg});
     try {
@@ -29,7 +27,6 @@ export namespace inject {
 
 export function injectAll<Values extends unknown[]>(...tokens: TokenList<Values>): NonNullable<Values[number]>[];
 export function injectAll<Value>(...tokens: Token<Value>[]): NonNullable<Value>[] {
-  const context = useInjectionContext();
-  assert(context, ErrorMessage.InjectOutsideOfContext);
+  const context = ensureInjectionContext();
   return context.container.resolveAll(...tokens);
 }
diff --git a/src/injection-context.ts b/src/injection-context.ts
@@ -1,4 +1,5 @@
 import type {Container} from "./container";
+import {assert, ErrorMessage} from "./errors";
 import type {InstanceRef} from "./instance";
 import type {Provider} from "./provider";
 import type {Scope} from "./scope";
@@ -25,3 +26,10 @@ export type ResolvedScope = Exclude<Scope, typeof Scope.Inherited>;
 
 // @internal
 export const [withInjectionContext, useInjectionContext] = createContext<InjectionContext>();
+
+// @internal
+export function ensureInjectionContext() {
+  const context = useInjectionContext();
+  assert(context, ErrorMessage.InjectOutsideOfContext);
+  return context;
+}
diff --git a/src/utils/invariant.ts b/src/utils/invariant.ts
@@ -0,0 +1,6 @@
+// @internal
+export function invariant(condition: unknown): asserts condition {
+  if (!condition) {
+    throw new Error("invariant violation");
+  }
+}
diff --git a/src/utils/keyed-stack.ts b/src/utils/keyed-stack.ts
@@ -1,11 +1,18 @@
+import {invariant} from "./invariant";
+
 // @internal
 export class KeyedStack<K, V> {
   private entries = new Array<{key: K; value: V}>();
+
   private keys = new Set<K>();
 
-  push(key: K, value: V) {
-    this.entries.push({key, value});
-    this.keys.add(key);
+  has(key: K) {
+    return this.keys.has(key);
+  }
+
+  peek() {
+    const entry = this.entries.at(-1);
+    return entry?.value;
   }
 
   pop() {
@@ -16,12 +23,9 @@ export class KeyedStack<K, V> {
     }
   }
 
-  peek() {
-    const entry = this.entries.at(-1);
-    return entry?.value;
-  }
-
-  has(key: K) {
-    return this.keys.has(key);
+  push(key: K, value: V) {
+    invariant(!this.keys.has(key));
+    this.keys.add(key);
+    this.entries.push({key, value});
   }
 }