feat: registerAsyncConstructor

Author: castarco

README.md

@@ -33,28 +33,6 @@ import { ... } from 'https://denopkg.com/Coder-Spirit/lambda-ioc@[VERSION]/lambd
 import { ... } from 'https://deno.land/x/lambda_ioc@[VERSION]/lambda-ioc/deno/index.ts'
 ```
 
-## Benefits
-
-- 100% type safe:
-  - The type checker will complain if we try to resolve unregistered
-    dependencies.
-  - The type checker will complain if we try to register new dependencies that
-    depend on unregistered dependencies, or if there is any kind of type
-    mismatch.
-- Purely functional
-- Immutable
-- Circular dependencies are impossible
-
-## Drawbacks
-
-- All dependencies must be declared "in order".
-  - This implies that this IoC container cannot be used in combination with some
-    auto-wiring solutions, such as IoC decorators.
-- The involved types are a bit convoluted:
-  - They might cause the type checker to be slow.
-  - In some situations, the type checker might be unable to infer the involved
-    types due to excessive "nested types" depth.
-
 ## Example
 
 ```ts
@@ -105,13 +83,33 @@ container.resolveGroup('group2') // ~ [3, 4], not necessarily in the same order
 ```
 
 It is also possible to register and resolve asynchronous factories and
-dependencies. They are not documented yet because some "helpers" are missing,
-and therefore it's a bit more annoying to take advantage of that feature.
-
-If you are curious, just try out:
+dependencies. If you are curious, just try out:
 - `registerAsync`
+- `registerAsyncConstructor`
 - `resolveAsync`
 
+## Benefits
+
+- 100% type safe:
+  - The type checker will complain if we try to resolve unregistered
+    dependencies.
+  - The type checker will complain if we try to register new dependencies that
+    depend on unregistered dependencies, or if there is any kind of type
+    mismatch.
+- Purely functional
+- Immutable
+- Circular dependencies are impossible
+
+## Drawbacks
+
+- All dependencies must be declared "in order".
+  - This implies that this IoC container cannot be used in combination with some
+    auto-wiring solutions, such as IoC decorators.
+- The involved types are a bit convoluted:
+  - They might cause the type checker to be slow.
+  - In some situations, the type checker might be unable to infer the involved
+    types due to excessive "nested types" depth.
+
 ## Differences respect to Diddly
 
 - First-class support for Deno.

lambda-ioc/README.md

@@ -33,28 +33,6 @@ import { ... } from 'https://denopkg.com/Coder-Spirit/lambda-ioc@[VERSION]/lambd
 import { ... } from 'https://deno.land/x/lambda_ioc@[VERSION]/lambda-ioc/deno/index.ts'
 ```
 
-## Benefits
-
-- 100% type safe:
-  - The type checker will complain if we try to resolve unregistered
-    dependencies.
-  - The type checker will complain if we try to register new dependencies that
-    depend on unregistered dependencies, or if there is any kind of type
-    mismatch.
-- Purely functional
-- Immutable
-- Circular dependencies are impossible
-
-## Drawbacks
-
-- All dependencies must be declared "in order".
-  - This implies that this IoC container cannot be used in combination with some
-    auto-wiring solutions, such as IoC decorators.
-- The involved types are a bit convoluted:
-  - They might cause the type checker to be slow.
-  - In some situations, the type checker might be unable to infer the involved
-    types due to excessive "nested types" depth.
-
 ## Example
 
 ```ts
@@ -105,13 +83,33 @@ container.resolveGroup('group2') // ~ [3, 4], not necessarily in the same order
 ```
 
 It is also possible to register and resolve asynchronous factories and
-dependencies. They are not documented yet because some "helpers" are missing,
-and therefore it's a bit more annoying to take advantage of that feature.
-
-If you are curious, just try out:
+dependencies. If you are curious, just try out:
 - `registerAsync`
+- `registerAsyncConstructor`
 - `resolveAsync`
 
+## Benefits
+
+- 100% type safe:
+  - The type checker will complain if we try to resolve unregistered
+    dependencies.
+  - The type checker will complain if we try to register new dependencies that
+    depend on unregistered dependencies, or if there is any kind of type
+    mismatch.
+- Purely functional
+- Immutable
+- Circular dependencies are impossible
+
+## Drawbacks
+
+- All dependencies must be declared "in order".
+  - This implies that this IoC container cannot be used in combination with some
+    auto-wiring solutions, such as IoC decorators.
+- The involved types are a bit convoluted:
+  - They might cause the type checker to be slow.
+  - In some situations, the type checker might be unable to infer the involved
+    types due to excessive "nested types" depth.
+
 ## Differences respect to Diddly
 
 - First-class support for Deno.

lambda-ioc/deno/combinators.ts

@@ -1,11 +1,10 @@
 import {
   AsyncDependencyFactory,
-  ContainerKey,
   ReadableContainer,
   ReadableSyncContainer,
   SyncDependencyFactory,
 } from './container.ts';
-import { ParamsToResolverKeys, TupleO, Zip } from './util.ts';
+import { ContainerKey, ParamsToResolverKeys, TupleO, Zip } from './util.ts';
 
 /**
  * Given a dependency factory, returns a new factory that will always resolve

lambda-ioc/deno/container.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/ban-types */
 
-export type ContainerKey = string | symbol
+import { ContainerKey, ContextualParamsToResolverKeys } from './util.ts';
 
 type ExtractPrefix<S extends ContainerKey> =
   S extends `${infer Prefix}:${string}` ? Prefix : never
@@ -176,6 +176,51 @@ export interface WritableContainer<
     }
   >
 
+  /**
+   * Registers a new constructor that might have asynchronous-resolvable
+   * dependencies. This method is helpful when the constructor combinator is
+   * not powerful enough (as it's only able to resolve synchronously).
+   *
+   * @param name The "name" of the dependency (can be a symbol).
+   * @param constructor A class constructor, that will be use to resolve the
+   *                    registered dependency.
+   * @param args A list of dependency names that will be passed to the
+   *             registered constructor at construction time, when we try to
+   *             resolve the dependency.
+   */
+  registerAsyncConstructor<
+    TName extends ContainerKey,
+    TParams extends readonly (
+      | TSyncDependencies[keyof TSyncDependencies]
+      | TAsyncDependencies[keyof TAsyncDependencies]
+    )[],
+    TClass extends TName extends keyof TSyncDependencies
+      ? never
+      : TName extends keyof TAsyncDependencies
+      ? TAsyncDependencies[TName]
+      : unknown,
+    TDependencies extends ContextualParamsToResolverKeys<
+      TSyncDependencies,
+      TAsyncDependencies,
+      TParams
+    >,
+  >(
+    name: TName,
+    constructor: new (...args: TParams) => TClass,
+    ...args: TDependencies
+  ): Container<
+    TSyncDependencies,
+    {
+      [TK in
+        | keyof TAsyncDependencies
+        | TName]: TK extends keyof TAsyncDependencies
+        ? TName extends TK
+          ? TClass
+          : TAsyncDependencies[TK]
+        : TClass
+    }
+  >
+
   /**
    * Register an already instantiated dependency.
    *
@@ -367,6 +412,54 @@ function __createContainer<
       }
     },
 
+    registerAsyncConstructor<
+      TName extends ContainerKey,
+      TParams extends readonly (
+        | TSyncDependencies[keyof TSyncDependencies]
+        | TAsyncDependencies[keyof TAsyncDependencies]
+      )[],
+      TClass extends TName extends keyof TSyncDependencies
+        ? never
+        : TName extends keyof TAsyncDependencies
+        ? TAsyncDependencies[TName]
+        : unknown,
+      TDependencies extends ContextualParamsToResolverKeys<
+        TSyncDependencies,
+        TAsyncDependencies,
+        TParams
+      >,
+    >(
+      name: TName,
+      constructor: new (...args: TParams) => TClass,
+      ...args: TDependencies
+    ): ContainerWithNewAsyncDep<TName, TClass> {
+      const factory = async (container: typeof this) => {
+        const argPromises = args.map((arg) => {
+          return (arg as string) in syncDependencies
+            ? container.resolve(arg as keyof TSyncDependencies)
+            : container.resolveAsync(arg as keyof TAsyncDependencies)
+        })
+        const resolvedParams = (await Promise.all(
+          argPromises,
+        )) as unknown as TParams
+
+        return new constructor(...resolvedParams)
+      }
+
+      if (name in asyncDependencies) {
+        return __createContainer(syncDependencies, {
+          ...asyncDependencies,
+          [name]: factory,
+        }) as ContainerWithNewAsyncDep<TName, TClass>
+      } else {
+        ;(asyncDependencies as Record<TName, unknown>)[name] = factory
+        return __createContainer(
+          syncDependencies,
+          asyncDependencies,
+        ) as ContainerWithNewAsyncDep<TName, TClass>
+      }
+    },
+
     registerValue<TName extends ContainerKey, TDependency>(
       name: TName,
       dependency: TDependency,

lambda-ioc/deno/util.ts

@@ -1,13 +1,34 @@
 /* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { ContainerKey } from './container.ts';
+export type ContainerKey = string | symbol
 
 export type Zip<A extends readonly unknown[], B extends readonly unknown[]> = {
   [K in keyof A]: K extends keyof B ? [A[K], B[K]] : never
 }
 
-export type ParamsToResolverKeys<T extends readonly unknown[] | []> = { [K in keyof T]: ContainerKey }
+export type ParamsToResolverKeys<T extends readonly unknown[] | []> = {
+  [K in keyof T]: ContainerKey
+}
+
+export type ContextualParamsToResolverKeys<
+  TSyncDependencies extends Record<ContainerKey, unknown>,
+  TAsyncDependencies extends Record<ContainerKey, unknown>,
+  TParams extends
+    | readonly (
+        | TSyncDependencies[keyof TSyncDependencies]
+        | TAsyncDependencies[keyof TAsyncDependencies]
+      )[]
+    | [],
+> = {
+  [K in keyof TParams]:
+    | KeysMatching<TSyncDependencies, TParams[K]>
+    | KeysMatching<TAsyncDependencies, TParams[K]>
+}
+
+type KeysMatching<Collection, Value> = {
+  [K in keyof Collection]-?: Collection[K] extends Value ? K : never
+}[keyof Collection]
 
 export type MergeNoDuplicates<A extends {}, B extends {}> = {
   [K in keyof A | keyof B]: K extends keyof B

lambda-ioc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coderspirit/lambda-ioc",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/cjs/index.d.ts",

lambda-ioc/src/__tests__/container.test.ts

@@ -119,6 +119,32 @@ describe('container', () => {
     expect(g2).toContain(50)
     expect(g2).toContain(60)
   })
+
+  it('can register constructors with a mix of sync & async dependencies', async () => {
+    class C {
+      constructor(public readonly a: number, public readonly b: string) {}
+    }
+
+    const container = createContainer()
+      .registerValue('numeric', 10)
+      .registerAsync('text', () => Promise.resolve('hello'))
+      .registerAsyncConstructor('C', C, 'numeric', 'text')
+
+    const c1 = await container.resolveAsync('C')
+    expect(c1.a).toBe(10)
+    expect(c1.b).toBe('hello')
+
+    // Re-registering a new dependency with the same name should work, as long
+    // as we preserve its type.
+    const secondContainer = container
+      .registerAsync('float', () => Promise.resolve(34.5))
+      .registerValue('name', 'Bob')
+      .registerAsyncConstructor('C', C, 'float', 'name')
+
+    const c2 = await secondContainer.resolveAsync('C')
+    expect(c2.a).toBe(34.5)
+    expect(c2.b).toBe('Bob')
+  })
 })
 
 // Type tests

lambda-ioc/src/combinators.ts

@@ -1,11 +1,10 @@
 import {
   AsyncDependencyFactory,
-  ContainerKey,
   ReadableContainer,
   ReadableSyncContainer,
   SyncDependencyFactory,
 } from './container'
-import { ParamsToResolverKeys, TupleO, Zip } from './util'
+import { ContainerKey, ParamsToResolverKeys, TupleO, Zip } from './util'
 
 /**
  * Given a dependency factory, returns a new factory that will always resolve