@quantform/core 0.4.11 → 0.5.15

package/src/bootstrap.ts

@@ -1,11 +1,13 @@
 import {
   AdapterAggregate,
-  BacktesterAdapter,
   BacktesterListener,
   BacktesterStreamer,
-  PaperAdapter
+  createBacktesterAdapterFactory,
+  createPaperAdapterFactory,
+  DefaultTimeProvider
 } from './adapter';
 import { Session, SessionDescriptor } from './domain';
+import { Cache, Feed, inMemoryStorageFactory } from './storage';
 import { Store } from './store';
 
 export class Bootstrap {
@@ -29,12 +31,20 @@ export class Bootstrap {
    * @param to
    */
   useBacktestPeriod(from?: number, to?: number): Bootstrap {
+    if (!this.descriptor.simulation) {
+      this.descriptor.simulation = {
+        balance: {},
+        from: undefined,
+        to: undefined
+      };
+    }
+
     if (from) {
-      this.descriptor.options.backtester.from = from;
+      this.descriptor.simulation.from = from;
     }
 
     if (to) {
-      this.descriptor.options.backtester.to = to;
+      this.descriptor.simulation.to = to;
     }
 
     return this;
@@ -47,16 +57,27 @@ export class Bootstrap {
    */
   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 storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const feed = new Feed(storage('feed'));
+    const cache = new Cache(storage('cache'));
+
+    const streamer = new BacktesterStreamer(
+      store,
+      feed,
+      this.descriptor.simulation,
+      listener
+    );
 
     const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(
-        it => new BacktesterAdapter(new PaperAdapter(it, store, backtester), streamer)
+      this.descriptor.adapter.map(it =>
+        createBacktesterAdapterFactory(
+          createPaperAdapterFactory(it, this.descriptor.simulation),
+          streamer
+        )
       ),
-      store
+      streamer.getTimeProvider(),
+      store,
+      cache
     );
 
     const session = new Session(store, aggregate, this.descriptor);
@@ -69,22 +90,29 @@ export class Bootstrap {
    * @returns new session object.
    */
   paper(): Session {
-    if (!this.descriptor.options) {
-      this.descriptor.options = {};
+    if (!this.descriptor.simulation) {
+      this.descriptor.simulation = {
+        balance: {},
+        from: undefined,
+        to: undefined
+      };
     }
 
-    if (!this.descriptor.options.paper) {
-      this.descriptor.options.paper = {
-        balance: {}
-      };
+    if (!this.descriptor.simulation.balance) {
+      this.descriptor.simulation.balance = {};
     }
 
     const store = new Store();
-    const { paper } = this.descriptor.options;
+    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const cache = new Cache(storage('cache'));
 
     const aggregate = new AdapterAggregate(
-      this.descriptor.adapter.map(it => new PaperAdapter(it, store, paper)),
-      store
+      this.descriptor.adapter.map(it =>
+        createPaperAdapterFactory(it, this.descriptor.simulation)
+      ),
+      DefaultTimeProvider,
+      store,
+      cache
     );
 
     return new Session(store, aggregate, this.descriptor);
@@ -96,7 +124,15 @@ export class Bootstrap {
    */
   live(): Session {
     const store = new Store();
-    const aggregate = new AdapterAggregate(this.descriptor.adapter, store);
+    const storage = this.descriptor.storage ?? inMemoryStorageFactory();
+    const cache = new Cache(storage('cache'));
+
+    const aggregate = new AdapterAggregate(
+      this.descriptor.adapter,
+      DefaultTimeProvider,
+      store,
+      cache
+    );
 
     return new Session(store, aggregate, this.descriptor);
   }

package/src/cli/build.ts

@@ -0,0 +1,15 @@
+import { spawn } from 'child_process';
+
+import { buildDirectory } from './internal/workspace';
+
+export default async function (): Promise<number> {
+  return new Promise<number>((resolve, reject) => {
+    const process = spawn('swc', ['./src', '--out-dir', buildDirectory()], {
+      stdio: 'inherit',
+      shell: false
+    });
+
+    process.once('exit', resolve);
+    process.once('error', reject);
+  });
+}

package/src/cli/dev.ts

@@ -0,0 +1,18 @@
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name: string, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  const id = options.id ? Number(options.id) : undefined;
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+  const session = bootstrap.useSessionId(id).paper();
+
+  await session.awake(module.default);
+}

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { ChildProcess, spawn } from 'child_process';
+import { program } from 'commander';
+import watch from 'node-watch';
+
+import build from './build';
+import dev from './dev';
+import pull from './pull';
+import run from './run';
+import test from './test';
+
+program
+  .command('build')
+  .description('builds a production version of the app')
+  .action(async () => {
+    await build();
+  });
+
+program
+  .command('run')
+  .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
+  .option('-w', 'watch mode')
+  .description('executes strategy in live trading mode')
+  .action(run);
+
+program
+  .command('dev')
+  .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
+  .option('-w', 'watch mode')
+  .description('executes strategy in paper e.g. simulation mode')
+  .action(dev);
+
+program
+  .command('test')
+  .description('executes strategy in backtesting mode for specified period')
+  .argument('<name>', 'strategy to execute')
+  .option('-f, --from <from>', 'date from')
+  .option('-t, --to <to>', 'date to')
+  .option('-w', 'watch mode')
+  .action(test);
+
+program
+  .command('pull')
+  .description('pulls instrument historical data to storage')
+  .argument('<name>', 'strategy to execute')
+  .argument('<instrument>', 'instrument to import')
+  .option('-f, --from <from>', 'date from')
+  .option('-t, --to <to>', 'date to')
+  .action(pull);
+
+program.name('quantform').description('quantform tools');
+
+if (process.argv.length < 3) {
+  program.help();
+} else {
+  if (process.argv.every(it => it != '-w')) {
+    program.parse(process.argv);
+  } else {
+    const argv = process.argv.splice(1).filter(it => it != '-w');
+    let child: ChildProcess;
+
+    const spawnChildProcess = () => {
+      console.clear();
+
+      if (child) {
+        child.kill();
+      }
+
+      child = spawn('node', argv, {
+        stdio: ['inherit', 'inherit', 'inherit', 'ipc']
+      });
+    };
+
+    spawnChildProcess();
+
+    watch(process.cwd() + '/src', { recursive: true }, () => spawnChildProcess());
+  }
+}

package/src/cli/internal/workspace.ts

@@ -0,0 +1,18 @@
+import { join } from 'path';
+import { Observable } from 'rxjs';
+
+import { Session, SessionDescriptor } from './../../domain';
+import { workingDirectory } from './../../shared';
+
+export type StrategyModule = {
+  descriptor: SessionDescriptor;
+  default: (session: Session) => Observable<any>;
+};
+
+export function buildDirectory() {
+  return join(process.cwd(), workingDirectory(), 'build');
+}
+
+export async function getModule(name: string): Promise<StrategyModule> {
+  return await import(join(buildDirectory(), name));
+}

package/src/cli/pull.ts

@@ -0,0 +1,71 @@
+import { Presets, SingleBar } from 'cli-progress';
+
+import { Bootstrap } from '../bootstrap';
+import { instrumentOf } from '../domain';
+import { Feed } from '../storage';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name: string, instrument: string, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  const id = options.id ? Number(options.id) : undefined;
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+  const session = bootstrap.useSessionId(id).paper();
+
+  if (!module.descriptor.storage) {
+    throw new Error('Please provide a "storage" property in session descriptor.');
+  }
+
+  const from = options.from
+    ? Date.parse(options.from)
+    : module.descriptor.simulation.from;
+
+  if (!from) {
+    throw new Error(
+      'Please set a "from" date in session descriptor or provide the date as parameter.'
+    );
+  }
+
+  const to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+
+  if (!to) {
+    throw new Error(
+      'Please set a "to" date in session descriptor or provide the date as parameter.'
+    );
+  }
+
+  console.time('Pulling completed in');
+
+  await session.awake(undefined);
+
+  const bar = new SingleBar({}, Presets.shades_classic);
+  const feed = new Feed(module.descriptor.storage('feed'));
+
+  bar.start(100, 0);
+
+  await session.aggregate.feed({
+    instrument: instrumentOf(instrument),
+    from,
+    to,
+    destination: feed,
+    callback: timestamp => {
+      const duration = to - from;
+      const completed = timestamp - from;
+
+      bar.update(Math.floor((completed / duration) * 100));
+    }
+  });
+
+  bar.update(100);
+  bar.stop();
+
+  await session.dispose();
+
+  console.timeLog('Pulling completed in');
+}

package/src/cli/run.ts

@@ -0,0 +1,22 @@
+import * as dotenv from 'dotenv';
+
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  dotenv.config();
+
+  const id = options.id ? Number(options.id) : undefined;
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+  const session = bootstrap.useSessionId(id).live();
+
+  await session.awake(module.default);
+}

package/src/cli/test.ts

@@ -0,0 +1,53 @@
+import { Bootstrap } from '../bootstrap';
+import build from './build';
+import { getModule } from './internal/workspace';
+
+export default async function (name, options: any) {
+  if (await build()) {
+    return;
+  }
+
+  const module = await getModule(name);
+
+  const bootstrap = new Bootstrap(module.descriptor);
+
+  if (!module.descriptor.storage) {
+    throw new Error('Please provide a "storage" property in session descriptor.');
+  }
+
+  const from = options.from
+    ? Date.parse(options.from)
+    : module.descriptor.simulation.from;
+
+  if (!from) {
+    throw new Error(
+      'Please set a "from" date in session descriptor or provide the date as parameter.'
+    );
+  }
+
+  const to = options.to ? Date.parse(options.to) : module.descriptor.simulation.to;
+
+  if (!to) {
+    throw new Error(
+      'Please set a "to" date in session descriptor or provide the date as parameter.'
+    );
+  }
+
+  await new Promise<void>(async resolve => {
+    const [session] = bootstrap.useBacktestPeriod(from, to).backtest({
+      onBacktestStarted: () => {
+        console.log('backtest started');
+        console.time('backtest completed');
+      },
+      onBacktestCompleted: async () => {
+        await session.dispose();
+
+        console.timeEnd('backtest completed');
+
+        resolve();
+      }
+    });
+
+    await session.awake(module.default);
+  });
+}

package/src/domain/asset.spec.ts

@@ -1,66 +1,70 @@
 import { Asset, assetOf } from './asset';
 
-describe('asset tests', () => {
-  test('should instantiate proper asset', () => {
+describe('Asset', () => {
+  test('should construct a new asset', () => {
     const sut = new Asset('abc', 'xyz', 4);
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
+    expect(sut.adapterName).toEqual('xyz');
     expect(sut.scale).toEqual(4);
     expect(sut.tickSize).toEqual(0.0001);
     expect(sut.fixed(1.1234567)).toEqual(1.1234);
     expect(sut.floor(1.1234567)).toEqual(1.1234);
     expect(sut.ceil(1.1234567)).toEqual(1.1235);
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.id).toEqual('xyz:abc');
+  });
+
+  test('should throw for missing asset name', () => {
+    const fn = () => new Asset('xyz', '', 5);
+
+    expect(fn).toThrowError();
+  });
+
+  test('should throw for missing adapter name', () => {
+    const fn = () => new Asset('', 'xyz', 5);
+
+    expect(fn).toThrowError();
   });
 });
 
-describe('asset selector tests', () => {
-  test('should instantiate proper asset selector', () => {
+describe('AssetSelector', () => {
+  test('should construct a new asset selector from unified string', () => {
     const sut = assetOf('xyz:abc');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc');
   });
 
   test('should instantiate proper asset selector capital case', () => {
     const sut = assetOf('XYZ:ABC');
 
     expect(sut.name).toEqual('abc');
-    expect(sut.adapter).toEqual('xyz');
-    expect(sut.toString()).toEqual('xyz:abc');
+    expect(sut.adapterName).toEqual('xyz');
+    expect(sut.id).toEqual('xyz:abc');
   });
 
   test('should throw invalid format message for missing separator', () => {
-    const fn = () => {
-      assetOf('xyzabc');
-    };
+    const fn = () => assetOf('xyzabc');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for multiple separators', () => {
-    const fn = () => {
-      assetOf('xyz:abc:');
-    };
+  test('should throw for multiple separators', () => {
+    const fn = () => assetOf('xyz:abc:');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for missing asset name', () => {
-    const fn = () => {
-      assetOf('xyz:');
-    };
+  test('should throw for missing asset name', () => {
+    const fn = () => assetOf('xyz:');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 
-  test('should throw invalid format message for missing adapter name', () => {
-    const fn = () => {
-      assetOf(':abc');
-    };
+  test('should throw for missing adapter name', () => {
+    const fn = () => assetOf(':abc');
 
-    expect(fn).toThrow(Error);
+    expect(fn).toThrowError();
   });
 });

package/src/domain/asset.ts

@@ -1,19 +1,28 @@
 import { ceil, fixed, floor } from '../shared/decimals';
+import { invalidArgumentError, invalidAssetSelectorError } from './error';
+
+export const AssetSelectorSeparator = ':';
 
 /**
  * Supposed to query specific @see Asset from based on string notation.
  */
 export class AssetSelector {
-  private readonly id: string;
-
+  readonly id: string;
   readonly name: string;
-  readonly adapter: string;
+  readonly adapterName: string;
 
-  constructor(name: string, adapter: string) {
-    this.name = name.toLowerCase();
-    this.adapter = adapter.toLowerCase();
+  constructor(name: string, adapterName: string) {
+    if (!name?.length) {
+      throw invalidArgumentError(name);
+    }
 
-    this.id = `${this.adapter}:${this.name}`;
+    if (!adapterName?.length) {
+      throw invalidArgumentError(adapterName);
+    }
+
+    this.name = name.toLowerCase();
+    this.adapterName = adapterName.toLowerCase();
+    this.id = `${this.adapterName}${AssetSelectorSeparator}${this.name}`;
   }
 
   /**
@@ -27,21 +36,14 @@ export class AssetSelector {
 /**
  * Creates @see AssetSelector based on unified string notation.
  */
-export function assetOf(asset: string): AssetSelector {
-  const section = asset.split(':');
+export function assetOf(selector: string): AssetSelector {
+  const [adapterName, name, ...rest] = selector.split(AssetSelectorSeparator);
 
-  if (section.length != 2) {
-    throw Error('invalid asset format');
+  if (!adapterName || !name || rest.length) {
+    throw invalidAssetSelectorError(selector);
   }
 
-  const assetName = section[1];
-  const adapterName = section[0];
-
-  if (assetName.length == 0 || adapterName.length == 0) {
-    throw Error('invalid asset format');
-  }
-
-  return new AssetSelector(assetName, adapterName);
+  return new AssetSelector(name, adapterName);
 }
 
 /**
@@ -51,8 +53,12 @@ export function assetOf(asset: string): AssetSelector {
 export class Asset extends AssetSelector {
   readonly tickSize: number;
 
-  constructor(name: string, adapter: string, public readonly scale: number) {
-    super(name, adapter);
+  constructor(name: string, adapterName: string, public readonly scale: number) {
+    super(name, adapterName);
+
+    if (scale && (scale < 0 || Number.isNaN(scale))) {
+      throw invalidArgumentError(scale);
+    }
 
     this.tickSize = 1.0 / Math.pow(10, this.scale);
   }

package/src/domain/balance.operator.spec.ts

@@ -0,0 +1,25 @@
+import { Subject } from 'rxjs';
+
+import { State } from '../store';
+import { Asset } from './asset';
+import { Balance } from './balance';
+import { balance } from './balance.operator';
+import { Component } from './component';
+
+describe('balance', () => {
+  const asset = new Asset('abc', 'xyz', 4);
+  const state = new State();
+
+  beforeEach(() => {
+    state.balance.upsert(new Balance(asset));
+  });
+
+  test('should pipe a balance on subscription', done => {
+    new Subject<Component>().pipe(balance(asset, state)).subscribe({
+      next: it => {
+        expect(it.asset).toEqual(asset);
+        done();
+      }
+    });
+  });
+});

package/src/domain/balance.operator.ts

@@ -0,0 +1,15 @@
+import { filter, map, Observable, startWith } from 'rxjs';
+
+import { State } from '../store';
+import { AssetSelector } from './asset';
+import { Balance } from './balance';
+import { Component } from './component';
+
+export function balance(selector: AssetSelector, state: State) {
+  return (source$: Observable<Component>) =>
+    source$.pipe(
+      startWith(state.balance.get(selector.id)),
+      filter(it => it instanceof Balance && (!selector || it.asset.id == selector.id)),
+      map(it => it as Balance)
+    );
+}