@quantform/core 0.3.219 → 0.3.223

package/src/session/session.ts

@@ -3,6 +3,7 @@ import {
   filter,
   map,
   mergeMap,
+  share,
   shareReplay,
   startWith,
   switchMap,
@@ -20,13 +21,12 @@ import {
   OrderState
 } from '../domain';
 import { Store } from '../store';
-import { from, Observable, Subscription } from 'rxjs';
+import { concat, from, Observable, Subject, Subscription } from 'rxjs';
 import { Behaviour, CombinedBehaviour, FunctionBehaviour } from '../behaviour';
 import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import { Worker } from '../common';
 import { Trade } from '../domain/trade';
 import { SessionDescriptor } from './session-descriptor';
-import { Measure } from '../storage/measurement';
 import {
   AdapterHistoryQuery,
   AdapterOrderCancelCommand,
@@ -34,12 +34,18 @@ import {
   AdapterSubscribeCommand
 } from '../adapter';
 
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
+
 export class Session {
   private initialized = false;
   private subscription: Subscription;
   private behaviour: Behaviour;
   private worker = new Worker();
 
+  get timestamp(): number {
+    return this.store.snapshot.timestamp;
+  }
+
   constructor(
     readonly store: Store,
     readonly aggregate: AdapterAggregate,
@@ -83,33 +89,49 @@ export class Session {
     await this.worker.wait();
   }
 
-  save(...measure: Measure[]) {
-    if (!this.descriptor?.measurement) {
+  statement(output: Record<string, any>) {
+    if (!this.behaviour?.statement) {
       return;
     }
 
-    this.worker.enqueue(() =>
-      this.descriptor.measurement.save(this.descriptor.id, measure)
-    );
+    this.behaviour.statement(output);
   }
 
-  query(params: { type: string; timestamp?: number }): Observable<Measure> {
-    return from(
+  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, {
-        type: params.type,
-        timestamp: params.timestamp ?? this.store.snapshot.timestamp,
-        limit: 1,
-        direction: 'BACKWARD'
+        to: params.timestamp ?? this.timestamp,
+        kind: params.kind,
+        count: 1
       })
-    ).pipe(map(it => it[0]));
-  }
+    ).pipe(
+      map(it =>
+        it.length ? { timestamp: it[0].timestamp, ...it[0].payload } : defaultValue
+      ),
+      share()
+    );
 
-  statement(output: Record<string, any>) {
-    if (!this.behaviour?.statement) {
-      return;
-    }
+    const subject$ = new Subject<T>();
 
-    this.behaviour.statement(output);
+    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])
+      );
+
+      subject$.next({ ...value, timestamp });
+    };
+
+    return [concat(stored$, subject$.asObservable()), setter];
+  }
+
+  useOptimizer(path: string): any {
+    return undefined;
   }
 
   async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {

package/src/storage/feed.ts

@@ -1,13 +1,38 @@
 import { StoreEvent } from '../store/event';
 import { InstrumentSelector } from '../domain';
-import { timestamp } from '../common';
+import { Storage, StorageQueryOptions } from './storage';
 
-export interface Feed {
-  read(
+export class Feed {
+  constructor(private readonly storage: Storage) {}
+
+  index(): Promise<Array<string>> {
+    return this.storage.index();
+  }
+
+  save(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
+    return this.storage.save(
+      instrument.toString(),
+      events.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.type,
+        json: JSON.stringify(it, (key, value) =>
+          key != 'timestamp' && key != 'type' && key != 'instrument' ? value : undefined
+        )
+      }))
+    );
+  }
+
+  async query(
     instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp
-  ): Promise<StoreEvent[]>;
+    options: StorageQueryOptions
+  ): Promise<StoreEvent[]> {
+    const rows = await this.storage.query(instrument.toString(), options);
 
-  write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      type: it.kind,
+      instrument,
+      ...JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/index.ts

@@ -1,4 +1,3 @@
 export * from './feed';
-export * from './in-memory.feed';
-export * from './feed.interceptor';
+export * from './storage';
 export * from './measurement';

package/src/storage/measurement.ts

@@ -1,24 +1,37 @@
 import { timestamp } from '../common';
+import { Storage, StorageQueryOptions } from './storage';
 
 export interface Measure {
   timestamp: timestamp;
-  type: string;
-
-  [key: string]: any;
+  kind: string;
+  payload: any;
 }
 
-export interface Measurement {
-  index(): Promise<Array<number>>;
+export class Measurement {
+  constructor(private readonly storage: Storage) {}
+
+  async index(): Promise<Array<number>> {
+    return (await this.storage.index()).map(it => Number(it));
+  }
+
+  save(session: number, measurements: Measure[]): Promise<void> {
+    return this.storage.save(
+      session.toString(),
+      measurements.map(it => ({
+        timestamp: it.timestamp,
+        kind: it.kind,
+        json: JSON.stringify(it.payload)
+      }))
+    );
+  }
 
-  query(
-    session: number,
-    options: {
-      timestamp: timestamp;
-      type?: string;
-      limit: number;
-      direction: 'FORWARD' | 'BACKWARD';
-    }
-  ): Promise<Measure[]>;
+  async query(session: number, options: StorageQueryOptions): Promise<Measure[]> {
+    const rows = await this.storage.query(session.toString(), options);
 
-  save(session: number, measurements: Measure[]): Promise<void>;
+    return rows.map(it => ({
+      timestamp: it.timestamp,
+      kind: it.kind,
+      payload: JSON.parse(it.json)
+    }));
+  }
 }

package/src/storage/storage.ts

@@ -0,0 +1,76 @@
+export type StorageDocument = {
+  timestamp: number;
+  kind: string;
+  json: string;
+};
+
+export type StorageQueryOptions = {
+  from?: number;
+  to?: number;
+  kind?: string;
+  count: number;
+};
+
+export interface Storage {
+  index(): Promise<Array<string>>;
+
+  save(library: string, documents: StorageDocument[]): Promise<void>;
+
+  query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
+}
+
+export class InMemoryStorage implements Storage {
+  private tables: Record<string, StorageDocument[]> = {};
+
+  async index(): Promise<Array<string>> {
+    return Object.keys(this.tables);
+  }
+
+  async query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]> {
+    if (!this.tables[library]) {
+      return [];
+    }
+
+    let query = this.tables[library];
+
+    if (options.from) {
+      query = query.filter(it => it.timestamp > options.from);
+    }
+
+    if (options.to) {
+      query = query.filter(it => it.timestamp < options.to);
+    }
+
+    if (options.kind) {
+      query = query.filter(it => it.kind == options.kind);
+    }
+
+    if (options.from == undefined && options.to) {
+      query = query.reverse();
+    }
+
+    if (options.count) {
+      query = query.slice(0, options.count);
+    }
+
+    return query;
+  }
+
+  async save(library: string, documents: StorageDocument[]): Promise<void> {
+    if (!this.tables[library]) {
+      this.tables[library] = [];
+    }
+
+    const buffer = this.tables[library];
+
+    for (const document of documents) {
+      buffer.push(document);
+    }
+
+    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+  }
+
+  clear() {
+    this.tables = {};
+  }
+}

package/src/tests/backtester-adapter.spec.ts

@@ -1,7 +1,7 @@
 import { AdapterAwakeCommand } from '../adapter';
 import { AdapterSubscribeCommand } from '../adapter';
 import { Asset, Commision, instrumentOf } from '../domain';
-import { InMemoryFeed } from '../storage';
+import { InMemoryStorage, Feed } from '../storage';
 import { Store } from '../store';
 import { InstrumentPatchEvent, TradePatchEvent } from '../store/event';
 import { Adapter, AdapterContext } from '../adapter/adapter';
@@ -43,7 +43,7 @@ class DefaultAdapter extends Adapter {
 const instrument = instrumentOf('binance:btc-usdt');
 const adapter = new DefaultAdapter();
 const store = new Store();
-const feed = new InMemoryFeed();
+const feed = new Feed(new InMemoryStorage());
 
 describe('backtester adapter tests', () => {
   test('should return proper adapter name and timestamp', () => {
@@ -78,7 +78,7 @@ describe('backtester adapter tests', () => {
       }
     });
 
-    feed.write(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);
+    feed.save(instrument, [new TradePatchEvent(instrument, 100, 10, 1)]);
 
     const sut = new BacktesterAdapter(adapter, streamer);
 

package/dist/storage/feed.interceptor.d.ts

@@ -1,14 +0,0 @@
-import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store/event';
-import { Feed } from './feed';
-export declare abstract class FeedInterceptor implements Feed {
-    private readonly feed;
-    constructor(feed: Feed);
-    abstract intercept(instrument: InstrumentSelector, event: StoreEvent): StoreEvent | StoreEvent[];
-    read(instrument: InstrumentSelector, from: number, to: number): Promise<StoreEvent[]>;
-    write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
-}
-export declare function fromCandle(feed: Feed, options: {
-    orderbook: boolean;
-    trade: boolean;
-}): Feed;

package/dist/storage/feed.interceptor.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromCandle = exports.FeedInterceptor = void 0;
-const event_1 = require("../store/event");
-class FeedInterceptor {
-    constructor(feed) {
-        this.feed = feed;
-    }
-    async read(instrument, from, to) {
-        const output = new Array();
-        for (const event of await this.feed.read(instrument, from, to)) {
-            const intercepted = this.intercept(instrument, event);
-            if (!intercepted) {
-                continue;
-            }
-            if (Array.isArray(intercepted)) {
-                output.push(...intercepted);
-            }
-            else {
-                output.push(intercepted);
-            }
-        }
-        return output;
-    }
-    write(instrument, events) {
-        return this.feed.write(instrument, events);
-    }
-}
-exports.FeedInterceptor = FeedInterceptor;
-class FeedCandleInterceptor extends FeedInterceptor {
-    constructor(feed, options) {
-        super(feed);
-        this.options = options;
-    }
-    intercept(instrument, event) {
-        const output = [];
-        if (event.type == 'candle') {
-            if (this.options.orderbook) {
-                output.push(new event_1.OrderbookPatchEvent(instrument, event.close, 0, event.close, 0, event.timestamp));
-            }
-            if (this.options.trade) {
-                output.push(new event_1.TradePatchEvent(event.instrument, event.close, 0, event.timestamp));
-            }
-            return output;
-        }
-    }
-}
-function fromCandle(feed, options) {
-    return new FeedCandleInterceptor(feed, options);
-}
-exports.fromCandle = fromCandle;
-//# sourceMappingURL=feed.interceptor.js.map

package/dist/storage/feed.interceptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"feed.interceptor.js","sourceRoot":"","sources":["../../src/storage/feed.interceptor.ts"],"names":[],"mappings":";;;AACA,0CAAkF;AAGlF,MAAsB,eAAe;IACnC,YAA6B,IAAU;QAAV,SAAI,GAAJ,IAAI,CAAM;IAAG,CAAC;IAO3C,KAAK,CAAC,IAAI,CACR,UAA8B,EAC9B,IAAY,EACZ,EAAU;QAEV,MAAM,MAAM,GAAG,IAAI,KAAK,EAAc,CAAC;QAEvC,KAAK,MAAM,KAAK,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE;YAC9D,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YAEtD,IAAI,CAAC,WAAW,EAAE;gBAChB,SAAS;aACV;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE;gBAC9B,MAAM,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC;aAC7B;iBAAM;gBACL,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC1B;SACF;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,CAAC,UAA8B,EAAE,MAAoB;QACxD,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC7C,CAAC;CACF;AAnCD,0CAmCC;AAED,MAAM,qBAAsB,SAAQ,eAAe;IACjD,YACE,IAAU,EACO,OAGhB;QAED,KAAK,CAAC,IAAI,CAAC,CAAC;QALK,YAAO,GAAP,OAAO,CAGvB;IAGH,CAAC;IAED,SAAS,CACP,UAA8B,EAC9B,KAAuB;QAEvB,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,IAAI,KAAK,CAAC,IAAI,IAAI,QAAQ,EAAE;YAC1B,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;gBAC1B,MAAM,CAAC,IAAI,CACT,IAAI,2BAAmB,CACrB,UAAU,EACV,KAAK,CAAC,KAAK,EACX,CAAC,EACD,KAAK,CAAC,KAAK,EACX,CAAC,EACD,KAAK,CAAC,SAAS,CAChB,CACF,CAAC;aACH;YAED,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE;gBACtB,MAAM,CAAC,IAAI,CACT,IAAI,uBAAe,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CACvE,CAAC;aACH;YAED,OAAO,MAAM,CAAC;SACf;IACH,CAAC;CACF;AAED,SAAgB,UAAU,CACxB,IAAU,EACV,OAGC;IAED,OAAO,IAAI,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAClD,CAAC;AARD,gCAQC"}

package/dist/storage/in-memory.feed.d.ts

@@ -1,10 +0,0 @@
-import { timestamp } from '../common';
-import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store/event';
-import { Feed } from '.';
-export declare class InMemoryFeed implements Feed {
-    private data;
-    read(instrument: InstrumentSelector, from: timestamp, to: timestamp): Promise<StoreEvent[]>;
-    write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void>;
-    clear(): void;
-}

package/dist/storage/in-memory.feed.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InMemoryFeed = void 0;
-class InMemoryFeed {
-    constructor() {
-        this.data = {};
-    }
-    async read(instrument, from, to) {
-        if (!this.data[instrument.toString()]) {
-            return [];
-        }
-        return this.data[instrument.toString()]
-            .filter(it => it.timestamp > from && it.timestamp <= to)
-            .sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
-    }
-    async write(instrument, events) {
-        if (!this.data[instrument.toString()]) {
-            this.data[instrument.toString()] = [];
-        }
-        const buffer = this.data[instrument.toString()];
-        for (const event of events) {
-            buffer.push(event);
-        }
-    }
-    clear() {
-        this.data = {};
-    }
-}
-exports.InMemoryFeed = InMemoryFeed;
-//# sourceMappingURL=in-memory.feed.js.map

package/dist/storage/in-memory.feed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"in-memory.feed.js","sourceRoot":"","sources":["../../src/storage/in-memory.feed.ts"],"names":[],"mappings":";;;AAKA,MAAa,YAAY;IAAzB;QACU,SAAI,GAAiC,EAAE,CAAC;IA+BlD,CAAC;IA7BC,KAAK,CAAC,IAAI,CACR,UAA8B,EAC9B,IAAe,EACf,EAAa;QAEb,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrC,OAAO,EAAE,CAAC;SACX;QAED,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;aACpC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC,SAAS,IAAI,EAAE,CAAC;aACvD,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,UAA8B,EAAE,MAAoB;QAC9D,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE;YACrC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC;SACvC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEhD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,CAAC;CACF;AAhCD,oCAgCC"}

package/src/storage/feed.interceptor.ts

@@ -1,92 +0,0 @@
-import { InstrumentSelector } from '../domain';
-import { StoreEvent, OrderbookPatchEvent, TradePatchEvent } from '../store/event';
-import { Feed } from './feed';
-
-export abstract class FeedInterceptor implements Feed {
-  constructor(private readonly feed: Feed) {}
-
-  abstract intercept(
-    instrument: InstrumentSelector,
-    event: StoreEvent
-  ): StoreEvent | StoreEvent[];
-
-  async read(
-    instrument: InstrumentSelector,
-    from: number,
-    to: number
-  ): Promise<StoreEvent[]> {
-    const output = new Array<StoreEvent>();
-
-    for (const event of await this.feed.read(instrument, from, to)) {
-      const intercepted = this.intercept(instrument, event);
-
-      if (!intercepted) {
-        continue;
-      }
-
-      if (Array.isArray(intercepted)) {
-        output.push(...intercepted);
-      } else {
-        output.push(intercepted);
-      }
-    }
-
-    return output;
-  }
-
-  write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
-    return this.feed.write(instrument, events);
-  }
-}
-
-class FeedCandleInterceptor extends FeedInterceptor {
-  constructor(
-    feed: Feed,
-    private readonly options: {
-      orderbook: boolean;
-      trade: boolean;
-    }
-  ) {
-    super(feed);
-  }
-
-  intercept(
-    instrument: InstrumentSelector,
-    event: StoreEvent & any
-  ): StoreEvent | StoreEvent[] {
-    const output = [];
-
-    if (event.type == 'candle') {
-      if (this.options.orderbook) {
-        output.push(
-          new OrderbookPatchEvent(
-            instrument,
-            event.close, // + instrument.quote.tickSize,
-            0,
-            event.close, // - instrument.quote.tickSize,
-            0,
-            event.timestamp
-          )
-        );
-      }
-
-      if (this.options.trade) {
-        output.push(
-          new TradePatchEvent(event.instrument, event.close, 0, event.timestamp)
-        );
-      }
-
-      return output;
-    }
-  }
-}
-
-export function fromCandle(
-  feed: Feed,
-  options: {
-    orderbook: boolean;
-    trade: boolean;
-  }
-): Feed {
-  return new FeedCandleInterceptor(feed, options);
-}

package/src/storage/in-memory.feed.ts

@@ -1,38 +0,0 @@
-import { timestamp } from '../common';
-import { InstrumentSelector } from '../domain';
-import { StoreEvent } from '../store/event';
-import { Feed } from '.';
-
-export class InMemoryFeed implements Feed {
-  private data: Record<string, StoreEvent[]> = {};
-
-  async read(
-    instrument: InstrumentSelector,
-    from: timestamp,
-    to: timestamp
-  ): Promise<StoreEvent[]> {
-    if (!this.data[instrument.toString()]) {
-      return [];
-    }
-
-    return this.data[instrument.toString()]
-      .filter(it => it.timestamp > from && it.timestamp <= to)
-      .sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
-  }
-
-  async write(instrument: InstrumentSelector, events: StoreEvent[]): Promise<void> {
-    if (!this.data[instrument.toString()]) {
-      this.data[instrument.toString()] = [];
-    }
-
-    const buffer = this.data[instrument.toString()];
-
-    for (const event of events) {
-      buffer.push(event);
-    }
-  }
-
-  clear() {
-    this.data = {};
-  }
-}