@quantform/core 0.3.230 → 0.3.231

package/src/bin.ts

@@ -3,199 +3,17 @@ import {
   BacktesterOptions,
   BacktesterStreamer
 } from './adapter/backtester';
-import { AdapterAggregate, AdapterFeedCommand } from './adapter';
+import { AdapterAggregate } from './adapter';
 import { PaperAdapter, PaperOptions } from './adapter/paper';
 import { Session, SessionDescriptor } from './session';
 import { Store } from './store';
-import { instrumentOf } from './domain';
-import { Topic, event, handler } from './shared/topic';
-import minimist = require('minimist');
-import { Logger } from './shared';
-
-export interface IpcCommand {
-  type;
-}
-
-@event
-export class IpcPaperModeCommand implements IpcCommand {
-  type = 'paper';
-  id?: number;
-  balance: { [key: string]: number };
-}
-
-@event
-export class IpcBacktestModeCommand implements IpcCommand {
-  type = 'backtest';
-  from: number;
-  to: number;
-  balance: { [key: string]: number };
-}
-
-@event
-export class IpcLiveModeCommand implements IpcCommand {
-  id?: number;
-  type = 'live';
-}
-
-@event
-export class IpcUniverseQuery implements IpcCommand {
-  type = 'universe';
-  exchange: string;
-}
-
-@event
-export class IpcFeedCommand implements IpcCommand {
-  type = 'feed';
-  instrument: string;
-  from: number;
-  to: number;
-}
-
-class ExecutionAccessor {
-  session: Session;
-}
-
-class ExecutionHandler extends Topic<{ type: string }, ExecutionAccessor> {
-  constructor(private readonly descriptor: SessionDescriptor) {
-    super();
-  }
-
-  @handler(IpcLiveModeCommand)
-  async onLiveMode(command: IpcLiveModeCommand, accessor: ExecutionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = live(this.descriptor);
-
-    await accessor.session.awake();
-  }
-
-  @handler(IpcPaperModeCommand)
-  async onPaperMode(command: IpcPaperModeCommand, accessor: ExecutionAccessor) {
-    if (command.id) {
-      this.descriptor.id = command.id;
-    }
-
-    accessor.session = paper(this.descriptor, {
-      balance: command.balance
-    });
-
-    await accessor.session.awake();
-  }
-
-  @handler(IpcBacktestModeCommand)
-  onBacktestMode(command: IpcBacktestModeCommand, accessor: ExecutionAccessor) {
-    return new Promise<void>(async resolve => {
-      const [session, streamer] = backtest(this.descriptor, {
-        from: command.from,
-        to: command.to,
-        balance: command.balance,
-        progress: timestamp =>
-          this.notify({
-            type: 'backtest:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          }),
-        completed: async () => {
-          const statement = {};
-
-          await accessor.session.dispose();
-
-          this.notify({ type: 'backtest:completed', statement });
-
-          resolve();
-        }
-      });
-
-      accessor.session = session;
-
-      this.notify({ type: 'backtest:started' });
-
-      await accessor.session.awake();
-      await streamer.tryContinue().catch(it => Logger.error(it));
-    });
-  }
-
-  @handler(IpcUniverseQuery)
-  onUniverse(query: IpcUniverseQuery, accessor: ExecutionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
-  }
-
-  @handler(IpcFeedCommand)
-  async onFeed(command: IpcFeedCommand, accessor: ExecutionAccessor) {
-    accessor.session = accessor.session ?? idle(this.descriptor);
-    const instrument = instrumentOf(command.instrument);
-
-    await accessor.session.awake();
-
-    this.notify({ type: 'feed:started' });
-
-    await accessor.session.aggregate.dispatch(
-      instrument.base.exchange,
-      new AdapterFeedCommand(
-        instrument,
-        command.from,
-        command.to,
-        this.descriptor.feed,
-        timestamp =>
-          this.notify({
-            type: 'feed:updated',
-            timestamp,
-            from: command.from,
-            to: command.to
-          })
-      )
-    );
-
-    this.notify({ type: 'feed:completed' });
-
-    await accessor.session.dispose();
-  }
-
-  private notify(message: any) {
-    if (!process.send) {
-      return;
-    }
-
-    process.send(message);
-  }
-}
-
-export async function run(
-  descriptor: SessionDescriptor,
-  ...commands: IpcCommand[]
-): Promise<Session> {
-  const handler = new ExecutionHandler(descriptor);
-  const accessor = new ExecutionAccessor();
-  const argv = minimist(process.argv.slice(2));
-
-  if (argv.command) {
-    const json = Buffer.from(argv.command, 'base64').toString('utf-8');
-
-    commands.push(JSON.parse(json));
-  } else {
-    if (!commands.length) {
-      commands.push(new IpcPaperModeCommand());
-    }
-  }
-
-  for (const command of commands) {
-    await handler.dispatch(command, accessor);
-  }
-
-  process.on('message', async (request: any) => {
-    const response = await handler.dispatch(request, accessor);
-
-    if (response) {
-      process.send(response);
-    }
-  });
-
-  return accessor.session;
-}
 
+/**
+ * Starts a new backtest session.
+ * @param descriptor session descriptor.
+ * @param options backtest options.
+ * @returns new session object.
+ */
 export function backtest(
   descriptor: SessionDescriptor,
   options: BacktesterOptions
@@ -213,6 +31,12 @@ export function backtest(
   return [new Session(store, aggregate, descriptor), streamer];
 }
 
+/**
+ * Starts a new paper session.
+ * @param descriptor session descriptor.
+ * @param options backtest options.
+ * @returns new session object.
+ */
 export function paper(descriptor: SessionDescriptor, options: PaperOptions): Session {
   const store = new Store();
 
@@ -224,6 +48,11 @@ export function paper(descriptor: SessionDescriptor, options: PaperOptions): Ses
   return new Session(store, aggregate, descriptor);
 }
 
+/**
+ * Starts a new live session.
+ * @param descriptor session descriptor.
+ * @returns new session object.
+ */
 export function live(descriptor: SessionDescriptor): Session {
   const store = new Store();
   const aggregate = new AdapterAggregate(store, descriptor.adapter);
@@ -231,6 +60,10 @@ export function live(descriptor: SessionDescriptor): Session {
   return new Session(store, aggregate, descriptor);
 }
 
+/**
+ * Starts a new idle session.
+ * @param descriptor session descriptor.
+ */
 export function idle(descriptor: SessionDescriptor): Session {
   const store = new Store();
   const aggregate = new AdapterAggregate(store, descriptor.adapter);

package/src/index.ts

@@ -9,3 +9,4 @@ export * from './storage';
 export * from './store';
 export * from './store/event';
 export * from './bin';
+export * from './ipc';

package/src/ipc.ts

@@ -0,0 +1,277 @@
+import { AdapterFeedCommand } from './adapter';
+import { Session, SessionDescriptor } from './session';
+import { instrumentOf } from './domain';
+import { Topic, event, handler } from './shared/topic';
+import { Logger } from './shared';
+import { backtest, idle, live, paper } from './bin';
+import minimist = require('minimist');
+
+/**
+ * Base command/query interface for IPC communication.
+ */
+export interface IpcCommand {
+  /**
+   * The command name to handle.
+   */
+  type;
+}
+
+/**
+ * Command to start a new live session.
+ */
+@event
+export class IpcLiveCommand implements IpcCommand {
+  type = 'live';
+
+  /**
+   * The optional session identifier.
+   */
+  id?: number;
+}
+
+/**
+ * Command to start a new paper session.
+ */
+@event
+export class IpcPaperCommand implements IpcCommand {
+  type = 'paper';
+
+  /**
+   * The optional session identifier.
+   */
+  id?: number;
+
+  /**
+   * Specifies trading balance, for example:
+   * { "binance:usdt": 1000 }
+   */
+  balance: { [key: string]: number };
+}
+
+/**
+ * Command to start a new backtest session.
+ */
+@event
+export class IpcBacktestCommand implements IpcCommand {
+  type = 'backtest';
+
+  /**
+   * Start date of the backtest in unix timestamp.
+   */
+  from: number;
+
+  /**
+   * Due date of the backtest in unix timestamp.
+   */
+  to: number;
+
+  /**
+   * Specifies trading balance, for example:
+   * { "binance:usdt": 1000 }
+   */
+  balance: { [key: string]: number };
+}
+
+@event
+export class IpcUniverseQuery implements IpcCommand {
+  type = 'universe';
+  exchange: string;
+}
+
+/**
+ * Feeds specific session descriptor with instrument data.
+ */
+@event
+export class IpcFeedCommand implements IpcCommand {
+  type = 'feed';
+
+  /**
+   * Instrument to feed.
+   */
+  instrument: string;
+
+  /**
+   * Start date of the feed in unix timestamp.
+   */
+  from: number;
+
+  /**
+   * Due date of the feed in unix timestamp.
+   */
+  to: number;
+}
+
+/**
+ * Stores current session instance.
+ */
+class IpcSessionAccessor {
+  session: Session;
+}
+
+/**
+ * Inter process communication handler.
+ */
+class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
+  constructor(private readonly descriptor: SessionDescriptor) {
+    super();
+  }
+
+  /**
+   * @see IpcLiveCommand
+   */
+  @handler(IpcLiveCommand)
+  async onLiveMode(command: IpcLiveCommand, accessor: IpcSessionAccessor) {
+    if (command.id) {
+      this.descriptor.id = command.id;
+    }
+
+    accessor.session = live(this.descriptor);
+
+    await accessor.session.awake();
+  }
+
+  /**
+   * @see IpcPaperCommand
+   */
+  @handler(IpcPaperCommand)
+  async onPaperMode(command: IpcPaperCommand, accessor: IpcSessionAccessor) {
+    if (command.id) {
+      this.descriptor.id = command.id;
+    }
+
+    accessor.session = paper(this.descriptor, {
+      balance: command.balance
+    });
+
+    await accessor.session.awake();
+  }
+
+  /**
+   * @see IpcBacktestCommand
+   */
+  @handler(IpcBacktestCommand)
+  onBacktestMode(command: IpcBacktestCommand, accessor: IpcSessionAccessor) {
+    return new Promise<void>(async resolve => {
+      const [session, streamer] = backtest(this.descriptor, {
+        from: command.from,
+        to: command.to,
+        balance: command.balance,
+        progress: timestamp =>
+          this.notify({
+            type: 'backtest:updated',
+            timestamp,
+            from: command.from,
+            to: command.to
+          }),
+        completed: async () => {
+          const statement = {};
+
+          await accessor.session.dispose();
+
+          this.notify({ type: 'backtest:completed', statement });
+
+          resolve();
+        }
+      });
+
+      accessor.session = session;
+
+      this.notify({ type: 'backtest:started' });
+
+      await accessor.session.awake();
+      await streamer.tryContinue().catch(it => Logger.error(it));
+    });
+  }
+
+  /**
+   * @see IpcUniverseQuery
+   */
+  @handler(IpcUniverseQuery)
+  onUniverse(query: IpcUniverseQuery, accessor: IpcSessionAccessor) {
+    accessor.session = accessor.session ?? idle(this.descriptor);
+  }
+
+  /**
+   * @see IpcFeedCommand
+   */
+  @handler(IpcFeedCommand)
+  async onFeed(command: IpcFeedCommand, accessor: IpcSessionAccessor) {
+    accessor.session = accessor.session ?? idle(this.descriptor);
+    const instrument = instrumentOf(command.instrument);
+
+    await accessor.session.awake();
+
+    this.notify({ type: 'feed:started' });
+
+    await accessor.session.aggregate.dispatch(
+      instrument.base.exchange,
+      new AdapterFeedCommand(
+        instrument,
+        command.from,
+        command.to,
+        this.descriptor.feed,
+        timestamp =>
+          this.notify({
+            type: 'feed:updated',
+            timestamp,
+            from: command.from,
+            to: command.to
+          })
+      )
+    );
+
+    this.notify({ type: 'feed:completed' });
+
+    await accessor.session.dispose();
+  }
+
+  /**
+   * Sends a message to parent process.
+   */
+  private notify(message: any) {
+    if (!process.send) {
+      return;
+    }
+
+    process.send(message);
+  }
+}
+
+/**
+ * Starts new managed session and subscribes to parent process messages.
+ * @param descriptor session descriptor.
+ * @param commands collection of commands to execute before session is started.
+ * @returns new session.
+ */
+export async function run(
+  descriptor: SessionDescriptor,
+  ...commands: IpcCommand[]
+): Promise<Session> {
+  const handler = new IpcHandler(descriptor);
+  const accessor = new IpcSessionAccessor();
+  const argv = minimist(process.argv.slice(2));
+
+  if (argv.command) {
+    const json = Buffer.from(argv.command, 'base64').toString('utf-8');
+
+    commands.push(JSON.parse(json));
+  } else {
+    if (!commands.length) {
+      commands.push(new IpcPaperCommand());
+    }
+  }
+
+  for (const command of commands) {
+    await handler.dispatch(command, accessor);
+  }
+
+  process.on('message', async (request: any) => {
+    const response = await handler.dispatch(request, accessor);
+
+    if (response) {
+      process.send(response);
+    }
+  });
+
+  return accessor.session;
+}