Merge pull request #438 from proto-kit/feature/dependency-factory-all-static

Made all dependencyfactories static

Author: rpanic

packages/common/src/config/ModuleContainer.ts

@@ -1,6 +1,7 @@
 import "reflect-metadata";
 
 import {
+  ClassProvider,
   DependencyContainer,
   Frequency,
   InjectionToken,
@@ -18,6 +19,7 @@ import { MergeObjects, StringKeyOf, TypedClass } from "../types";
 import {
   DependencyFactory,
   InferDependencies,
+  isGeneratedProvider,
 } from "../dependencyFactory/DependencyFactory";
 import { EventEmitterProxy } from "../events/EventEmitterProxy";
 
@@ -116,11 +118,9 @@ export type FilterNeverValues<Type extends Record<string, unknown>> = {
 
 export type DependenciesFromModules<Modules extends ModulesRecord> =
   FilterNeverValues<{
-    [Key in keyof Modules]: Modules[Key] extends TypedClass<DependencyFactory>
-      ? InferDependencies<InstanceType<Modules[Key]>>
-      : Modules[Key] extends DependencyFactory
-        ? InferDependencies<Modules[Key]>
-        : never;
+    [Key in keyof Modules]: Modules[Key] extends DependencyFactory<any>
+      ? InferDependencies<Modules[Key]>
+      : never;
   }>;
 
 export type ResolvableModules<Modules extends ModulesRecord> = MergeObjects<
@@ -265,7 +265,7 @@ export class ModuleContainer<Modules extends ModulesRecord>
         this.registerAliases(moduleName, useClass);
 
         if (this.isDependencyFactory(useClass)) {
-          this.useDependencyFactory(useClass);
+          this.useDependencyFactory(useClass, moduleName);
         }
       }
     });
@@ -379,7 +379,9 @@ export class ModuleContainer<Modules extends ModulesRecord>
     }
   }
 
-  private isDependencyFactory(type: any): type is DependencyFactory {
+  private isDependencyFactory<T, Class extends ClassProvider<T>["useClass"]>(
+    type: Class
+  ): type is DependencyFactory<T> & Class {
     return "dependencies" in type;
   }
 
@@ -399,9 +401,13 @@ export class ModuleContainer<Modules extends ModulesRecord>
    * This will be automatically called for every module, but can also be called
    * explicitly to initialize an extra factory
    * @param factory
+   * @param token
    * @private
    */
-  protected useDependencyFactory(factory: DependencyFactory) {
+  protected useDependencyFactory<T>(
+    factory: DependencyFactory<T>,
+    token?: string
+  ) {
     const dependencies = factory.dependencies();
 
     // eslint-disable-next-line sonarjs/cognitive-complexity
@@ -422,7 +428,20 @@ export class ModuleContainer<Modules extends ModulesRecord>
         }
 
         // Find correct provider type and call respective register
-        if (isValueProvider(declaration)) {
+        if (isGeneratedProvider(declaration)) {
+          if (token === undefined) {
+            throw new Error(
+              "Cannot use generated provider without injection token"
+            );
+          }
+          // Here we first resolve the instance and then give it to the generator
+          this.container.register(key, {
+            useFactory: instanceCachingFactory((container) => {
+              const instance = container.resolve<T>(token);
+              return declaration.useGenerated(instance, this.container);
+            }),
+          });
+        } else if (isValueProvider(declaration)) {
           this.container.register(key, declaration);
         } else if (isFactoryProvider(declaration)) {
           // this enables us to have a singletoned factory
@@ -442,7 +461,7 @@ export class ModuleContainer<Modules extends ModulesRecord>
 
           // Register static dependencies
           if (this.isDependencyFactory(declaration.useClass)) {
-            this.useDependencyFactory(declaration.useClass);
+            this.useDependencyFactory(declaration.useClass, key);
           }
         } else if (isTokenProvider(declaration)) {
           this.container.register(key, declaration, {
@@ -476,10 +495,6 @@ export class ModuleContainer<Modules extends ModulesRecord>
           container.reset();
           return container;
         });
-
-        if (this.isDependencyFactory(containedModule)) {
-          this.useDependencyFactory(containedModule);
-        }
       },
       { frequency: ModuleContainer.moduleDecorationFrequency }
     );
@@ -496,10 +511,10 @@ export class ModuleContainer<Modules extends ModulesRecord>
     this.registerValue({
       ChildContainerProvider: () => this.container.createChildContainer(),
     });
+    this.container.register("ParentContainer", { useValue: this });
 
     // register all provided modules when the container is created
     this.registerModules(this.definition);
-    this.container.register("ParentContainer", { useValue: this });
   }
 
   public get dependencyContainer(): DependencyContainer {

packages/common/src/dependencyFactory/DependencyFactory.ts

@@ -1,5 +1,6 @@
 import {
   ClassProvider,
+  DependencyContainer,
   FactoryProvider,
   TokenProvider,
   ValueProvider,
@@ -8,15 +9,26 @@ import {
 import { TypedClass } from "../types";
 import { noop } from "../utils";
 
-export type DependencyDeclaration<Dependency> =
+export type GeneratedProvider<Dependency, Module> = {
+  useGenerated: (module: Module, container: DependencyContainer) => Dependency;
+};
+
+export type DependencyDeclaration<Dependency, This = unknown> =
   | ClassProvider<Dependency>
   | FactoryProvider<Dependency>
   | TokenProvider<Dependency>
-  | ValueProvider<Dependency>;
+  | ValueProvider<Dependency>
+  | GeneratedProvider<Dependency, This>;
 
-export type DependencyRecord = Record<
+export function isGeneratedProvider<Dependency, Module>(
+  input: DependencyDeclaration<Dependency, Module>
+): input is GeneratedProvider<Dependency, Module> {
+  return "useGenerated" in input;
+}
+
+export type DependencyRecord<This = unknown> = Record<
   string,
-  DependencyDeclaration<unknown> & { forceOverwrite?: boolean }
+  DependencyDeclaration<unknown, This> & { forceOverwrite?: boolean }
 >;
 
 /**
@@ -31,37 +43,39 @@ export type DependencyRecord = Record<
  * DependencyFactories are designed to only be used statically for sets of
  * deps that are necessary for the sequencer to work.
  */
-export interface DependencyFactory {
-  dependencies: () => DependencyRecord;
+export interface DependencyFactory<Type> {
+  dependencies: () => DependencyRecord<Type>;
 }
 
-export function dependencyFactory<T>() {
+export function dependencyFactory<T extends TypedClass<unknown>>() {
   return (
     /**
-     * Check if the target class itself satisfies DependencyFactory
+     * Check if the target class extends RuntimeModule, while
+     * also providing static config presets
      */
-    target: TypedClass<T> & DependencyFactory
+    target: T & DependencyFactory<InstanceType<T>>
   ) => {
     noop();
   };
 }
 
 export type TypeFromDependencyDeclaration<
-  Declaration extends DependencyDeclaration<unknown>,
+  Declaration extends DependencyDeclaration<any>,
 > =
-  Declaration extends DependencyDeclaration<infer Dependency>
+  Declaration extends DependencyDeclaration<infer Dependency, any>
     ? Dependency
     : never;
 
 export type CapitalizeAny<Key extends string | number | symbol> =
   Key extends string ? Capitalize<Key> : Key;
 
-export type MapDependencyRecordToTypes<Record extends DependencyRecord> = {
+export type MapDependencyRecordToTypes<Record extends DependencyRecord<any>> = {
   [Key in keyof Record as CapitalizeAny<Key>]: TypedClass<
     TypeFromDependencyDeclaration<Record[Key]>
   >;
 };
 
-export type InferDependencies<Class> = Class extends DependencyFactory
-  ? MapDependencyRecordToTypes<ReturnType<Class["dependencies"]>>
-  : never;
+export type InferDependencies<Class extends TypedClass<any>> =
+  Class extends DependencyFactory<any>
+    ? MapDependencyRecordToTypes<ReturnType<Class["dependencies"]>>
+    : never;

packages/common/test/config/ModuleContainer.test.ts

@@ -44,6 +44,9 @@ class TestModule extends BaseTestModule<TestModuleConfig> {
       dependencyModule1: {
         useClass: ChildModule,
       },
+      dependencyModule2: {
+        useGenerated: (module: TestModule) => "test",
+      },
     };
   }
 }
@@ -108,6 +111,9 @@ describe("moduleContainer", () => {
 
     expect(dm.x()).toBe("dependency factory works");
     expect(dm.testModule).toBeDefined();
+
+    const dm2 = container.resolve("DependencyModule2");
+    expect(dm2).toBe("test");
   });
 
   it("should throw on resolution, if config was not provided", () => {

packages/module/src/factories/MethodIdFactory.ts

@@ -1,4 +1,4 @@
-import { dependencyFactory, DependencyRecord } from "@proto-kit/common";
+import { dependencyFactory } from "@proto-kit/common";
 
 import { MethodIdResolver } from "../runtime/MethodIdResolver";
 
@@ -9,6 +9,6 @@ export class MethodIdFactory {
       methodIdResolver: {
         useClass: MethodIdResolver,
       },
-    } satisfies DependencyRecord;
+    };
   }
 }

packages/persistance/src/PrismaDatabaseConnection.ts

@@ -5,7 +5,7 @@ import {
   StorageDependencyMinimumDependencies,
   Tracer,
 } from "@proto-kit/sequencer";
-import { DependencyFactory, OmitKeys } from "@proto-kit/common";
+import { OmitKeys } from "@proto-kit/common";
 
 import { PrismaStateService } from "./services/prisma/PrismaStateService";
 import { PrismaBatchStore } from "./services/prisma/PrismaBatchStore";
@@ -38,7 +38,7 @@ export interface PrismaConnection {
 @sequencerModule()
 export class PrismaDatabaseConnection
   extends SequencerModule<PrismaDatabaseConfig>
-  implements DependencyFactory, PrismaConnection
+  implements PrismaConnection
 {
   public constructor(private readonly tracer: Tracer) {
     super();
@@ -53,13 +53,20 @@ export class PrismaDatabaseConnection
     return this.initializedClient;
   }
 
-  public dependencies(): OmitKeys<
-    StorageDependencyMinimumDependencies,
+  public static dependencies(): OmitKeys<
+    StorageDependencyMinimumDependencies<{
+      readonly prisma: PrismaDatabaseConnection;
+    }>,
     "blockTreeStore" | "asyncLinkedLeafStore" | "unprovenLinkedLeafStore"
   > {
     return {
       asyncStateService: {
-        useFactory: () => new PrismaStateService(this, this.tracer, "batch"),
+        useGenerated: (service) =>
+          new PrismaStateService(
+            service.prisma,
+            service.prisma.tracer,
+            "batch"
+          ),
       },
       batchStorage: {
         useClass: PrismaBatchStore,
@@ -71,7 +78,12 @@ export class PrismaDatabaseConnection
         useClass: PrismaBlockStorage,
       },
       unprovenStateService: {
-        useFactory: () => new PrismaStateService(this, this.tracer, "block"),
+        useGenerated: (service) =>
+          new PrismaStateService(
+            service.prisma,
+            service.prisma.tracer,
+            "block"
+          ),
       },
       settlementStorage: {
         useClass: PrismaSettlementStorage,

packages/persistance/src/PrismaRedisDatabase.ts

@@ -6,7 +6,7 @@ import {
   closeable,
   Tracer,
 } from "@proto-kit/sequencer";
-import { ChildContainerProvider } from "@proto-kit/common";
+import { ChildContainerProvider, dependencyFactory } from "@proto-kit/common";
 import { PrismaClient } from "@prisma/client";
 import { RedisClientType } from "redis";
 import { inject } from "tsyringe";
@@ -31,6 +31,7 @@ export interface PrismaRedisCombinedConfig {
 
 @sequencerModule()
 @closeable()
+@dependencyFactory()
 export class PrismaRedisDatabase
   extends SequencerModule<PrismaRedisCombinedConfig>
   implements PrismaConnection, RedisConnection, Database
@@ -63,28 +64,28 @@ export class PrismaRedisDatabase
     this.redis.create(childContainerProvider);
   }
 
-  public dependencies(): StorageDependencyMinimumDependencies {
+  public static dependencies(): StorageDependencyMinimumDependencies<PrismaRedisDatabase> {
     return {
-      ...this.prisma.dependencies(),
-      ...this.redis.dependencies(),
+      ...PrismaDatabaseConnection.dependencies(),
+      ...RedisConnectionModule.dependencies(),
 
       asyncLinkedLeafStore: {
-        useFactory: () => {
+        useGenerated: (module) => {
           return new PrismaLinkedLeafStore(
-            this.prisma,
-            this.redis,
-            this.tracer,
+            module.prisma,
+            module.redis,
+            module.tracer,
             "batch"
           );
         },
       },
 
       unprovenLinkedLeafStore: {
-        useFactory: () => {
+        useGenerated: (module) => {
           return new PrismaLinkedLeafStore(
-            this.prisma,
-            this.redis,
-            this.tracer,
+            module.prisma,
+            module.redis,
+            module.tracer,
             "block"
           );
         },