@travetto/di 3.1.0-rc.2 → 3.1.0-rc.4

package/README.md

@@ -195,6 +195,45 @@ class Config {
 }
 ```
 
+## Non-Framework Dependencies
+The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
+
+It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) decorators.
+
+**Code: Example External Dependencies**
+```typescript
+import { EventEmitter } from 'events';
+import { Writable } from 'stream';
+
+import { Inject, Injectable, InjectableFactory } from '@travetto/di';
+
+class Source {
+  @InjectableFactory()
+  static emitter(): EventEmitter {
+    return new EventEmitter();
+  }
+
+  @InjectableFactory(Symbol.for('custom-1'))
+  static writable(): Writable {
+    return {} as Writable;
+  }
+
+  @InjectableFactory(Symbol.for('custom-2'))
+  static writableAlt(): Writable {
+    return {} as Writable;
+  }
+}
+
+@Injectable()
+class Service {
+  @Inject()
+  emitter: EventEmitter;
+
+  @Inject(Symbol.for('custom-2'))
+  writable: Writable;
+}
+```
+
 ## 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:
 

package/package.json

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

package/support/transformer.injectable.ts

@@ -3,6 +3,7 @@ import ts from 'typescript';
 import {
   TransformerState, DecoratorMeta, OnClass, OnProperty, OnStaticMethod, DecoratorUtil, LiteralUtil, OnSetter
 } from '@travetto/transformer';
+import { ForeignType } from '@travetto/transformer/src/resolver/types';
 
 const INJECTABLE_MOD = '@travetto/di/src/decorator';
 
@@ -11,6 +12,12 @@ const INJECTABLE_MOD = '@travetto/di/src/decorator';
  */
 export class InjectableTransformer {
 
+  static foreignTarget(state: TransformerState, ret: ForeignType): ts.Expression {
+    return state.fromLiteral({
+      Ⲑid: `${ret.source.split('node_modules')[1]}+${ret.name}`
+    });
+  }
+
   /**
    * Handle a specific declaration param/property
    */
@@ -25,14 +32,26 @@ export class InjectableTransformer {
     const callExpr = existing?.expression as ts.CallExpression;
     const args: ts.Expression[] = [...(callExpr?.arguments ?? [])];
 
-    let optional: ts.Expression | undefined = undefined;
-    if (optional === undefined && !!param.questionToken) {
-      optional = state.fromLiteral(true);
+    const payload: { target?: unknown, qualifier?: unknown, optional?: boolean } = {};
+
+    if (!!param.questionToken) {
+      payload.optional = true;
     }
 
     const keyParam = ts.isSetAccessorDeclaration(param) ? param.parameters[0] : param;
-    const target = state.getOrImport(state.resolveExternalType(keyParam));
-    args.unshift(state.fromLiteral({ target, optional }));
+    const type = state.resolveType(keyParam);
+
+    if (type.key === 'managed') {
+      payload.target = state.getOrImport(type);
+    } else if (type.key === 'foreign') {
+      payload.target = this.foreignTarget(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}`);
+    }
+
+    args.unshift(state.fromLiteral(payload));
 
     return args;
   }
@@ -52,7 +71,7 @@ export class InjectableTransformer {
       if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
         for (const typeExpression of clause.types) {
           const resolvedType = state.resolveType(typeExpression);
-          if (resolvedType.key === 'external') {
+          if (resolvedType.key === 'managed') {
             const resolved = state.getOrImport(resolvedType);
             interfaces.push(resolved);
           }
@@ -134,21 +153,22 @@ export class InjectableTransformer {
     const dependencies = node.parameters.map(x => this.processDeclaration(state, x));
 
     // Read target from config or resolve
-    let target;
+    const config: { dependencies: unknown[], target?: unknown, qualifier?: unknown, src?: unknown } = {
+      dependencies,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      src: (node.parent as ts.ClassDeclaration).name,
+    };
     const ret = state.resolveReturnType(node);
-    if (ret.key === 'external') {
-      target = state.getOrImport(ret);
+    if (ret.key === 'managed') {
+      config.target = state.getOrImport(ret);
+    } else if (ret.key === 'foreign') {
+      config.target = this.foreignTarget(state, ret);
     }
 
     // Build decl
     const args = [...(dec && ts.isCallExpression(dec.expression) ? dec.expression.arguments : [undefined])];
 
-    args.unshift(state.extendObjectLiteral({
-      dependencies,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      src: (node.parent as ts.ClassDeclaration).name,
-      target
-    }));
+    args.unshift(state.extendObjectLiteral(config));
 
     // Replace decorator
     return state.factory.updateMethodDeclaration(