Merge pull request #299 from proto-kit/refactor/remove-module-definition

Refactor/remove module definition

Author: rpanic

packages/api/src/graphql/GraphqlSequencerModule.ts

@@ -6,7 +6,6 @@ import {
   Configurable,
   log,
   ModuleContainer,
-  ModulesConfig,
   ModulesRecord,
   TypedClass,
 } from "@proto-kit/common";
@@ -22,20 +21,13 @@ export type GraphqlModulesRecord = ModulesRecord<
   TypedClass<GraphqlModule<unknown>>
 >;
 
-export interface GraphqlModulesDefintion<
-  GraphQLModules extends GraphqlModulesRecord,
-> {
-  modules: GraphQLModules;
-  config?: ModulesConfig<GraphQLModules>;
-}
-
 @closeable()
 export class GraphqlSequencerModule<GraphQLModules extends GraphqlModulesRecord>
   extends ModuleContainer<GraphQLModules>
   implements Configurable<unknown>, SequencerModule<unknown>, Closeable
 {
   public static from<GraphQLModules extends GraphqlModulesRecord>(
-    definition: GraphqlModulesDefintion<GraphQLModules>
+    definition: GraphQLModules
   ): TypedClass<GraphqlSequencerModule<GraphQLModules>> {
     return class ScopedGraphQlContainer extends GraphqlSequencerModule<GraphQLModules> {
       public constructor() {
@@ -58,8 +50,8 @@ export class GraphqlSequencerModule<GraphQLModules extends GraphqlModulesRecord>
     this.graphqlServer.setContainer(this.container);
 
     // eslint-disable-next-line guard-for-in
-    for (const moduleName in this.definition.modules) {
-      const moduleClass = this.definition.modules[moduleName];
+    for (const moduleName in this.definition) {
+      const moduleClass = this.definition[moduleName];
 
       if (
         Object.prototype.isPrototypeOf.call(

packages/api/src/graphql/modules/QueryGraphqlModule.ts

@@ -316,7 +316,7 @@ export class QueryGraphqlModule<
   ): ObjMap<GraphQLFieldConfig<unknown, unknown>> {
     const types: ObjMap<GraphQLFieldConfig<unknown, unknown>> = {};
 
-    for (const key in container.definition.modules) {
+    for (const key in container.definition) {
       const query = containerQuery[key];
 
       const moduleTypes: ObjMap<GraphQLFieldConfig<unknown, unknown>> = {};

packages/common/src/config/ModuleContainer.ts

@@ -109,18 +109,6 @@ export type RecursivePartial<T> = {
   [Key in keyof T]?: Partial<T[Key]>;
 };
 
-/**
- * Parameters required when creating a module container instance
- */
-export interface ModuleContainerDefinition<Modules extends ModulesRecord> {
-  modules: Modules;
-  // config is optional, as it may be provided by the parent/wrapper class
-  /**
-   * @deprecated
-   */
-  config?: ModulesConfig<Modules>;
-}
-
 // Removes all keys with a "never" value from an object
 export type FilterNeverValues<Type extends Record<string, unknown>> = {
   [Key in keyof Type as Type[Key] extends never ? never : Key]: Type[Key];
@@ -166,15 +154,15 @@ export class ModuleContainer<Modules extends ModulesRecord>
 
   private eventEmitterProxy: EventEmitterProxy<Modules> | undefined = undefined;
 
-  public constructor(public definition: ModuleContainerDefinition<Modules>) {
+  public constructor(public definition: Modules) {
     super();
   }
 
   /**
    * @returns list of module names
    */
   public get moduleNames() {
-    return Object.keys(this.definition.modules);
+    return Object.keys(this.definition);
   }
 
   /**
@@ -219,7 +207,7 @@ export class ModuleContainer<Modules extends ModulesRecord>
   public assertIsValidModuleName(
     moduleName: string
   ): asserts moduleName is StringKeyOf<Modules> {
-    if (!this.isValidModuleName(this.definition.modules, moduleName)) {
+    if (!this.isValidModuleName(this.definition, moduleName)) {
       throw errors.onlyValidModuleNames(moduleName);
     }
   }
@@ -349,13 +337,20 @@ export class ModuleContainer<Modules extends ModulesRecord>
 
   public resolveOrFail<ModuleType>(
     moduleName: string,
-    moduleType: TypedClass<ModuleType>
+    moduleType?: TypedClass<ModuleType>
   ) {
+    if (!this.container.isRegistered(moduleName)) {
+      throw new Error(`Dependency with token ${moduleName} not registered`);
+    }
+
     const instance = this.container.resolve<ModuleType>(moduleName);
-    const isValidModuleInstance = instance instanceof moduleType;
 
-    if (!isValidModuleInstance) {
-      throw errors.validModuleInstance(moduleName, moduleType.name);
+    if (moduleType !== undefined) {
+      const isValidModuleInstance = instance instanceof moduleType;
+
+      if (!isValidModuleInstance) {
+        throw errors.validModuleInstance(moduleName, moduleType.name);
+      }
     }
 
     return instance;
@@ -501,7 +496,7 @@ export class ModuleContainer<Modules extends ModulesRecord>
     });
 
     // register all provided modules when the container is created
-    this.registerModules(this.definition.modules);
+    this.registerModules(this.definition);
     this.container.register("ParentContainer", { useValue: this });
   }
 

packages/common/src/config/Startable.ts

@@ -0,0 +1,3 @@
+export interface Startable {
+  start(): Promise<void>;
+}

packages/common/src/events/EventEmitterProxy.ts

@@ -45,9 +45,7 @@ export class EventEmitterProxy<
   public constructor(private readonly container: ModuleContainer<Modules>) {
     super();
     container.moduleNames.forEach((moduleName) => {
-      if (
-        container.isValidModuleName(container.definition.modules, moduleName)
-      ) {
+      if (container.isValidModuleName(container.definition, moduleName)) {
         const module = container.resolve(moduleName);
         if (this.isEventEmitter(module)) {
           module.events.onAll((events: any, args: any[]) => {

packages/common/src/index.ts

@@ -3,6 +3,7 @@ export * from "./config/ConfigurableModule";
 export * from "./config/ChildContainerProvider";
 export * from "./config/ChildContainerCreatable";
 export * from "./config/injectAlias";
+export * from "./config/Startable";
 export * from "./types";
 export * from "./zkProgrammable/ZkProgrammable";
 export * from "./zkProgrammable/ProvableMethodExecutionContext";

packages/common/test/config/ContainerEvents.test.ts

@@ -42,10 +42,8 @@ describe("test event propagation", () => {
     expect.assertions(1);
 
     const container = new TestContainer({
-      modules: {
-        test: TestModule,
-        test2: TestModule2,
-      },
+      test: TestModule,
+      test2: TestModule2,
     });
 
     container.configure({

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

@@ -84,12 +84,10 @@ describe("moduleContainer", () => {
 
   beforeEach(() => {
     container = new TestModuleContainer({
-      modules: {
-        TestModule,
-        OtherTestModule,
-        // this module would not be assignable to TestModuleContainer
-        // WrongTestModule,
-      },
+      TestModule,
+      OtherTestModule,
+      // this module would not be assignable to TestModuleContainer
+      // WrongTestModule,
     });
   });
 

packages/deployment/src/environment/Environment.ts

@@ -1,12 +1,8 @@
-import { log, assertValidTextLogLevel } from "@proto-kit/common";
-import { AppChain } from "@proto-kit/sdk";
+import { log, assertValidTextLogLevel, Startable } from "@proto-kit/common";
+import { AppChain } from "@proto-kit/sequencer";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
-export interface Startable {
-  start(): Promise<void>;
-}
-
 export type StartableEnvironment<T> = Record<string, T>;
 
 export class Environment<T extends Startable> {
@@ -75,7 +71,7 @@ export class Environment<T extends Startable> {
 
     // TODO Temporary workaround
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    (appChain as unknown as AppChain<any, any, any, any>).configurePartial({
+    (appChain as unknown as AppChain<any>).configurePartial({
       Sequencer: {
         DatabasePruneModule: {
           pruneOnStartup: prune,

packages/indexer/src/Indexer.ts

@@ -1,7 +1,6 @@
 import {
   ChildContainerProvider,
   ModuleContainer,
-  ModuleContainerDefinition,
   ModulesRecord,
   TypedClass,
 } from "@proto-kit/common";
@@ -18,7 +17,7 @@ export class Indexer<
   Modules extends IndexerModulesRecord,
 > extends ModuleContainer<Modules> {
   public static from<Modules extends IndexerModulesRecord>(
-    definition: ModuleContainerDefinition<Modules>
+    definition: Modules
   ): Indexer<Modules> {
     return new Indexer(definition);
   }