@quantform/core 0.4.11 → 0.5.15

package/src/domain/session.ts

@@ -1,22 +1,19 @@
 import {
-  concat,
   defer,
-  distinctUntilChanged,
   filter,
+  finalize,
   from,
   map,
-  merge,
   mergeMap,
   Observable,
-  share,
   shareReplay,
   startWith,
-  Subject,
   Subscription,
   switchMap,
   take
 } from 'rxjs';
-import { Adapter, BacktesterOptions, PaperOptions } from '../adapter';
+
+import { AdapterFactory, BacktesterOptions, PaperOptions } from '../adapter';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import {
   AssetSelector,
@@ -26,28 +23,21 @@ import {
   InstrumentSelector,
   Order,
   Orderbook,
-  OrderState,
-  Position
+  Position,
+  Trade
 } from '../domain';
-import { Trade } from '../domain/trade';
-import { now, Worker } from '../shared';
-import { Feed, Measurement } from '../storage';
+import { now } from '../shared';
+import { StorageFactory } from '../storage';
 import { Store } from '../store';
-
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+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.
- * You can use @run function to start a new session managed by CLI.
- * To start managed session you should install @quantform/cli package and run
- * specific command:
- *  - qf paper (to paper trade strategy)
- *  - qf backtest (to backtest strategy based on provided feed)
- *  - qf live (to live trade strategy)
- * or run on your own in code:
- *  - paper(descriptor, options)
- *  - backtest(descriptor, options)
- *  - live(descriptor)
  */
 export interface SessionDescriptor {
   /**
@@ -61,40 +51,29 @@ export interface SessionDescriptor {
   /**
    * Collection of adapters used to connect to the exchanges.
    */
-  adapter: Adapter[];
+  adapter: AdapterFactory[];
 
   /**
    * Provides historical data for backtest, it's not required for live and paper
-   * sessions.
-   */
-  feed?: Feed;
-
-  /**
-   * Stores session variables i.e. indicators, orders, or any other type of time
+   * 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.
    */
-  measurement?: Measurement;
+  storage?: StorageFactory;
 
   /**
    * Session additional options.
    */
-  options?: {
-    backtester?: BacktesterOptions;
-    paper?: PaperOptions;
-  };
+  simulation?: PaperOptions & BacktesterOptions;
 }
 
 export class Session {
   private initialized = false;
   private subscription: Subscription;
-  private worker = new Worker();
 
   get timestamp(): number {
     return this.store.snapshot.timestamp;
   }
 
-  readonly statement: Record<string, Record<string, any>> = {};
-
   constructor(
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
@@ -117,7 +96,9 @@ export class Session {
     await this.aggregate.awake();
 
     if (describe) {
-      this.subscription = describe(this).subscribe();
+      this.subscription = describe(this)
+        .pipe(finalize(() => this.dispose()))
+        .subscribe();
     }
   }
 
@@ -126,70 +107,16 @@ export class Session {
       return;
     }
 
-    this.store.dispose();
-
     if (this.subscription) {
       this.subscription.unsubscribe();
+      this.subscription = undefined;
     }
 
-    await this.aggregate.dispose();
-    await this.worker.wait();
-  }
-
-  useStatement(section: string): Record<string, any> {
-    return this.statement[section] ?? (this.statement[section] = {});
-  }
-
-  /**
-   * Returns last stored measurement and setter for it in session.
-   * For example you can save and restore variables in same session between runs.
-   * Example usage:
-   * const [order$, setOrder] = session.measurement<Order>('order');
-   *
-   * order.pipe(tap(it => console.log(`your last order was: ${it}`)));
-   *
-   * setOrder(order);
-   */
-  useMeasure<T extends { timestamp: number }>(
-    params: { kind: string; timestamp?: number },
-    defaultValue: T = undefined
-  ): [Observable<T>, (value: Optional<T, 'timestamp'>) => void] {
-    const stored$ = from(
-      this.descriptor.measurement.query(this.descriptor.id, {
-        to: params.timestamp ?? this.timestamp,
-        kind: params.kind,
-        count: 1
-      })
-    ).pipe(
-      map(it =>
-        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
-      ),
-      share()
-    );
-
-    const subject$ = new Subject<T>();
-
-    const setter = (value: T) => {
-      const timestamp = value.timestamp ?? this.timestamp;
-      const measure = { timestamp, kind: params.kind, payload: value };
-
-      this.worker.enqueue(() =>
-        this.descriptor.measurement.save(this.descriptor.id, [measure])
-      );
+    this.store.dispose();
 
-      subject$.next({ ...value, timestamp });
-    };
+    await this.aggregate.dispose();
 
-    return [concat(stored$, subject$.asObservable()), setter];
-  }
-
-  /**
-   * Return values for patch provided in optimization file.
-   * Example usage:
-   * const orderSize = session.useOptimizer('order.size');
-   */
-  useOptimizer(path: string): any {
-    return undefined;
+    this.initialized = false;
   }
 
   /**
@@ -202,26 +129,21 @@ export class Session {
 
   /**
    * Opens a new order.
-   * Example:
-   * session.open(Order.buyMarket(instrument, 100));
+   * Example of buy order:
+   * session.open(Order.market(instrument, 100));
    */
-  open(order: Order): Observable<Order> {
-    const subject = new Subject<Order>();
-
-    this.aggregate.open(order).catch(subject.error);
-
-    return merge(
-      subject.asObservable(),
-      this.order(order.instrument).pipe(filter(it => it.id == order.id))
+  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)))
     );
   }
 
   /**
    * Cancels specific order.
    */
-  cancel(order: Order): Observable<Order> {
+  cancel(order: Order): Observable<Readonly<Order>> {
     return defer(() => from(this.aggregate.cancel(order))).pipe(
-      switchMap(it =>
+      switchMap(() =>
         this.store.changes$.pipe(filter(it => it instanceof Order && order.id == it.id))
       ),
       map(it => it as Order)
@@ -232,146 +154,84 @@ export class Session {
    * Subscribes to specific instrument changes.
    * When adapter awake then it will fetch collection of all available instruments.
    */
-  instrument(selector: InstrumentSelector): Observable<Instrument> {
+  instrument(selector: InstrumentSelector): Observable<Readonly<Instrument>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(it => it instanceof Instrument && it.toString() == selector.toString()),
-      map(it => it as Instrument)
-    );
+    return this.store.changes$.pipe(instrument(selector, this.store.snapshot));
   }
 
   /**
    * Subscribes to instruments changes.
    * When adapter awake then it will fetch collection of all available instruments.
    */
-  instruments(): Observable<Instrument[]> {
-    return this.store.changes$.pipe(
-      filter(it => it instanceof Instrument),
-      map(() => Object.values(this.store.snapshot.universe.instrument)),
-      startWith(Object.values(this.store.snapshot.universe.instrument)),
-      filter(it => it.length > 0),
-      distinctUntilChanged((lhs, rhs) => lhs.length == rhs.length)
-    );
+  instruments(): Observable<Readonly<Instrument[]>> {
+    return this.store.changes$.pipe(instruments(this.store.snapshot));
+  }
+
+  /**
+   * Subscribes to balance changes.
+   */
+  balance(selector: AssetSelector): Observable<Readonly<Balance>> {
+    return this.store.changes$.pipe(balance(selector, this.store.snapshot));
   }
 
   /**
    * Subscribes to trade/ticker changes.
    */
-  trade(selector: InstrumentSelector): Observable<Trade> {
+  trade(selector: InstrumentSelector): Observable<Readonly<Trade>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Trade && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Trade)
-    );
+    return this.store.changes$.pipe(trade(selector, this.store.snapshot));
   }
 
   /**
    * Subscribes to orderbook changes.
    * Right now you can access only best bid and best ask.
    */
-  orderbook(selector: InstrumentSelector): Observable<Orderbook> {
+  orderbook(selector: InstrumentSelector): Observable<Readonly<Orderbook>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Orderbook && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Orderbook)
-    );
+    return this.store.changes$.pipe(orderbook(selector, this.store.snapshot));
   }
 
   /**
    * Subscribes to position on leveraged market.
    */
-  position(selector: InstrumentSelector): Observable<Position> {
+  position(selector: InstrumentSelector): Observable<Readonly<Position>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Position && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Position)
-    );
+    return this.store.changes$.pipe(position(selector));
   }
 
   /**
    * Subscribes to positions on leveraged markets.
    */
-  positions(selector: InstrumentSelector): Observable<Position[]> {
+  positions(selector: InstrumentSelector): Observable<Readonly<Position[]>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Position && it.instrument.toString() == selector.toString()
-      ),
-      map(() =>
-        Object.values(
-          this.store.snapshot.balance[selector.quote.toString()].position
-        ).filter(it => it.instrument.toString() == selector.toString())
-      ),
-      startWith([])
-    );
+    return this.store.changes$.pipe(positions(selector, this.store.snapshot));
   }
 
-  order(selector: InstrumentSelector): Observable<Order> {
+  order(selector: InstrumentSelector): Observable<Readonly<Order>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it => it instanceof Order && it.instrument.toString() == selector.toString()
-      ),
-      map(it => it as Order)
-    );
+    return this.store.changes$.pipe(order(selector));
   }
 
-  orders(selector: InstrumentSelector, states?: OrderState[]): Observable<Order[]> {
+  orders(selector: InstrumentSelector): Observable<Readonly<Order[]>> {
     this.subscribe([selector]);
 
-    return this.store.changes$.pipe(
-      filter(
-        it =>
-          it instanceof Order &&
-          it.instrument.toString() == selector.toString() &&
-          (!states || states.includes(it.state))
-      ),
-      map(() => this.store.snapshot.order),
-      startWith(this.store.snapshot.order),
-      map(it =>
-        Object.values(it)
-          .filter(
-            it =>
-              it.instrument.toString() == selector.toString() &&
-              (states ? states.includes(it.state) : true)
-          )
-          .sort((lhs, rhs) => rhs.createdAt - lhs.createdAt)
-      )
-    );
-  }
-
-  balance(selector: AssetSelector): Observable<Balance> {
-    return this.store.changes$.pipe(
-      startWith(this.store.snapshot.balance[selector.toString()]),
-      filter(
-        it =>
-          it instanceof Balance &&
-          (!selector || it.asset.toString() == selector.toString())
-      ),
-      map(it => it as Balance)
-    );
+    return this.store.changes$.pipe(orders(selector, this.store.snapshot));
   }
 
   history(
     selector: InstrumentSelector,
     timeframe: number,
     length: number
-  ): Observable<Candle> {
+  ): Observable<Readonly<Candle>> {
     return this.store.changes$.pipe(
-      startWith(this.store.snapshot.universe.instrument[selector.toString()]),
-      filter(it => it instanceof Instrument && it.toString() == selector.toString()),
+      startWith(this.store.snapshot.universe.instrument.get(selector.id)),
+      filter(it => it instanceof Instrument && it.id == selector.id),
       switchMap(() =>
         from(this.aggregate.history({ instrument: selector, timeframe, length }))
       ),

package/src/domain/trade.operator.spec.ts

@@ -0,0 +1,31 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Component } from './component';
+import { Instrument } from './instrument';
+import { Trade } from './trade';
+import { trade } from './trade.operator';
+
+describe('trade', () => {
+  const instrument = new Instrument(
+    new Asset('abc', 'xyz', 4),
+    new Asset('def', 'xyz', 4),
+    'abc-def'
+  );
+
+  const state = new State();
+
+  beforeEach(() => {
+    state.trade.upsert(new Trade(instrument));
+  });
+
+  test('should pipe an orderbook on subscription', done => {
+    new Subject<Component>().pipe(trade(instrument, state)).subscribe({
+      next: it => {
+        expect(it.id).toEqual(instrument.id);
+        done();
+      }
+    });
+  });
+});

package/src/domain/trade.operator.ts

@@ -0,0 +1,15 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { Component } from './component';
+import { InstrumentSelector } from './instrument';
+import { Trade } from './trade';
+
+export function trade(selector: InstrumentSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.trade.get(selector.id)),
+      filter(it => it instanceof Trade && it.instrument.id == selector.id),
+      map(it => it as Trade)
+    );
+}

package/src/domain/trade.spec.ts

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

package/src/domain/trade.ts

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

package/src/index.ts

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

package/src/indicator/atr.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { Candle } from '../domain';
 import { rma } from './rma';
 import { truerange } from './truerange';

package/src/indicator/cross.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { crossover, crossunder } from './cross';
 
-describe('crossunder tests', () => {
+describe('crossunder', () => {
   test('should crossunder uptrend once', done => {
     from([1, 2, 3, 4, 5])
       .pipe(
@@ -75,7 +76,7 @@ describe('crossunder tests', () => {
   });
 });
 
-describe('crossover tests', () => {
+describe('crossover', () => {
   test('should crossover downtrend once', done => {
     from([5, 4, 3, 2, 1])
       .pipe(

package/src/indicator/donchian.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share, withLatestFrom } from 'rxjs';
+
 import { Candle } from '../domain';
 import { minMax } from './min-max';
 

package/src/indicator/ema.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { ema } from './ema';
 
-describe('ema tests', () => {
+describe('ema', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/ema.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { sma } from './sma';
 
 export function ema<T>(length: number, fn: (it: T) => number) {

package/src/indicator/envelope.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { sma } from './sma';
 
 export function envelope<T>(length: number, percent: number, valueFn: (it: T) => number) {

package/src/indicator/macd.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share, withLatestFrom } from 'rxjs';
+
 import { ema } from './ema';
 
 export function macd<T>(

package/src/indicator/min-max.ts

@@ -1,4 +1,5 @@
 import { filter, map, Observable, share } from 'rxjs';
+
 import { window } from './window';
 
 export function minMax<T>(length: number, fn: (it: T) => number) {

package/src/indicator/rma.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { sma } from '.';
 
 export function rma<T>(length: number, fn: (it: T) => number) {

package/src/indicator/sma.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { sma } from './sma';
 
-describe('sma tests', () => {
+describe('sma', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/sma.ts

@@ -1,4 +1,5 @@
 import { filter, map, Observable, share, tap } from 'rxjs';
+
 import { window } from './window';
 
 export function sma<T>(length: number, fn: (it: T) => number) {

package/src/indicator/swma.ts

@@ -1,4 +1,5 @@
 import { filter, map, Observable, share } from 'rxjs';
+
 import { window } from './window';
 
 export function swma<T>(fn: (it: T) => number) {

package/src/indicator/tma.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { tma } from './tma';
 
-describe('tma tests', () => {
+describe('tma', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/tma.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { swma } from './swma';
 import { wma } from './wma';
 

package/src/indicator/trailing.spec.ts

@@ -1,7 +1,8 @@
 import { from } from 'rxjs';
+
 import { trailingdown, trailingup } from './trailing';
 
-describe('trailing up tests', () => {
+describe('trailingup', () => {
   test('should trigger uptrend once', done => {
     let triggered = false;
 
@@ -37,7 +38,7 @@ describe('trailing up tests', () => {
   });
 });
 
-describe('trailingdown tests', () => {
+describe('trailingdown', () => {
   test('should trigger downtrend once', done => {
     let triggered = false;
 

package/src/indicator/truerange.spec.ts

@@ -1,10 +1,11 @@
 import { from } from 'rxjs';
+
 import { Candle } from '../domain';
 import { now } from '../shared';
 import { sma } from './sma';
 import { truerange } from './truerange';
 
-describe('truerange atr tests', () => {
+describe('truerange', () => {
   test('should return expected value', done => {
     let value;
 

package/src/indicator/truerange.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { Candle } from '../domain';
 
 export function truerange<T>(fn: (it: T) => Candle) {

package/src/indicator/window.ts

@@ -1,4 +1,5 @@
 import { map, Observable, share } from 'rxjs';
+
 import { RingBuffer } from './ring-buffer';
 
 export function window<T, Y>(length: number, fn: (value: T) => Y) {