siringa 0.0.2 → 0.0.5

package/README.md

@@ -10,6 +10,7 @@ decorator metadata.
 * [Quick Start](#quick-start)
 * [One-Time Injection](#one-time-injection)
 * [Name-based Injection](#name-based-injection)
+* [Promises Injection](#promises-injection)
 * [Using Factories](#using-factories)
 * [Using Instances](#using-instances)
 * [Child Injectors](#child-injectors)
@@ -116,6 +117,40 @@ const bar = await injector.get('bar')
 const foo = await injector.get('foo')
 ```
 
+Promises Injection
+------------------
+
+Sometimes it might be necessary to be injected a `Promise` of a component,
+rather than a component itself.
+
+For example, in an _Lambda Function_ we might want to asynchronously use other
+services (retrieve secrets, connect to databases, ...) while starting to process
+a request.
+
+In this case we can request to be injected a (yet unresolved) `Promise` of a
+bound component:
+
+```ts
+import { promise } from 'siringa'
+
+class Foo {
+  foo() { /* ... your code... */ }
+}
+
+class Bar {
+  // The `promise(...)` function declares the injection of a `Promise`
+  static $inject = [ promise(Foo) ] as const
+
+  // Called by the injector with the correct `Promise` for dependencies
+  constructor(private _foo: Promise<Foo>) {}
+
+  // Your code
+  bar() {
+    await (this._foo).bar()
+  }
+}
+```
+
 Using Factories
 ---------------
 
@@ -278,6 +313,11 @@ annotated with _JSDoc_).
   Create a new instance of the given injectable (a _class_) injecting all its
   required dependencies
 
+* `injections.make(factory: Factory): ReturnType<Factory>` \
+   Simple utility method to invoke the factory with the correct `Injections`
+   and return its result. This can be used to alleviate issues when top-level
+   await is not available.
+
 #### Sub Injectors
 
 * `injections.injector(): Injector` \

package/dist/index.js

@@ -2,33 +2,34 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
+  return to;
 };
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  Injector: () => Injector
+  Injector: () => Injector,
+  promise: () => promise
 });
+module.exports = __toCommonJS(src_exports);
 function bindingName(binding) {
   return typeof binding === "function" ? `[class ${binding.name}]` : `"${binding}"`;
 }
+var promisedBinding = Symbol.for("siringa.promisedBinding");
+function promise(binding) {
+  return { [promisedBinding]: binding };
+}
 var Injector = class {
   #factories = /* @__PURE__ */ new Map();
   #promises = /* @__PURE__ */ new Map();
@@ -40,14 +41,14 @@ var Injector = class {
       const message2 = `Recursion detected injecting ${bindingName(binding)}`;
       return Promise.reject(new Error(message2));
     }
-    const promise = this.#promises.get(binding);
-    if (promise)
-      return promise;
+    const promise2 = this.#promises.get(binding);
+    if (promise2)
+      return promise2;
     const factory = this.#factories.get(binding);
     if (factory) {
-      const promise2 = Promise.resolve().then(() => factory([...stack, binding]));
-      this.#promises.set(binding, promise2);
-      return promise2;
+      const promise3 = Promise.resolve().then(() => factory([...stack, binding]));
+      this.#promises.set(binding, promise3);
+      return promise3;
     }
     if (this.#parent)
       return this.#parent.#get(binding, []);
@@ -56,8 +57,18 @@ var Injector = class {
   }
   async #inject(injectable, stack) {
     var _a;
-    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => this.#get(binding, stack));
-    const injections = promises ? await Promise.all(promises) : [];
+    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => {
+      switch (typeof binding) {
+        case "string":
+        case "function":
+          return this.#get(binding, stack);
+        default:
+          return binding;
+      }
+    });
+    const injections = promises ? (await Promise.all(promises)).map((i) => {
+      return promisedBinding in i ? this.#get(i[promisedBinding], stack) : i;
+    }) : [];
     return new injectable(...injections);
   }
   bind(binding, maybeInjectable) {
@@ -80,18 +91,25 @@ var Injector = class {
   async get(binding) {
     return this.#get(binding, []);
   }
-  async inject(injectable) {
+  inject(injectable) {
     return this.#inject(injectable, []);
   }
+  make(factory) {
+    return factory({
+      get: (component) => this.#get(component, []),
+      inject: async (injectable) => this.#inject(injectable, []),
+      injector: () => this.injector()
+    });
+  }
   injector() {
     const injector = new Injector();
     injector.#parent = this;
     return injector;
   }
 };
-module.exports = __toCommonJS(src_exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Injector
+  Injector,
+  promise
 });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AA4HA,qBAAqB,SAA0B;AAC7C,SAAO,OAAO,YAAY,aAAa,UAAU,QAAQ,UAAU,IAAI;AAAA;AA0DlE,qBAGyC;AAAA,EACrC,aAA+D,oBAAI;AAAA,EACnE,YAAwC,oBAAI;AAAA,EACrD;AAAA,QAIM,KAAK,SAAkB,OAAgC;AAC3D,QAAI,MAAM,SAAS,UAAU;AAC3B,UAAI;AAAc,eAAO,kBAAkB,SAAS;AACpD,YAAM,WAAU,gCAAgC,YAAY;AAC5D,aAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAGlC,UAAM,UAAU,eAAe,IAAI;AACnC,QAAI;AAAS,aAAO;AAEpB,UAAM,UAAU,gBAAgB,IAAI;AACpC,QAAI,SAAS;AACX,YAAM,WAAU,QAAQ,UAAU,KAAK,MAAM,QAAQ,CAAE,GAAG,OAAO;AACjE,qBAAe,IAAI,SAAS;AAC5B,aAAO;AAAA;AAGT,QAAI;AAAc,aAAO,kBAAkB,SAAS;AAEpD,UAAM,UAAU,6BAA6B,YAAY;AACzD,WAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAAA,QAG5B,QAAQ,YAAgD,OAAgC;AAxNhG;AAyNI,UAAM,WAAW,iBAAW,YAAX,mBAAoB,IAAI,CAAC,YAAiB,UAAU,SAAS;AAC9E,UAAM,aAAa,WAAW,MAAM,QAAQ,IAAI,YAAY;AAG5D,WAAO,IAAI,WAAW,GAAG;AAAA;AAAA,EAuB3B,KACE,SACA,iBACM;AACN,UAAM,aAAa,kBAAkB,kBACjC;AAEJ,oBAAgB,IAAI,SAAS,OAAO,UAAU,aAAa,YAAY;AACvE,WAAO;AAAA;AAAA,EAkBT,OACE,SACA,SACM;AACN,oBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ;AAAA,MACpD,KAAK,CAAC,cAAmB,UAAU,WAAW;AAAA,MAC9C,QAAQ,OAAO,eAAoB,aAAa,YAAY;AAAA,MAC5D,UAAU,MAAM,KAAK;AAAA;AAGvB,WAAO;AAAA;AAAA,EAkBT,IACE,SACA,UACM;AACN,mBAAe,IAAI,SAAS,QAAQ,QAAQ;AAC5C,WAAO;AAAA;AAAA,QAYH,IACJ,SACc;AACd,WAAO,UAAU,SAAS;AAAA;AAAA,QAStB,OACJ,YAC0B;AAC1B,WAAO,aAAa,YAAY;AAAA;AAAA,EAMlC,WAA6C;AAC3C,UAAM,WAAW,IAAI;AACrB,uBAAmB;AACnB,WAAO;AAAA;AAAA;",
+  "mappings": "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",
   "names": []
 }

package/dist/index.mjs

@@ -2,6 +2,10 @@
 function bindingName(binding) {
   return typeof binding === "function" ? `[class ${binding.name}]` : `"${binding}"`;
 }
+var promisedBinding = Symbol.for("siringa.promisedBinding");
+function promise(binding) {
+  return { [promisedBinding]: binding };
+}
 var Injector = class {
   #factories = /* @__PURE__ */ new Map();
   #promises = /* @__PURE__ */ new Map();
@@ -13,14 +17,14 @@ var Injector = class {
       const message2 = `Recursion detected injecting ${bindingName(binding)}`;
       return Promise.reject(new Error(message2));
     }
-    const promise = this.#promises.get(binding);
-    if (promise)
-      return promise;
+    const promise2 = this.#promises.get(binding);
+    if (promise2)
+      return promise2;
     const factory = this.#factories.get(binding);
     if (factory) {
-      const promise2 = Promise.resolve().then(() => factory([...stack, binding]));
-      this.#promises.set(binding, promise2);
-      return promise2;
+      const promise3 = Promise.resolve().then(() => factory([...stack, binding]));
+      this.#promises.set(binding, promise3);
+      return promise3;
     }
     if (this.#parent)
       return this.#parent.#get(binding, []);
@@ -29,8 +33,18 @@ var Injector = class {
   }
   async #inject(injectable, stack) {
     var _a;
-    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => this.#get(binding, stack));
-    const injections = promises ? await Promise.all(promises) : [];
+    const promises = (_a = injectable.$inject) == null ? void 0 : _a.map((binding) => {
+      switch (typeof binding) {
+        case "string":
+        case "function":
+          return this.#get(binding, stack);
+        default:
+          return binding;
+      }
+    });
+    const injections = promises ? (await Promise.all(promises)).map((i) => {
+      return promisedBinding in i ? this.#get(i[promisedBinding], stack) : i;
+    }) : [];
     return new injectable(...injections);
   }
   bind(binding, maybeInjectable) {
@@ -53,9 +67,16 @@ var Injector = class {
   async get(binding) {
     return this.#get(binding, []);
   }
-  async inject(injectable) {
+  inject(injectable) {
     return this.#inject(injectable, []);
   }
+  make(factory) {
+    return factory({
+      get: (component) => this.#get(component, []),
+      inject: async (injectable) => this.#inject(injectable, []),
+      injector: () => this.injector()
+    });
+  }
   injector() {
     const injector = new Injector();
     injector.#parent = this;
@@ -63,6 +84,7 @@ var Injector = class {
   }
 };
 export {
-  Injector
+  Injector,
+  promise
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../src/index.ts"],
-  "mappings": ";AA4HA,qBAAqB,SAA0B;AAC7C,SAAO,OAAO,YAAY,aAAa,UAAU,QAAQ,UAAU,IAAI;AAAA;AA0DlE,qBAGyC;AAAA,EACrC,aAA+D,oBAAI;AAAA,EACnE,YAAwC,oBAAI;AAAA,EACrD;AAAA,QAIM,KAAK,SAAkB,OAAgC;AAC3D,QAAI,MAAM,SAAS,UAAU;AAC3B,UAAI;AAAc,eAAO,kBAAkB,SAAS;AACpD,YAAM,WAAU,gCAAgC,YAAY;AAC5D,aAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAGlC,UAAM,UAAU,eAAe,IAAI;AACnC,QAAI;AAAS,aAAO;AAEpB,UAAM,UAAU,gBAAgB,IAAI;AACpC,QAAI,SAAS;AACX,YAAM,WAAU,QAAQ,UAAU,KAAK,MAAM,QAAQ,CAAE,GAAG,OAAO;AACjE,qBAAe,IAAI,SAAS;AAC5B,aAAO;AAAA;AAGT,QAAI;AAAc,aAAO,kBAAkB,SAAS;AAEpD,UAAM,UAAU,6BAA6B,YAAY;AACzD,WAAO,QAAQ,OAAO,IAAI,MAAM;AAAA;AAAA,QAG5B,QAAQ,YAAgD,OAAgC;AAxNhG;AAyNI,UAAM,WAAW,iBAAW,YAAX,mBAAoB,IAAI,CAAC,YAAiB,UAAU,SAAS;AAC9E,UAAM,aAAa,WAAW,MAAM,QAAQ,IAAI,YAAY;AAG5D,WAAO,IAAI,WAAW,GAAG;AAAA;AAAA,EAuB3B,KACE,SACA,iBACM;AACN,UAAM,aAAa,kBAAkB,kBACjC;AAEJ,oBAAgB,IAAI,SAAS,OAAO,UAAU,aAAa,YAAY;AACvE,WAAO;AAAA;AAAA,EAkBT,OACE,SACA,SACM;AACN,oBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ;AAAA,MACpD,KAAK,CAAC,cAAmB,UAAU,WAAW;AAAA,MAC9C,QAAQ,OAAO,eAAoB,aAAa,YAAY;AAAA,MAC5D,UAAU,MAAM,KAAK;AAAA;AAGvB,WAAO;AAAA;AAAA,EAkBT,IACE,SACA,UACM;AACN,mBAAe,IAAI,SAAS,QAAQ,QAAQ;AAC5C,WAAO;AAAA;AAAA,QAYH,IACJ,SACc;AACd,WAAO,UAAU,SAAS;AAAA;AAAA,QAStB,OACJ,YAC0B;AAC1B,WAAO,aAAa,YAAY;AAAA;AAAA,EAMlC,WAA6C;AAC3C,UAAM,WAAW,IAAI;AACrB,uBAAmB;AACnB,WAAO;AAAA;AAAA;",
+  "mappings": ";AA2JA,qBAAqB,SAA0B;AAC7C,SAAO,OAAO,YAAY,aAAa,UAAU,QAAQ,UAAU,IAAI;AACzE;AAGA,IAAM,kBAAkB,OAAO,IAAI,yBAAyB;AAGrD,iBAAoC,SAAgC;AACzE,SAAO,GAAG,kBAAkB,QAAQ;AACtC;AA2DO,qBAGyC;AAAA,EACrC,aAA+D,oBAAI,IAAI;AAAA,EACvE,YAAwC,oBAAI,IAAI;AAAA,EACzD;AAAA,QAIM,KAAK,SAAkB,OAAgC;AAC3D,QAAI,MAAM,SAAS,OAAO,GAAG;AAC3B,UAAI;AAAc,eAAO,kBAAkB,SAAS,CAAC,CAAC;AACtD,YAAM,WAAU,gCAAgC,YAAY,OAAO;AACnE,aAAO,QAAQ,OAAO,IAAI,MAAM,QAAO,CAAC;AAAA,IAC1C;AAEA,UAAM,WAAU,eAAe,IAAI,OAAO;AAC1C,QAAI;AAAS,aAAO;AAEpB,UAAM,UAAU,gBAAgB,IAAI,OAAO;AAC3C,QAAI,SAAS;AACX,YAAM,WAAU,QAAQ,QAAQ,EAAE,KAAK,MAAM,QAAQ,CAAE,GAAG,OAAO,OAAQ,CAAC,CAAC;AAC3E,qBAAe,IAAI,SAAS,QAAO;AACnC,aAAO;AAAA,IACT;AAEA,QAAI;AAAc,aAAO,kBAAkB,SAAS,CAAC,CAAC;AAEtD,UAAM,UAAU,6BAA6B,YAAY,OAAO;AAChE,WAAO,QAAQ,OAAO,IAAI,MAAM,OAAO,CAAC;AAAA,EAC1C;AAAA,QAEM,QAAQ,YAAgD,OAAgC;AAjQhG;AAkQI,UAAM,WAAW,iBAAW,YAAX,mBAAoB,IAAI,CAAC,YAAuC;AAC/E,cAAQ,OAAO;AAAA,aACR;AAAA,aACA;AACH,iBAAO,UAAU,SAAS,KAAK;AAAA;AAE/B,iBAAO;AAAA;AAAA,IAEb;AAEA,UAAM,aAAa,WAAY,OAAM,QAAQ,IAAI,QAAQ,GAAG,IAAI,CAAC,MAAM;AACrE,aAAO,mBAAmB,IAAI,UAAU,EAAE,kBAAkB,KAAK,IAAI;AAAA,IACvE,CAAC,IAAI,CAAC;AAGN,WAAO,IAAI,WAAW,GAAG,UAAU;AAAA,EACrC;AAAA,EAsBA,KACE,SACA,iBACM;AACN,UAAM,aAAa,kBAAkB,kBACjC;AAEJ,oBAAgB,IAAI,SAAS,OAAO,UAAU,aAAa,YAAY,KAAK,CAAC;AAC7E,WAAO;AAAA,EACT;AAAA,EAiBA,OACE,SACA,SACM;AACN,oBAAgB,IAAI,SAAS,OAAO,UAAU,QAAQ;AAAA,MACpD,KAAK,CAAC,cAAmB,UAAU,WAAW,KAAK;AAAA,MACnD,QAAQ,OAAO,eAAoB,aAAa,YAAY,KAAK;AAAA,MACjE,UAAU,MAAM,KAAK,SAAS;AAAA,IAChC,CAAC,CAAC;AAEF,WAAO;AAAA,EACT;AAAA,EAiBA,IACE,SACA,UACM;AACN,mBAAe,IAAI,SAAS,QAAQ,QAAQ,QAAQ,CAAC;AACrD,WAAO;AAAA,EACT;AAAA,QAWM,IACJ,SACc;AACd,WAAO,UAAU,SAAS,CAAC,CAAC;AAAA,EAC9B;AAAA,EAUA,OACE,YAC0B;AAC1B,WAAO,aAAa,YAAY,CAAC,CAAC;AAAA,EACpC;AAAA,EAQA,KACE,SACe;AACf,WAAO,QAAQ;AAAA,MACb,KAAK,CAAC,cAAmB,UAAU,WAAW,CAAC,CAAC;AAAA,MAChD,QAAQ,OAAO,eAAoB,aAAa,YAAY,CAAC,CAAC;AAAA,MAC9D,UAAU,MAAM,KAAK,SAAS;AAAA,IAChC,CAAC;AAAA,EACH;AAAA,EAKA,WAA6C;AAC3C,UAAM,WAAW,IAAI,SAAiC;AACtD,uBAAmB;AACnB,WAAO;AAAA,EACT;AACF;",
   "names": []
 }

package/index.d.ts

@@ -1,12 +1,18 @@
 /** A generic constructor */
 declare type Constructor<T = any> = abstract new (...args: any) => T;
+/** The _type_ for a binding, either a `Constructor` or a `string`. */
+declare type Binding = Constructor | string;
+/** The _type_ of a binding in the context of an `Injector`. */
+declare type InjectorBinding<Components extends Constructor, Provisions extends Record<string, any>> = Components | (keyof Provisions & string) | PromisedBinding<Components | (keyof Provisions & string)>;
+/** A tuple of `InjectorBinding`s (what's needed by `$inject`). */
+declare type InjectTuple<Components extends Constructor, Provisions extends Record<string, any>> = readonly [InjectorBinding<Components, Provisions>, ...(InjectorBinding<Components, Provisions>)[]];
 /**
  * Check that an `Injector`'s static `$inject` member matches the `Injector`'s
  * own components and provisions
  */
 declare type CheckInject<Inject, // the tuple from "$inject"
 Components extends Constructor, // the `Injector`'s components
-Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends keyof Provisions ? readonly [I1] : I1 extends Extract<Components, I1> ? readonly [I1] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
+Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends PromisedBinding<infer I2> ? I2 extends keyof Provisions ? readonly [PromisedBinding<I2>] : I2 extends Extract<Components, I2> ? readonly [PromisedBinding<I2>] : readonly [PromisedBinding<never>] : I1 extends keyof Provisions ? readonly [I1] : I1 extends Extract<Components, I1> ? readonly [I1] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
     ...CheckInject<[I1], Components, Provisions>,
     ...CheckInject<I2, Components, Provisions>
 ] : readonly [Components | keyof Provisions, ...(Components | keyof Provisions)[]];
@@ -15,7 +21,7 @@ Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly
  * named provisions.
  */
 declare type MapInject<Inject, // the tuple from "$inject"
-Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends keyof Provisions ? readonly [Provisions[I1]] : I1 extends Constructor ? readonly [InstanceType<I1>] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
+Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends PromisedBinding<infer I2> ? I2 extends keyof Provisions ? readonly [Promise<Provisions[I2]>] : I2 extends Constructor ? readonly [Promise<InstanceType<I2>>] : readonly [never] : I1 extends keyof Provisions ? readonly [Provisions[I1]] : I1 extends Constructor ? readonly [InstanceType<I1>] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
     ...MapInject<[I1], Provisions>,
     ...MapInject<I2, Provisions>
 ] : readonly [never];
@@ -30,7 +36,7 @@ Provisions extends Record<string, any>> = I extends {
     $inject: CheckInject<Inject, Components, Provisions>;
     new (...args: MapInject<Inject, Provisions>): any;
 } : I extends new () => any ? I : {
-    $inject: readonly [Components | keyof Provisions, ...(Components | keyof Provisions)[]];
+    $inject: InjectTuple<Components, Provisions>;
 };
 /**
  * Return the unrolled type of a `Promise`
@@ -44,18 +50,25 @@ P extends string, // the new (string) key of the provision
 T> = {
     [key in P | keyof Provisions]: key extends P ? UnrollPromise<T> : Provisions[key];
 };
+/** A constant symbol identifying a _promised binding_. */
+declare const promisedBinding: unique symbol;
+/** Declare a _binding_ to be _promised_ (inject its `Promise`). */
+export declare function promise<B extends Binding>(binding: B): PromisedBinding<B>;
+export interface PromisedBinding<B extends Binding = Binding> {
+    [promisedBinding]: B;
+}
 /** An `Injectable` defines a constructor for an injectable class */
 export interface Injectable<Components extends Constructor, Provisions extends Record<string, any>, T = any> {
     prototype: T;
     new (...args: any): T;
-    $inject?: readonly (Components | keyof Provisions)[];
+    $inject?: InjectTuple<Components, Provisions>;
 }
 /**
  * The `Injections` interface abstracts the idea of getting bound and
  * provisioned instances from an `Injector`, injecting new `Injectable`
  * instances, and creating sub-`Injector`s.
  */
-export interface Injections<Components extends Constructor, Provisions extends Record<string, any>> {
+export interface Injections<Components extends Constructor = never, Provisions extends Record<string, any> = {}> {
     /** Get a _bound_ instance from an `Injector`. */
     get<C extends Components>(component: C): Promise<InstanceType<C>>;
     /** Get a _provisioned_ instance from an `Injector`. */
@@ -89,9 +102,9 @@ export declare class Injector<Components extends Constructor = never, Provisions
     /** Use a `Factory` to create instances bound to the given name. */
     create<P extends string, F extends Factory<Components, Provisions>>(provision: P, factory: F): Injector<Components, ExtendProvisions<Provisions, P, ReturnType<F>>>;
     /** Use the given instance binding it to to the given `Constructor`. */
-    use<C extends Constructor>(component: C, instance: InstanceType<C>): Injector<Components | C, Provisions>;
+    use<C extends Constructor>(component: C, instance: InstanceType<C> | PromiseLike<InstanceType<C>>): Injector<Components | C, Provisions>;
     /** Use the given instance binding it to to the given name. */
-    use<P extends string, T>(provision: P, instance: T): Injector<Components, ExtendProvisions<Provisions, P, T>>;
+    use<P extends string, T>(provision: P, instance: T | PromiseLike<T>): Injector<Components, ExtendProvisions<Provisions, P, T>>;
     /** Get a _bound_ instance from an `Injector` */
     get<C extends Components>(component: C): Promise<InstanceType<C>>;
     /** Get a _provisioned_ instance from an `Injector` */
@@ -103,6 +116,13 @@ export declare class Injector<Components extends Constructor = never, Provisions
      * @param injectable The constructor of the instance to create.
      */
     inject<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Promise<InstanceType<I>>;
+    /**
+     * Simple utility method to invoke the factory with the correct `Injections`
+     * and return its result.
+     *
+     * This can be used to alleviate issues when top-level await is not available.
+     */
+    make<F extends Factory<Components, Provisions>>(factory: F): ReturnType<F>;
     /** Create a sub-`Injector` child of this one. */
     injector(): Injector<Components, Provisions>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siringa",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "Simple type-checking injection library for Typescript",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -24,19 +24,19 @@
     "@types/chai-as-promised": "^7.1.5",
     "@types/mocha": "^9.1.0",
     "@types/node": "~16.11.26",
-    "@typescript-eslint/eslint-plugin": "^5.12.1",
-    "@typescript-eslint/parser": "^5.12.1",
+    "@typescript-eslint/eslint-plugin": "^5.17.0",
+    "@typescript-eslint/parser": "^5.17.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "esbuild": "^0.14.23",
-    "eslint": "^8.9.0",
+    "esbuild": "^0.14.28",
+    "eslint": "^8.12.0",
     "eslint-config-google": "^0.14.0",
-    "mocha": "^9.2.1",
+    "mocha": "^9.2.2",
     "nodemon": "^2.0.15",
     "nyc": "^15.1.0",
     "source-map-support": "^0.5.21",
     "tsd": "^0.19.1",
-    "typescript": "^4.5.5"
+    "typescript": "^4.6.3"
   },
   "directories": {
     "test": "test"

package/src/index.ts

@@ -1,6 +1,22 @@
 /** A generic constructor */
 type Constructor<T = any> = abstract new (...args: any) => T
 
+/** The _type_ for a binding, either a `Constructor` or a `string`. */
+type Binding = Constructor | string
+
+/** The _type_ of a binding in the context of an `Injector`. */
+type InjectorBinding<
+  Components extends Constructor,
+  Provisions extends Record<string, any>,
+> = Components | (keyof Provisions & string) | PromisedBinding<Components | (keyof Provisions & string)>
+
+/** A tuple of `InjectorBinding`s (what's needed by `$inject`). */
+type InjectTuple<
+  Components extends Constructor,
+  Provisions extends Record<string, any>,
+> = readonly [ InjectorBinding<Components, Provisions>, ...(InjectorBinding<Components, Provisions>)[] ]
+
+
 /* ========================================================================== */
 
 /**
@@ -19,6 +35,12 @@ type CheckInject<
   // if "$inject" is a single-element tuple, check that that this element is
   // actually included in the list of components
   Inject extends readonly [ infer I1 ] ?
+    I1 extends PromisedBinding<infer I2> ?
+      I2 extends keyof Provisions ?
+        readonly [ PromisedBinding<I2> ] :
+      I2 extends Extract<Components, I2> ?
+        readonly [ PromisedBinding<I2> ] :
+      readonly [ PromisedBinding<never> ] :
     I1 extends keyof Provisions ?
       readonly [ I1 ] :
     I1 extends Extract<Components, I1> ?
@@ -53,6 +75,14 @@ type MapInject<
 
   // "$inject" is a single-element tuple
   Inject extends readonly [ infer I1 ] ?
+    I1 extends PromisedBinding<infer I2> ?
+      // promised bindings
+      I2 extends keyof Provisions ?
+        readonly [ Promise<Provisions[I2]> ] :
+      I2 extends Constructor ?
+        readonly [ Promise<InstanceType<I2>> ] :
+      readonly [ never ] :
+    // resolved (non promised) bindings
     I1 extends keyof Provisions ?
       readonly [ Provisions[I1] ] :
     I1 extends Constructor ?
@@ -93,7 +123,7 @@ type CheckInjectable<
     I :
 
   // Anything else requires "$inject" to be present
-  { $inject: readonly [ Components | keyof Provisions, ...(Components | keyof Provisions)[] ] }
+  { $inject: InjectTuple<Components, Provisions> }
 
 /* ========================================================================== */
 
@@ -118,17 +148,28 @@ type ExtendProvisions<
       Provisions[key]
 }
 
-/* ========================================================================== */
-
-type Binding = Constructor | string
+/* ========================================================================== *
+ * EXPORTED TYPES                                                             *
+ * ========================================================================== */
 
+/** Utility to nicely print a binding name */
 function bindingName(binding: Binding): string {
   return typeof binding === 'function' ? `[class ${binding.name}]` : `"${binding}"`
 }
 
-/* ========================================================================== *
- * EXPORTED TYPES                                                             *
- * ========================================================================== */
+/** A constant symbol identifying a _promised binding_. */
+const promisedBinding = Symbol.for('siringa.promisedBinding')
+
+/** Declare a _binding_ to be _promised_ (inject its `Promise`). */
+export function promise<B extends Binding>(binding: B): PromisedBinding<B> {
+  return { [promisedBinding]: binding }
+}
+
+/* ========================================================================== */
+
+export interface PromisedBinding<B extends Binding = Binding> {
+  [promisedBinding]: B
+}
 
 /** An `Injectable` defines a constructor for an injectable class */
 export interface Injectable<
@@ -138,7 +179,7 @@ export interface Injectable<
 > {
   prototype: T
   new (...args: any): T
-  $inject?: readonly (Components | keyof Provisions)[]
+  $inject?: InjectTuple<Components, Provisions>
 }
 
 /**
@@ -147,8 +188,8 @@ export interface Injectable<
  * instances, and creating sub-`Injector`s.
  */
 export interface Injections<
-  Components extends Constructor,
-  Provisions extends Record<string, any>,
+  Components extends Constructor = never,
+  Provisions extends Record<string, any> = {},
 > {
   /** Get a _bound_ instance from an `Injector`. */
   get<C extends Components>(component: C): Promise<InstanceType<C>>
@@ -215,8 +256,19 @@ export class Injector<
   }
 
   async #inject(injectable: Injectable<Components, Provisions>, stack: Binding[]): Promise<any> {
-    const promises = injectable.$inject?.map((binding: any) => this.#get(binding, stack))
-    const injections = promises ? await Promise.all(promises) : []
+    const promises = injectable.$inject?.map((binding: Binding | PromisedBinding) => {
+      switch (typeof binding) {
+        case 'string':
+        case 'function':
+          return this.#get(binding, stack)
+        default:
+          return binding
+      }
+    })
+
+    const injections = promises ? (await Promise.all(promises)).map((i) => {
+      return promisedBinding in i ? this.#get(i[promisedBinding], stack) : i
+    }) : []
 
     // eslint-disable-next-line new-cap
     return new injectable(...injections)
@@ -286,13 +338,13 @@ export class Injector<
   /** Use the given instance binding it to to the given `Constructor`. */
   use<C extends Constructor>(
     component: C,
-    instance: InstanceType<C>,
+    instance: InstanceType<C> | PromiseLike<InstanceType<C>>,
   ): Injector<Components | C, Provisions>
 
   /** Use the given instance binding it to to the given name. */
   use<P extends string, T>(
     provision: P,
-    instance: T,
+    instance: T | PromiseLike<T>,
   ): Injector<Components, ExtendProvisions<Provisions, P, T>>
 
   // Overloaded implementation
@@ -319,18 +371,36 @@ export class Injector<
     return this.#get(binding, [])
   }
 
+  /* INJECTIONS ============================================================= */
+
   /**
    * Create a new instance of the specified `Injectable`, providing all
    * necessary injections.
    *
    * @param injectable The constructor of the instance to create.
    */
-  async inject<I extends Injectable<Components, Provisions>>(
+  inject<I extends Injectable<Components, Provisions>>(
     injectable: I & CheckInjectable<I, Components, Provisions>,
   ): Promise<InstanceType<I>> {
     return this.#inject(injectable, [])
   }
 
+  /**
+   * Simple utility method to invoke the factory with the correct `Injections`
+   * and return its result.
+   *
+   * This can be used to alleviate issues when top-level await is not available.
+   */
+  make<F extends Factory<Components, Provisions>>(
+    factory: F,
+  ): ReturnType<F> {
+    return factory({
+      get: (component: any) => this.#get(component, []),
+      inject: async (injectable: any) => this.#inject(injectable, []),
+      injector: () => this.injector(),
+    })
+  }
+
   /* CHILD INJECTORS ======================================================== */
 
   /** Create a sub-`Injector` child of this one. */