@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/cli/run.ts

@@ -1,25 +1,29 @@
 import { join } from 'path';
+import { lastValueFrom } from 'rxjs';
 
-import { spawn } from '..';
-import { SessionBuilder } from '../domain/session-builder';
-import { now } from '../shared';
-import build from './build';
-import { buildDirectory } from './internal/workspace';
+import build from '@lib/cli/build';
+import { buildDirectory } from '@lib/cli/internal/workspace';
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+import { liveExecutionMode } from '@lib/use-execution-mode';
 
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
-  await import(join(buildDirectory(), 'index'));
 
-  const builder = new SessionBuilder().useSessionId(
-    options.id ? Number(options.id) : now()
-  );
+  const script = await import(join(buildDirectory(), name));
+  const dependencies = script.module2 as Dependency[];
 
-  const rules = await spawn(name, builder);
+  const module = new Module([
+    ...core(),
+    ...dependencies,
+    liveExecutionMode({ recording: true })
+  ]);
 
-  const session = builder.live();
-  await session.awake();
+  const { act } = await module.awake();
 
-  rules(session).subscribe();
+  const output = await act(() => lastValueFrom(script.default(options)));
+
+  console.log(output);
 }

package/src/component/distinct-until-timesamp-changed.ts

@@ -0,0 +1,11 @@
+import { filter, Observable, tap } from 'rxjs';
+
+export function distinctUntilTimestampChanged<T extends { timestamp: number }>() {
+  let prevTimestamp: number | undefined;
+
+  return (stream: Observable<T>) =>
+    stream.pipe(
+      filter(it => prevTimestamp === undefined || it.timestamp > prevTimestamp),
+      tap(it => (prevTimestamp = it.timestamp))
+    );
+}

package/src/component/error.ts

@@ -0,0 +1,32 @@
+import { decimal } from '@lib/shared';
+
+export class InsufficientFundsError extends Error {
+  constructor(assetName: string, requiredAmount: decimal, availableAmount: decimal) {
+    super(
+      `insufficient funds of ${assetName} has: ${availableAmount.toString()} requires: ${requiredAmount.toString()}`
+    );
+  }
+}
+
+export class InvalidArgumentsError extends Error {
+  constructor(argName: Record<string, unknown>) {
+    super(`invalid arguments: ${argName}`);
+  }
+}
+
+export class InvalidAssetSelectorError extends Error {
+  constructor(selector: string) {
+    super(`invalid asset selector: ${selector}`);
+  }
+}
+export class InvalidInstrumentSelectorError extends Error {
+  constructor(selector: string) {
+    super(`invalid instrument selector: ${selector}`);
+  }
+}
+
+export class AdapterMismatchError extends Error {
+  constructor() {
+    super('adapters must be the same');
+  }
+}

package/src/component/index.ts

@@ -0,0 +1,7 @@
+export * from '@lib/asset';
+export * from '@lib/component/error';
+export * from '@lib/component/ohlc';
+export * from '@lib/component/ohlc-operator';
+export * from '@lib/instrument';
+export * from '@lib/component/timeframe';
+export * from '@lib/component/distinct-until-timesamp-changed';

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

@@ -1,10 +1,9 @@
 import { from } from 'rxjs';
 
-import { d } from '../shared';
-import { Ohlc } from './ohlc';
-import { mergeOhlc, ohlc, ohlcCompleted } from './ohlc-operator';
+import { mergeOhlc, Ohlc, ohlc, ohlcCompleted } from '@lib/component';
+import { d } from '@lib/shared';
 
-describe('ohlc', () => {
+describe(ohlc.name, () => {
   test('should aggregate and pipe ohlc updates', done => {
     const input$ = from([
       { timestamp: 1, rate: d(1) },
@@ -35,7 +34,7 @@ describe('ohlc', () => {
   });
 });
 
-describe('ohlcCompleted', () => {
+describe(ohlcCompleted.name, () => {
   test('should aggregate and pipe distinct completed ohlc', done => {
     const input$ = from([
       { timestamp: 1, rate: d(1) },
@@ -60,7 +59,7 @@ describe('ohlcCompleted', () => {
   });
 });
 
-describe('mergeOhlc', () => {
+describe(mergeOhlc.name, () => {
   test('should pipe and merge ohlc from history', done => {
     const history$ = from([
       new Ohlc(1, d(1), d(1.5), d(0.5), d(2)),

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

@@ -11,9 +11,8 @@ import {
   switchMap
 } from 'rxjs';
 
-import { decimal } from '../shared';
-import { Ohlc } from './ohlc';
-import { tf } from './timeframe';
+import { Ohlc, tf } from '@lib/component';
+import { decimal } from '@lib/shared';
 
 function aggregate(
   candle: Ohlc | undefined,

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/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/not-found';

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 {}