@travetto/di 7.1.3 → 8.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/di",
-  "version": "7.1.3",
+  "version": "8.0.0-alpha.0",
   "type": "module",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
@@ -28,10 +28,10 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/registry": "^7.1.3"
+    "@travetto/registry": "^8.0.0-alpha.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.1.2"
+    "@travetto/transformer": "^8.0.0-alpha.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/error.ts

@@ -1,10 +1,10 @@
-import { AppError, type Class } from '@travetto/runtime';
+import { RuntimeError, type Class } from '@travetto/runtime';
 
 function getName(symbol: symbol): string {
   return symbol.toString().split(/[()]/g)[1];
 }
 
-export class InjectionError extends AppError {
+export class InjectionError extends RuntimeError {
   constructor(message: string, target: Class, qualifiers?: symbol[]) {
     super(`${message}: [${target.Ⲑid}]${qualifiers ? `[${qualifiers.map(getName)}]` : ''}`, {
       category: 'notfound',

package/src/registry/registry-index.ts

@@ -1,5 +1,5 @@
 import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castKey, castTo, type Class, describeFunction, getParentClass, hasFunction, TypedObject } from '@travetto/runtime';
+import { RuntimeError, castKey, castTo, type Class, describeFunction, getParentClass, hasFunction, TypedObject } from '@travetto/runtime';
 import { type SchemaFieldConfig, type SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import type { Dependency, InjectableCandidate, InjectableClassMetadata, InjectableConfig, ResolutionType } from '../types.ts';
@@ -184,29 +184,27 @@ export class DependencyRegistryIndex implements RegistryIndex {
    */
   async getInstance<T>(candidateType: Class<T>, requestedQualifier?: symbol, resolution?: ResolutionType): Promise<T> {
     if (!candidateType) {
-      throw new AppError('Unable to get instance when target is undefined');
+      throw new RuntimeError('Unable to get instance when target is undefined');
     }
 
     const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier, resolution);
 
-    if (!this.#instances.has(target)) {
-      this.#instances.set(target, new Map());
-      this.#instancePromises.set(target, new Map());
-    }
+    const instances = this.#instances.getOrInsert(target, new Map());
+    const instancePromises = this.#instancePromises.getOrInsert(target, new Map());
 
-    if (this.#instancePromises.get(target)!.has(qualifier)) {
-      return castTo(this.#instancePromises.get(target)!.get(qualifier));
+    if (instancePromises.has(qualifier)) {
+      return castTo(instancePromises.get(qualifier));
     }
 
     const instancePromise = this.construct(candidateType, qualifier);
-    this.#instancePromises.get(target)!.set(qualifier, instancePromise);
+    instancePromises.set(qualifier, instancePromise);
     try {
       const instance = await instancePromise;
-      this.#instances.get(target)!.set(qualifier, instance);
+      instances.set(qualifier, instance);
       return instance;
     } catch (error) {
       // Clear it out, don't save failed constructions
-      this.#instancePromises.get(target)!.delete(qualifier);
+      instancePromises.delete(qualifier);
       throw error;
     }
   }

package/src/registry/registry-resolver.ts

@@ -7,10 +7,7 @@ import { InjectionError } from '../error.ts';
 type Resolved<T> = { candidate: InjectableCandidate<T>, qualifier: symbol, target: Class };
 
 function setInMap<T>(map: Map<Class, Map<typeof key, T>>, cls: Class, key: symbol | string, dest: T): void {
-  if (!map.has(cls)) {
-    map.set(cls, new Map());
-  }
-  map.get(cls)!.set(key, dest);
+  map.getOrInsert(cls, new Map()).set(key, dest);
 }
 
 export class DependencyRegistryResolver {

package/support/test/suite.ts

@@ -1,9 +1,21 @@
-import type { Class } from '@travetto/runtime';
+import { type Class } from '@travetto/runtime';
 import { Registry } from '@travetto/registry';
-import { SuiteRegistryIndex } from '@travetto/test';
+import { SuiteRegistryIndex, type SuitePhaseHandler } from '@travetto/test';
 
 import { DependencyRegistryIndex } from '../../src/registry/registry-index.ts';
 
+class ModelSuiteHandler<T extends object> implements SuitePhaseHandler<T> {
+  target: Class;
+  constructor(target: Class<T>) {
+    this.target = target;
+  }
+
+  async beforeEach(instance: T) {
+    await Registry.init();
+    await DependencyRegistryIndex.injectFields(instance, this.target);
+  }
+}
+
 /**
  * Registers a suite as injectable
  * @kind decorator
@@ -11,12 +23,7 @@ import { DependencyRegistryIndex } from '../../src/registry/registry-index.ts';
 export function InjectableSuite() {
   return (cls: Class) => {
     SuiteRegistryIndex.getForRegister(cls).register({
-      beforeEach: [
-        async function (this: unknown) {
-          await Registry.init();
-          await DependencyRegistryIndex.injectFields(this, cls);
-        },
-      ]
+      phaseHandlers: [new ModelSuiteHandler(cls)]
     });
   };
 }