Added static dependencyfactories

Author: rpanic

packages/api/src/metrics/OpenTelemetryTracer.ts

@@ -1,7 +1,21 @@
 import opentelemetry, { SpanStatusCode } from "@opentelemetry/api";
 import { Tracer } from "@proto-kit/sequencer";
+import { inject, injectable } from "tsyringe";
+import { noop } from "@proto-kit/common";
 
+import type { OpenTelemetryServer } from "./OpenTelemetryServer";
+
+@injectable()
 export class OpenTelemetryTracer implements Tracer {
+  public constructor(
+    // We need to import this here, so that the OpenTelemetryServer will be resolved
+    // before this module, and therefore will be already started when this module is
+    // eventually consumed and used
+    @inject("OpenTelemetryServer") openTelemetryServer: OpenTelemetryServer
+  ) {
+    noop();
+  }
+
   private tracer: ReturnType<typeof opentelemetry.trace.getTracer> | undefined =
     undefined;
 

packages/common/src/config/ModuleContainer.ts

@@ -263,6 +263,10 @@ export class ModuleContainer<
         this.onAfterModuleResolution(moduleName);
 
         this.registerAliases(moduleName, useClass);
+
+        if (this.isDependencyFactory(useClass)) {
+          this.useDependencyFactory(useClass);
+        }
       }
     });
   }
@@ -285,16 +289,6 @@ export class ModuleContainer<
     });
   }
 
-  protected registerClasses(modules: Record<string, TypedClass<unknown>>) {
-    Object.entries(modules).forEach(([moduleName, useClass]) => {
-      this.container.register(
-        moduleName,
-        { useClass },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    });
-  }
-
   /**
    * Provide additional configuration after the ModuleContainer was created.
    *
@@ -403,14 +397,18 @@ export class ModuleContainer<
   protected useDependencyFactory(factory: DependencyFactory) {
     const dependencies = factory.dependencies();
 
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     Object.entries(dependencies).forEach(([rawKey, declaration]) => {
       const key = rawKey.charAt(0).toUpperCase() + rawKey.slice(1);
 
       if (
         !this.container.isRegistered(key) ||
         declaration.forceOverwrite === true
       ) {
-        if (this.container.isRegistered(key) && declaration.forceOverwrite) {
+        if (
+          this.container.isRegistered(key) &&
+          (declaration?.forceOverwrite ?? false)
+        ) {
           log.warn(
             `You are trying to overwrite dependency ${key}, which is already registered. This is currently not supported. Try to define your dependency earlier.`
           );
@@ -434,6 +432,11 @@ export class ModuleContainer<
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             declaration.useClass as TypedClass<unknown>
           );
+
+          // Register static dependencies
+          if (this.isDependencyFactory(declaration.useClass)) {
+            this.useDependencyFactory(declaration.useClass);
+          }
         } else if (isTokenProvider(declaration)) {
           this.container.register(key, declaration, {
             lifecycle: Lifecycle.Singleton,

packages/module/src/factories/MethodIdFactory.ts

@@ -1,9 +1,9 @@
-import { DependencyFactory, DependencyRecord } from "@proto-kit/common";
+import { DependencyRecord } from "@proto-kit/common";
 
 import { MethodIdResolver } from "../runtime/MethodIdResolver";
 
-export class MethodIdFactory implements DependencyFactory {
-  public dependencies() {
+export class MethodIdFactory {
+  public static dependencies() {
     return {
       methodIdResolver: {
         useClass: MethodIdResolver,

packages/module/src/runtime/Runtime.ts

@@ -303,7 +303,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
   public create(childContainerProvider: ChildContainerProvider) {
     super.create(childContainerProvider);
 
-    this.useDependencyFactory(this.container.resolve(MethodIdFactory));
+    this.useDependencyFactory(MethodIdFactory);
   }
 
   public get areProofsEnabled(): AreProofsEnabled | undefined {

packages/sdk/src/appChain/AppChain.ts

@@ -313,9 +313,9 @@ export class AppChain<
   ) {
     this.create(() => dependencyContainer);
 
-    this.useDependencyFactory(this.container.resolve(AreProofsEnabledFactory));
-    this.useDependencyFactory(this.container.resolve(SharedDependencyFactory));
-    this.useDependencyFactory(this.container.resolve(ConsoleLoggingFactory));
+    this.useDependencyFactory(AreProofsEnabledFactory);
+    this.useDependencyFactory(SharedDependencyFactory);
+    this.useDependencyFactory(ConsoleLoggingFactory);
 
     this.container
       .resolve<AreProofsEnabled>("AreProofsEnabled")

packages/sdk/src/appChain/AreProofsEnabledFactory.ts

@@ -1,9 +1,5 @@
 import { injectable } from "tsyringe";
-import {
-  AreProofsEnabled,
-  DependencyFactory,
-  DependencyRecord,
-} from "@proto-kit/common";
+import { AreProofsEnabled, DependencyRecord } from "@proto-kit/common";
 
 @injectable()
 export class InMemoryAreProofsEnabled implements AreProofsEnabled {
@@ -18,8 +14,8 @@ export class InMemoryAreProofsEnabled implements AreProofsEnabled {
   }
 }
 
-export class AreProofsEnabledFactory implements DependencyFactory {
-  public dependencies() {
+export class AreProofsEnabledFactory {
+  public static dependencies() {
     return {
       areProofsEnabled: {
         useClass: InMemoryAreProofsEnabled,

packages/sdk/src/appChain/SharedDependencyFactory.ts

@@ -1,8 +1,4 @@
-import {
-  DependencyDeclaration,
-  DependencyFactory,
-  DependencyRecord,
-} from "@proto-kit/common";
+import { DependencyDeclaration, DependencyRecord } from "@proto-kit/common";
 import { StateServiceProvider } from "@proto-kit/protocol";
 import { MethodIdResolver } from "@proto-kit/module";
 
@@ -11,8 +7,8 @@ export interface SharedDependencyRecord extends DependencyRecord {
   methodIdResolver: DependencyDeclaration<MethodIdResolver>;
 }
 
-export class SharedDependencyFactory implements DependencyFactory {
-  public dependencies(): SharedDependencyRecord {
+export class SharedDependencyFactory {
+  public static dependencies(): SharedDependencyRecord {
     return {
       stateServiceProvider: {
         useClass: StateServiceProvider,

packages/sequencer/src/logging/ConsoleLoggingFactory.ts

@@ -1,11 +1,9 @@
-import { injectable } from "tsyringe";
-import { DependencyFactory, DependencyRecord } from "@proto-kit/common";
+import { DependencyRecord } from "@proto-kit/common";
 
 import { ConsoleTracer } from "./ConsoleTracer";
 
-@injectable()
-export class ConsoleLoggingFactory implements DependencyFactory {
-  public dependencies() {
+export class ConsoleLoggingFactory {
+  public static dependencies() {
     return {
       Tracer: {
         useClass: ConsoleTracer,