feat: introduce cc2ic

Author: castarco

README.md

@@ -37,6 +37,7 @@ import { ... } from 'https://deno.land/x/lambda_ioc@[VERSION]/lambda-ioc/deno/in
 
 ```ts
 import {
+  cc2ic, // Stands for "class-constructor to interface-constructor"
   constructor,
   createContainer,
   func
@@ -46,7 +47,12 @@ function printNameAndAge(name: string, age: number) {
   console.log(`${name} is aged ${age}`)
 }
 
-class Person {
+interface Human {
+  age: number
+  name: readonly string
+}
+
+class Person implements Human {
   constructor(
     public readonly age: number,
     public readonly name: string
@@ -60,6 +66,11 @@ const container = createContainer()
   .register('fn', func(printNameAndAge, 'someName', 'someAge'))
   // And constructors too
   .register('Person', constructor(Person, 'someAge', 'someName'))
+  // We can do that directly, without having import `constructor`:
+  .registerConstructor('AnotherPerson', Person, 'someAge', 'someName')
+  // In case we want to register a "concrete" constructor to provide an
+  // abstract interface, we'll have to apply a small hack, using `cc2ic`:
+  .registerConstructor('Human', cc2ic<Human>()(Person), 'someAge', 'someName')
   // We can "define groups" by using `:` as an infix, the group's name will be
   // the first part of the string before `:`.
   // Groups can be used in all "register" methods.

lambda-ioc/deno/combinators.ts

@@ -113,6 +113,15 @@ export function constructor<
   }
 }
 
+// Class-Constructor to Interface-Constructor
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function cc2ic<I>(): <CC extends new (...args: any[]) => I>(cc: CC) => AsInterfaceCtor<I, CC> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return identity as <C extends I, CC extends new (...args: any[]) => C>(
+    cc: CC,
+  ) => AsInterfaceCtor<I, CC>
+}
+
 // -----------------------------------------------------------------------------
 // Private Types
 // -----------------------------------------------------------------------------
@@ -125,3 +134,22 @@ type SyncFuncContainer<
     Extract<Zip<TSyncDependencies, TParams>, readonly [ContainerKey, any][]>
   >
 >
+
+// Converts a "class constructor" type to an "interface constructor" type
+type AsInterfaceCtor<
+  I, // The interface we are interested on
+  // We have to pass CC to know its constructor parameters
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  CC extends new (...args: any[]) => I = new () => I,
+> = CC extends new (...args: infer A) => infer C
+  ? C extends I
+    ? new (...args: A) => I
+    : never
+  : never
+
+// -----------------------------------------------------------------------------
+// Private Functions
+// -----------------------------------------------------------------------------
+
+// Helper function, here to avoid creating too many anonymous lambdas
+const identity = (x: unknown) => x

lambda-ioc/deno/index.ts

@@ -8,4 +8,10 @@ export {
   type WritableContainer,
   createContainer,
 } from './container.ts';
-export { asyncSingleton, constructor, func, singleton } from './combinators.ts';
+export {
+  asyncSingleton,
+  cc2ic,
+  constructor,
+  func,
+  singleton,
+} from './combinators.ts';

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

@@ -0,0 +1,33 @@
+import { cc2ic } from '../combinators'
+import { createContainer } from '..'
+
+interface IA {
+  f: () => string
+}
+
+class A implements IA {
+  constructor(private readonly s: string) {}
+  public f(): string {
+    return this.s
+  }
+}
+
+class B {
+  constructor(private readonly a: IA) {}
+  public g(): IA {
+    return this.a
+  }
+}
+
+describe('container regressions', () => {
+  describe('registerConstructor', () => {
+    it('allows to register constructors they are depended upon through interfaces', () => {
+      const container = createContainer()
+        .registerValue('greeting', 'hello')
+        .registerConstructor('A', cc2ic<IA>()(A), 'greeting') // We have to rely on cc2ic
+        .registerConstructor('B', B, 'A')
+
+      expect(container.resolve('B').g().f()).toBe('hello')
+    })
+  })
+})

lambda-ioc/src/combinators.ts

@@ -113,6 +113,15 @@ export function constructor<
   }
 }
 
+// Class-Constructor to Interface-Constructor
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function cc2ic<I>(): <CC extends new (...args: any[]) => I>(cc: CC) => AsInterfaceCtor<I, CC> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return identity as <C extends I, CC extends new (...args: any[]) => C>(
+    cc: CC,
+  ) => AsInterfaceCtor<I, CC>
+}
+
 // -----------------------------------------------------------------------------
 // Private Types
 // -----------------------------------------------------------------------------
@@ -125,3 +134,22 @@ type SyncFuncContainer<
     Extract<Zip<TSyncDependencies, TParams>, readonly [ContainerKey, any][]>
   >
 >
+
+// Converts a "class constructor" type to an "interface constructor" type
+type AsInterfaceCtor<
+  I, // The interface we are interested on
+  // We have to pass CC to know its constructor parameters
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  CC extends new (...args: any[]) => I = new () => I,
+> = CC extends new (...args: infer A) => infer C
+  ? C extends I
+    ? new (...args: A) => I
+    : never
+  : never
+
+// -----------------------------------------------------------------------------
+// Private Functions
+// -----------------------------------------------------------------------------
+
+// Helper function, here to avoid creating too many anonymous lambdas
+const identity = (x: unknown) => x

lambda-ioc/src/index.ts

@@ -8,4 +8,10 @@ export {
   type WritableContainer,
   createContainer,
 } from './container'
-export { asyncSingleton, constructor, func, singleton } from './combinators'
+export {
+  asyncSingleton,
+  cc2ic,
+  constructor,
+  func,
+  singleton,
+} from './combinators'