@quantform/core 0.7.0-beta.4 → 0.7.0-beta.40

package/dist/with-request.js

@@ -0,0 +1,69 @@
+"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, json) {
+        super(`Request network error, received status code: ${statusCode}`);
+        this.statusCode = statusCode;
+        this.json = json;
+    }
+}
+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, () => json));
+            }
+            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.4",
+  "version": "0.7.0-beta.40",
   "license": "MIT",
   "author": "Mateusz Majchrzak",
   "description": "Node.js library for building systematic trading strategies in reactive way.",

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/dev.ts

@@ -1,31 +1,15 @@
-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 { Module } from '@lib/module';
-import { strat } from '@lib/strat';
 import { paperExecutionMode } from '@lib/use-execution-mode';
 
+import { Script } from './internal/script';
+
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const script = (await import(join(buildDirectory(), name))).default as ReturnType<
-    typeof strat
-  >;
-
-  const module = new Module([
-    ...core(),
-    ...script.dependencies,
-    paperExecutionMode({ recording: false })
-  ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.fn()));
+  const script = new Script(name, [paperExecutionMode({ recording: false })]);
+  const output = await script.run();
 
   console.log(output);
 }

package/src/cli/internal/script.ts

@@ -0,0 +1,49 @@
+import { join } from 'path';
+import {
+  finalize,
+  firstValueFrom,
+  fromEvent,
+  last,
+  merge,
+  of,
+  switchMap,
+  take
+} from 'rxjs';
+
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+
+import { buildDirectory } from './workspace';
+
+export class Script {
+  constructor(
+    private readonly name: string,
+    private readonly dependencies: Dependency[]
+  ) {}
+
+  async run() {
+    const script = await import(join(buildDirectory(), this.name));
+    const module = new Module([...core(), ...script.onInstall(), ...this.dependencies]);
+
+    const { act } = await module.awake();
+
+    return await act(() => {
+      process.stdin.resume();
+
+      return firstValueFrom(
+        merge(
+          script.onAwake().pipe(last()),
+          fromEvent(process, 'exit'),
+          fromEvent(process, 'SIGINT'),
+          fromEvent(process, 'SIGUSR1'),
+          fromEvent(process, 'SIGUSR2'),
+          fromEvent(process, 'uncaughtException')
+        ).pipe(
+          take(1),
+          switchMap(it => script.onExit() ?? of(it)),
+          finalize(() => process.exit(0))
+        )
+      );
+    });
+  }
+}

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 { idleExecutionMode } 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, [idleExecutionMode()]);
+  //const output = await script.run();
 
-  console.timeLog('Pulling completed in');*/
+  //console.log(output);
 }

package/src/cli/replay.ts

@@ -1,31 +1,19 @@
-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 { Script } from './internal/script';
+
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
-
-  const module = new Module([
-    ...core(),
-    ...dependencies,
+  const script = new Script(name, [
     replayOptions({ from: 0, to: Number.MAX_VALUE }),
     replayExecutionMode()
   ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const output = await script.run();
 
   console.log(output);
 }

package/src/cli/run.ts

@@ -1,29 +1,15 @@
-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 { liveExecutionMode } from '@lib/use-execution-mode';
 
+import { Script } from './internal/script';
+
 export default async function (name: string, options: any) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
-
-  const module = new Module([
-    ...core(),
-    ...dependencies,
-    liveExecutionMode({ recording: true })
-  ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const script = new Script(name, [liveExecutionMode({ recording: true })]);
+  const output = await script.run();
 
   console.log(output);
 }

package/src/index.ts

@@ -7,21 +7,12 @@ 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/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,29 @@ 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 ReturnType<jest.FunctionProperties<Required<T>>[M]>
+    );
+
+  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,8 @@
 export * from './use-replay';
-export * from './use-replay-coordinator';
+export * from './use-replay-breakpoint';
 export * from './use-replay-options';
-export * from './use-replay-reader';
-export * from './use-replay-writer';
-export * from './with-replay';
+export * from './use-replay-storage';
+export * from './use-replay-storage-buffer';
+export * from './use-replay-manager';
+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 { useReplayBreakpoint } from './use-replay-breakpoint';
+
+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) => useReplayBreakpoint(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/use-replay-breakpoint.ts

@@ -0,0 +1,29 @@
+import { finalize, Observable } from 'rxjs';
+
+import { useExecutionMode } from '@lib/use-execution-mode';
+import { useLogger } from '@lib/use-logger';
+
+import { useReplayManager } from './use-replay-manager';
+
+export function useReplayBreakpoint<T>(input: Observable<T>): Observable<T> {
+  const { isReplay } = useExecutionMode();
+
+  if (!isReplay) {
+    return input;
+  }
+
+  const { info } = useLogger('useReplayBreakpoint');
+  const { stop, tryContinue } = useReplayManager();
+
+  info('locking resource...');
+
+  stop();
+
+  return input.pipe(
+    finalize(() => {
+      info('unlocking resource');
+
+      tryContinue();
+    })
+  );
+}

package/src/replay/use-replay-manager.ts

@@ -0,0 +1,106 @@
+import { defer, filter, map, Observable, Subject } from 'rxjs';
+
+import { dependency, useHash } from '@lib/use-hash';
+import { useLogger } from '@lib/use-logger';
+import { withMemo } from '@lib/with-memo';
+
+import { useReplayOptions } from './use-replay-options';
+import { useReplayStorageBuffer } from './use-replay-storage-buffer';
+
+export const useReplayManager = withMemo(() => {
+  const { from, to } = useReplayOptions();
+  const { info } = useLogger('useReplayManager');
+
+  let timestamp = from;
+  let stopAcquire = 1;
+  const subscriptions = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
+
+  const stream$ = new Subject<
+    [ReturnType<typeof useReplayStorageBuffer<any>>, { timestamp: number; payload: any }]
+  >();
+
+  const getNextStorage = async () => {
+    let next: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
+
+    for (const cursor of subscriptions) {
+      if (cursor.size() == 0 && !cursor.completed()) {
+        await cursor.fetchNextPage(timestamp, to + 1);
+      }
+
+      if (cursor.peek()) {
+        if (!next || next.peek().timestamp > cursor.peek().timestamp) {
+          next = cursor;
+        }
+      }
+    }
+
+    return next;
+  };
+
+  const processNext = async () => {
+    const cursor = await getNextStorage();
+
+    if (!cursor || !cursor.peek()) {
+      stream$.complete();
+
+      return false;
+    }
+
+    const sample = cursor.dequeue();
+
+    timestamp = sample.timestamp;
+
+    stream$.next([cursor, sample]);
+
+    return true;
+  };
+
+  const next = async () => {
+    if (await processNext()) {
+      if (stopAcquire === 0) {
+        setImmediate(next);
+      }
+    }
+  };
+
+  const tryContinue = () => {
+    if (stopAcquire == 0) {
+      return;
+    }
+
+    stopAcquire = Math.max(0, stopAcquire - 1);
+
+    if (stopAcquire != 0) {
+      return;
+    }
+
+    next();
+  };
+
+  return {
+    timestamp() {
+      return timestamp;
+    },
+    stop() {
+      stopAcquire++;
+    },
+    tryContinue,
+    when<T>(dependencies: dependency[]): Observable<{ timestamp: number; payload: T }> {
+      const storage = useReplayStorageBuffer<T>(dependencies);
+
+      if (!subscriptions.includes(storage)) {
+        info('subscribing to replay', useHash(dependencies));
+        subscriptions.push(storage);
+      }
+
+      return defer(() => {
+        tryContinue();
+
+        return stream$.pipe(
+          filter(([cur]) => cur === storage),
+          map(([, it]) => ({ timestamp: it.timestamp, payload: it.payload as T }))
+        );
+      });
+    }
+  };
+});

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

@@ -0,0 +1,43 @@
+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);
+
+  let page = new Array<{ timestamp: number; payload: T }>();
+  let index = 0;
+  let completed = false;
+
+  return {
+    size() {
+      return page.length - index;
+    },
+    peek() {
+      return page[index];
+    },
+    dequeue() {
+      return page[index++];
+    },
+    completed() {
+      return completed;
+    },
+    async fetchNextPage(from: number, to: number) {
+      if (completed) {
+        return;
+      }
+
+      index = 0;
+
+      page = await query({
+        where: {
+          timestamp: between(from, to)
+        },
+        limit: 10000
+      });
+      completed = page.length == 0;
+    }
+  };
+});