@travetto/di 7.1.4 → 8.0.0-alpha.1

package/README.md

@@ -268,7 +268,7 @@ class Service {
 ```
 
 ## Manual Invocation
-Some times you will need to lookup a dependency dynamically, or you want to control the injection process at a more granular level. To achieve that you will need to directly access the [DependencyRegistryIndex](https://github.com/travetto/travetto/tree/main/module/di/src/registry/registry-index.ts#L19). The registry allows for requesting a dependency by class reference:
+Some times you will need to lookup a dependency dynamically, or you want to control the injection process at a more granular level. To achieve that you will need to directly access the [DependencyRegistryIndex](https://github.com/travetto/travetto/tree/main/module/di/src/registry/registry-index.ts#L16). The registry allows for requesting a dependency by class reference:
 
 **Code: Example of Manual Lookup**
 ```typescript

package/package.json

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

package/src/decorator.ts

@@ -15,7 +15,7 @@ const fromInput = <T extends { qualifier?: symbol }>(input?: T | symbol): T =>
  */
 export function Injectable(input?: Partial<InjectableCandidate> | symbol) {
   return <T extends Class>(cls: T): void => {
-    DependencyRegistryIndex.getForRegister(cls).registerClass(fromInput(input));
+    DependencyRegistryIndex.registerClass(cls, fromInput(input));
   };
 }
 
@@ -47,8 +47,18 @@ export function Inject(input?: InjectConfig | symbol) {
  */
 export function InjectableFactory(input?: Partial<InjectableCandidate> | symbol) {
   return <T extends Class>(cls: T, property: string, descriptor: TypedPropertyDescriptor<(...args: Any[]) => Any>): void => {
-    DependencyRegistryIndex.getForRegister(cls).registerFactory(property, fromInput(input), {
+    DependencyRegistryIndex.registerFactory(cls, property, fromInput(input), {
       factory: (...params: unknown[]) => descriptor.value!.apply(cls, params),
     });
   };
+}
+
+/**
+ * Register post construction handler
+ * @kind decorator
+ */
+export function PostConstruct(priority: number = 10) {
+  return (instance: ClassInstance, property: string, descriptor: TypedPropertyDescriptor<() => Any>): void => {
+    DependencyRegistryIndex.registerPostConstruct(getClass(instance), { operation: descriptor.value!, priority });
+  };
 }

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-adapter.ts

@@ -13,14 +13,12 @@ function combineInjectableCandidates<T extends InjectableCandidate>(base: T, ...
 
 function combineClasses<T extends InjectableConfig>(base: T, ...overrides: Partial<T>[]): typeof base {
   for (const override of overrides) {
-    Object.assign(base, {
-      ...base,
-      ...override,
-      candidates: {
-        ...base.candidates,
-        ...override.candidates,
-      }
-    });
+    if (override.candidates) {
+      base.candidates = { ...base.candidates, ...override.candidates };
+    }
+    if (override.postConstruct) {
+      base.postConstruct = [...base.postConstruct, ...override.postConstruct];
+    }
   }
   return base;
 }
@@ -34,7 +32,7 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
   }
 
   register(...data: Partial<InjectableConfig<unknown>>[]): InjectableConfig<unknown> {
-    this.#config ??= { class: this.#cls, candidates: {} };
+    this.#config ??= { class: this.#cls, candidates: {}, postConstruct: [] };
     return combineClasses(this.#config, ...data);
   }
 
@@ -61,13 +59,16 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
     return this.#config;
   }
 
-  finalize(): void {
+  finalize(parent?: InjectableConfig): void {
     for (const method of Object.keys(this.#config.candidates)) {
       const candidate = this.#config.candidates[method];
       const candidateType = SchemaRegistryIndex.get(candidate.class).getMethodReturnType(method);
       candidate.candidateType = candidateType;
       candidate.qualifier ??= getDefaultQualifier(candidateType);
     }
+    // Inherit post construct from parent
+    this.#config.postConstruct = [...(parent?.postConstruct ?? []), ...this.#config.postConstruct]
+      .sort((a, b) => (a.priority ?? 1) - (b.priority ?? 1));
   }
 
   getCandidateConfigs(): InjectableCandidate[] {

package/src/registry/registry-index.ts

@@ -1,17 +1,14 @@
 import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
-import { AppError, castKey, castTo, type Class, describeFunction, getParentClass, hasFunction, TypedObject } from '@travetto/runtime';
+import { castKey, castTo, type Class, describeFunction, getParentClass, TypedObject } from '@travetto/runtime';
 import { type SchemaFieldConfig, type SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
 
-import type { Dependency, InjectableCandidate, InjectableClassMetadata, InjectableConfig, ResolutionType } from '../types.ts';
+import type { Dependency, InjectableCandidate, InjectableConfig, PostConstructor, ResolutionType } from '../types.ts';
 import { DependencyRegistryAdapter } from './registry-adapter.ts';
 import { InjectionError } from '../error.ts';
 import { DependencyRegistryResolver } from './registry-resolver.ts';
 
 const MetadataSymbol = Symbol();
 
-const hasPostConstruct = hasFunction<{ postConstruct: () => Promise<unknown> }>('postConstruct');
-const hasPreDestroy = hasFunction<{ preDestroy: () => Promise<unknown> }>('preDestroy');
-
 function readMetadata(item: { metadata?: Record<symbol, unknown> }): Dependency | undefined {
   return castTo<Dependency | undefined>(item.metadata?.[MetadataSymbol]);
 }
@@ -24,6 +21,18 @@ export class DependencyRegistryIndex implements RegistryIndex {
     return this.#instance.store.getForRegister(cls);
   }
 
+  static registerPostConstruct<T>(cls: Class<T>, handler: PostConstructor<T>): void {
+    this.#instance.store.getForRegister(cls).register({ postConstruct: [castTo(handler)] });
+  }
+
+  static registerClass(cls: Class, ...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
+    return this.#instance.store.getForRegister(cls).registerClass(...data);
+  }
+
+  static registerFactory(cls: Class, method: string, ...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
+    return this.#instance.store.getForRegister(cls).registerFactory(method, ...data);
+  }
+
   static getInstance<T>(candidateType: Class<T>, qualifier?: symbol, resolution?: ResolutionType): Promise<T> {
     return this.#instance.getInstance(candidateType, qualifier, resolution);
   }
@@ -40,10 +49,6 @@ export class DependencyRegistryIndex implements RegistryIndex {
     return this.#instance.injectFields(cls, item, cls);
   }
 
-  static registerClassMetadata(cls: Class, metadata: InjectableClassMetadata): void {
-    SchemaRegistryIndex.getForRegister(cls).registerMetadata<InjectableClassMetadata>(MetadataSymbol, metadata);
-  }
-
   static registerParameterMetadata(cls: Class, method: string, index: number, metadata: Dependency): void {
     SchemaRegistryIndex.getForRegister(cls).registerParameterMetadata(method, index, MetadataSymbol, metadata);
   }
@@ -52,7 +57,6 @@ export class DependencyRegistryIndex implements RegistryIndex {
     SchemaRegistryIndex.getForRegister(cls).registerFieldMetadata(field, MetadataSymbol, metadata);
   }
 
-  #instances = new Map<Class, Map<symbol, unknown>>();
   #instancePromises = new Map<Class, Map<symbol, Promise<unknown>>>();
   #resolver = new DependencyRegistryResolver();
 
@@ -135,12 +139,12 @@ export class DependencyRegistryIndex implements RegistryIndex {
   /**
    * Retrieve mapped dependencies
    */
-  async injectFields<T>(candidateType: Class, instance: T, srcClass: Class): Promise<T> {
+  async injectFields<T>(candidateType: Class, instance: T, sourceClass: Class): Promise<T> {
     const inputs = SchemaRegistryIndex.getOptional(candidateType)?.getFields() ?? {};
 
     const promises = TypedObject.entries(inputs)
       .filter(([key, input]) => readMetadata(input) !== undefined && (input.access !== 'readonly' && instance[castKey(key)] === undefined))
-      .map(async ([key, input]) => [key, await this.#resolveDependencyValue(readMetadata(input) ?? {}, input, srcClass)] as const);
+      .map(async ([key, input]) => [key, await this.#resolveDependencyValue(readMetadata(input) ?? {}, input, sourceClass)] as const);
 
     const pairs = await Promise.all(promises);
 
@@ -155,78 +159,35 @@ export class DependencyRegistryIndex implements RegistryIndex {
    */
   async construct<T>(candidateType: Class<T>, qualifier: symbol): Promise<T> {
     const { candidate } = this.#resolver.resolveCandidate(candidateType, qualifier);
-    const targetType = candidate.candidateType;
+    const { candidateType: targetType } = candidate;
     const params = await this.fetchDependencyParameters(candidate);
-    const inst = await candidate.factory(...params);
+    const instance = await candidate.factory(...params);
 
     // And auto-wire fields
-    await this.injectFields(targetType, inst, candidate.class);
-
-    // Run post construct, if it wasn't passed in, otherwise it was already created
-    if (hasPostConstruct(inst) && !params.includes(inst)) {
-      await inst.postConstruct();
-    }
+    await this.injectFields(targetType, instance, candidate.class);
 
-    const metadata = SchemaRegistryIndex.has(targetType) ?
-      SchemaRegistryIndex.get(targetType).getMetadata<InjectableClassMetadata>(MetadataSymbol) : undefined;
+    // Run post constructors if output is not already as a dependency
+    const isParameterTargetType = params.find(param => typeof param === 'object' && param !== null && param.constructor === targetType);
 
-    // Run post constructors
-    for (const operation of Object.values(metadata?.postConstruct ?? {})) {
-      await operation(inst);
+    if (!isParameterTargetType) {
+      // Run post constructors
+      const postConstruct = this.store.has(targetType) ? this.getConfig(targetType).postConstruct : [];
+      for (const { operation } of postConstruct) {
+        await operation.call(instance);
+      }
     }
 
-    // Proxy if necessary
-    return inst;
+    return instance;
   }
 
   /**
    * Get or create the instance
    */
   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');
-    }
-
     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());
-    }
-
-    if (this.#instancePromises.get(target)!.has(qualifier)) {
-      return castTo(this.#instancePromises.get(target)!.get(qualifier));
-    }
-
-    const instancePromise = this.construct(candidateType, qualifier);
-    this.#instancePromises.get(target)!.set(qualifier, instancePromise);
-    try {
-      const instance = await instancePromise;
-      this.#instances.get(target)!.set(qualifier, instance);
-      return instance;
-    } catch (error) {
-      // Clear it out, don't save failed constructions
-      this.#instancePromises.get(target)!.delete(qualifier);
-      throw error;
-    }
-  }
-
-  /**
-   * Destroy an instance
-   */
-  destroyInstance(candidateType: Class, requestedQualifier: symbol): void {
-    const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier);
-
-    const activeInstance = this.#instances.get(target)?.get(qualifier);
-    if (hasPreDestroy(activeInstance)) {
-      activeInstance.preDestroy();
-    }
-
-    this.#resolver.removeClass(candidateType, qualifier);
-    this.#instances.get(target)?.delete(qualifier);
-    this.#instancePromises.get(target)?.delete(qualifier);
-
-    // May not exist
-    console.debug('On uninstall', { id: target, qualifier: qualifier.toString(), classId: target });
+    return castTo(this.#instancePromises
+      .getOrInsert(target, new Map())
+      .getOrInsertComputed(qualifier, () => this.construct(target, qualifier)));
   }
 }

package/src/registry/registry-resolver.ts

@@ -1,4 +1,4 @@
-import { SchemaRegistryIndex } from '@travetto/schema';
+import { SchemaRegistryIndex, UnknownType } from '@travetto/schema';
 import { castTo, type Class } from '@travetto/runtime';
 
 import { getDefaultQualifier, type InjectableCandidate, PrimaryCandidateSymbol, type ResolutionType } from '../types.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 {
@@ -125,6 +122,10 @@ export class DependencyRegistryResolver {
    * @param qualifier
    */
   resolveCandidate<T>(candidateType: Class<T>, qualifier?: symbol, resolution?: ResolutionType): Resolved<T> {
+    if (!candidateType) {
+      throw new InjectionError('Unable to resolve candidate when target is undefined', UnknownType, qualifier ? [qualifier] : undefined);
+    }
+
     const qualifiers = this.#byCandidateType.get(candidateType) ?? new Map<symbol, InjectableCandidate>();
 
     let config: InjectableCandidate;

package/src/types.ts

@@ -63,6 +63,13 @@ export interface InjectableCandidate<T = unknown> {
   qualifier?: symbol;
 }
 
+/** Post Construct Handler */
+export type PostConstructor<T> = {
+  operation: ((this: T) => Promise<unknown> | unknown);
+  priority: number;
+};
+
+
 /**
  * Full injectable configuration for a class
  */
@@ -75,14 +82,14 @@ export interface InjectableConfig<T = unknown> {
    * Candidates that are injectable
    */
   candidates: Record<string, InjectableCandidate>;
+  /**
+   * Post construct methods to run after construction of the instance
+   */
+  postConstruct: PostConstructor<T>[];
 }
 
 export function getDefaultQualifier(cls: Class): symbol {
   return Symbol.for(cls.Ⲑid);
 }
 
-export const PrimaryCandidateSymbol = Symbol();
-
-export type InjectableClassMetadata = {
-  postConstruct: Record<string, (<T>(inst: T) => Promise<void>)>;
-};
+export const PrimaryCandidateSymbol = Symbol();

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)]
     });
   };
 }