Allow storing any value (not just objects) in the registry

Author: parzhitsky

packages/v1/src/di/context.ts

@@ -1,5 +1,5 @@
 import { ConstructorUnknown, ConstructorOf } from './constructor-of.type.js'
-import { ObjectRegistry } from './object-registry.js'
+import { ValueRegistry } from './value-registry.js'
 
 class Logger {
   constructor(protected readonly id: number) { }
@@ -20,13 +20,13 @@ export class Context {
   protected readonly injections = new Map<ConstructorUnknown, Injections>()
   protected readonly replacements = new Map<ConstructorUnknown, ConstructorUnknown>()
 
-  constructor(protected readonly registry = new ObjectRegistry()) { }
+  constructor(protected readonly registry = new ValueRegistry()) { }
 
   registerConstructor(Entity: ConstructorUnknown): this {
     this.logger.log(`Registering "${Entity.name}" …`)
 
-    if (!this.registry.hasObjectCreator(Entity)) {
-      this.registry.addObjectCreator(Entity, async (...dependencies) => new Entity(...dependencies as never))
+    if (!this.registry.hasCreator(Entity)) {
+      this.registry.addCreator(Entity, async (...dependencies) => new Entity(...dependencies as never))
     }
 
     return this
@@ -128,15 +128,15 @@ export class Context {
       Instance = Replacement as ConstructorOf<Instance, Dependencies>
     }
 
-    if (!this.registry.hasObject(Instance)) {
+    if (!this.registry.has(Instance)) {
       const dependencies = await this.resolveDependencies(Instance)
 
       this.logger.log(`Preparing instance of "${Instance.name}" …`)
 
-      await this.registry.prepareObject(Instance, dependencies)
+      await this.registry.prepare(Instance, dependencies)
     }
 
-    const instance = this.registry.getObject<Instance>(Instance)
+    const instance = this.registry.get<Instance>(Instance)
 
     return instance
   }

packages/v1/src/di/main.ts

@@ -1,10 +1,10 @@
 import { ConstructorOf } from './constructor-of.type.js'
 import { Context } from './context.js'
 import { createDecorators } from './create-decorators.js'
-import { ObjectRegistry } from './object-registry.js'
+import { ValueRegistry } from './value-registry.js'
 
-const objectRegistry = new ObjectRegistry()
-const context = new Context(objectRegistry)
+const registry = new ValueRegistry()
+const context = new Context(registry)
 
 export const {
   Instance,

packages/v1/src/di/object-registry.ts

@@ -0,0 +1,76 @@
+import { MaybePromise } from './maybe-promise.type.js'
+
+// We reasonably limit token types because we want to stringify them without heavy heuristics
+type Token = string | number | symbol | { readonly name: string }
+
+function read(token: Token): string {
+  return token instanceof Object ? token.name : token.toString()
+}
+
+interface Creator<O, Dependencies extends readonly unknown[]> {
+  (...deps: Dependencies): MaybePromise<O>
+}
+
+export class ValueRegistry {
+  protected readonly creators = new Map<Token, Creator<unknown, never>>()
+  protected readonly values = new Map<Token, unknown>()
+
+  hasCreator(token: Token): boolean {
+    return this.creators.has(token)
+  }
+
+  addCreator<Value, Dependencies extends readonly unknown[]>(
+    token: Token,
+    creator: Creator<Value, Dependencies>,
+  ): void {
+    if (this.hasCreator(token)) {
+      throw new Error(`Cannot add creator: creator for "${read(token)}" already added`)
+    }
+
+    this.creators.set(token, creator)
+  }
+
+  replaceCreator(
+    token: Token,
+    creator: Creator<unknown, never>,
+  ): void {
+    if (!this.hasCreator(token)) {
+      throw new Error(`Cannot replace creator: creator for "${read(token)}" was not added`)
+    }
+
+    this.creators.set(token, creator)
+  }
+
+  has(token: Token): boolean {
+    return this.values.has(token)
+  }
+
+  async prepare<Dependencies extends readonly unknown[]>(
+    token: Token,
+    dependencies: Dependencies,
+  ): Promise<void> {
+    if (this.has(token)) {
+      throw new Error(`Cannot prepare value: "${read(token)}" is already prepared`)
+    }
+
+    const create = this.creators.get(token)
+
+    if (!create) {
+      throw new Error(`Cannot prepare value: creator for "${read(token)}" was not added`)
+    }
+
+    const value = await create(...dependencies as never)
+
+    this.values.set(token, value)
+  }
+
+  get<Value>(token: Token): Value {
+    if (!this.has(token)) {
+      throw new Error(`Cannot get value: "${read(token)}" was not prepared`)
+    }
+
+    const value = this.values.get(token)!
+
+    return value as Value
+  }
+}