@proto-kit/common 0.1.1-develop.340 → 0.1.1-develop.455

package/src/config/ModuleContainer.ts

@@ -4,17 +4,38 @@ import "reflect-metadata";
 import {
   DependencyContainer,
   Frequency,
+  injectable,
   InjectionToken,
+  instancePerContainerCachingFactory,
+  isClassProvider,
+  isFactoryProvider,
+  isValueProvider,
   Lifecycle,
 } from "tsyringe";
 import log from "loglevel";
+import merge from "lodash/merge";
 
-import { StringKeyOf, TypedClass } from "../types";
-import { DependencyFactory } from "../dependencyFactory/DependencyFactory";
+import { MergeObjects, StringKeyOf, TypedClass } from "../types";
+import {
+  DependencyFactory,
+  InferDependencies,
+} from "../dependencyFactory/DependencyFactory";
 
-import { Configurable, ConfigurableModule } from "./ConfigurableModule";
+import {
+  Configurable,
+  ConfigurableModule,
+  NoConfig,
+} from "./ConfigurableModule";
 import { ChildContainerProvider } from "./ChildContainerProvider";
 import { ChildContainerCreatable } from "./ChildContainerCreatable";
+import { EventEmitter } from "../events/EventEmitter";
+import {
+  EventEmittingComponent,
+  EventsRecord,
+} from "../events/EventEmittingComponent";
+import { EventEmitterProxy } from "../events/EventEmitterProxy";
+import { memoize } from "lodash";
+import { Memoize } from "typescript-memoize";
 
 const errors = {
   configNotSetInContainer: (moduleName: string) =>
@@ -78,10 +99,16 @@ export type ModulesConfig<Modules extends ModulesRecord> = {
   [ConfigKey in StringKeyOf<Modules>]: InstanceType<
     Modules[ConfigKey]
   > extends Configurable<infer Config>
-    ? Config
+    ? Config extends NoConfig
+      ? Config | undefined
+      : Config
     : never;
 };
 
+export type RecursivePartial<T> = {
+  [Key in keyof T]?: T[Key] extends object ? RecursivePartial<T[Key]> : T[Key];
+};
+
 /**
  * Parameters required when creating a module container instance
  */
@@ -91,6 +118,23 @@ export interface ModuleContainerDefinition<Modules extends ModulesRecord> {
   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];
+};
+
+export type DependenciesFromModules<Modules extends ModulesRecord> =
+  FilterNeverValues<{
+    [Key in keyof Modules]: Modules[Key] extends TypedClass<DependencyFactory>
+      ? InferDependencies<InstanceType<Modules[Key]>>
+      : never;
+  }>;
+
+export type ResolvableModules<Modules extends ModulesRecord> = MergeObjects<
+  DependenciesFromModules<Modules>
+> &
+  Modules;
+
 /**
  * Reusable module container facilitating registration, resolution
  * configuration, decoration and validation of modules
@@ -107,8 +151,13 @@ export class ModuleContainer<
   // DI container holding all the registered modules
   private providedContainer?: DependencyContainer = undefined;
 
+  private eventEmitterProxy: EventEmitterProxy<Modules> | undefined = undefined;
+
   public constructor(public definition: ModuleContainerDefinition<Modules>) {
     super();
+    if (definition.config !== undefined) {
+      this.config = definition.config;
+    }
   }
 
   /**
@@ -161,16 +210,16 @@ export class ModuleContainer<
     modules: Modules,
     moduleName: string
   ): asserts moduleName is StringKeyOf<Modules> {
-    this.isValidModuleName(modules, moduleName);
+    if (!this.isValidModuleName(modules, moduleName)) {
+      throw errors.onlyValidModuleNames(moduleName);
+    }
   }
 
   public isValidModuleName(
     modules: Modules,
     moduleName: number | string | symbol
-  ): asserts moduleName is StringKeyOf<Modules> {
-    if (!Object.prototype.hasOwnProperty.call(modules, moduleName)) {
-      throw errors.onlyValidModuleNames(moduleName);
-    }
+  ): moduleName is StringKeyOf<Modules> {
+    return Object.prototype.hasOwnProperty.call(modules, moduleName);
   }
 
   public assertContainerInitialized(
@@ -207,16 +256,11 @@ export class ModuleContainer<
     }
   }
 
-  /**
-   * Inject a set of dependencies using the given list of DependencyFactories
-   * This method should be called during startup
-   */
-  protected registerDependencyFactories(
-    factories: TypedClass<DependencyFactory>[]
-  ) {
-    factories.forEach((factory) => {
-      this.container.resolve(factory).initDependencies(this.container);
-    });
+  public get events(): EventEmitterProxy<Modules> {
+    if (this.eventEmitterProxy === undefined) {
+      this.eventEmitterProxy = new EventEmitterProxy<Modules>(this);
+    }
+    return this.eventEmitterProxy;
   }
 
   /**
@@ -250,13 +294,22 @@ export class ModuleContainer<
    * @param config
    */
   public configure(config: ModulesConfig<Modules>) {
-    this.definition.config = config;
+    this.config = config;
+  }
+
+  public configurePartial(config: RecursivePartial<ModulesConfig<Modules>>) {
+    this.config = merge<
+      ModulesConfig<Modules> | NoConfig,
+      RecursivePartial<ModulesConfig<Modules>>
+    >(this.currentConfig ?? {}, config);
   }
 
   // eslint-disable-next-line accessor-pairs
   public set config(config: ModulesConfig<Modules>) {
-    super.config = config;
-    this.definition.config = config;
+    super.config = merge<
+      ModulesConfig<Modules> | NoConfig,
+      ModulesConfig<Modules>
+    >(this.currentConfig ?? {}, config);
   }
 
   /**
@@ -269,12 +322,12 @@ export class ModuleContainer<
    * @param moduleName
    * @returns
    */
-  public resolve<ResolvableModuleName extends StringKeyOf<Modules>>(
-    moduleName: ResolvableModuleName
-  ): InstanceType<Modules[ResolvableModuleName]> {
-    return this.container.resolve<InstanceType<Modules[ResolvableModuleName]>>(
-      moduleName
-    );
+  public resolve<KeyType extends StringKeyOf<ResolvableModules<Modules>>>(
+    moduleName: KeyType
+  ): InstanceType<ResolvableModules<Modules>[KeyType]> {
+    return this.container.resolve<
+      InstanceType<ResolvableModules<Modules>[KeyType]>
+    >(moduleName);
   }
 
   public resolveOrFail<ModuleType>(
@@ -299,14 +352,77 @@ export class ModuleContainer<
     moduleName: StringKeyOf<Modules>,
     containedModule: InstanceType<Modules[StringKeyOf<Modules>]>
   ) {
-    const config = this.definition.config?.[moduleName];
+    // Has to be super.config, getters behave really weird when subtyping
+    const config = super.config?.[moduleName];
 
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!config) {
       throw errors.configNotSetInContainer(moduleName.toString());
     }
 
-    containedModule.config = config;
+    if (containedModule instanceof ModuleContainer) {
+      containedModule.configure(config);
+    } else {
+      containedModule.config = config;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private isDependencyFactory(type: any): type is DependencyFactory {
+    return "dependencies" in type;
+  }
+
+  /**
+   * Inject a set of dependencies using the given list of DependencyFactories
+   * This method should be called during startup
+   */
+  protected initializeDependencyFactories(factories: StringKeyOf<Modules>[]) {
+    factories.forEach((factoryName) => {
+      this.resolve(factoryName);
+    });
+  }
+
+  /**
+   * Retrieves all dependencies generated by a particular dependencyfactory
+   * and injects them inside this modulecontainer's DI container.
+   * This will be automatically called for every module, but can also be called
+   * explicitly to initialize an extra factory
+   * @param factory
+   * @private
+   */
+  protected useDependencyFactory(factory: DependencyFactory) {
+    const dependencies = factory.dependencies();
+
+    Object.entries(dependencies).forEach(([rawKey, declaration]) => {
+      const key = rawKey.charAt(0).toUpperCase() + rawKey.slice(1);
+
+      if (
+        !this.container.isRegistered(key) ||
+        declaration.forceOverwrite === true
+      ) {
+        // Find correct provider type and call respective register
+        if (isValueProvider(declaration)) {
+          this.container.register(key, declaration);
+        } else if (isFactoryProvider(declaration)) {
+          // this enables us to have a singletoned factory
+          // that returns the same instance for each resolve
+          this.container.register(key, {
+            useFactory: instancePerContainerCachingFactory(
+              declaration.useFactory
+            ),
+          });
+        } else if (isClassProvider(declaration)) {
+          this.container.register(key, declaration, {
+            lifecycle: Lifecycle.Singleton,
+          });
+        } else {
+          // Can never be reached
+          throw new Error("Above if-statement is exhaustive");
+        }
+      } else {
+        log.debug(`Dependency ${key} already registered, skipping`);
+      }
+    });
   }
 
   /**
@@ -328,6 +444,10 @@ export class ModuleContainer<
           container.reset();
           return container;
         });
+
+        if (this.isDependencyFactory(containedModule)) {
+          this.useDependencyFactory(containedModule);
+        }
       },
       { frequency: ModuleContainer.moduleDecorationFrequency }
     );

package/src/dependencyFactory/DependencyFactory.ts

@@ -1,25 +1,21 @@
-import { DependencyContainer, injectable, Lifecycle } from "tsyringe";
+import {
+  ClassProvider,
+  FactoryProvider,
+  ValueProvider,
+} from "tsyringe";
 
 import { TypedClass } from "../types";
-import { log } from "../log";
+import { BaseModuleInstanceType } from "../config/ModuleContainer";
 
-const errors = {
-  descriptorUndefined: () =>
-    new Error("Descriptor of that dependency is undefined!"),
+export type DependencyDeclaration<Dependency> =
+  | ClassProvider<Dependency>
+  | FactoryProvider<Dependency>
+  | ValueProvider<Dependency>;
 
-  dependencyFactoryCalledDirectly: () =>
-    new Error(
-      "You cannot access the depdendency method directly, use container.resolve"
-    ),
-};
-
-const globalFactoryDependencies = new Map<
+export type DependencyRecord = Record<
   string,
-  | {
-      [key: string]: () => unknown;
-    }
-  | undefined
->();
+  DependencyDeclaration<unknown> & { forceOverwrite?: boolean }
+>;
 
 /**
  * This is an abstract class for creating DependencyFactories, a pattern
@@ -32,105 +28,20 @@ const globalFactoryDependencies = new Map<
  *
  * DependencyFactories are designed to only be used statically for sets of
  * deps that are necessary for the sequencer to work.
- *
- * Every Factory need the @dependencyFactory annotation (which basically
- * proxies @injectable()) and every method that returns a dependency has to be
- * of the format `() => Dependency` and be annotated with @dependency.
  */
-export abstract class DependencyFactory {
-  public initDependencies(container: DependencyContainer) {
-    const dependencies =
-      globalFactoryDependencies.get(this.constructor.name) ?? {};
-
-    for (const [key, useFactory] of Object.entries(dependencies)) {
-      container.register(`${key}_singleton-prototype`, {
-        useFactory: useFactory.bind(this),
-      });
-
-      const upperCaseKey = key.charAt(0).toUpperCase() + key.slice(1);
-
-      container.register(
-        upperCaseKey,
-        {
-          useToken: `${key}_singleton-prototype`,
-        },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-
-      log.debug(
-        `Registered dependency ${upperCaseKey} from factory ${this.constructor.name}`
-      );
-    }
-  }
+export interface DependencyFactory {
+  dependencies: () => DependencyRecord;
 }
 
-// type DTypes = { [key: string]: TypedClass<unknown> }
-// type Factories<T extends DTypes> = {
-//   [key in keyof T]: T[key] extends TypedClass<infer R> ? () => R : never
-// }
-//
-// export abstract class DF2<Types extends DTypes> {
-//   public constructor(private factories: Factories<Types>) {
-//
-//   }
-//   generateDependencies(): Types {
-//     let x = this.factories;
-//     return {} as Types;
-//   }
-// }
+export type TypeFromDependencyDeclaration<
+  Declaration extends DependencyDeclaration<unknown>
+> = Declaration extends DependencyDeclaration<infer Dependency> ? Dependency : never;
 
-// export function DF2C<T extends Types>(object: Factories<T>): T {
-//   const c = class C extends DF2<T>{
-//     generateDependencies(): T {
-//       return undefined;
-//     }
-//   }
-//   return new c();
-// }
-
-// class DF2I extends DF2<{x: typeof ConfigurableModule}> {
-//   constructor() {
-//     super({
-//       x: this.x
-//     });
-//   }
-//
-//   x(): ConfigurableModule<any> {
-//     return {} as ConfigurableModule<any>;
-//   }
-//
-// }
-
-export function dependency() {
-  return function decorator<Target extends DependencyFactory, Dependency>(
-    target: Target,
-    key: string,
-    descriptor: TypedPropertyDescriptor<() => Dependency>
-  ) {
-    if (descriptor.value !== undefined) {
-      const className = target.constructor.name;
-      if (!globalFactoryDependencies.has(className)) {
-        globalFactoryDependencies.set(className, {});
-      }
-
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      globalFactoryDependencies.get(target.constructor.name)![key] =
-        descriptor.value;
-
-      descriptor.value = () => {
-        throw errors.dependencyFactoryCalledDirectly();
-      };
-    } else {
-      throw errors.descriptorUndefined();
-    }
-    return descriptor;
-  };
-}
+export type MapDependencyRecordToTypes<Record extends DependencyRecord> = {
+  [Key in keyof Record]: TypedClass<TypeFromDependencyDeclaration<Record[Key]>>;
+};
 
-export function dependencyFactory() {
-  return function decorator<Target extends DependencyFactory>(
-    target: TypedClass<Target>
-  ) {
-    injectable()(target);
-  };
-}
+export type InferDependencies<Class extends BaseModuleInstanceType> =
+  Class extends DependencyFactory
+    ? MapDependencyRecordToTypes<ReturnType<Class["dependencies"]>>
+    : never;

package/src/events/EventEmitter.ts

@@ -0,0 +1,58 @@
+import { EventsRecord } from "./EventEmittingComponent";
+
+type ListenersHolder<Events extends EventsRecord> = {
+  // eslint-disable-next-line putout/putout
+  [key in keyof Events]?: ((...args: Events[key]) => void)[];
+};
+
+export class EventEmitter<Events extends EventsRecord> {
+  private readonly listeners: ListenersHolder<Events> = {};
+
+  // eslint-disable-next-line putout/putout
+  private readonly wildcardListeners: ((
+    event: keyof Events,
+    args: Events[keyof Events]
+  ) => void)[] = [];
+
+  public emit<Key extends keyof Events>(
+    event: Key,
+    ...parameters: Events[Key]
+  ) {
+    const listeners = this.listeners[event];
+    if (listeners !== undefined) {
+      listeners.forEach((listener) => {
+        listener(...parameters);
+      });
+    }
+    this.wildcardListeners.forEach((wildcardListener) => {
+      wildcardListener(event, parameters);
+    });
+  }
+
+  public onAll(listener: (event: keyof Events, args: unknown[]) => void): void {
+    this.wildcardListeners.push(listener);
+  }
+
+  public on<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    (this.listeners[event] ??= []).push(listener);
+  }
+
+  /**
+   * Primitive .off() with identity comparison for now.
+   * Could be replaced by returning an id in .on() and using that.
+   */
+  public off<Key extends keyof Events>(
+    event: Key,
+    listener: (...args: Events[Key]) => void
+  ) {
+    const events = this.listeners[event];
+    if (events !== undefined) {
+      this.listeners[event] = events.filter(
+        (candidate) => candidate !== listener
+      );
+    }
+  }
+}

package/src/events/EventEmitterProxy.ts

@@ -0,0 +1,57 @@
+import type {
+  BaseModuleType,
+  ModuleContainer,
+  ModulesRecord,
+} from "../config/ModuleContainer";
+import { StringKeyOf, UnionToIntersection } from "../types";
+
+import { EventEmitter } from "./EventEmitter";
+import { EventEmittingComponent, EventsRecord } from "./EventEmittingComponent";
+
+export type CastToEventsRecord<Record> = Record extends EventsRecord
+  ? Record
+  : {};
+
+export type ModuleEvents<ModuleType extends BaseModuleType> =
+  InstanceType<ModuleType> extends EventEmittingComponent<infer Events>
+    ? Events
+    : InstanceType<ModuleType> extends ModuleContainer<infer NestedModules>
+    ? CastToEventsRecord<ContainerEvents<NestedModules>>
+    : EventsRecord;
+
+export type ContainerEvents<Modules extends ModulesRecord> = {
+  [Key in StringKeyOf<Modules>]: ModuleEvents<Modules[Key]>;
+};
+
+export type FlattenObject<Target extends Record<string, EventsRecord>> =
+  UnionToIntersection<Target[keyof Target]>;
+
+export type FlattenedContainerEvents<Modules extends ModulesRecord> =
+  FlattenObject<ContainerEvents<Modules>>;
+
+export class EventEmitterProxy<
+  Modules extends ModulesRecord
+> extends EventEmitter<CastToEventsRecord<FlattenedContainerEvents<Modules>>> {
+  public constructor(private readonly container: ModuleContainer<Modules>) {
+    super();
+    container.moduleNames.forEach((moduleName) => {
+      if (
+        container.isValidModuleName(container.definition.modules, moduleName)
+      ) {
+        const module = container.resolve(moduleName);
+        if (this.isEventEmitter(module)) {
+          module.events.onAll((events: any, args: unknown[]) => {
+            this.emit(events, ...(args as any));
+          });
+        }
+      }
+    });
+  }
+
+  private isEventEmitter(
+    module: any
+  ): module is EventEmittingComponent<EventsRecord> {
+    const emitter = module.events;
+    return emitter !== undefined && emitter instanceof EventEmitter;
+  }
+}

package/src/events/EventEmittingComponent.ts

@@ -0,0 +1,7 @@
+import type { EventEmitter } from "./EventEmitter";
+
+export type EventsRecord = Record<string, unknown[]>;
+
+export interface EventEmittingComponent<Events extends EventsRecord> {
+  events: EventEmitter<Events>;
+}

package/src/index.ts

@@ -9,3 +9,10 @@ export * from "./zkProgrammable/provableMethod";
 export * from "./utils";
 export * from "./dependencyFactory/DependencyFactory";
 export * from "./log";
+export * from "./events/EventEmittingComponent";
+export * from "./events/EventEmitter";
+export * from "./trees/MerkleTreeStore";
+export * from "./trees/InMemoryMerkleTreeStorage";
+export * from "./trees/RollupMerkleTree";
+export * from "./events/EventEmitterProxy";
+export * from "./trees/MockAsyncMerkleStore";

package/src/trees/InMemoryMerkleTreeStorage.ts

@@ -0,0 +1,17 @@
+import { MerkleTreeStore } from "./MerkleTreeStore";
+
+export class InMemoryMerkleTreeStorage implements MerkleTreeStore {
+  protected nodes: {
+    [key: number]: {
+      [key: string]: bigint;
+    };
+  } = {};
+
+  public getNode(key: bigint, level: number): bigint | undefined {
+    return this.nodes[level]?.[key.toString()];
+  }
+
+  public setNode(key: bigint, level: number, value: bigint): void {
+    (this.nodes[level] ??= {})[key.toString()] = value;
+  }
+}

package/src/trees/MerkleTreeStore.ts

@@ -0,0 +1,5 @@
+export interface MerkleTreeStore {
+  setNode: (key: bigint, level: number, value: bigint) => void;
+
+  getNode: (key: bigint, level: number) => bigint | undefined;
+}

package/src/trees/MockAsyncMerkleStore.ts

@@ -0,0 +1,29 @@
+import { InMemoryMerkleTreeStorage } from "./InMemoryMerkleTreeStorage";
+import { noop } from "./../utils";
+
+export class MockAsyncMerkleTreeStore {
+  public readonly store = new InMemoryMerkleTreeStorage();
+
+  public commit(): void {
+    noop();
+  }
+
+  public openTransaction(): void {
+    noop();
+  }
+
+  public async getNodeAsync(
+    key: bigint,
+    level: number
+  ): Promise<bigint | undefined> {
+    return this.store.getNode(key, level);
+  }
+
+  public async setNodeAsync(
+    key: bigint,
+    level: number,
+    value: bigint
+  ): Promise<void> {
+    this.store.setNode(key, level, value);
+  }
+}