@quantform/core 0.5.23 → 0.6.4

package/src/domain/session.ts

@@ -1,19 +1,21 @@
 import {
+  concat,
   defer,
   filter,
-  finalize,
   from,
   map,
   mergeMap,
   Observable,
+  of,
+  ReplaySubject,
+  share,
   shareReplay,
   startWith,
-  Subscription,
   switchMap,
   take
 } from 'rxjs';
+import { v4 } from 'uuid';
 
-import { AdapterFactory, BacktesterOptions, PaperOptions } from '../adapter';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
@@ -21,71 +23,39 @@ import {
   Candle,
   Instrument,
   InstrumentSelector,
+  invalidInstrumentSelectorError,
   Order,
   Orderbook,
   Position,
   Trade
 } from '../domain';
-import { now } from '../shared';
-import { StorageFactory } from '../storage';
+import { decimal } from '../shared';
+import { Measurement } from '../storage';
 import { Store } from '../store';
-import { balance } from './balance.operator';
-import { instrument, instruments } from './instrument.operator';
-import { order, orders } from './order.operator';
-import { orderbook } from './orderbook.operator';
-import { position, positions } from './position.operator';
-import { trade } from './trade.operator';
-
-/**
- * Describes a single session.
- */
-export interface SessionDescriptor {
-  /**
-   * Unique session identifier, used to identify session in the storage.
-   * You can generate new id every time you start the new session or provide
-   * session id explicitly to resume previous session (in code or via CLI).
-   * If you don't provide session id, it will generate new one based on time.
-   */
-  id?: number;
-
-  /**
-   * Collection of adapters used to connect to the exchanges.
-   */
-  adapter: AdapterFactory[];
+import { balance } from './balance-operator';
+import { instrument, instruments } from './instrument-operator';
+import { order, orders } from './order-operator';
+import { orderbook } from './orderbook-operator';
+import { position, positions } from './position-operator';
+import { trade } from './trade-operator';
 
-  /**
-   * Provides historical data for backtest, it's not required for live and paper
-   * sessions. Stores session variables i.e. indicators, orders, or any other type of time
-   * series data. You can install @quantform/editor to render this data in your browser.
-   */
-  storage?: StorageFactory;
-
-  /**
-   * Session additional options.
-   */
-  simulation?: PaperOptions & BacktesterOptions;
-}
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 
 export class Session {
   private initialized = false;
-  private subscription: Subscription;
 
   get timestamp(): number {
     return this.store.snapshot.timestamp;
   }
 
   constructor(
+    readonly id: number,
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
-    readonly descriptor?: SessionDescriptor
-  ) {
-    // generate session id based on time if not provided.
-    if (descriptor && !descriptor.id) {
-      descriptor.id = now();
-    }
-  }
+    readonly measurement: Measurement | undefined
+  ) { }
 
-  async awake(describe: (session: Session) => Observable<any>): Promise<void> {
+  async awake(): Promise<void> {
     if (this.initialized) {
       return;
     }
@@ -94,12 +64,6 @@ export class Session {
 
     // awake all adapters and synchronize trading accounts with store.
     await this.aggregate.awake();
-
-    if (describe) {
-      this.subscription = describe(this)
-        .pipe(finalize(() => this.dispose()))
-        .subscribe();
-    }
   }
 
   async dispose(): Promise<void> {
@@ -107,11 +71,6 @@ export class Session {
       return;
     }
 
-    if (this.subscription) {
-      this.subscription.unsubscribe();
-      this.subscription = undefined;
-    }
-
     this.store.dispose();
 
     await this.aggregate.dispose();
@@ -129,12 +88,31 @@ export class Session {
 
   /**
    * Opens a new order.
-   * Example of buy order:
-   * session.open(Order.market(instrument, 100));
    */
-  open(order: Order): Observable<Readonly<Order>> {
-    return from(this.aggregate.open(order)).pipe(
-      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
+  open(order: {
+    instrument: InstrumentSelector;
+    quantity: decimal;
+    rate?: decimal;
+  }): Observable<Readonly<Order>> {
+    const instrument = this.store.snapshot.universe.instrument.get(order.instrument.id);
+    if (!instrument) {
+      throw invalidInstrumentSelectorError(order.instrument.id);
+    }
+
+    const newOrder = new Order(
+      this.timestamp,
+      v4(),
+      instrument,
+      order.quantity,
+      this.timestamp,
+      order.rate
+    );
+
+    return of(newOrder).pipe(
+      switchMap(() => this.aggregate.open(newOrder)),
+      switchMap(() =>
+        this.order(order.instrument).pipe(filter(it => it.id == newOrder.id))
+      )
     );
   }
 
@@ -143,10 +121,7 @@ export class Session {
    */
   cancel(order: Order): Observable<Readonly<Order>> {
     return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(() =>
-        this.store.changes$.pipe(filter(it => it instanceof Order && order.id == it.id))
-      ),
-      map(it => it as Order)
+      switchMap(() => this.order(order.instrument).pipe(filter(it => it.id == order.id)))
     );
   }
 
@@ -238,4 +213,44 @@ export class Session {
       mergeMap(it => it)
     );
   }
+
+  measure<T extends { timestamp: number }>(
+    spec: {
+      kind: string;
+      timestamp?: number;
+    },
+    defaultValue?: Optional<T, 'timestamp'>
+  ): [Observable<T>, (value: T) => void] {
+    if (!this.measurement) {
+      throw new Error();
+    }
+
+    const changes$ = new ReplaySubject<Optional<T, 'timestamp'>>();
+    const persisted$ = from(
+      this.measurement.query(this.id, {
+        to: spec.timestamp ?? this.timestamp,
+        kind: spec.kind,
+        count: 1
+      })
+    ).pipe(
+      map(it =>
+        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
+      ),
+      share()
+    );
+
+    const setter = (value: Optional<T, 'timestamp'>) => {
+      const timestamp = value.timestamp ?? this.timestamp;
+      const measure = { timestamp, kind: spec.kind, payload: value };
+
+      this.measurement?.save(this.id, [measure]);
+
+      changes$.next({ ...value, timestamp });
+    };
+
+    return [
+      concat(persisted$, changes$.asObservable()).pipe(filter(it => it !== undefined)),
+      setter
+    ];
+  }
 }

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

@@ -1,23 +1,27 @@
 import { Subject } from 'rxjs';
 
+import { d } from '../shared';
 import { State } from '../store';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Component } from './component';
 import { Instrument } from './instrument';
 import { Trade } from './trade';
-import { trade } from './trade.operator';
+import { trade } from './trade-operator';
 
 describe('trade', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   const state = new State();
 
   beforeEach(() => {
-    state.trade.upsert(new Trade(instrument));
+    state.trade.upsert(new Trade(0, instrument, d.Zero, d.Zero));
   });
 
   test('should pipe an orderbook on subscription', done => {

package/src/domain/trade.spec.ts

@@ -1,16 +1,20 @@
+import { d } from '../shared';
 import { Asset } from './asset';
+import { Commission } from './commission';
 import { Instrument } from './instrument';
 import { Trade } from './trade';
 
 describe('Trade', () => {
   const instrument = new Instrument(
+    0,
     new Asset('abc', 'xyz', 4),
     new Asset('def', 'xyz', 4),
-    'abc-def'
+    'abc-def',
+    Commission.Zero
   );
 
   test('should construct an empty trade', () => {
-    const sut = new Trade(instrument);
+    const sut = new Trade(0, instrument, d.Zero, d.Zero);
 
     expect(sut.id).toEqual(instrument.id);
   });

package/src/domain/trade.ts

@@ -1,4 +1,4 @@
-import { decimal, timestamp } from '../shared';
+import { decimal } from '../shared';
 import { Instrument } from '.';
 import { Component } from './component';
 
@@ -7,13 +7,15 @@ import { Component } from './component';
  * and seller of the same asset.
  */
 export class Trade implements Component {
-  id: string;
-  kind = 'trade';
-  timestamp: timestamp;
-  rate: decimal;
-  quantity: decimal;
+  readonly id: string;
+  readonly kind = 'trade';
 
-  constructor(public readonly instrument: Instrument) {
+  constructor(
+    public timestamp: number,
+    public readonly instrument: Instrument,
+    public rate: decimal,
+    public quantity: decimal
+  ) {
     this.id = instrument.id;
   }
 

package/src/index.ts

@@ -1,7 +1,6 @@
 export * from './adapter';
-export * from './bootstrap';
 export * from './domain';
-export * from './indicator';
 export * from './shared';
 export * from './storage';
 export * from './store';
+export * from './strategy';

package/src/shared/collections.spec.ts

@@ -1,4 +1,4 @@
-import { Liquidity, LiquidityAskComparer } from '..';
+import { Liquidity, LiquidityAskComparer } from '../domain';
 import { d, PriorityList } from '.';
 
 describe('PriorityList', () => {
@@ -15,16 +15,20 @@ describe('PriorityList', () => {
       { rate: d(5), quantity: d(0) }
     ];
 
-    const sut = new PriorityList<Liquidity>(LiquidityAskComparer, 'rate');
+    const sut = new PriorityList<Liquidity>(LiquidityAskComparer, it =>
+      it.rate.toString()
+    );
 
     input.forEach(it => (it.quantity.greaterThan(0) ? sut.enqueue(it) : sut.dequeue(it)));
 
     const volume = sut.reduce((it, agg) => agg.add(it.quantity.mul(it.rate)), d.Zero);
 
-    expect(sut.head.rate).toEqual(d(2));
-    expect(sut.head.quantity).toEqual(d(3));
+    const head = sut.head ?? fail();
+
+    expect(head.rate).toEqual(d(2));
+    expect(head.quantity).toEqual(d(3));
     expect(volume).toEqual(d(6));
-    expect(sut.getByKey(2).quantity).toEqual(d(3));
-    expect(sut.getByKey(3)).toEqual(undefined);
+    expect(sut.getByKey(d(2).toString()).quantity).toEqual(d(3));
+    expect(sut.getByKey(d(3).toString())).toEqual(undefined);
   });
 });

package/src/shared/collections.ts

@@ -16,42 +16,53 @@ export class Set<T extends { id: string }> {
   }
 
   upsert(value: T) {
-    this.array.forEach((it, idx) => {
-      if (it.id == value.id) {
-        this.array[idx] = value;
+    const index = this.array.findIndex(it => it.id == value.id);
 
-        return value;
-      }
-    });
+    if (index >= 0) {
+      this.array[index] = value;
+
+      return value;
+    }
 
     this.array.push(value);
 
     return value;
   }
 
+  remove(value: T) {
+    const index = this.array.indexOf(value);
+    if (index > -1) {
+      this.array.splice(index, 1);
+    }
+  }
+
   asReadonlyArray(): ReadonlyArray<T> {
     return this.array;
   }
+
+  clear() {
+    this.array.splice(0, this.array.length);
+  }
 }
 
-export class PriorityList<T extends { next: T }> {
-  private valueByKey: Record<any, T> = {};
+export class PriorityList<T extends { next: T | undefined }> {
+  private valueByKey: Record<string, T> = {};
 
-  head: T;
+  head: T | undefined;
 
   constructor(
     private readonly comparer: (lhs: Omit<T, 'next'>, rhs: Omit<T, 'next'>) => number,
-    private readonly key: keyof Omit<T, 'next'>
+    private readonly getKeyFn: (key: Omit<T, 'next'>) => string
   ) {}
 
-  getByKey(key: any): T {
+  getByKey(key: string): T {
     return this.valueByKey[key];
   }
 
-  private make(value: Omit<T, 'next'>, next: T = undefined): T {
+  private make(value: Omit<T, 'next'>, next: T | undefined = undefined): T {
     const node = { ...value, next } as T;
 
-    this.valueByKey[node[this.key].toString()] = node;
+    this.valueByKey[this.getKeyFn(node)] = node;
 
     return node;
   }
@@ -98,17 +109,19 @@ export class PriorityList<T extends { next: T }> {
     if (this.comparer(this.head, value) == 0) {
       this.head = this.head.next;
 
-      delete this.valueByKey[value[this.key].toString()];
+      delete this.valueByKey[this.getKeyFn(value)];
     }
 
     this.visit(it => {
       if (it.next && this.comparer(it.next, value) == 0) {
         it.next = it.next.next;
 
-        delete this.valueByKey[value[this.key].toString()];
+        delete this.valueByKey[this.getKeyFn(value)];
 
-        return false;
+        return true;
       }
+
+      return false;
     });
   }
 

package/src/shared/environment.ts

@@ -0,0 +1,13 @@
+export function workingDirectory() {
+  return './.quantform/';
+}
+
+export function getEnvVar(name: string, optional = false): string {
+  const value = process.env[name];
+
+  if (!value && !optional) {
+    throw new Error(`Missing environment variable: ${name}`);
+  }
+
+  return value ?? '';
+}

package/src/shared/index.ts

@@ -1,6 +1,6 @@
 export * from './datetime';
 export * from './decimals';
-export * from './io';
+export * from './environment';
 export * from './logger';
 export * from './policy';
 export * from './collections';

package/src/shared/logger.ts

@@ -1,9 +1,37 @@
+import chalk from 'chalk';
+
+import { now } from './datetime';
+
+const colorize = (content: string) => {
+  let hash = 0x811c9dc5;
+
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+
+  return chalk.hex('#' + (hash * 0xfffff * 1000000).toString(16).slice(0, 6))(content);
+};
+
+const time = () => chalk.gray(new Date(now()).toISOString());
+
 export class Logger {
-  public static info = console && console.info && console.info.bind(console);
-  public static log = console && console.log && console.log.bind(console);
-  public static debug = console && console.debug && console.debug.bind(console);
-  public static warn = console && console.warn && console.warn.bind(console);
-  public static error = console && console.error && console.error.bind(console);
-  public static assert = console && console.assert && console.assert.bind(console);
-  public static trace = console && console.trace && console.trace.bind(console);
+  public static info = (context: string, message: string) =>
+    console.info(`${time()} ${colorize(context)}: ${message}`);
+
+  public static debug = (context: string, message: string) =>
+    console.debug(`${time()} ${colorize(context)}: ${message}`);
+
+  public static warn = (context: string, message: string) =>
+    console.warn(`${time()} ${colorize(context)}: ${message}`);
+
+  public static error = (context: string, error: unknown) => {
+    let message = 'Unknown Error';
+
+    if (error instanceof Error) {
+      message = error.message;
+    }
+
+    console.error(`${time()} ${colorize(context)}: ${message}`);
+  };
 }

package/src/shared/pipe.ts

@@ -1,6 +1,6 @@
 import { filter, map, Observable } from 'rxjs';
 
-// tslint:disable-next-line: no-any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T> = new (...args: any[]) => T;
 
 export function ofType<T extends K, K>(type: Constructor<T>) {

package/src/storage/cache.ts

@@ -16,7 +16,9 @@ export class Cache {
       to: time + 1
     });
 
-    if ((!payload.length || payload[0].timestamp < time - options.ttl) ?? 60 * 60 * 24) {
+    const ttl = options.ttl ?? 60 * 60 * 24;
+
+    if (!payload.length || payload[0].timestamp < time - ttl) {
       const value = await getter();
 
       await this.storage.save(options.key, [

package/src/storage/feed.ts

@@ -118,5 +118,7 @@ export class Feed {
         document.timestamp
       );
     }
+
+    throw new Error(`Unsupported event: ${document.kind}`);
   }
 }

package/src/storage/storage.ts

@@ -73,23 +73,25 @@ export class InMemoryStorage implements Storage {
 
     let query = this.tables[library];
 
-    if (options.from) {
-      query = query.filter(it => it.timestamp > options.from);
+    const { from, to, kind, count } = options;
+
+    if (from) {
+      query = query.filter(it => it.timestamp > from);
     }
 
-    if (options.to) {
-      query = query.filter(it => it.timestamp < options.to);
+    if (to) {
+      query = query.filter(it => it.timestamp < to);
     }
 
-    if (options.kind) {
-      query = query.filter(it => it.kind == options.kind);
+    if (kind) {
+      query = query.filter(it => it.kind == kind);
     }
 
-    if (options.from == undefined && options.to) {
+    if (from == undefined && to) {
       query = query.reverse();
     }
 
-    if (options.count) {
+    if (count) {
       query = query.slice(0, options.count);
     }
 

package/src/store/error.ts

@@ -0,0 +1,36 @@
+import { AssetSelector, InstrumentSelector, OrderState } from '../domain';
+
+export function assetNotSupportedError(selector: AssetSelector) {
+  return new Error(`asset ${selector.id} not supported.`);
+}
+
+export function instrumentNotSubscribedError(selector: InstrumentSelector) {
+  return new Error(`trying to patch a not subscribed instrument ${selector.id}`);
+}
+
+export function instrumentNotSupportedError(selector: InstrumentSelector) {
+  return new Error(`instrument ${selector.id} not supported.`);
+}
+
+export function liquidationError() {
+  return new Error('you have been liquidated.');
+}
+
+export function orderNotFoundError(id: string) {
+  return new Error(`trying to patch unknown order: ${id}`);
+}
+
+export function balanceNotFoundError(selector: AssetSelector) {
+  return new Error(`balance not found: ${selector.id}`);
+}
+
+export function orderInvalidStateError(
+  currentState: OrderState,
+  requiredStates: OrderState[]
+) {
+  return new Error(
+    `order state ${currentState} is not in one of required states: ${requiredStates.join(
+      ', '
+    )}`
+  );
+}

package/src/store/index.ts

@@ -1,9 +1,9 @@
 export * from './store';
 export * from './store-state';
-export * from './store-balance.event';
-export * from './store-instrument.event';
-export * from './store-order.event';
-export * from './store-orderbook.event';
-export * from './store-position.event';
-export * from './store-trade.event';
-export * from './store.event';
+export * from './store-balance-event';
+export * from './store-instrument-event';
+export * from './store-order-event';
+export * from './store-orderbook-event';
+export * from './store-position-event';
+export * from './store-trade-event';
+export * from './store-event';

package/src/store/{store-balance.event.spec.ts → store-balance-event.spec.ts}

@@ -1,8 +1,8 @@
 import { Asset, Commission } from '../domain';
 import { d, now } from '../shared';
 import { Store } from '.';
-import { BalancePatchEvent } from './store-balance.event';
-import { InstrumentPatchEvent } from './store-instrument.event';
+import { BalancePatchEvent } from './store-balance-event';
+import { InstrumentPatchEvent } from './store-instrument-event';
 
 describe('BalancePatchEvent', () => {
   test('should patch a store', () => {
@@ -19,7 +19,7 @@ describe('BalancePatchEvent', () => {
     );
     store.dispatch(new BalancePatchEvent(base, d(100), d.Zero, timestamp));
 
-    const balance = store.snapshot.balance.get(base.id);
+    const balance = store.snapshot.balance.get(base.id) ?? fail();
 
     expect(balance).toEqual(component);
     expect(balance.free).toEqual(d(100));