@quantform/core 0.7.0-beta.5 → 0.7.0-beta.51

package/lib/with-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-request.d.ts","sourceRoot":"","sources":["../src/with-request.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAMlC,MAAM,MAAM,aAAa,GACrB,KAAK,GACL,MAAM,GACN,MAAM,GACN,KAAK,GACL,QAAQ,GACR,SAAS,GACT,SAAS,GACT,OAAO,GACP,OAAO,CAAC;AAEZ,qBAAa,mBAAoB,SAAQ,KAAK;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAGxC;AAED,wBAAgB,WAAW,CAAC,EAC1B,MAAM,EACN,GAAG,EACH,OAAO,EACP,IAAI,EACL,EAAE;IACD,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;eAGoC,MAAM;aAAW,OAAO;GA6C5D"}

package/lib/with-request.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRequest = exports.RequestNetworkError = void 0;
+const node_crypto_1 = require("node:crypto");
+const rxjs_1 = require("rxjs");
+const undici_1 = require("undici");
+const use_logger_1 = require("./use-logger");
+const use_timestamp_1 = require("./use-timestamp");
+class RequestNetworkError extends Error {
+    constructor(statusCode) {
+        super(`Request network error, received status code: ${statusCode}`);
+        this.statusCode = statusCode;
+    }
+}
+exports.RequestNetworkError = RequestNetworkError;
+function withRequest({ method, url, headers, body }) {
+    const { error, debug } = (0, use_logger_1.useLogger)(withRequest.name);
+    return new rxjs_1.Observable(subscriber => {
+        const correlationId = (0, node_crypto_1.randomUUID)();
+        debug('requesting', { correlationId, method, url, headers, body });
+        (0, undici_1.request)(url, { method, headers, body })
+            .then(({ statusCode, body }) => __awaiter(this, void 0, void 0, function* () {
+            const json = yield body.json();
+            debug('received', {
+                correlationId,
+                method,
+                url,
+                headers,
+                body: json,
+                statusCode
+            });
+            if (statusCode !== 200) {
+                error(`errored`, {
+                    method,
+                    url,
+                    headers,
+                    body,
+                    statusCode
+                });
+                subscriber.error(new RequestNetworkError(statusCode));
+            }
+            else {
+                subscriber.next({ timestamp: (0, use_timestamp_1.useTimestamp)(), payload: json });
+            }
+        }))
+            .catch((e) => {
+            error(`errored`, {
+                method,
+                url,
+                headers,
+                body,
+                error: e
+            });
+            subscriber.error(error);
+        })
+            .finally(() => subscriber.complete());
+    });
+}
+exports.withRequest = withRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantform/core",
-  "version": "0.7.0-beta.5",
+  "version": "0.7.0-beta.51",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",
@@ -12,10 +12,10 @@
     "access": "public"
   },
   "bin": {
-    "qf": "./dist/cli/index.js"
+    "qf": "./lib/cli/index.js"
   },
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "dependencies": {
     "@swc/cli": "^0.1.62",
     "@swc/core": "^1.3.44",
@@ -37,7 +37,7 @@
     "rxjs": "^7.8.0"
   },
   "peerDependencies": {
-    "rxjs": "^7.5.6"
+    "rxjs": "^7.8.0"
   },
   "scripts": {
     "build": "tsc && tsc-alias",

package/src/asset/asset.ts

@@ -3,6 +3,12 @@ import { d, decimal } from '@lib/shared';
 
 export const AssetSelectorSeparator = ':';
 
+export class MissingAssetError extends Error {
+  constructor(asset: AssetSelector) {
+    super(`Missing asset: ${asset}`);
+  }
+}
+
 /**
  * Supposed to query specific @see Asset based on string notation.
  */

package/src/cli/index.ts

@@ -5,10 +5,10 @@ import { program } from 'commander';
 import watch from 'node-watch';
 
 import build from '@lib/cli/build';
-import dev from '@lib/cli/dev';
+import live from '@lib/cli/live';
+import paper from '@lib/cli/paper';
 import pull from '@lib/cli/pull';
-import test from '@lib/cli/replay';
-import run from '@lib/cli/run';
+import replay from '@lib/cli/replay';
 
 program
   .command('build')
@@ -18,29 +18,32 @@ program
   });
 
 program
-  .command('run')
+  .command('live')
   .argument('<name>', 'strategy to execute')
   .option('-i, --id <id>', 'session identifier')
+  .option('-r, --recording', 'recording mode for replay purposes')
   .option('-w', 'watch mode')
   .description('executes strategy in live trading mode')
-  .action(run);
+  .action(live);
 
 program
-  .command('dev')
+  .command('paper')
   .argument('<name>', 'strategy to execute')
   .option('-i, --id <id>', 'session identifier')
+  .option('-r, --recording', 'recording mode for replay purposes')
   .option('-w', 'watch mode')
   .description('executes strategy in paper e.g. simulation mode')
-  .action(dev);
+  .action(paper);
 
 program
   .command('replay')
   .description('executes strategy in backtesting mode for specified period')
   .argument('<name>', 'strategy to execute')
+  .option('-i, --id <id>', 'session identifier')
   .option('-f, --from <from>', 'date from')
   .option('-t, --to <to>', 'date to')
   .option('-w', 'watch mode')
-  .action(test);
+  .action(replay);
 
 program
   .command('pull')

package/src/cli/internal/script.ts

@@ -0,0 +1,70 @@
+import { join } from 'path';
+import {
+  catchError,
+  finalize,
+  firstValueFrom,
+  forkJoin,
+  fromEvent,
+  last,
+  merge,
+  of,
+  switchMap,
+  take
+} from 'rxjs';
+
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+import { whenReplayFinished } from '@lib/replay';
+import { strategy } from '@lib/strategy';
+
+import { buildDirectory } from './workspace';
+
+export class Script {
+  constructor(
+    private readonly filename: string,
+    private readonly dependencies: Dependency[]
+  ) {}
+
+  async run() {
+    const script = await import(join(buildDirectory(), this.filename));
+
+    const { dependencies, description } = script.default as ReturnType<typeof strategy>;
+
+    const module = new Module([...core(), ...dependencies, ...this.dependencies]);
+
+    const { act } = await module.awake();
+
+    return await act(() => {
+      process.stdin.resume();
+
+      return firstValueFrom(
+        merge(
+          forkJoin(description.before.map(before => before()))
+            .pipe(
+              switchMap(() =>
+                forkJoin(description.behavior.map(behavior => behavior())).pipe(last())
+              )
+            )
+            .pipe(last()),
+          whenReplayFinished().pipe(last()),
+          fromEvent(process, 'exit'),
+          fromEvent(process, 'SIGINT'),
+          fromEvent(process, 'SIGUSR1'),
+          fromEvent(process, 'SIGUSR2'),
+          fromEvent(process, 'uncaughtException')
+        ).pipe(
+          catchError(e => {
+            console.error(e);
+
+            return of(e);
+          }),
+          take(1),
+          switchMap(
+            it => forkJoin(description.after.map(after => after())).pipe(last()) ?? of(it)
+          ),
+          finalize(() => process.exit(0))
+        )
+      );
+    });
+  }
+}

package/src/cli/live.ts

@@ -0,0 +1,22 @@
+import build from '@lib/cli/build';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
+
+export default async function (
+  name: string,
+  options: { id?: string; recording?: boolean }
+) {
+  if (await build()) {
+    return;
+  }
+
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    useExecutionMode.liveOptions({ recording: options.recording ?? false })
+  ]);
+  const output = await script.run();
+
+  console.log(output);
+}

package/src/cli/paper.ts

@@ -0,0 +1,22 @@
+import build from '@lib/cli/build';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
+
+export default async function (
+  name: string,
+  options: { id?: string; recording?: boolean }
+) {
+  if (await build()) {
+    return;
+  }
+
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    useExecutionMode.paperOptions({ recording: options.recording ?? false })
+  ]);
+  const output = await script.run();
+
+  console.log(output);
+}

package/src/cli/pull.ts

@@ -1,75 +1,15 @@
-import { join } from 'path';
-
 import build from '@lib/cli/build';
-import { buildDirectory } from '@lib/cli/internal/workspace';
-import { core } from '@lib/core';
-import { Module } from '@lib/module';
-import { strat } from '@lib/strat';
-import { paperExecutionMode } from '@lib/use-execution-mode';
-import { token } from '@lib/use-memo';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
 
 export default async function (name: string, instrument: string, options: any) {
   if (await build()) {
     return;
   }
-  await import(join(buildDirectory(), 'index'));
-
-  const script = (await import(join(buildDirectory(), name))) as ReturnType<typeof strat>;
-
-  const module = new Module([
-    ...core(),
-    ...script.dependencies,
-    paperExecutionMode({ recording: false })
-  ]);
-
-  const { act } = await module.awake();
-
-  const o = await act(() => script.fn());
-  console.log(module.get<any>(token));
-
-  /*const builder = new SessionBuilder().useSessionId(
-    options.id ? Number(options.id) : now()
-  );
-
-  await spawn(name, builder);
-
-  const session = builder.paper();
-
-  console.time('Pulling completed in');
-
-  await session.awake();
-
-  const bar = new SingleBar(
-    {
-      format: `Pulling ${instrument} [{bar}] {percentage}% | ETA: {eta}s | {value}/{total}`
-    },
-    Presets.rect
-  );
-
-  const feed = new Feed(builder.storage('feed'));
-  const from = options.from ? Date.parse(options.from) : builder.period.from;
-  const to = options.to ? Date.parse(options.to) : builder.period.to;
-
-  bar.start(100, 0);
-
-  await session.aggregate.feed(
-    instrumentOf(instrument),
-    from,
-    to,
-    async (timestamp, events) => {
-      const duration = to - from;
-      const completed = timestamp - from;
-
-      await feed.save(events);
-
-      bar.update(Math.floor((completed / duration) * 100));
-    }
-  );
-
-  bar.update(100);
-  bar.stop();
 
-  await session.dispose();
+  const script = new Script(name, [useExecutionMode.idleOptions()]);
+  //const output = await script.run();
 
-  console.timeLog('Pulling completed in');*/
+  //console.log(output);
 }

package/src/cli/replay.ts

@@ -1,31 +1,27 @@
-import { join } from 'path';
-import { lastValueFrom } from 'rxjs';
-
 import build from '@lib/cli/build';
-import { buildDirectory } from '@lib/cli/internal/workspace';
-import { core } from '@lib/core';
-import { Dependency, Module } from '@lib/module';
 import { replayOptions } from '@lib/replay';
-import { replayExecutionMode } from '@lib/use-execution-mode';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
 
-export default async function (name: string, options: any) {
+export default async function (
+  name: string,
+  options: { id?: string; from?: string; to?: string }
+) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
+  const from = options.from ? new Date(options.from).getTime() : 0;
+  const to = options.to ? new Date(options.to).getTime() : Number.MAX_VALUE;
 
-  const module = new Module([
-    ...core(),
-    ...dependencies,
-    replayOptions({ from: 0, to: Number.MAX_VALUE }),
-    replayExecutionMode()
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    replayOptions({ from, to }),
+    useExecutionMode.replayOptions()
   ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const output = await script.run();
 
   console.log(output);
 }

package/src/core.ts

@@ -1,14 +1,14 @@
 import { Dependency } from '@lib/module';
-import { memo } from '@lib/use-memo';
+import { useMemo } from '@lib/use-memo';
 
 import { InMemoryStorageFactory } from './storage';
-import { storage } from './storage/use-storage-factory';
-import { paperExecutionMode } from './use-execution-mode';
+import { useStorageFactory } from './storage/use-storage-factory';
+import { useExecutionMode } from './use-execution-mode';
 
 export function core(): Dependency[] {
   return [
-    memo(),
-    paperExecutionMode({ recording: false }),
-    storage(new InMemoryStorageFactory())
+    useMemo.options(),
+    useExecutionMode.paperOptions({ recording: false }),
+    useStorageFactory.options(new InMemoryStorageFactory())
   ];
 }

package/src/index.ts

@@ -7,21 +7,14 @@ export * from '@lib/use-timestamp';
 export * from '@lib/simulator';
 export * from '@lib/make-test-module';
 export * from '@lib/core';
-export * from '@lib/use-state';
-export * from '@lib/replay/use-replay-coordinator';
 export * from '@lib/use-execution-mode';
-export * from '@lib/storage/use-storage';
-export * from '@lib/storage/use-cache';
+export * from '@lib/storage';
 export * from '@lib/use-logger';
 export * from '@lib/replay';
-export * from '@lib/replay/use-replay-coordinator';
 export * from '@lib/use-socket';
-export * from '@lib/use-request';
-export * from '@lib/defined';
-export * from '@lib/as-readonly';
-export * from '@lib/use';
+export * from '@lib/when-socket';
+export * from '@lib/with-request';
+export * from '@lib/with-memo';
 export * from '@lib/session';
-export * from '@lib/exclude';
-export * from '@lib/use-lock';
-export * from '@lib/strat';
-export * from '@lib/not-found';
+export * from '@lib/strategy';
+export * from '@lib/operators';

package/src/instrument/instrument.ts

@@ -5,6 +5,12 @@ import { Commission } from './commission/commission';
 
 export const InstrumentSelectorSeparator = '-';
 
+export class MissingInstrumentError extends Error {
+  constructor(instrument: InstrumentSelector) {
+    super(`Missing instrument: ${instrument}`);
+  }
+}
+
 export class InstrumentSelector {
   readonly id: string;
   readonly base: AssetSelector;

package/src/make-test-module.ts

@@ -1,4 +1,4 @@
-import { Observable, tap } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 
 import { core } from '@lib/core';
 import { Dependency, Module } from '@lib/module';
@@ -20,9 +20,9 @@ export const mockedFunc = <Func extends MockableFunction>(mockedFunc: Func) =>
   mockedFunc as jest.MockedFunction<typeof mockedFunc>;
 
 export function toArray<T>(observable: Observable<T>) {
-  const array = Array.of<T>();
+  const array = Array.of<T | Error>();
 
-  const clone = (it: T): T => {
+  const clone = (it: T | Error): T | Error => {
     if (typeof it === 'symbol') {
       return it;
     }
@@ -38,9 +38,25 @@ export function toArray<T>(observable: Observable<T>) {
     return it;
   };
 
-  observable.pipe(tap(it => array.push(clone(it)))).subscribe();
+  observable.subscribe({
+    next: it => array.push(clone(it)),
+    error: it => array.push(it)
+  });
 
   return array;
 }
 
 export type InferObservableType<T> = T extends Observable<infer U> ? U : never;
+
+export function mockSubject<
+  T extends jest.FunctionProperties<Required<T>>,
+  M extends keyof jest.FunctionProperties<Required<T>>
+>(object: T, method: M) {
+  const subject = new Subject<
+    InferObservableType<ReturnType<jest.FunctionProperties<Required<T>>[M]>>
+  >();
+
+  jest.spyOn<T, M>(object, method).mockReturnValue(subject.asObservable() as any);
+
+  return subject;
+}

package/src/operators.ts

@@ -0,0 +1,18 @@
+import { filter, map, Observable } from 'rxjs';
+
+export function asReadonly<T>() {
+  return (input: Observable<T>) => input.pipe(map(it => it as Readonly<T>));
+}
+
+export function defined<T>() {
+  return (observable: Observable<T | undefined | null>) =>
+    observable.pipe(filter(it => it !== undefined && it !== null));
+}
+
+export function exclude<T, S extends symbol>(s: S) {
+  return (observable: Observable<T | S>) =>
+    observable.pipe(
+      filter(it => it !== s),
+      map(it => it as Exclude<T, typeof s>)
+    );
+}

package/src/replay/index.ts

@@ -1,6 +1,9 @@
 export * from './use-replay';
-export * from './use-replay-coordinator';
+export * from './use-replay-lock';
 export * from './use-replay-options';
-export * from './use-replay-reader';
-export * from './use-replay-writer';
-export * from './with-replay';
+export * from './storage/use-replay-storage';
+export * from './storage/use-replay-storage-buffer';
+export * from './use-replay-manager';
+export * from './when-replay-finished';
+export * from './replay';
+export * from './replay-guard';

package/src/replay/replay-guard.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+
+import { dependency } from '@lib/use-hash';
+
+import { useReplayLock } from './use-replay-lock';
+
+export function replayGuard<T extends Array<dependency>, K>(
+  fn: (...args: T) => Observable<{ timestamp: number; payload: K }>
+): (...args: T) => Observable<{ timestamp: number; payload: K }> {
+  return (...args: T) => useReplayLock(fn(...args));
+}

package/src/replay/replay.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+
+import { dependency } from '@lib/use-hash';
+import { withMemo } from '@lib/with-memo';
+
+import { useReplay } from './use-replay';
+
+export function replay<T extends Array<dependency>, K>(
+  fn: (...args: T) => Observable<{ timestamp: number; payload: K }>,
+  dependencies: dependency[]
+): (...args: T) => Observable<{ timestamp: number; payload: K }> {
+  return withMemo((...args: T) => useReplay(fn(...args), [...dependencies, ...args]));
+}

package/src/replay/storage/use-replay-storage-buffer.ts

@@ -0,0 +1,52 @@
+import { useReplayOptions } from '@lib/replay/use-replay-options';
+import { between } from '@lib/storage';
+import { dependency } from '@lib/use-hash';
+import { withMemo } from '@lib/with-memo';
+
+import { useReplayStorage } from './use-replay-storage';
+
+export const useReplayStorageBuffer = withMemo(<T>(dependencies: dependency[]) => {
+  const { query } = useReplayStorage<T>(dependencies);
+  const { from, to } = useReplayOptions();
+
+  console.log(from, to);
+
+  let page = new Array<{ timestamp: number; payload: T }>();
+  let index = 0;
+  let completed = false;
+  let count = 0;
+
+  return {
+    size() {
+      return page.length - index;
+    },
+    peek() {
+      return page[index];
+    },
+    dequeue() {
+      return page[index++];
+    },
+    completed() {
+      return completed;
+    },
+    async fetchNextPage() {
+      if (completed) {
+        return;
+      }
+
+      index = 0;
+
+      page = await query({
+        where: {
+          timestamp: between(from, to)
+        },
+        limit: 10000,
+        offset: count,
+        orderBy: 'ASC'
+      });
+
+      count += page.length;
+      completed = page.length == 0;
+    }
+  };
+});