@quantform/core 0.7.0-beta.33 → 0.7.0-beta.35

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,13 +7,10 @@ export * from '@lib/use-timestamp';
 export * from '@lib/simulator';
 export * from '@lib/make-test-module';
 export * from '@lib/core';
-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/when-socket';
 export * from '@lib/with-request';
 export * from '@lib/with-memo';

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

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

@@ -0,0 +1,85 @@
+import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { Query, QueryObject, Storage } from '@lib/storage';
+import { useStorage } from '@lib/storage';
+
+import { useReplayStorage } from './use-replay-storage';
+
+jest.mock('@lib/storage', () => ({
+  ...jest.requireActual('@lib/storage'),
+  useStorage: jest.fn()
+}));
+
+describe(useReplayStorage.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  describe('query', () => {
+    test('happy path', async () => {
+      await fixtures.given.stored(fixtures.sample);
+      const sample = await fixtures.when.queried({});
+
+      expect(sample).toEqual(fixtures.sample);
+    });
+  });
+
+  describe('save', () => {
+    test('happy path', async () => {
+      await fixtures.when.saved(fixtures.sample);
+      await fixtures.then.stored(fixtures.sample);
+    });
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+  const save: Storage['save'] = jest.fn();
+  const query: jest.MockedFunction<Storage['query']> = jest.fn();
+
+  mockedFunc(useStorage).mockReturnValue({ save, query } as any);
+
+  return {
+    sample: [
+      { timestamp: 1, payload: { o: 1.1, h: 1.1, l: 1.1, c: 1.1 } },
+      { timestamp: 2, payload: { o: 1.1, h: 2.2, l: 1.1, c: 2.2 } },
+      { timestamp: 3, payload: { o: 1.1, h: 3.3, l: 1.1, c: 3.3 } }
+    ],
+
+    given: {
+      stored<T>(sample: { timestamp: number; payload: T }[]) {
+        return query.mockReturnValue(
+          Promise.resolve(
+            sample.map(it => ({
+              timestamp: it.timestamp,
+              payload: JSON.stringify(it.payload)
+            }))
+          )
+        );
+      }
+    },
+    when: {
+      saved<T>(sample: { timestamp: number; payload: T }[]) {
+        return act(() => useReplayStorage(dependencies).save(sample));
+      },
+      queried<T>(query: Query<QueryObject>) {
+        return act(() => useReplayStorage<T>(dependencies).query(query));
+      }
+    },
+
+    then: {
+      stored<T>(sample: { timestamp: number; payload: T }[]) {
+        expect(save).toHaveBeenCalledWith(
+          expect.anything(),
+          sample.map(it => ({
+            timestamp: it.timestamp,
+            payload: JSON.stringify(it.payload)
+          }))
+        );
+      }
+    }
+  };
+}

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

@@ -1,8 +1,29 @@
-import { Storage, useStorage } from '@lib/storage';
+import { Query, QueryObject, Storage, useStorage } from '@lib/storage';
+import { dependency, useHash } from '@lib/use-hash';
 
-export const replaySerializableObject = (key: string) =>
-  Storage.createObject(key, { timestamp: 'number', json: 'string' });
+export function useReplayStorage<T>(dependencies: dependency[]) {
+  const storage = useStorage(['replay']);
+  const storageObjectKey = useHash(dependencies);
+  const storageObject = Storage.createObject(storageObjectKey, {
+    timestamp: 'number',
+    payload: 'string'
+  });
 
-export function useReplayStorage() {
-  return useStorage(['replay']);
+  return {
+    async query(query: Query<QueryObject>) {
+      return (await storage.query(storageObject, query)).map(it => ({
+        timestamp: it.timestamp,
+        payload: JSON.parse(it.payload) as T
+      }));
+    },
+    save(objects: { timestamp: number; payload: T }[]) {
+      return storage.save(
+        storageObject,
+        objects.map(it => ({
+          timestamp: it.timestamp,
+          payload: JSON.stringify(it.payload)
+        }))
+      );
+    }
+  };
 }

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

@@ -1,15 +1,21 @@
+import exp from 'constants';
 import { from, lastValueFrom, tap } from 'rxjs';
 
 import { makeTestModule } from '@lib/make-test-module';
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
 import { replayExecutionMode } from '@lib/use-execution-mode';
 import { dependency } from '@lib/use-hash';
 
 import { between } from '..';
 import { useReplay } from './use-replay';
 import { replayOptions } from './use-replay-options';
-import { useReplayReader } from './use-replay-reader';
-import { useReplayWriter } from './use-replay-writer';
+
+describe(useReplay.name, () => {
+  test('happy path', () => {
+    expect(true).toBe(true);
+  });
+});
+
+/*
 
 describe.skip(useReplayCoordinator.name, () => {
   let fixtures: Awaited<ReturnType<typeof getFixtures>>;
@@ -130,3 +136,4 @@ async function getFixtures() {
     }
   };
 }
+*/

package/src/replay/use-replay.ts

@@ -1,34 +1,28 @@
-import { concatMap, map, Observable } from 'rxjs';
+import { Observable, tap } from 'rxjs';
 
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
 import { useExecutionMode } from '@lib/use-execution-mode';
 import { dependency } from '@lib/use-hash';
 
-import { useReplayWriter } from './use-replay-writer';
+import { useReplayManager } from './use-replay-manager';
+import { useReplayStorage } from './use-replay-storage';
 
-export const useReplay = <T>(
+export function useReplay<T>(
   input: Observable<{ timestamp: number; payload: T }>,
   dependencies: dependency[]
-) => {
+) {
   const { isReplay, recording } = useExecutionMode();
 
   if (isReplay) {
-    const { subscribe } = useReplayCoordinator();
+    const { when } = useReplayManager();
 
-    return subscribe(dependencies).pipe(
-      map(it => it as unknown as { timestamp: number; payload: T })
-    );
+    return when<T>(dependencies);
   }
 
   if (recording) {
-    const writer = useReplayWriter(dependencies);
-    return input.pipe(
-      concatMap(async it => {
-        await writer([it]);
-        return it;
-      })
-    );
+    const { save } = useReplayStorage<T>(dependencies);
+
+    return input.pipe(tap(it => save([it])));
   }
 
   return input;
-};
+}

package/src/storage/index.ts

@@ -1,4 +1,5 @@
 export * from './storage';
+export * from './use-cache';
 export * from './use-storage';
 export * from './use-storage-factory';
 export * from './in-memory';

package/src/use-execution-mode.ts

@@ -3,28 +3,35 @@ import { useContext } from '@lib/module';
 const injectionToken = Symbol('execution-mode');
 
 type ExecutionMode = {
-  mode: 'REPLAY' | 'PAPER' | 'LIVE';
+  mode: 'replay' | 'paper' | 'live' | 'idle';
   recording: boolean;
 };
 
 export function replayExecutionMode() {
   return {
     provide: injectionToken,
-    useValue: { mode: 'REPLAY', recording: false } as ExecutionMode
+    useValue: { mode: 'replay', recording: false } as ExecutionMode
   };
 }
 
 export function paperExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'PAPER', ...options } as ExecutionMode
+    useValue: { mode: 'paper', ...options } as ExecutionMode
   };
 }
 
 export function liveExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'LIVE', ...options } as ExecutionMode
+    useValue: { mode: 'live', ...options } as ExecutionMode
+  };
+}
+
+export function idleExecutionMode() {
+  return {
+    provide: injectionToken,
+    useValue: { mode: 'idle', recording: false } as ExecutionMode
   };
 }
 
@@ -32,10 +39,11 @@ export const useExecutionMode = () => {
   const mode = useContext<ExecutionMode>(injectionToken);
 
   return {
-    isReplay: mode.mode === 'REPLAY',
-    isPaper: mode.mode === 'PAPER',
-    isLive: mode.mode === 'LIVE',
-    isSimulation: mode.mode !== 'LIVE',
+    isReplay: mode.mode === 'replay',
+    isPaper: mode.mode === 'paper',
+    isLive: mode.mode === 'live',
+    isIdle: mode.mode === 'idle',
+    isSimulation: mode.mode !== 'live',
     recording: mode.recording
   };
 };

package/src/use-timestamp.ts

@@ -1,11 +1,11 @@
-import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
+import { useReplayManager } from '@lib/replay';
 import { useExecutionMode } from '@lib/use-execution-mode';
 
 export function useTimestamp() {
   const { isReplay } = useExecutionMode();
 
   if (isReplay) {
-    return useReplayCoordinator().timestamp();
+    return useReplayManager().timestamp();
   }
 
   return Date.now();

package/dist/replay/use-replay-coordinator.d.ts

@@ -1,10 +0,0 @@
-import { dependency } from '../use-hash';
-export declare function useReplayCoordinator(): {
-    timestamp: () => number;
-    stop: () => number;
-    tryContinue: () => void;
-    subscribe: (dependencies: dependency[]) => import("rxjs").Observable<{
-        timestamp: number;
-    }>;
-};
-//# sourceMappingURL=use-replay-coordinator.d.ts.map

package/dist/replay/use-replay-coordinator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-coordinator.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,wBAAgB,oBAAoB;;;;8BAUC,UAAU,EAAE;mBAFW,MAAM;;EAsFjE"}

package/dist/replay/use-replay-coordinator.js

@@ -1,119 +0,0 @@
-"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.useReplayCoordinator = void 0;
-const rxjs_1 = require("rxjs");
-const use_memo_1 = require("../use-memo");
-const __1 = require("..");
-const use_replay_options_1 = require("./use-replay-options");
-const use_replay_reader_1 = require("./use-replay-reader");
-function useReplayCoordinator() {
-    const options = (0, use_replay_options_1.useReplayOptions)();
-    return (0, use_memo_1.useMemo)(() => {
-        let timestamp = options.from;
-        let stopAcquire = 1;
-        let sequence = 0;
-        const subscriptions = Array.of();
-        const stream$ = new rxjs_1.Subject();
-        const subscribe = (dependencies) => {
-            const cursor = useSampleCursor(dependencies);
-            if (!subscriptions.includes(cursor)) {
-                subscriptions.push(cursor);
-            }
-            return (0, rxjs_1.defer)(() => {
-                tryContinue();
-                return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === cursor), (0, rxjs_1.map)(([, it]) => it));
-            });
-        };
-        const current = () => __awaiter(this, void 0, void 0, function* () {
-            let next;
-            for (const cursor of subscriptions) {
-                if (cursor.size() == 0 && !cursor.completed) {
-                    yield cursor.fetchNextPage(timestamp, options.to + 1);
-                }
-                if (cursor.peek()) {
-                    if (!next || next.peek().timestamp > cursor.peek().timestamp) {
-                        next = cursor;
-                    }
-                }
-            }
-            return next;
-        });
-        const processNext = () => __awaiter(this, void 0, void 0, function* () {
-            const cursor = yield current();
-            if (!cursor || !cursor.peek()) {
-                stream$.complete();
-                return false;
-            }
-            const sample = cursor.dequeue();
-            timestamp = sample.timestamp;
-            sequence++;
-            stream$.next([cursor, sample]);
-            return true;
-        });
-        const next = () => __awaiter(this, void 0, void 0, function* () {
-            if (yield processNext()) {
-                if (stopAcquire === 0) {
-                    setImmediate(next);
-                }
-            }
-        });
-        const stop = () => stopAcquire++;
-        const tryContinue = () => {
-            if (stopAcquire == 0) {
-                return;
-            }
-            stopAcquire = Math.max(0, stopAcquire - 1);
-            if (stopAcquire != 0) {
-                return;
-            }
-            next();
-        };
-        return {
-            timestamp: () => timestamp,
-            stop,
-            tryContinue,
-            subscribe
-        };
-    }, [useReplayCoordinator.name]);
-}
-exports.useReplayCoordinator = useReplayCoordinator;
-function useSampleCursor(dependencies) {
-    return (0, use_memo_1.useMemo)(() => {
-        const read = (0, use_replay_reader_1.useReplayReader)(dependencies);
-        let page = new Array();
-        let index = 0;
-        let completed = false;
-        const size = () => page.length - index;
-        const peek = () => page[index];
-        const dequeue = () => page[index++];
-        const fetchNextPage = (from, to) => __awaiter(this, void 0, void 0, function* () {
-            if (completed) {
-                return;
-            }
-            index = 0;
-            page = yield read({
-                where: {
-                    timestamp: (0, __1.between)(from, to)
-                },
-                limit: 10000
-            });
-            completed = page.length == 0;
-        });
-        return {
-            size,
-            peek,
-            dequeue,
-            fetchNextPage,
-            completed
-        };
-    }, [useSampleCursor.name, ...dependencies]);
-}