@quantform/core 0.6.6 → 0.7.0-beta.10

package/src/{domain → component}/ohlc.spec.ts

@@ -1,5 +1,5 @@
-import { d, now } from '../shared';
-import { Ohlc } from './ohlc';
+import { Ohlc } from '@lib/component';
+import { d, now } from '@lib/shared';
 
 describe('Ohlc', () => {
   test('should construct a ohlc', () => {

package/src/{domain → component}/ohlc.ts

@@ -1,4 +1,4 @@
-import { decimal, timestamp } from '../shared';
+import { decimal, timestamp } from '@lib/shared';
 
 export class Ohlc {
   constructor(
@@ -8,7 +8,7 @@ export class Ohlc {
     public low: decimal,
     public close: decimal,
     public volume?: decimal
-  ) { }
+  ) {}
 
   apply(value: decimal) {
     this.high = decimal.max(this.high, value);

package/src/core.ts

@@ -0,0 +1,14 @@
+import { Dependency } from '@lib/module';
+import { memo } from '@lib/use-memo';
+
+import { InMemoryStorageFactory } from './storage';
+import { storage } from './storage/use-storage-factory';
+import { paperExecutionMode } from './use-execution-mode';
+
+export function core(): Dependency[] {
+  return [
+    memo(),
+    paperExecutionMode({ recording: false }),
+    storage(new InMemoryStorageFactory())
+  ];
+}

package/src/defined.ts

@@ -0,0 +1,6 @@
+import { filter, Observable } from 'rxjs';
+
+export function defined<T>() {
+  return (observable: Observable<T | undefined | null>) =>
+    observable.pipe(filter(it => it !== undefined && it !== null));
+}

package/src/errored.ts

@@ -0,0 +1 @@
+export const errored = Symbol.for('errored');

package/src/exclude.ts

@@ -0,0 +1,9 @@
+import { filter, map, Observable } from 'rxjs';
+
+export function exclude<T, S extends symbol>(s: S) {
+  return (observable: Observable<T | S>) =>
+    observable.pipe(
+      filter(it => it !== s),
+      map(it => it as Exclude<T, typeof s>)
+    );
+}

package/src/index.ts

@@ -1,80 +1,27 @@
-import chalk from 'chalk';
-import { finalize, forkJoin, Observable, of, switchMap } from 'rxjs';
-
-import { Session, SessionBuilder, SessionFeature } from './domain';
-export * from './adapter';
-export * from './domain';
-export * from './shared';
-export * from './storage';
-export * from './store';
-
-import { Logger } from './shared';
-
-const registry: Record<string, () => Array<SessionFeature>> = {};
-
-export type SessionHook = (session: Session) => Observable<any>;
-
-/**
- * Describes a single strategy logic
- */
-export let rule: (name: string | undefined, describe: SessionHook) => void;
-
-/**
- *
- */
-export let beforeAll: (describe: SessionHook) => void;
-
-/**
- *
- * @param name
- * @param describe
- */
-export function describe(name: string, describe: () => Array<SessionFeature>) {
-  registry[name] = describe;
-}
-
-/**
- *
- * @param name
- * @param builder
- * @returns
- */
-export async function spawn(name: string, builder: SessionBuilder) {
-  const describe = registry[name];
-  if (!describe) {
-    throw new Error(`missing strategy: ${name}`);
-  }
-
-  const ruleHooks = new Array<SessionHook>();
-  const beforeAllHooks = new Array<SessionHook>();
-
-  beforeAll = (describe: SessionHook) => {
-    beforeAllHooks.push(describe);
-  };
-
-  rule = (ruleName: string | undefined, describe: SessionHook) => {
-    if (ruleName) {
-      Logger.info(name, `${chalk.italic(ruleName)} rule found`);
-    }
-
-    ruleHooks.push(describe);
-  };
-
-  for (const feature of describe()) {
-    feature(builder);
-  }
-
-  return (session: Session) => {
-    const beforeAll$ = beforeAllHooks.map(it => it(session));
-    const rule$ = ruleHooks.map(it => it(session));
-
-    if (!beforeAll$.length) {
-      beforeAll$.push(of(true));
-    }
-
-    return forkJoin(beforeAll$).pipe(
-      switchMap(() => forkJoin(rule$)),
-      finalize(() => session.dispose())
-    );
-  };
-}
+export * from '@lib/component';
+export * from '@lib/shared';
+export * from '@lib/storage';
+export * from '@lib/module';
+export * from '@lib/use-memo';
+export * from '@lib/use-timestamp';
+export * from '@lib/simulator';
+export * from '@lib/make-test-module';
+export * from '@lib/core';
+export * from '@lib/use-state';
+export * from '@lib/replay/use-replay-coordinator';
+export * from '@lib/use-execution-mode';
+export * from '@lib/storage/use-storage';
+export * from '@lib/storage/use-cache';
+export * from '@lib/use-logger';
+export * from '@lib/replay';
+export * from '@lib/replay/use-replay-coordinator';
+export * from '@lib/use-socket';
+export * from '@lib/use-request';
+export * from '@lib/defined';
+export * from '@lib/as-readonly';
+export * from '@lib/use';
+export * from '@lib/session';
+export * from '@lib/exclude';
+export * from '@lib/use-lock';
+export * from '@lib/strat';
+export * from '@lib/errored';

package/src/{domain → instrument/commission}/commission.spec.ts

@@ -1,7 +1,8 @@
-import { d } from '../shared';
-import { commissionPercentOf } from './commission';
+import { d } from '@lib/shared';
 
-describe('Commission', () => {
+import { Commission, commissionPercentOf } from './commission';
+
+describe(Commission.name, () => {
   test('should construct a Commission', () => {
     const sut = commissionPercentOf({
       maker: d(0.1),

package/src/{domain → instrument/commission}/commission.ts

@@ -1,4 +1,4 @@
-import { d, decimal } from '../shared';
+import { d, decimal } from '@lib/shared';
 
 export class Commission {
   static readonly Zero = commissionPercentOf({ maker: d.Zero, taker: d.Zero });

package/src/instrument/index.ts

@@ -0,0 +1,2 @@
+export * from '@lib/instrument/instrument';
+export * from '@lib/instrument/commission/commission';

package/src/{domain → instrument}/instrument.spec.ts

@@ -1,9 +1,14 @@
-import { d } from '../shared';
-import { Asset, assetOf } from './asset';
-import { commissionPercentOf } from './commission';
-import { Instrument, instrumentOf } from './instrument';
+import {
+  Asset,
+  assetOf,
+  commissionPercentOf,
+  Instrument,
+  instrumentOf,
+  InstrumentSelector
+} from '@lib/component';
+import { d } from '@lib/shared';
 
-describe('Instrument', () => {
+describe(Instrument.name, () => {
   test('should construct a instrument', () => {
     const sut = new Instrument(
       0,
@@ -24,7 +29,7 @@ describe('Instrument', () => {
   });
 });
 
-describe('InstrumentSelector', () => {
+describe(InstrumentSelector.name, () => {
   test('should construct a instrument selector', () => {
     const sut = instrumentOf('xyz:abc-def');
 

package/src/{domain → instrument}/instrument.ts

@@ -1,7 +1,7 @@
-import { Asset, AssetSelector, AssetSelectorSeparator } from './asset';
-import { Commission } from './commission';
-import { Component } from './component';
-import { adapterMismatchError, invalidInstrumentSelectorError } from './error';
+import { Asset, AssetSelector, AssetSelectorSeparator } from '@lib/asset';
+import { AdapterMismatchError, InvalidInstrumentSelectorError } from '@lib/component';
+
+import { Commission } from './commission/commission';
 
 export const InstrumentSelectorSeparator = '-';
 
@@ -16,12 +16,16 @@ export class InstrumentSelector {
 
     this.id = `${this.base.id}${InstrumentSelectorSeparator}${this.quote.name}`;
   }
+
+  toString() {
+    return this.id;
+  }
 }
 
 /**
  * Represents trading market which is made up by two trading assets (base and quoted).
  */
-export class Instrument extends InstrumentSelector implements Component {
+export class Instrument extends InstrumentSelector {
   readonly cross: Instrument | undefined;
   leverage: number | undefined = undefined;
 
@@ -35,7 +39,7 @@ export class Instrument extends InstrumentSelector implements Component {
     super(base.name, quote.name, base.adapterName);
 
     if (base.adapterName != quote.adapterName) {
-      throw adapterMismatchError();
+      throw new AdapterMismatchError();
     }
   }
 }
@@ -43,12 +47,12 @@ export class Instrument extends InstrumentSelector implements Component {
 export function instrumentOf(selector: string): InstrumentSelector {
   const [adapterName, asset, ...rest] = selector.split(AssetSelectorSeparator);
   if (!adapterName || !asset || rest.length) {
-    throw invalidInstrumentSelectorError(selector);
+    throw new InvalidInstrumentSelectorError(selector);
   }
 
   const [baseAssetName, quoteAssetName] = asset.split(InstrumentSelectorSeparator);
   if (!baseAssetName || !quoteAssetName) {
-    throw invalidInstrumentSelectorError(selector);
+    throw new InvalidInstrumentSelectorError(selector);
   }
 
   return new InstrumentSelector(baseAssetName, quoteAssetName, adapterName);

package/src/make-test-module.ts

@@ -0,0 +1,46 @@
+import { Observable, tap } from 'rxjs';
+
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+
+export async function makeTestModule(dependencies: Dependency[]) {
+  const module = new Module([...core(), ...dependencies]);
+
+  const { act } = await module.awake();
+
+  return {
+    act,
+    get: module.get.bind(module)
+  };
+}
+
+type MockableFunction = (...args: any[]) => any;
+
+export const mockedFunc = <Func extends MockableFunction>(mockedFunc: Func) =>
+  mockedFunc as jest.MockedFunction<typeof mockedFunc>;
+
+export function toArray<T>(observable: Observable<T>) {
+  const array = Array.of<T>();
+
+  const clone = (it: T): T => {
+    if (typeof it === 'symbol') {
+      return it;
+    }
+
+    if (Array.isArray(it)) {
+      return it.map(it => clone(it)) as T;
+    }
+
+    if (typeof it === 'object') {
+      return { ...it };
+    }
+
+    return it;
+  };
+
+  observable.pipe(tap(it => array.push(clone(it)))).subscribe();
+
+  return array;
+}
+
+export type InferObservableType<T> = T extends Observable<infer U> ? U : never;

package/src/module.spec.ts

@@ -0,0 +1,74 @@
+import { Dependency, Module, provider } from '@lib/module';
+
+describe(Module.name, () => {
+  let fixtures: ReturnType<typeof getFixtures>;
+
+  beforeEach(() => {
+    fixtures = getFixtures();
+  });
+
+  test('builds empty module', async () => {
+    const module = fixtures.givenModuleCreated([]);
+    fixtures.whenModuleBuilt(module);
+  });
+
+  test('builds module and resolves single value dependency', async () => {
+    const definition = fixtures.definitions.singleValue;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+
+  test('builds module and resolves single class dependency', async () => {
+    const definition = fixtures.definitions.singleClass;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+
+  test('builds module and resolves many class dependencies', async () => {
+    const definition = fixtures.definitions.manyClass;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+});
+
+function getFixtures() {
+  return {
+    definitions: {
+      singleClass: [
+        {
+          provide: FakeService,
+          useClass: FakeService
+        }
+      ],
+      manyClass: [
+        {
+          provide: FakeService,
+          useClass: FakeService
+        },
+        {
+          provide: FakeService,
+          useClass: FakeService
+        }
+      ],
+      singleValue: [
+        {
+          provide: FakeService,
+          useValue: new FakeService()
+        }
+      ]
+    },
+    givenModuleCreated: (dependencies: Dependency[]) => new Module(dependencies),
+    whenModuleBuilt: (module: Module) => module.awake(),
+    thenCanResolveDependencies: (module: Module, dependencies: Dependency[]) => {
+      dependencies.forEach(it => {
+        expect(module.get<FakeService>(it.provide)).toBeTruthy();
+      });
+    }
+  };
+}
+
+@provider()
+class FakeService {}

package/src/module.ts

@@ -0,0 +1,156 @@
+import 'reflect-metadata';
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+  container,
+  DependencyContainer,
+  inject,
+  injectable,
+  injectAll,
+  InjectionToken,
+  Lifecycle
+} from 'tsyringe';
+
+export const provider = injectable;
+export const provide = inject;
+export const provideAll = injectAll;
+
+export type Dependency = {
+  provide: InjectionToken;
+  useClass?: any;
+  useValue?: any;
+};
+
+function noModuleError() {
+  return new Error('Please do not use dependency injection outside of hooks context.');
+}
+
+function withModuleError() {
+  return new Error('Please do not use with hooks in context.');
+}
+
+function notInitializedModuleError() {
+  return new Error('You need to initialize a module before use.');
+}
+
+function missingInjectionTokenError(token: InjectionToken) {
+  return new Error(`Unable to resolve unregistered dependency: ${token.toString()}`);
+}
+
+/**
+ *
+ */
+const moduleLocalStorage = new AsyncLocalStorage();
+
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export const useContext = <T>(token: InjectionToken<T>) => {
+  const module = moduleLocalStorage.getStore() as Module | undefined;
+
+  if (!module) {
+    throw noModuleError();
+  }
+
+  return module.get<T>(token);
+};
+
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export const throwWithContext = () => {
+  if (moduleLocalStorage.getStore()) {
+    throw withModuleError();
+  }
+};
+
+/**
+ * A module is a collection of services, values, and factories that can be
+ * registered with a dependency container.
+ */
+export class Module {
+  private container?: DependencyContainer;
+
+  constructor(private readonly dependencies: Dependency[]) {}
+
+  /**
+   * Builds and initializes dependencies.
+   */
+  async awake(): Promise<{ act: <T>(func: () => T) => T }> {
+    this.container = this.buildContainer();
+
+    return {
+      /**
+       * Associate callback function with current executing module
+       */
+      act: <T>(func: () => T) => moduleLocalStorage.run(this, func)
+    };
+  }
+
+  /**
+   * Disposes all dependencies instantiated by this module.
+   * @returns
+   */
+  dispose() {
+    if (!this.container) {
+      return;
+    }
+
+    this.container = undefined;
+  }
+
+  /**
+   * Builds a new instance of dependency container based on module definition.
+   * @returns
+   */
+  protected buildContainer(): DependencyContainer {
+    const childContainer = container.createChildContainer();
+
+    this.dependencies.forEach(it => {
+      if (it.useValue) {
+        childContainer.register(it.provide, { useValue: it.useValue });
+      } else {
+        childContainer.register(it.provide, it.useClass ?? it.provide, {
+          lifecycle: Lifecycle.Singleton
+        });
+      }
+    });
+
+    return childContainer;
+  }
+
+  /**
+   * Resolves a dependency from the module.
+   * @param token represents the identifier for the dependency that you want to
+   * resolve from the container.
+   * @returns instance of the dependency.
+   */
+  get<T>(token: InjectionToken<T>): T {
+    if (!this.container) {
+      throw notInitializedModuleError();
+    }
+
+    if (!this.container.isRegistered(token)) {
+      throw missingInjectionTokenError(token);
+    }
+
+    return this.container.resolve<T>(token);
+  }
+
+  /**
+   * Resolves a collection of dependencies from the module.
+   * @param token
+   * @returns
+   */
+  getAll<T>(token: InjectionToken<T>): T[] {
+    if (!this.container) {
+      throw notInitializedModuleError();
+    }
+
+    if (!this.container.isRegistered(token)) {
+      throw missingInjectionTokenError(token);
+    }
+
+    return container.resolveAll<T>(token);
+  }
+}

package/src/replay/index.ts

@@ -0,0 +1,6 @@
+export * from './use-replay';
+export * from './use-replay-coordinator';
+export * from './use-replay-options';
+export * from './use-replay-reader';
+export * from './use-replay-writer';
+export * from './with-replay';