@quantform/core 0.3.247 → 0.3.248

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/bin.ts

@@ -27,7 +27,6 @@ export function backtest(
     listener
   );
   const aggregate = new AdapterAggregate(
-    store,
     descriptor.adapter.map(
       it =>
         new PaperAdapter(
@@ -35,7 +34,8 @@ export function backtest(
           store,
           descriptor.options.backtester
         )
-    )
+    ),
+    store
   );
 
   return [new Session(store, aggregate, descriptor), streamer];
@@ -51,8 +51,8 @@ export function paper(descriptor: SessionDescriptor): Session {
   const store = new Store();
 
   const aggregate = new AdapterAggregate(
-    store,
-    descriptor.adapter.map(it => new PaperAdapter(it, store, descriptor.options.paper))
+    descriptor.adapter.map(it => new PaperAdapter(it, store, descriptor.options.paper)),
+    store
   );
 
   return new Session(store, aggregate, descriptor);
@@ -65,7 +65,7 @@ export function paper(descriptor: SessionDescriptor): Session {
  */
 export function live(descriptor: SessionDescriptor): Session {
   const store = new Store();
-  const aggregate = new AdapterAggregate(store, descriptor.adapter);
+  const aggregate = new AdapterAggregate(descriptor.adapter, store);
 
   return new Session(store, aggregate, descriptor);
 }

package/src/ipc.ts

@@ -1,4 +1,3 @@
-import { AdapterFeedCommand } from './adapter';
 import { Session, SessionDescriptor } from './session';
 import { instrumentOf } from './domain';
 import { Topic, event, handler } from './shared/topic';
@@ -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;
 }
 
 /**
@@ -122,7 +131,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     accessor.session = live(this.descriptor);
 
-    this.notify({
+    this.emit({
       type: 'live:started',
       session: accessor.session.descriptor?.id
     });
@@ -141,7 +150,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     accessor.session = paper(this.descriptor);
 
-    this.notify({
+    this.emit({
       type: 'paper:started',
       session: accessor.session.descriptor?.id
     });
@@ -154,10 +163,17 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
    */
   @handler(IpcBacktestCommand)
   onBacktestMode(command: IpcBacktestCommand, accessor: IpcSessionAccessor) {
+    if (command.from) {
+      this.descriptor.options.backtester.from = command.from;
+    }
+    if (command.to) {
+      this.descriptor.options.backtester.to = command.to;
+    }
+
     return new Promise<void>(async resolve => {
       const [session, streamer] = backtest(this.descriptor, {
         onBacktestStarted: (streamer: BacktesterStreamer) => {
-          this.notify({
+          this.emit({
             type: 'backtest:started',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
@@ -166,7 +182,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
           });
         },
         onBacktestUpdated: (streamer: BacktesterStreamer) => {
-          this.notify({
+          this.emit({
             type: 'backtest:updated',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
@@ -177,7 +193,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
         onBacktestCompleted: async (streamer: BacktesterStreamer) => {
           await accessor.session.dispose();
 
-          this.notify({
+          this.emit({
             type: 'backtest:completed',
             session: session.descriptor?.id,
             timestamp: streamer.timestamp,
@@ -206,26 +222,23 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     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,
+      this.descriptor.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();
   }
@@ -239,7 +252,7 @@ class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
 
     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,7 +262,7 @@ 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();
   }
@@ -268,7 +281,7 @@ 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);
     }

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)