@quantform/core 0.4.11 → 0.5.15

package/src/ipc.spec.ts

@@ -1,73 +0,0 @@
-import { EventEmitter } from 'events';
-import { of, take, tap } from 'rxjs';
-import { Adapter, AdapterContext, PaperAdapter, PaperSpotSimulator } from './adapter';
-import { PaperSimulator } from './adapter/paper/simulator/paper-simulator';
-import { run } from './ipc';
-import { task } from './shared';
-
-class DefaultAdapter extends Adapter {
-  name = 'default';
-
-  timestamp() {
-    return 123;
-  }
-
-  createPaperSimulator(adapter: PaperAdapter): PaperSimulator {
-    return new PaperSpotSimulator(adapter);
-  }
-
-  awake(context: AdapterContext): Promise<void> {
-    return super.awake(context);
-  }
-
-  async account(): Promise<void> {}
-}
-
-describe('ipc feed tests', () => {
-  test('should dispatch session started event', done => {
-    const command = {
-      type: 'paper'
-    };
-
-    const ipcSub = new EventEmitter();
-
-    ipcSub.on('message', (message: any) => {
-      expect(message.type).toBe('paper:started');
-      done();
-    });
-
-    run(
-      {
-        adapter: [new DefaultAdapter()],
-        ipcSub,
-        options: {
-          paper: {
-            balance: { 'default:usd': 100 }
-          }
-        }
-      },
-      command
-    );
-  });
-
-  test('should execute user task', done => {
-    task('hello-world', session => {
-      return of(1).pipe(
-        take(1),
-        tap(() => done())
-      );
-    });
-
-    const command = {
-      type: 'task',
-      taskName: 'hello-world'
-    };
-
-    run(
-      {
-        adapter: [new DefaultAdapter()]
-      },
-      command
-    );
-  });
-});

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/policy.spec.ts

@@ -1,29 +0,0 @@
-import { cache } from './policy';
-
-describe('cache policy tests', () => {
-  test('string as key cache', async () => {
-    let counter = 0;
-
-    const request = async () => {
-      return ++counter;
-    };
-
-    expect(await cache('abc', request)).toBe(1);
-    expect(await cache('abc', request)).toBe(1);
-    expect(await cache('abc', () => request())).toBe(1);
-    expect(await cache('abc', () => request())).toBe(1);
-  });
-
-  test('object as key cache', async () => {
-    let counter = 0;
-
-    const request = async () => {
-      return ++counter;
-    };
-
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, request)).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, request)).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, () => request())).toBe(1);
-    expect(await cache({ from: 1, to: 2, content: 'abc' }, () => request())).toBe(1);
-  });
-});

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/topic.spec.ts

@@ -1,34 +0,0 @@
-import { event, handler, Topic } from './topic';
-
-describe('topic tests', () => {
-  test('string as key cache', () => {
-    interface Event {
-      type: string;
-    }
-
-    interface Context {
-      counter: number;
-    }
-
-    const context = <Context>{
-      counter: 1
-    };
-
-    @event
-    class IncrementEvent implements Event {
-      type = 'increment';
-    }
-
-    class MathematicBaseTopic extends Topic<Event, Context> {}
-    class MathematicTopic extends MathematicBaseTopic {
-      @handler(IncrementEvent)
-      increment(event: IncrementEvent, context: Context) {
-        context.counter++;
-      }
-    }
-
-    new MathematicTopic().dispatch(new IncrementEvent(), context);
-
-    expect(context.counter).toBe(2);
-  });
-});

package/src/shared/topic.ts

@@ -1,43 +0,0 @@
-import 'reflect-metadata';
-
-export class Topic<T extends { type: string } = { type: string }, C = any> {
-  private readonly handler: Record<string, Function> = {};
-
-  constructor() {
-    this.register(this);
-  }
-
-  register(target: any) {
-    for (const key of Reflect.getMetadataKeys(target.constructor.prototype)) {
-      if (!key.startsWith('event:')) {
-        continue;
-      }
-
-      this.handler[key] = Reflect.getMetadata(key, target.constructor.prototype);
-    }
-  }
-
-  dispatch(event: T, context: C): any {
-    const handler = this.handler['event:' + event.type];
-
-    return handler
-      ? handler.call(this, event, context)
-      : this.onUnknownEvent(event, context);
-  }
-
-  onUnknownEvent(event: T, context: C) {
-    throw new Error(`No handler for event ${event.type}`);
-  }
-}
-
-export function handler(event: any) {
-  return function (target: any, key: string) {
-    const type = Reflect.getMetadata('event:type', event.prototype);
-
-    Reflect.defineMetadata('event:' + type, target[key], target);
-  };
-}
-
-export const event = (target: any) => {
-  Reflect.defineMetadata('event:type', new target().type, target.prototype);
-};

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();
-      });
-    }
-  }
-}

package/src/store/event/index.ts

@@ -1,8 +0,0 @@
-export * from './store-balance.event';
-export * from './store-candle.event';
-export * from './store-instrument.event';
-export * from './store-order.event';
-export * from './store-orderbook.event';
-export * from './store-position.event';
-export * from './store-trade.event';
-export * from './store.event';