@travetto/di 6.0.0-rc.1 → 6.0.0

package/README.md

@@ -43,9 +43,9 @@ class CustomService {
   }
 }
 
-const CUSTOM2 = Symbol.for('di-custom2');
+const Custom2Symbol = Symbol.for('di-custom2');
 
-@Injectable({ target: CustomService, qualifier: CUSTOM2 })
+@Injectable({ target: CustomService, qualifier: Custom2Symbol })
 class CustomService2 extends CustomService {
   override async coolOperation() {
     await super.coolOperation();
@@ -54,7 +54,7 @@ class CustomService2 extends CustomService {
 }
 
 class Consumer {
-  @Inject(CUSTOM2) // Pull in specific service
+  @Inject(Custom2Symbol) // Pull in specific service
   service: CustomService;
 }
 ```
@@ -125,7 +125,7 @@ class RuntimeService {
 
 In this example, the enabled flag is specified in relationship to the deployment environment.  When coupled with optional properties, and optional chaining, allows for seamless inclusion of optional dependencies at runtime.
 
-**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module @Controller decorator registers the associated class as an injectable element.
+**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative api for Web Applications with support for the dependency injection.") module @Controller decorator registers the associated class as an injectable element.
 
 ## Injection
 Once all of your necessary dependencies are defined, now is the time to provide those [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) instances to your code.  There are three primary methods for injection: 
@@ -135,7 +135,7 @@ The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decor
 **Code: Example Injectable with dependencies as Inject fields**
 ```typescript
 import { Injectable, Inject } from '@travetto/di';
-import { DependentService } from './dep';
+import { DependentService } from './dep.ts';
 
 @Injectable()
 class CustomService {
@@ -153,7 +153,7 @@ The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/d
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
 import { Injectable } from '@travetto/di';
-import { DependentService } from './dep';
+import { DependentService } from './dep.ts';
 
 @Injectable()
 class CustomService {
@@ -176,7 +176,7 @@ Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/d
 ```typescript
 import { InjectableFactory } from '@travetto/di';
 
-import { DependentService, CustomService } from './dep';
+import { DependentService, CustomService } from './dep.ts';
 
 class Config {
   @InjectableFactory()
@@ -216,7 +216,7 @@ By default, if there is only one candidate without qualification, then that cand
 **Code: Example Multiple Candidate Types**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
-import { Contract, ComplexContract } from './injectable-multiple-default';
+import { Contract, ComplexContract } from './injectable-multiple-default.ts';
 
 class Config {
   // Complex will be marked as the available Contract
@@ -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 [DependencyRegistry](https://github.com/travetto/travetto/tree/main/module/di/src/registry.ts#L1). 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 [DependencyRegistry](https://github.com/travetto/travetto/tree/main/module/di/src/registry.ts#L25). The registry allows for requesting a dependency by class reference:
 
 **Code: Example of Manual Lookup**
 ```typescript
@@ -290,11 +290,10 @@ Additionally, support for interfaces (over class inheritance) is provided, but r
 **Code: Example Interface Injection**
 ```typescript
 import { DependencyRegistry, Inject, Injectable, InjectableFactory } from '@travetto/di';
-
-class TargetConcrete { }
+import { toConcrete } from '@travetto/runtime';
 
 /**
- * @concrete #TargetConcrete
+ * @concrete
  */
 export interface ServiceContract {
   deleteUser(userId: string): Promise<void>;
@@ -316,7 +315,7 @@ class SpecificService {
 class ManualInvocationOfInterface {
   @InjectableFactory()
   static getCustomService(): Promise<ServiceContract> {
-    return DependencyRegistry.getInstance<ServiceContract>(TargetConcrete);
+    return DependencyRegistry.getInstance<ServiceContract>(toConcrete<ServiceContract>());
   }
 }
 ```

package/__index__.ts

@@ -1,5 +1,4 @@
-import type { } from './src/global';
-export * from './src/decorator';
-export * from './src/error';
-export * from './src/registry';
-export * from './src/types';
+export * from './src/decorator.ts';
+export * from './src/error.ts';
+export * from './src/registry.ts';
+export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/di",
-  "version": "6.0.0-rc.1",
+  "version": "6.0.0",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -27,10 +27,10 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/registry": "^6.0.0-rc.1"
+    "@travetto/registry": "^6.0.0"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^6.0.0-rc.1"
+    "@travetto/transformer": "^6.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator.ts

@@ -1,7 +1,7 @@
 import { asConstructable, asFull, TypedFunction, type Class } from '@travetto/runtime';
 
-import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types';
-import { DependencyRegistry, ResolutionType } from './registry';
+import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types.ts';
+import { DependencyRegistry, ResolutionType } from './registry.ts';
 
 function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Partial<InjectConfig> | undefined)[]): T {
   let out: Partial<T> = {};

package/src/error.ts

@@ -1,5 +1,5 @@
 import { AppError } from '@travetto/runtime';
-import { ClassTarget } from './types';
+import { ClassTarget } from './types.ts';
 
 function getName(symbol: symbol): string {
   return symbol.toString().split(/[()]/g)[1];

package/src/registry.ts

@@ -1,20 +1,20 @@
 import {
   Class, Runtime, asConstructable, castTo, classConstruct, describeFunction,
-  asFull, castKey, TypedFunction, hasFunction
+  asFull, castKey, TypedFunction, hasFunction, AppError
 } from '@travetto/runtime';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
 
-import { Dependency, InjectableConfig, ClassTarget, InjectableFactoryConfig } from './types';
-import { InjectionError } from './error';
-import { AutoCreateTarget } from './internal/types';
+import { Dependency, InjectableConfig, ClassTarget, InjectableFactoryConfig, PostConstructHandler } from './types.ts';
+import { InjectionError } from './error.ts';
 
+class AutoCreate { }
 type TargetId = string;
 type ClassId = string;
 export type Resolved<T> = { config: InjectableConfig<T>, qualifier: symbol, id: string };
 
 export type ResolutionType = 'strict' | 'loose' | 'any';
 
-const PrimaryCandidateSymbol = Symbol.for('@travetto/di:primary');
+const PrimaryCandidateSymbol = Symbol();
 
 const hasPostConstruct = hasFunction<{ postConstruct: () => Promise<unknown> }>('postConstruct');
 const hasPreDestroy = hasFunction<{ preDestroy: () => Promise<unknown> }>('preDestroy');
@@ -104,12 +104,12 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Retrieve all dependencies
    */
-  async fetchDependencies(managed: InjectableConfig, deps?: Dependency[]): Promise<unknown[]> {
+  async fetchDependencies<T>(managed: InjectableConfig<T>, deps?: Dependency[], keys?: string[]): Promise<unknown[]> {
     if (!deps || !deps.length) {
       return [];
     }
 
-    const promises = deps.map(async x => {
+    const promises = deps.map(async (x, i) => {
       try {
         return await this.getInstance(x.target, x.qualifier, x.resolution);
       } catch (err) {
@@ -117,7 +117,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
           return undefined;
         } else {
           if (err && err instanceof Error) {
-            err.message = `${err.message} via=${managed.class.Ⲑid}`;
+            err.message = `${err.message} via=${managed.class.Ⲑid}[${keys?.[i] ?? 'constructor'}]`;
           }
           throw err;
         }
@@ -136,7 +136,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
     // And auto-wire
     if (keys.length) {
-      const deps = await this.fetchDependencies(config, keys.map(x => config.dependencies.fields[x]));
+      const deps = await this.fetchDependencies(config, keys.map(x => config.dependencies.fields[x]), keys);
       for (let i = 0; i < keys.length; i++) {
         instance[castKey<T>(keys[i])] = castTo(deps[i]);
       }
@@ -174,6 +174,11 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       await inst.postConstruct();
     }
 
+    // Run post constructors
+    for (const op of Object.values(managed.postConstruct)) {
+      await op(inst);
+    }
+
     return inst;
   }
 
@@ -226,13 +231,11 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   override async init(): Promise<void> {
     await super.init();
     if (Runtime.dynamic) {
-      const { DependencyRegistration } = await import('../support/dynamic.injection');
+      const { DependencyRegistration } = await import('../support/dynamic.injection.ts');
       DependencyRegistration.init(this);
     }
-    // Allow for auto-creation
-    for (const cfg of await this.getCandidateTypes(AutoCreateTarget)) {
-      await this.getInstance(cfg.class, cfg.qualifier);
-    }
+
+    await this.getCandidateInstances(AutoCreate);
   }
 
   /**
@@ -265,7 +268,8 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       dependencies: {
         fields: {},
         cons: []
-      }
+      },
+      postConstruct: {}
     };
   }
 
@@ -275,6 +279,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   async getInstance<T>(target: ClassTarget<T>, qual?: symbol, resolution?: ResolutionType): Promise<T> {
     this.verifyInitialized();
 
+    if (!target) {
+      throw new AppError('Unable to get instance when target is undefined');
+    }
+
     const { id: classId, qualifier } = this.resolveTarget(target, qual, resolution);
     if (!this.instances.has(classId) || !this.instances.get(classId)!.has(qualifier)) {
       await this.createInstance(target, qualifier); // Wait for proxy
@@ -285,7 +293,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Get all available candidate types for the target
    */
-  getCandidateTypes<T, U = T>(target: Class<U>): InjectableConfig<T>[] {
+  getCandidateTypes<T>(target: Class<T>): InjectableConfig<T>[] {
     const qualifiers = this.targetToClass.get(target.Ⲑid)!;
     const uniqueQualifiers = qualifiers ? Array.from(new Set(qualifiers.values())) : [];
     return castTo(uniqueQualifiers.map(id => this.get(id)));
@@ -294,7 +302,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Get candidate instances by target type, with an optional filter
    */
-  getCandidateInstances<T>(target: Class, predicate?: (cfg: InjectableConfig<T>) => boolean): Promise<T[]> {
+  getCandidateInstances<T>(target: Class<T>, predicate?: (cfg: InjectableConfig<T>) => boolean): Promise<T[]> {
     const inputs = this.getCandidateTypes<T>(target).filter(x => !predicate || predicate(x));
     return Promise.all(inputs.map(l => this.getInstance<T>(l.class, l.qualifier)));
   }
@@ -307,6 +315,14 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     conf.dependencies!.cons = dependencies;
   }
 
+  /**
+   * Register a post construct handler
+   */
+  registerPostConstructHandler<T>(cls: Class<T>, name: string, handler: PostConstructHandler<T>): void {
+    const conf = this.getOrCreatePending(cls);
+    conf.postConstruct![name] = castTo(handler);
+  }
+
   /**
    * Register a property as a dependency
    */
@@ -325,7 +341,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     config.class = cls;
     config.qualifier = pConfig.qualifier ?? config.qualifier ?? Symbol.for(cls.Ⲑid);
     if (pConfig.interfaces) {
-      config.interfaces?.push(...pConfig.interfaces);
+      (config.interfaces ??= []).push(...pConfig.interfaces);
     }
     if (pConfig.primary !== undefined) {
       config.primary = pConfig.primary;
@@ -344,6 +360,9 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
         }
       };
     }
+    if (pConfig.autoCreate) {
+      (config.interfaces ??= []).push(AutoCreate);
+    }
   }
 
   /**
@@ -412,7 +431,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
     const config: InjectableConfig<T> = castTo(this.getOrCreatePending(cls));
 
-    if (!(typeof config.enabled === 'boolean' ? config.enabled : config.enabled())) {
+    if (config.enabled !== undefined && !(typeof config.enabled === 'boolean' ? config.enabled : config.enabled())) {
       return config; // Do not setup if disabled
     }
 
@@ -444,6 +463,11 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
         ...config.interfaces
       ];
 
+      config.postConstruct = {
+        ...parentConfig.postConstruct,
+        ...config.postConstruct
+      };
+
       // Inherit cons deps if no constructor defined
       if (config.dependencies.cons === undefined) {
         config.dependencies.cons = parentConfig.dependencies.cons;
@@ -550,17 +574,6 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     // Compute fields to be auto-wired
     return await this.resolveFieldDependencies(this.get(cls), o);
   }
-
-  /**
-   * Execute the run method of a given class
-   */
-  async runInstance<T extends { run(..._args: unknown[]): unknown }>(
-    cls: Class<T>, ...args: Parameters<T['run']>
-  ): Promise<Awaited<ReturnType<T['run']>>> {
-    await RootRegistry.init();
-    const inst = await this.getInstance<T>(cls);
-    return castTo<Awaited<ReturnType<T['run']>>>(inst.run(...args));
-  }
 }
 
 export const DependencyRegistry = new $DependencyRegistry();

package/src/types.ts

@@ -2,6 +2,8 @@ import { Class } from '@travetto/runtime';
 
 export type ClassTarget<T = unknown> = Class<T> | Function;
 
+export type PostConstructHandler<T> = (value: T) => (void | Promise<void>);
+
 /**
  * State of a Dependency
  */
@@ -16,6 +18,24 @@ interface Core<T = unknown> {
   qualifier: symbol;
 }
 
+/**
+ * State of a Dependency Target
+ */
+interface CoreTarget<T = unknown> extends Core<T> {
+  /**
+   * Is this injectable enabled
+   */
+  enabled?: boolean | (() => boolean);
+  /**
+   * Is this the primary instance
+   */
+  primary?: boolean;
+  /**
+   * Should the target be auto-created
+   */
+  autoCreate?: boolean;
+}
+
 /**
  * State of a Dependency
  */
@@ -35,11 +55,7 @@ export interface Dependency<T = unknown> extends Core<T> {
 /**
  * Injectable configuration
  */
-export interface InjectableConfig<T = unknown> extends Core<T> {
-  /**
-   * Is this injectable enabled
-   */
-  enabled: boolean | (() => boolean);
+export interface InjectableConfig<T = unknown> extends CoreTarget<T> {
   /**
    * Reference for the class
    */
@@ -48,10 +64,6 @@ export interface InjectableConfig<T = unknown> extends Core<T> {
    * Factory function for the injectable
    */
   factory?: (...args: unknown[]) => T;
-  /**
-   * Is this the primary instance
-   */
-  primary: boolean;
   /**
    * List of dependencies as fields or as constructor arguments
    */
@@ -63,31 +75,22 @@ export interface InjectableConfig<T = unknown> extends Core<T> {
    * List of interface types
    */
   interfaces: Class[];
+  /**
+   * Post construct handlers
+   */
+  postConstruct: Record<string | symbol, PostConstructHandler<unknown>>;
 }
 
 /**
  * Factory configuration
  */
-export interface InjectableFactoryConfig<T = unknown> extends Core<T> {
-  /**
-   * Is this injectable enabled
-   */
-  enabled?: boolean | (() => boolean);
+export interface InjectableFactoryConfig<T = unknown> extends CoreTarget<T> {
   /**
    * Src of the factory method
    */
   src: Class<T>;
-  /**
-   * Is this the primary instance
-   */
-  primary?: boolean;
   /**
    * List of all dependencies as function arguments
    */
   dependencies?: Dependency[];
-}
-
-/**
- * @concrete ./internal/types#AutoCreateTarget
- */
-export interface AutoCreate { }
+}

package/support/dynamic.injection.ts

@@ -1,8 +1,8 @@
 import { Class, describeFunction } from '@travetto/runtime';
 import { RetargettingProxy } from '@travetto/registry';
 
-import type { DependencyRegistry, ResolutionType, Resolved } from '../src/registry';
-import type { ClassTarget, InjectableConfig } from '../src/types';
+import type { DependencyRegistry, ResolutionType, Resolved } from '../src/registry.ts';
+import type { ClassTarget, InjectableConfig } from '../src/types.ts';
 
 /**
  * Wraps the Dependency Registry to support proxying instances
@@ -89,14 +89,14 @@ class $DynamicDependencyRegistry {
 
   register(registry: typeof DependencyRegistry): void {
     this.#registry = registry;
-    this.#registryCreateInstance = registry['createInstance'].bind(registry);
-    this.#registryResolveTarget = registry['resolveTarget'].bind(registry);
-    this.#registryOnInstallFinalize = registry['onInstallFinalize'].bind(registry);
-    this.#registryDestroyInstance = registry['destroyInstance'].bind(registry);
+    this.#registryCreateInstance = registry.createInstance.bind(registry);
+    this.#registryResolveTarget = registry.resolveTarget.bind(registry);
+    this.#registryOnInstallFinalize = registry.onInstallFinalize.bind(registry);
+    this.#registryDestroyInstance = registry.destroyInstance.bind(registry);
 
-    this.#registry['createInstance'] = this.createInstance.bind(this);
-    this.#registry['destroyInstance'] = this.destroyInstance.bind(this);
-    this.#registry['onInstallFinalize'] = this.onInstallFinalize.bind(this);
+    this.#registry.createInstance = this.createInstance.bind(this);
+    this.#registry.destroyInstance = this.destroyInstance.bind(this);
+    this.#registry.onInstallFinalize = this.onInstallFinalize.bind(this);
   }
 }
 

package/support/test/suite.ts

@@ -2,7 +2,7 @@ import { castTo, Class, ClassInstance } from '@travetto/runtime';
 import { RootRegistry } from '@travetto/registry';
 import { SuiteRegistry } from '@travetto/test';
 
-import { DependencyRegistry } from '../../src/registry';
+import { DependencyRegistry } from '../../src/registry.ts';
 
 /**
  * Registers a suite as injectable

package/support/transformer.injectable.ts

@@ -1,33 +1,19 @@
 import ts from 'typescript';
 
-import {
-  TransformerState, DecoratorMeta, OnClass, OnProperty, OnStaticMethod, DecoratorUtil, LiteralUtil, OnSetter
-} from '@travetto/transformer';
-import { ForeignType } from '@travetto/transformer/src/resolver/types';
+import { TransformerState, DecoratorMeta, OnClass, OnProperty, OnStaticMethod, DecoratorUtil, LiteralUtil, OnSetter } from '@travetto/transformer';
 
-const INJECTABLE_MOD = '@travetto/di/src/decorator';
+const INJECTABLE_IMPORT = '@travetto/di/src/decorator.ts';
 
 /**
  * Injectable/Injection transformer
  */
 export class InjectableTransformer {
 
-  static getForeignTarget(state: TransformerState, ret: ForeignType): ts.Expression {
-    return state.fromLiteral({
-      Ⲑid: `${ret.source.split('node_modules/')[1]}+${ret.name}`
-    });
-  }
-
   /**
    * Handle a specific declaration param/property
    */
   static processDeclaration(state: TransformerState, param: ts.ParameterDeclaration | ts.SetAccessorDeclaration | ts.PropertyDeclaration): ts.Expression[] {
-    const existing = state.findDecorator(this, param, 'Inject', INJECTABLE_MOD);
-
-    if (!(existing || ts.isParameter(param))) {
-      return [];
-    }
-
+    const existing = state.findDecorator(this, param, 'Inject', INJECTABLE_IMPORT);
     const args: ts.Expression[] = [];
 
     if (existing && ts.isCallExpression(existing.expression)) {
@@ -41,18 +27,7 @@ export class InjectableTransformer {
     }
 
     const keyParam = ts.isSetAccessorDeclaration(param) ? param.parameters[0] : param;
-    const type = state.resolveType(keyParam);
-
-    if (type.key === 'managed') {
-      payload.target = state.getOrImport(type);
-    } else if (type.key === 'foreign') {
-      payload.target = this.getForeignTarget(state, type);
-    } else {
-      const file = param.getSourceFile().fileName;
-      const src = state.getFileImportName(file);
-      throw new Error(`Unable to import non-external type: ${param.getText()} ${type.key}: ${src}`);
-    }
-
+    payload.target = state.getConcreteType(keyParam);
     args.unshift(state.fromLiteral(payload));
 
     return args;
@@ -82,15 +57,15 @@ export class InjectableTransformer {
     }
 
     // Add injectable decorator if not there
-    const decl = state.findDecorator(this, node, 'Injectable', INJECTABLE_MOD);
+    const decl = state.findDecorator(this, node, 'Injectable', INJECTABLE_IMPORT);
     const args = decl && ts.isCallExpression(decl.expression) ? decl.expression.arguments : [undefined];
 
     return state.factory.updateClassDeclaration(node,
       DecoratorUtil.spliceDecorators(node, decl, [
-        state.createDecorator(INJECTABLE_MOD, 'Injectable', ...args, LiteralUtil.extendObjectLiteral(ts.factory, {}, {
+        state.createDecorator(INJECTABLE_IMPORT, 'Injectable', ...args, LiteralUtil.extendObjectLiteral(ts.factory, {}, {
           interfaces
         })),
-        state.createDecorator(INJECTABLE_MOD, 'InjectArgs', injectArgs)
+        state.createDecorator(INJECTABLE_IMPORT, 'InjectArgs', injectArgs)
       ]),
       node.name,
       node.typeParameters,
@@ -103,14 +78,14 @@ export class InjectableTransformer {
    * Handle Inject annotations for fields/args
    */
   @OnProperty('Inject')
-  static registerInjectProperty(state: TransformerState, node: ts.PropertyDeclaration, dm?: DecoratorMeta): typeof node {
-    const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_MOD);
+  static registerInjectProperty(state: TransformerState, node: ts.PropertyDeclaration): typeof node {
+    const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_IMPORT);
 
     // Doing decls
     return state.factory.updatePropertyDeclaration(
       node,
       DecoratorUtil.spliceDecorators(node, decl, [
-        state.createDecorator(INJECTABLE_MOD, 'Inject', ...this.processDeclaration(state, node)),
+        state.createDecorator(INJECTABLE_IMPORT, 'Inject', ...this.processDeclaration(state, node)),
       ], 0),
       node.name,
       node.questionToken,
@@ -123,11 +98,11 @@ export class InjectableTransformer {
   * Handle Inject annotations for fields/args
   */
   @OnSetter('Inject')
-  static registerInjectSetter(state: TransformerState, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta): typeof node {
-    const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_MOD);
+  static registerInjectSetter(state: TransformerState, node: ts.SetAccessorDeclaration): typeof node {
+    const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_IMPORT);
 
     const modifiers = DecoratorUtil.spliceDecorators(node, decl, [
-      state.createDecorator(INJECTABLE_MOD, 'Inject', ...this.processDeclaration(state, node)),
+      state.createDecorator(INJECTABLE_IMPORT, 'Inject', ...this.processDeclaration(state, node)),
     ], 0);
 
     // Doing decls
@@ -164,14 +139,14 @@ export class InjectableTransformer {
       dependencies,
       src: parent.name,
     };
-    let ret = state.resolveReturnType(node);
-    if (ret.key === 'literal' && ret.ctor === Promise && ret.typeArguments) {
-      ret = ret.typeArguments![0];
+    let returnType = state.resolveReturnType(node);
+    if (returnType.key === 'literal' && returnType.ctor === Promise && returnType.typeArguments) {
+      returnType = returnType.typeArguments![0];
     }
-    if (ret.key === 'managed') {
-      config.target = state.getOrImport(ret);
-    } else if (ret.key === 'foreign') {
-      config.target = this.getForeignTarget(state, ret);
+    if (returnType.key === 'managed') {
+      config.target = state.getOrImport(returnType);
+    } else if (returnType.key === 'foreign') {
+      config.target = state.getForeignTarget(returnType);
     }
 
     // Build decl
@@ -183,7 +158,7 @@ export class InjectableTransformer {
     return state.factory.updateMethodDeclaration(
       node,
       DecoratorUtil.spliceDecorators(node, dec, [
-        state.createDecorator(INJECTABLE_MOD, 'InjectableFactory', ...args)
+        state.createDecorator(INJECTABLE_IMPORT, 'InjectableFactory', ...args)
       ]),
       node.asteriskToken,
       node.name,

package/src/global.d.ts

@@ -1,27 +0,0 @@
-import './types';
-
-declare global {
-  /**
-   * @concrete node:buffer#Blob
-   */
-  interface Blob { }
-
-  /**
-   * @concrete node:buffer#File
-   */
-  interface File { }
-
-  namespace NodeJS {
-    /**
-     * @concrete node:stream#Readable
-     */
-    interface ReadableStream { }
-  }
-}
-
-declare module 'stream' {
-  /**
-   * @concrete node:stream#Readable
-   */
-  interface Readable { }
-}

package/src/internal/types.ts

@@ -1 +0,0 @@
-export class AutoCreateTarget { }