Refactor/remove module definition

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

@@ -317,7 +317,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];
@@ -156,15 +144,15 @@ export class ModuleContainer<
 
   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);
   }
 
   /**
@@ -209,7 +197,7 @@ export class ModuleContainer<
   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);
     }
   }
@@ -339,13 +327,20 @@ export class ModuleContainer<
 
   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;
@@ -491,6 +486,6 @@ export class ModuleContainer<
     });
 
     // register all provided modules when the container is created
-    this.registerModules(this.definition.modules);
+    this.registerModules(this.definition);
   }
 }

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,9 +1,4 @@
-import {
-  ModuleContainer,
-  ModuleContainerDefinition,
-  ModulesRecord,
-  TypedClass,
-} from "@proto-kit/common";
+import { ModuleContainer, ModulesRecord, TypedClass } from "@proto-kit/common";
 import { container } from "tsyringe";
 
 import { IndexerModule } from "./IndexerModule";
@@ -16,7 +11,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);
   }

packages/indexer/test/GeneratedResolverFactoryGraphqlModule.test.ts

@@ -30,14 +30,10 @@ class MockedGeneratedResolverFactoryGraphqlModule extends GeneratedResolverFacto
 
 describe("GeneratedResolverFactoryGraphqlModule", () => {
   const indexer = Indexer.from({
-    modules: {
-      GraphqlServer: GraphqlServer,
-      Graphql: GraphqlSequencerModule.from({
-        modules: {
-          GeneratedResolverFactory: MockedGeneratedResolverFactoryGraphqlModule,
-        },
-      }),
-    },
+    GraphqlServer: GraphqlServer,
+    Graphql: GraphqlSequencerModule.from({
+      GeneratedResolverFactory: MockedGeneratedResolverFactoryGraphqlModule,
+    }),
   });
 
   indexer.configurePartial({

packages/indexer/test/IndexBlockTask.test.ts

@@ -12,13 +12,11 @@ import { IndexBlockTask } from "../src/tasks/IndexBlockTask";
 
 describe("IndexBlockTask", () => {
   const indexer = Indexer.from({
-    modules: {
-      Database: InMemoryDatabase,
-      TaskQueue: LocalTaskQueue,
-      LocalTaskWorkerModule: LocalTaskWorkerModule.from({
-        IndexBlockTask: IndexBlockTask,
-      }),
-    },
+    Database: InMemoryDatabase,
+    TaskQueue: LocalTaskQueue,
+    LocalTaskWorkerModule: LocalTaskWorkerModule.from({
+      IndexBlockTask: IndexBlockTask,
+    }),
   });
 
   indexer.configurePartial({

packages/indexer/test/IndexerNotifier.test.ts

@@ -49,26 +49,22 @@ class TestBalances extends Balances {
 
 function createAppChain() {
   const appChain = new TestingAppChain({
-    Runtime: Runtime.from({
-      modules: VanillaRuntimeModules.with({
+    Runtime: Runtime.from(
+      VanillaRuntimeModules.with({
         Balances: TestBalances,
-      }),
-    }),
-    Protocol: Protocol.from({
-      modules: VanillaProtocolModules.with({}),
-    }),
-    Sequencer: Sequencer.from({
-      modules: InMemorySequencerModules.with({
+      })
+    ),
+    Protocol: Protocol.from(VanillaProtocolModules.with({})),
+    Sequencer: Sequencer.from(
+      InMemorySequencerModules.with({
         IndexerNotifier: IndexerNotifier,
-      }),
-    }),
-
-    modules: {
-      Signer: InMemorySigner,
-      TransactionSender: InMemoryTransactionSender,
-      QueryTransportModule: StateServiceQueryModule,
-      NetworkStateTransportModule: BlockStorageNetworkStateModule,
-    },
+      })
+    ),
+
+    Signer: InMemorySigner,
+    TransactionSender: InMemoryTransactionSender,
+    QueryTransportModule: StateServiceQueryModule,
+    NetworkStateTransportModule: BlockStorageNetworkStateModule,
   });
 
   appChain.configurePartial({

packages/module/src/runtime/Runtime.ts

@@ -103,10 +103,7 @@ export class RuntimeZkProgrammable<
 
     const runtimeMethods = runtime.runtimeModuleNames.reduce<Methods>(
       (allMethods, runtimeModuleName) => {
-        runtime.isValidModuleName(
-          runtime.definition.modules,
-          runtimeModuleName
-        );
+        runtime.isValidModuleName(runtime.definition, runtimeModuleName);
 
         /**
          * Couldnt find a better way to circumvent the type assertion
@@ -272,7 +269,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
   implements RuntimeEnvironment, CompilableModule
 {
   public static from<Modules extends RuntimeModulesRecord>(
-    definition: RuntimeDefinition<Modules>
+    definition: Modules
   ): TypedClass<Runtime<Modules>> {
     return class RuntimeScoped extends Runtime<Modules> {
       public constructor() {
@@ -284,7 +281,9 @@ export class Runtime<Modules extends RuntimeModulesRecord>
   // runtime modules composed into a ZkProgram
   public program?: ReturnType<typeof ZkProgram>;
 
-  public definition: RuntimeDefinition<Modules>;
+  // No idea why we have to do this, but if we don't re-define it here,
+  // js can't access it from the superclass somehow
+  public definition: Modules;
 
   public zkProgrammable: ZkProgrammable<undefined, MethodPublicOutput>;
 
@@ -293,7 +292,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
    *
    * @param modules - Configuration object for the constructed Runtime
    */
-  public constructor(definition: RuntimeDefinition<Modules>) {
+  public constructor(definition: Modules) {
     super(definition);
     this.definition = definition;
     this.zkProgrammable = new RuntimeZkProgrammable<Modules>(this);
@@ -378,7 +377,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
    * @returns A list of names of all the registered module names
    */
   public get runtimeModuleNames() {
-    return Object.keys(this.definition.modules);
+    return this.moduleNames;
   }
 
   public async compile(registry: CompileRegistry) {

packages/module/test/TestingRuntime.ts

@@ -13,9 +13,7 @@ export function createTestingRuntime<Modules extends RuntimeModulesRecord>(
 } {
   const state = new InMemoryStateService();
 
-  const Runtimeclass = Runtime.from({
-    modules,
-  });
+  const Runtimeclass = Runtime.from(modules);
   const runtime = new Runtimeclass();
 
   runtime.configure(config);