@quantform/core 0.3.246 → 0.3.252

package/src/adapter/adapter-aggregate.ts

@@ -4,8 +4,15 @@ import { Logger } from '../shared';
 import {
   AdapterAccountCommand,
   AdapterAwakeCommand,
-  AdapterDisposeCommand
+  AdapterDisposeCommand,
+  AdapterFeedCommand,
+  AdapterHistoryQuery,
+  AdapterOrderCancelCommand,
+  AdapterOrderOpenCommand,
+  AdapterSubscribeCommand
 } from './adapter.event';
+import { InstrumentSelector, Order, Candle } from '../domain';
+import { Feed } from './../storage';
 
 /**
  * Manages instances of all adapters provided in session descriptor.
@@ -14,21 +21,26 @@ import {
 export class AdapterAggregate {
   private readonly adapter: Record<string, Adapter> = {};
 
-  constructor(private readonly store: Store, adapters: Adapter[]) {
+  constructor(adapters: Adapter[], private readonly store: Store) {
     adapters.forEach(it => (this.adapter[it.name] = it));
   }
 
+  /**
+   * Returns adapter by name.
+   * @param adapterName adapter name.
+   * @returns
+   */
+  get(adapterName: string): Adapter {
+    return this.adapter[adapterName];
+  }
+
   /**
    * Sets up all adapters.
-   * @param usePrivateScope use private api (api keys needed).
    */
-  async awake(usePrivateScope = true): Promise<void> {
+  async awake(): Promise<void> {
     for (const adapter in this.adapter) {
       await this.dispatch(adapter, new AdapterAwakeCommand());
-
-      if (usePrivateScope) {
-        await this.dispatch(adapter, new AdapterAccountCommand());
-      }
+      await this.dispatch(adapter, new AdapterAccountCommand());
     }
   }
 
@@ -41,17 +53,102 @@ export class AdapterAggregate {
     }
   }
 
+  /**
+   * Subscribe to collection of instruments.
+   * @param selectors
+   */
+  async subscribe(selectors: InstrumentSelector[]): Promise<void> {
+    const grouped = selectors
+      .filter(it => it != null)
+      .reduce((aggregate, it) => {
+        const adapter = it.base.adapter;
+
+        if (aggregate[adapter]) {
+          aggregate[adapter].push(it);
+        } else {
+          aggregate[adapter] = [it];
+        }
+
+        return aggregate;
+      }, {});
+
+    for (const adapterName in grouped) {
+      await this.dispatch(adapterName, new AdapterSubscribeCommand(grouped[adapterName]));
+    }
+  }
+
+  /**
+   * Opens new order.
+   * @param order an order to open.
+   */
+  open(order: Order): Promise<void> {
+    return this.dispatch<AdapterOrderOpenCommand, void>(
+      order.instrument.base.adapter,
+      new AdapterOrderOpenCommand(order)
+    );
+  }
+
+  /**
+   * Cancels specific order.
+   */
+  cancel(order: Order): Promise<void> {
+    return this.dispatch(
+      order.instrument.base.adapter,
+      new AdapterOrderCancelCommand(order)
+    );
+  }
+
+  /**
+   *
+   * @param selector Returns collection of candles for specific history.
+   * @param timeframe
+   * @param length
+   * @returns
+   */
+  history(
+    selector: InstrumentSelector,
+    timeframe: number,
+    length: number
+  ): Promise<Candle[]> {
+    return this.dispatch<AdapterHistoryQuery, Candle[]>(
+      selector.base.adapter,
+      new AdapterHistoryQuery(selector, timeframe, length)
+    );
+  }
+
+  /**
+   * Feeds a storage with historical instrument data.
+   * @param selector
+   * @param from
+   * @param to
+   * @param destination
+   * @param callback
+   * @returns
+   */
+  feed(
+    selector: InstrumentSelector,
+    from: number,
+    to: number,
+    destination: Feed,
+    callback: (timestamp: number) => void
+  ): Promise<void> {
+    return this.dispatch(
+      selector.base.adapter,
+      new AdapterFeedCommand(selector, from, to, destination, callback)
+    );
+  }
+
   /**
    * Routes and executes command to a specific adapter.
    * @param adapterName name of adapter
-   * @param event
+   * @param command
    * @returns
    */
-  dispatch<TEvent extends { type: string }, TResponse>(
+  private dispatch<TCommand extends { type: string }, TResponse>(
     adapterName: string,
-    event: TEvent
+    command: TCommand
   ): Promise<TResponse> {
-    const adapter = this.adapter[adapterName];
+    const adapter = this.get(adapterName);
 
     if (!adapter) {
       throw new Error(
@@ -60,7 +157,7 @@ export class AdapterAggregate {
     }
 
     try {
-      return adapter.dispatch(event, new AdapterContext(adapter, this.store));
+      return adapter.dispatch(command, new AdapterContext(adapter, this.store));
     } catch (e) {
       Logger.error(e);
     }

package/src/adapter/backtester/backtester-streamer.ts

@@ -39,6 +39,10 @@ export class BacktesterStreamer {
     private readonly options: BacktesterOptions,
     private readonly listener?: BacktesterListener
   ) {
+    if (options.from == undefined || options.to == undefined) {
+      throw new Error('invalid backtest options, please provide from and to period.');
+    }
+
     this.timestamp = this.options.from;
   }
 

package/src/bootstrap.ts

@@ -0,0 +1,100 @@
+import {
+  BacktesterAdapter,
+  BacktesterListener,
+  BacktesterStreamer
+} from './adapter/backtester';
+import { AdapterAggregate } from './adapter';
+import { PaperAdapter } from './adapter/paper';
+import { Session, SessionDescriptor } from './session';
+import { Store } from './store';
+
+export class Bootstrap {
+  constructor(readonly descriptor: SessionDescriptor) {}
+
+  /**
+   * Set session id.
+   * @param id session id.
+   */
+  useSessionId(id?: number): Bootstrap {
+    if (id) {
+      this.descriptor.id = id;
+    }
+
+    return this;
+  }
+
+  /**
+   *
+   * @param from
+   * @param to
+   */
+  useBacktestPeriod(from?: number, to?: number): Bootstrap {
+    if (from) {
+      this.descriptor.options.backtester.from = from;
+    }
+
+    if (to) {
+      this.descriptor.options.backtester.to = to;
+    }
+
+    return this;
+  }
+
+  /**
+   * Starts a new backtest session.
+   * @param listener backtest event listener.
+   * @returns new session object.
+   */
+  backtest(listener?: BacktesterListener): [Session, BacktesterStreamer] {
+    const store = new Store();
+    const { feed } = this.descriptor;
+    const { backtester } = this.descriptor.options;
+
+    const streamer = new BacktesterStreamer(store, feed, backtester, listener);
+    const aggregate = new AdapterAggregate(
+      this.descriptor.adapter.map(
+        it => new PaperAdapter(new BacktesterAdapter(it, streamer), store, backtester)
+      ),
+      store
+    );
+
+    return [new Session(store, aggregate, this.descriptor), streamer];
+  }
+
+  /**
+   * Starts a new paper session.
+   * @returns new session object.
+   */
+  paper(): Session {
+    if (!this.descriptor.options) {
+      this.descriptor.options = {};
+    }
+
+    if (!this.descriptor.options.paper) {
+      this.descriptor.options.paper = {
+        balance: {}
+      };
+    }
+
+    const store = new Store();
+    const { paper } = this.descriptor.options;
+
+    const aggregate = new AdapterAggregate(
+      this.descriptor.adapter.map(it => new PaperAdapter(it, store, paper)),
+      store
+    );
+
+    return new Session(store, aggregate, this.descriptor);
+  }
+
+  /**
+   * Starts a new live session.
+   * @returns new session object.
+   */
+  live(): Session {
+    const store = new Store();
+    const aggregate = new AdapterAggregate(this.descriptor.adapter, store);
+
+    return new Session(store, aggregate, this.descriptor);
+  }
+}

package/src/index.ts

@@ -8,5 +8,5 @@ export * from './session';
 export * from './storage';
 export * from './store';
 export * from './store/event';
-export * from './bin';
+export * from './bootstrap';
 export * from './ipc';

package/src/ipc.ts

@@ -1,9 +1,8 @@
-import { AdapterFeedCommand } from './adapter';
 import { Session, SessionDescriptor } from './session';
 import { instrumentOf } from './domain';
 import { Topic, event, handler } from './shared/topic';
 import { runTask, Logger } from './shared';
-import { backtest, live, paper } from './bin';
+import { Bootstrap } from './bootstrap';
 import { BacktesterStreamer } from './adapter/backtester';
 import { Observable } from 'rxjs';
 import { EventEmitter } from 'events';
@@ -56,6 +55,16 @@ export class IpcPaperCommand implements IpcCommand {
 @event
 export class IpcBacktestCommand implements IpcCommand {
   type = 'backtest';
+
+  /**
+   * Start date of the feed in unix timestamp.
+   */
+  from?: number;
+
+  /**
+   * Due date of the feed in unix timestamp.
+   */
+  to?: number;
 }
 
 /**
@@ -107,7 +116,10 @@ export declare type IpcSessionDescriptor = SessionDescriptor & { ipcSub?: EventE
  * Inter process communication handler.
  */
 class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
-  constructor(private readonly descriptor: IpcSessionDescriptor) {
+  constructor(
+    private readonly bootstrap: Bootstrap,
+    private readonly ipcSub?: EventEmitter
+  ) {
     super();
   }
 
@@ -116,13 +128,9 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcLiveCommand)
   async onLiveMode(command: IpcLiveCommand, accessor: IpcSessionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = live(this.descriptor);
+    accessor.session = this.bootstrap.useSessionId(command.id).live();
 
-    this.notify({
+    this.emit({
       type: 'live:started',
       session: accessor.session.descriptor?.id
     });
@@ -135,13 +143,9 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcPaperCommand)
   async onPaperMode(command: IpcPaperCommand, accessor: IpcSessionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = paper(this.descriptor);
+    accessor.session = this.bootstrap.useSessionId(command.id).paper();
 
-    this.notify({
+    this.emit({
       type: 'paper:started',
       session: accessor.session.descriptor?.id
     });
@@ -154,35 +158,38 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcBacktestCommand)
   onBacktestMode(command: IpcBacktestCommand, accessor: IpcSessionAccessor) {
+    this.bootstrap.useBacktestPeriod(command.from, command.to).backtest();
+    const { from, to } = this.bootstrap.descriptor.options.backtester;
+
     return new Promise<void>(async resolve => {
-      const [session, streamer] = backtest(this.descriptor, {
+      const [session, streamer] = this.bootstrap.backtest({
         onBacktestStarted: (streamer: BacktesterStreamer) => {
-          this.notify({
+          this.emit({
             type: 'backtest:started',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
-            from: this.descriptor.options.backtester.from,
-            to: this.descriptor.options.backtester.to
+            from,
+            to
           });
         },
         onBacktestUpdated: (streamer: BacktesterStreamer) => {
-          this.notify({
+          this.emit({
             type: 'backtest:updated',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
-            from: this.descriptor.options.backtester.from,
-            to: this.descriptor.options.backtester.to
+            from,
+            to
           });
         },
         onBacktestCompleted: async (streamer: BacktesterStreamer) => {
           await accessor.session.dispose();
 
-          this.notify({
+          this.emit({
             type: 'backtest:completed',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
-            from: this.descriptor.options.backtester.from,
-            to: this.descriptor.options.backtester.to
+            from,
+            to
           });
 
           resolve();
@@ -201,31 +208,29 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcFeedCommand)
   async onFeed(command: IpcFeedCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? live(this.descriptor);
+    accessor.session = accessor.session ?? this.bootstrap.paper();
     const instrument = instrumentOf(command.instrument);
+    const { feed } = accessor.session.descriptor;
 
     await accessor.session.awake(undefined);
 
-    this.notify({ type: 'feed:started' });
-
-    await accessor.session.aggregate.dispatch(
-      instrument.base.adapter,
-      new AdapterFeedCommand(
-        instrument,
-        command.from,
-        command.to,
-        this.descriptor.feed,
-        timestamp =>
-          this.notify({
-            type: 'feed:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          })
-      )
+    this.emit({ type: 'feed:started' });
+
+    await accessor.session.aggregate.feed(
+      instrument,
+      command.from,
+      command.to,
+      feed,
+      timestamp =>
+        this.emit({
+          type: 'feed:updated',
+          timestamp,
+          from: command.from,
+          to: command.to
+        })
     );
 
-    this.notify({ type: 'feed:completed' });
+    this.emit({ type: 'feed:completed' });
 
     await accessor.session.dispose();
   }
@@ -235,11 +240,11 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcTaskCommand)
   async onTask(query: IpcTaskCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? live(this.descriptor);
+    accessor.session = accessor.session ?? this.bootstrap.live();
 
     await accessor.session.awake(undefined);
 
-    this.notify({ type: 'task:started', taskName: query.taskName });
+    this.emit({ type: 'task:started', taskName: query.taskName });
 
     let result = undefined;
 
@@ -249,14 +254,14 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
       result = e;
     }
 
-    this.notify({ type: 'task:completed', taskName: query.taskName, result });
+    this.emit({ type: 'task:completed', taskName: query.taskName, result });
 
     await accessor.session.dispose();
   }
 
   describe(): (session: Session) => Observable<any> {
     const pkg = require(join(process.cwd(), 'package.json'));
-    const describe = require(join(process.cwd(), pkg.main));
+    const describe = require(join(process.cwd(), pkg.main))?.default;
 
     if (describe instanceof Function) {
       return describe;
@@ -268,12 +273,12 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
   /**
    * Sends a message to parent process.
    */
-  private notify(message: any) {
+  private emit(message: any) {
     if (process.send) {
       process.send(message);
     }
 
-    this.descriptor.ipcSub?.emit('message', message);
+    this.ipcSub?.emit('message', message);
   }
 }
 
@@ -287,7 +292,7 @@ export async function run(
   descriptor: IpcSessionDescriptor,
   ...commands: IpcCommand[]
 ): Promise<Session> {
-  const handler = new IpcHandler(descriptor);
+  const handler = new IpcHandler(new Bootstrap(descriptor), descriptor.ipcSub);
   const accessor = new IpcSessionAccessor();
   const argv = minimist(process.argv.slice(2));
 

package/src/session/session.spec.ts

@@ -2,9 +2,7 @@ import { InstrumentPatchEvent } from '../store/event';
 import { Asset, Commission } from '../domain';
 import { now } from '../shared';
 import { SessionDescriptor } from './session-descriptor';
-import { paper } from '../bin';
-import { Session } from './session';
-import { of } from 'rxjs';
+import { Bootstrap } from '../bootstrap';
 
 describe('session tests', () => {
   const descriptor: SessionDescriptor = {
@@ -13,7 +11,7 @@ describe('session tests', () => {
   };
 
   test('should trigger once', done => {
-    const session = paper(descriptor);
+    const session = new Bootstrap(descriptor).paper();
 
     session.instruments().subscribe({
       next: it => {

package/src/session/session.ts

@@ -26,12 +26,6 @@ import { AdapterAggregate } from '../adapter/adapter-aggregate';
 import { Worker, now } from '../shared';
 import { Trade } from '../domain/trade';
 import { SessionDescriptor } from './session-descriptor';
-import {
-  AdapterHistoryQuery,
-  AdapterOrderCancelCommand,
-  AdapterOrderOpenCommand,
-  AdapterSubscribeCommand
-} from '../adapter';
 
 type Optional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
 
@@ -65,7 +59,7 @@ export class Session {
     this.initialized = true;
 
     // awake all adapters and synchronize trading accounts with store.
-    await this.aggregate.awake(this.descriptor != null);
+    await this.aggregate.awake();
 
     if (describe) {
       this.subscription = describe(this).subscribe();
@@ -147,24 +141,8 @@ export class Session {
    * Subscribes to specific instrument. Usually forces adapter to subscribe
    * for orderbook and ticker streams.
    */
-  async subscribe(instrument: Array<InstrumentSelector>): Promise<void> {
-    const grouped = instrument
-      .filter(it => it != null)
-      .reduce((aggregate, it) => {
-        const adapter = it.base.adapter;
-
-        if (aggregate[adapter]) {
-          aggregate[adapter].push(it);
-        } else {
-          aggregate[adapter] = [it];
-        }
-
-        return aggregate;
-      }, {});
-
-    for (const group in grouped) {
-      this.aggregate.dispatch(group, new AdapterSubscribeCommand(grouped[group]));
-    }
+  subscribe(instrument: Array<InstrumentSelector>): Promise<void> {
+    return this.aggregate.subscribe(instrument);
   }
 
   /**
@@ -173,24 +151,14 @@ export class Session {
    * session.open(Order.buyMarket(instrument, 100));
    */
   async open(...orders: Order[]): Promise<void> {
-    await Promise.all(
-      orders.map(it =>
-        this.aggregate.dispatch<AdapterOrderOpenCommand, void>(
-          it.instrument.base.adapter,
-          new AdapterOrderOpenCommand(it)
-        )
-      )
-    );
+    await Promise.all(orders.map(it => this.aggregate.open(it)));
   }
 
   /**
    * Cancels specific order.
    */
   cancel(order: Order): Promise<void> {
-    return this.aggregate.dispatch(
-      order.instrument.base.adapter,
-      new AdapterOrderCancelCommand(order)
-    );
+    return this.aggregate.cancel(order);
   }
 
   /**
@@ -372,14 +340,7 @@ export class Session {
     return this.store.changes$.pipe(
       startWith(this.store.snapshot.universe.instrument[selector.toString()]),
       filter(it => it instanceof Instrument && it.toString() == selector.toString()),
-      switchMap(() =>
-        from(
-          this.aggregate.dispatch<AdapterHistoryQuery, Candle[]>(
-            selector.base.adapter,
-            new AdapterHistoryQuery(selector, timeframe, length)
-          )
-        )
-      ),
+      switchMap(() => from(this.aggregate.history(selector, timeframe, length))),
       take(1),
       shareReplay(),
       mergeMap(it => it)

package/dist/bin.d.ts

@@ -1,5 +0,0 @@
-import { BacktesterListener, BacktesterStreamer } from './adapter/backtester';
-import { Session, SessionDescriptor } from './session';
-export declare function backtest(descriptor: SessionDescriptor, listener?: BacktesterListener): [Session, BacktesterStreamer];
-export declare function paper(descriptor: SessionDescriptor): Session;
-export declare function live(descriptor: SessionDescriptor): Session;

package/dist/bin.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.live = exports.paper = exports.backtest = void 0;
-const backtester_1 = require("./adapter/backtester");
-const adapter_1 = require("./adapter");
-const paper_1 = require("./adapter/paper");
-const session_1 = require("./session");
-const store_1 = require("./store");
-function backtest(descriptor, listener) {
-    const store = new store_1.Store();
-    const streamer = new backtester_1.BacktesterStreamer(store, descriptor.feed, descriptor.options.backtester, listener);
-    const aggregate = new adapter_1.AdapterAggregate(store, descriptor.adapter.map(it => new paper_1.PaperAdapter(new backtester_1.BacktesterAdapter(it, streamer), store, descriptor.options.backtester)));
-    return [new session_1.Session(store, aggregate, descriptor), streamer];
-}
-exports.backtest = backtest;
-function paper(descriptor) {
-    const store = new store_1.Store();
-    const aggregate = new adapter_1.AdapterAggregate(store, descriptor.adapter.map(it => new paper_1.PaperAdapter(it, store, descriptor.options.paper)));
-    return new session_1.Session(store, aggregate, descriptor);
-}
-exports.paper = paper;
-function live(descriptor) {
-    const store = new store_1.Store();
-    const aggregate = new adapter_1.AdapterAggregate(store, descriptor.adapter);
-    return new session_1.Session(store, aggregate, descriptor);
-}
-exports.live = live;
-//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";;;AAAA,qDAI8B;AAC9B,uCAA6C;AAC7C,2CAA+C;AAC/C,uCAAuD;AACvD,mCAAgC;AAQhC,SAAgB,QAAQ,CACtB,UAA6B,EAC7B,QAA6B;IAE7B,MAAM,KAAK,GAAG,IAAI,aAAK,EAAE,CAAC;IAE1B,MAAM,QAAQ,GAAG,IAAI,+BAAkB,CACrC,KAAK,EACL,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,OAAO,CAAC,UAAU,EAC7B,QAAQ,CACT,CAAC;IACF,MAAM,SAAS,GAAG,IAAI,0BAAgB,CACpC,KAAK,EACL,UAAU,CAAC,OAAO,CAAC,GAAG,CACpB,EAAE,CAAC,EAAE,CACH,IAAI,oBAAY,CACd,IAAI,8BAAiB,CAAC,EAAE,EAAE,QAAQ,CAAC,EACnC,KAAK,EACL,UAAU,CAAC,OAAO,CAAC,UAAU,CAC9B,CACJ,CACF,CAAC;IAEF,OAAO,CAAC,IAAI,iBAAO,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;AAC/D,CAAC;AAzBD,4BAyBC;AAQD,SAAgB,KAAK,CAAC,UAA6B;IACjD,MAAM,KAAK,GAAG,IAAI,aAAK,EAAE,CAAC;IAE1B,MAAM,SAAS,GAAG,IAAI,0BAAgB,CACpC,KAAK,EACL,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,oBAAY,CAAC,EAAE,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CACpF,CAAC;IAEF,OAAO,IAAI,iBAAO,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AACnD,CAAC;AATD,sBASC;AAOD,SAAgB,IAAI,CAAC,UAA6B;IAChD,MAAM,KAAK,GAAG,IAAI,aAAK,EAAE,CAAC;IAC1B,MAAM,SAAS,GAAG,IAAI,0BAAgB,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;IAElE,OAAO,IAAI,iBAAO,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;AACnD,CAAC;AALD,oBAKC"}