@quantform/core 0.4.8 → 0.5.13

package/src/ipc.ts

@@ -1,321 +0,0 @@
-import { EventEmitter } from 'events';
-import { join } from 'path';
-import { Observable } from 'rxjs';
-import { BacktesterStreamer } from './adapter/backtester';
-import { Bootstrap } from './bootstrap';
-import { instrumentOf, Session, SessionDescriptor } from './domain';
-import { Logger, runTask } from './shared';
-import { event, handler, Topic } from './shared/topic';
-import minimist = require('minimist');
-import dotenv = require('dotenv');
-
-// force to load environment variables from .env file if this file imported.
-dotenv.config();
-
-/**
- * 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;
-}
-
-/**
- * Command to start a new backtest session.
- */
-@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;
-}
-
-/**
- * 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;
-}
-
-/**
- * Executes user task defined in quantform.ts file.
- */
-@event
-export class IpcTaskCommand implements IpcCommand {
-  type = 'task';
-
-  /**
-   * Name of the task to execute.
-   */
-  taskName: string;
-}
-
-/**
- * Stores current session instance.
- */
-class IpcSessionAccessor {
-  session: Session;
-}
-
-export declare type IpcSessionDescriptor = SessionDescriptor & { ipcSub?: EventEmitter };
-
-/**
- * Inter process communication handler.
- */
-class IpcHandler extends Topic<{ type: string }, IpcSessionAccessor> {
-  constructor(
-    private readonly bootstrap: Bootstrap,
-    private readonly ipcSub?: EventEmitter
-  ) {
-    super();
-  }
-
-  /**
-   * @see IpcLiveCommand
-   */
-  @handler(IpcLiveCommand)
-  async onLiveMode(command: IpcLiveCommand, accessor: IpcSessionAccessor) {
-    accessor.session = this.bootstrap.useSessionId(command.id).live();
-
-    this.emit({
-      type: 'live:started',
-      session: accessor.session.descriptor?.id
-    });
-
-    await accessor.session.awake(this.describe());
-  }
-
-  /**
-   * @see IpcPaperCommand
-   */
-  @handler(IpcPaperCommand)
-  async onPaperMode(command: IpcPaperCommand, accessor: IpcSessionAccessor) {
-    accessor.session = this.bootstrap.useSessionId(command.id).paper();
-
-    this.emit({
-      type: 'paper:started',
-      session: accessor.session.descriptor?.id
-    });
-
-    await accessor.session.awake(this.describe());
-  }
-
-  /**
-   * @see IpcBacktestCommand
-   */
-  @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] = this.bootstrap.backtest({
-        onBacktestStarted: (streamer: BacktesterStreamer) => {
-          this.emit({
-            type: 'backtest:started',
-            session: session.descriptor?.id,
-            timestamp: streamer.timestamp,
-            from,
-            to
-          });
-        },
-        onBacktestUpdated: (streamer: BacktesterStreamer) => {
-          this.emit({
-            type: 'backtest:updated',
-            session: session.descriptor?.id,
-            timestamp: streamer.timestamp,
-            from,
-            to
-          });
-        },
-        onBacktestCompleted: async (streamer: BacktesterStreamer) => {
-          await accessor.session.dispose();
-
-          this.emit({
-            type: 'backtest:completed',
-            session: session.descriptor?.id,
-            timestamp: streamer.timestamp,
-            from,
-            to
-          });
-
-          resolve();
-        }
-      });
-
-      accessor.session = session;
-
-      await accessor.session.awake(this.describe());
-      await streamer.tryContinue().catch(it => Logger.error(it));
-    });
-  }
-
-  /**
-   * @see IpcFeedCommand
-   */
-  @handler(IpcFeedCommand)
-  async onFeed(command: IpcFeedCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? this.bootstrap.paper();
-    const instrument = instrumentOf(command.instrument);
-    const { feed } = accessor.session.descriptor;
-
-    await accessor.session.awake(undefined);
-
-    this.emit({ type: 'feed:started' });
-
-    await accessor.session.aggregate.feed({
-      instrument,
-      from: command.from,
-      to: command.to,
-      destination: feed,
-      callback: timestamp =>
-        this.emit({
-          type: 'feed:updated',
-          timestamp,
-          from: command.from,
-          to: command.to
-        })
-    });
-
-    this.emit({ type: 'feed:completed' });
-
-    await accessor.session.dispose();
-  }
-
-  /**
-   * @see IpcTaskCommand
-   */
-  @handler(IpcTaskCommand)
-  async onTask(query: IpcTaskCommand, accessor: IpcSessionAccessor) {
-    accessor.session = accessor.session ?? this.bootstrap.live();
-
-    await accessor.session.awake(undefined);
-
-    this.emit({ type: 'task:started', taskName: query.taskName });
-
-    let result = undefined;
-
-    try {
-      result = await runTask(query.taskName, accessor.session);
-    } catch (e) {
-      result = e;
-    }
-
-    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))?.default;
-
-    if (describe instanceof Function) {
-      return describe;
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Sends a message to parent process.
-   */
-  private emit(message: any) {
-    if (process.send) {
-      process.send(message);
-    }
-
-    this.ipcSub?.emit('message', 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: IpcSessionDescriptor,
-  ...commands: IpcCommand[]
-): Promise<Session> {
-  const handler = new IpcHandler(new Bootstrap(descriptor), descriptor.ipcSub);
-  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;
-}

package/src/shared/task.ts

@@ -1,30 +0,0 @@
-import { lastValueFrom, Observable } from 'rxjs';
-import { Session } from './../domain';
-
-declare type Task = (session: Session) => Observable<any> | Promise<any> | any;
-
-const tasks: Record<string, Task> = {};
-
-export function task(name: string, fn: Task) {
-  tasks[name] = fn;
-}
-
-export async function runTask(name: string, session: Session): Promise<void> {
-  const task = tasks[name];
-
-  if (!task) {
-    throw new Error('Unknown task: ' + name);
-  }
-
-  const result = tasks[name](session);
-
-  if (result instanceof Observable) {
-    return lastValueFrom(result);
-  }
-
-  if (result instanceof Promise) {
-    return await result;
-  }
-
-  return result;
-}

package/src/shared/worker.spec.ts

@@ -1,25 +0,0 @@
-import { Worker } from './worker';
-
-describe('worker tests', () => {
-  test('event handler tests', async () => {
-    const sut = new Worker();
-
-    let started = 0,
-      completed = 0;
-
-    sut.addListener('started', () => started++);
-    sut.addListener('completed', () => completed++);
-
-    sut.enqueue(
-      () =>
-        new Promise<void>(resolve => {
-          setTimeout(() => resolve(), 1);
-        })
-    );
-
-    await sut.wait();
-
-    expect(started).toBe(1);
-    expect(completed).toBe(1);
-  });
-});

package/src/shared/worker.ts

@@ -1,55 +0,0 @@
-import { EventEmitter } from 'stream';
-
-export type Work = () => Promise<void>;
-
-export class Worker extends EventEmitter {
-  private readonly queue = new Array<Work>();
-  private promise: Promise<void>;
-
-  enqueue(job: Work) {
-    this.queue.push(job);
-
-    this.tryNext();
-  }
-
-  wait(): Promise<void> {
-    if (!this.queue.length) {
-      return Promise.resolve();
-    }
-
-    return new Promise<void>(resolve => {
-      const listener = () => {
-        if (this.queue.length) {
-          return;
-        }
-
-        this.removeListener('completed', listener);
-
-        resolve();
-      };
-
-      this.addListener('completed', listener);
-    });
-  }
-
-  private tryNext() {
-    if (!this.queue.length) {
-      return;
-    }
-
-    if (!this.promise) {
-      const queued = this.queue[0];
-
-      this.emit('started');
-
-      this.promise = queued().finally(() => {
-        this.queue.shift();
-
-        this.promise = null;
-
-        this.emit('completed');
-        this.tryNext();
-      });
-    }
-  }
-}