@travetto/di 3.1.0-rc.3 → 3.1.0-rc.5

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.3",
+  "version": "3.1.0-rc.5",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -30,7 +30,7 @@
     "@travetto/registry": "^3.1.0-rc.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^3.1.0-rc.3"
+    "@travetto/transformer": "^3.1.0-rc.5"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/support/transformer.injectable.ts

@@ -25,14 +25,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 = state.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}`);
+    }
+
+    args.unshift(state.fromLiteral(payload));
 
     return args;
   }
@@ -52,7 +64,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 +146,25 @@ export class InjectableTransformer {
     const dependencies = node.parameters.map(x => this.processDeclaration(state, x));
 
     // Read target from config or resolve
-    let target;
-    const ret = state.resolveReturnType(node);
-    if (ret.key === 'external') {
-      target = state.getOrImport(ret);
+    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,
+    };
+    let ret = state.resolveReturnType(node);
+    if (ret.key === 'literal' && ret.ctor === Promise && ret.typeArguments) {
+      ret = ret.typeArguments![0];
+    }
+    if (ret.key === 'managed') {
+      config.target = state.getOrImport(ret);
+    } else if (ret.key === 'foreign') {
+      config.target = state.getForeignTarget(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(