@quantform/core 0.7.20 → 0.7.22

package/lib/replay/storage/use-replay-storage.js

@@ -1,39 +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.useReplayStorage = void 0;
-const storage_1 = require("../../storage");
-const use_hash_1 = require("../../use-hash");
-function useReplayStorage(dependencies) {
-    const storage = (0, storage_1.useStorage)(['replay']);
-    const storageObjectKey = (0, use_hash_1.useHash)(dependencies);
-    const storageObject = storage_1.Storage.createObject(storageObjectKey, {
-        timestamp: 'number',
-        payload: 'string'
-    });
-    return {
-        query(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield storage.query(storageObject, query)).map(it => ({
-                    timestamp: it.timestamp,
-                    payload: JSON.parse(it.payload)
-                }));
-            });
-        },
-        save(objects) {
-            return storage.save(storageObject, objects.map(it => ({
-                timestamp: it.timestamp,
-                payload: JSON.stringify(it.payload)
-            })));
-        }
-    };
-}
-exports.useReplayStorage = useReplayStorage;

package/lib/replay/storage/use-replay-storage.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=use-replay-storage.spec.d.ts.map

package/lib/replay/storage/use-replay-storage.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-storage.spec.d.ts","sourceRoot":"","sources":["../../../src/replay/storage/use-replay-storage.spec.ts"],"names":[],"mappings":""}

package/lib/replay/storage/use-replay-storage.spec.js

@@ -1,74 +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 });
-const make_test_module_1 = require("../../make-test-module");
-const storage_1 = require("../../storage");
-const use_replay_storage_1 = require("./use-replay-storage");
-jest.mock('@lib/storage', () => (Object.assign(Object.assign({}, jest.requireActual('@lib/storage')), { useStorage: jest.fn() })));
-describe(use_replay_storage_1.useReplayStorage.name, () => {
-    let fixtures;
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        fixtures = yield getFixtures();
-    }));
-    describe('query', () => {
-        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield fixtures.given.stored(fixtures.sample);
-            const sample = yield fixtures.when.queried({});
-            expect(sample).toEqual(fixtures.sample);
-        }));
-    });
-    describe('save', () => {
-        test('happy path', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield fixtures.when.saved(fixtures.sample);
-            yield fixtures.then.stored(fixtures.sample);
-        }));
-    });
-});
-function getFixtures() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { act } = yield (0, make_test_module_1.makeTestModule)([]);
-        const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
-        const save = jest.fn();
-        const query = jest.fn();
-        (0, make_test_module_1.mockedFunc)(storage_1.useStorage).mockReturnValue({ save, query });
-        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(sample) {
-                    return query.mockReturnValue(Promise.resolve(sample.map(it => ({
-                        timestamp: it.timestamp,
-                        payload: JSON.stringify(it.payload)
-                    }))));
-                }
-            },
-            when: {
-                saved(sample) {
-                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).save(sample));
-                },
-                queried(query) {
-                    return act(() => (0, use_replay_storage_1.useReplayStorage)(dependencies).query(query));
-                }
-            },
-            then: {
-                stored(sample) {
-                    expect(save).toHaveBeenCalledWith(expect.anything(), sample.map(it => ({
-                        timestamp: it.timestamp,
-                        payload: JSON.stringify(it.payload)
-                    })));
-                }
-            }
-        };
-    });
-}

package/lib/replay/use-replay-lock.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-export declare function useReplayLock<T>(input: Observable<T>): Observable<T>;
-//# sourceMappingURL=use-replay-lock.d.ts.map

package/lib/replay/use-replay-lock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-lock.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,UAAU,EAAE,MAAM,MAAM,CAAC;AAO5C,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAqBpE"}

package/lib/replay/use-replay-lock.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useReplayLock = void 0;
-const rxjs_1 = require("rxjs");
-const use_execution_mode_1 = require("../use-execution-mode");
-const use_logger_1 = require("../use-logger");
-const use_replay_manager_1 = require("./use-replay-manager");
-function useReplayLock(input) {
-    const { isReplay } = (0, use_execution_mode_1.useExecutionMode)();
-    if (!isReplay) {
-        return input;
-    }
-    const { info } = (0, use_logger_1.useLogger)('replay');
-    const { stop, tryContinue } = (0, use_replay_manager_1.useReplayManager)();
-    info('lock acquired');
-    stop();
-    return input.pipe((0, rxjs_1.finalize)(() => {
-        info('lock released');
-        tryContinue();
-    }));
-}
-exports.useReplayLock = useReplayLock;

package/lib/replay/use-replay-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-manager.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,UAAU,EAAW,MAAM,MAAM,CAAC;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;mBAQqC,MAAM;iBAAW,GAAG;;;;;2BAoD3D,UAAU,EAAE;mBAA2B,MAAM;;;CAatE,CAAC"}

package/lib/replay/use-replay-manager.js

@@ -1,68 +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.useReplayManager = void 0;
-const rxjs_1 = require("rxjs");
-const with_memo_1 = require("../with-memo");
-const use_replay_storage_cursor_1 = require("./storage/use-replay-storage-cursor");
-const use_replay_options_1 = require("./use-replay-options");
-exports.useReplayManager = (0, with_memo_1.withMemo)(() => {
-    const { from } = (0, use_replay_options_1.useReplayOptions)();
-    const { get, cursor } = (0, use_replay_storage_cursor_1.useReplayStorageCursor)();
-    let timestamp = from;
-    let stopAcquire = 1;
-    const stream$ = new rxjs_1.Subject();
-    const processNext = () => __awaiter(void 0, void 0, void 0, function* () {
-        const storage = yield cursor();
-        if (!storage || !storage.peek()) {
-            stream$.complete();
-            return false;
-        }
-        const sample = storage.dequeue();
-        timestamp = sample.timestamp;
-        stream$.next([storage, sample]);
-        return true;
-    });
-    const next = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (yield processNext()) {
-            if (stopAcquire === 0) {
-                setImmediate(next);
-            }
-        }
-    });
-    const tryContinue = () => {
-        if (stopAcquire == 0) {
-            return;
-        }
-        stopAcquire = Math.max(0, stopAcquire - 1);
-        if (stopAcquire != 0) {
-            return;
-        }
-        next();
-    };
-    return {
-        stream: stream$.asObservable(),
-        timestamp() {
-            return timestamp;
-        },
-        stop() {
-            stopAcquire++;
-        },
-        tryContinue,
-        watch(dependencies) {
-            const storage = get(dependencies);
-            return (0, rxjs_1.defer)(() => {
-                tryContinue();
-                return stream$.pipe((0, rxjs_1.filter)(([cur]) => cur === storage), (0, rxjs_1.map)(([, it]) => ({ timestamp: it.timestamp, payload: it.payload })));
-            });
-        }
-    };
-});

package/lib/replay/use-replay.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=use-replay.spec.d.ts.map

package/lib/replay/use-replay.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay.spec.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay.spec.ts"],"names":[],"mappings":""}

package/lib/replay/use-replay.spec.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const use_replay_1 = require("./use-replay");
-describe(use_replay_1.useReplay.name, () => {
-    test('happy path', () => {
-        expect(true).toBe(true);
-    });
-});
-/*
-
-describe.skip(useReplayCoordinator.name, () => {
-  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
-
-  beforeEach(async () => {
-    fixtures = await getFixtures();
-  });
-
-  test('return single data stream for single data source', async () => {
-    fixtures.givenRecordingEnabled(false);
-    await fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
-
-    const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample']);
-    await fixtures.whenUseSampleStreamerStarted();
-
-    expect(await sample1).toEqual(fixtures.sample1);
-  });
-
-  test('return combined data stream for multiple data sources', async () => {
-    fixtures.givenRecordingEnabled(false);
-    await fixtures.givenSampleStored(fixtures.sample1, ['sample1']);
-    await fixtures.givenSampleStored(fixtures.sample2, ['sample2']);
-
-    const sample1 = fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1']);
-    const sample2 = fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2']);
-    await fixtures.whenUseSampleStreamerStarted();
-
-    expect(await sample1).toEqual(fixtures.sample1);
-    expect(await sample2).toEqual(fixtures.sample2);
-  });
-
-  test('record and write data stream into storage', async () => {
-    fixtures.givenRecordingEnabled(true);
-    const sample1 = await fixtures.whenUseReplayCalled(fixtures.sample1, ['sample1x']);
-    const sample2 = await fixtures.whenUseReplayCalled(fixtures.sample2, ['sample2x']);
-
-    fixtures.thenReplaySampleStored(sample1, ['sample1x']);
-    fixtures.thenReplaySampleStored(sample2, ['sample2x']);
-  });
-});
-
-async function getFixtures() {
-  const executionMode = replayExecutionMode();
-
-  const { act } = await makeTestModule([
-    executionMode,
-    replayOptions({ from: 0, to: Number.MAX_VALUE })
-  ]);
-
-  return {
-    sample1: [
-      { timestamp: 1, payload: { o: 111, h: 112, l: 113, c: 114 } },
-      { timestamp: 2, payload: { o: 121, h: 122, l: 123, c: 124 } },
-      { timestamp: 3, payload: { o: 131, h: 132, l: 133, c: 134 } }
-    ],
-    sample2: [
-      { timestamp: 1, payload: { o: 211, h: 212, l: 213, c: 214 } },
-      { timestamp: 2, payload: { o: 221, h: 222, l: 223, c: 224 } },
-      { timestamp: 3, payload: { o: 231, h: 232, l: 233, c: 234 } }
-    ],
-
-    givenRecordingEnabled(recording: boolean) {
-      executionMode.useValue.recording = recording;
-    },
-
-    givenSampleStored<T>(
-      sample: { timestamp: number; payload: T }[],
-      dependencies: dependency[]
-    ) {
-      return act(() => {
-        const writer = useReplayWriter(dependencies);
-
-        return writer(sample);
-      });
-    },
-
-    async whenUseReplayCalled<T>(
-      input: { timestamp: number; payload: T }[],
-      dependencies: dependency[]
-    ) {
-      const sample = Array.of<{ timestamp: number; payload: T }>();
-
-      await act(() =>
-        lastValueFrom(
-          useReplay<T>(from(input), dependencies).pipe(tap(it => sample.push(it)))
-        )
-      );
-
-      return sample;
-    },
-
-    whenUseSampleStreamerStarted() {
-      act(() => {
-        const { tryContinue } = useReplayCoordinator();
-
-        tryContinue();
-      });
-    },
-
-    async thenReplaySampleStored<T extends { timestamp: number }>(
-      sample: T[],
-      dependencies: dependency[]
-    ) {
-      const stored = await act(() => {
-        const reader = useReplayReader(dependencies);
-
-        return reader({
-          where: {
-            timestamp: between(
-              sample[0].timestamp,
-              sample[sample.length - 1].timestamp + 1
-            )
-          }
-        });
-      });
-
-      expect(stored).toEqual(sample);
-    }
-  };
-}
-*/

package/src/backtest/index.ts

@@ -1,6 +0,0 @@
-export * from './use-backtest';
-export * from './use-backtest-options';
-export * from './use-backtest-scheduler';
-export * from './use-backtest-storage';
-export * from './use-backtest-sync';
-export * from './when-backtest-finished';

package/src/backtest/use-backtest-options.ts

@@ -1,23 +0,0 @@
-import { Dependency, useContext } from '@lib/module';
-
-const injectionToken = Symbol('backtest-options');
-
-type BacktestOptions = {
-  from: number;
-  to: number;
-};
-
-/**
- *
- */
-export function backtestOptions(options: BacktestOptions): Dependency {
-  return {
-    provide: injectionToken,
-    useValue: options
-  };
-}
-
-/**
- * Will return current backtest execution options.
- */
-export const useBacktestOptions = () => useContext<BacktestOptions>(injectionToken);

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

@@ -1,87 +0,0 @@
-import { hashCode } from '@lib/hash-code';
-import {
-  eq,
-  InferQueryObject,
-  Query,
-  QueryObject,
-  QueryObjectType,
-  Storage,
-  useStorage
-} from '@lib/storage';
-import { Uri } from '@lib/uri';
-
-import { useBacktestScheduler } from './use-backtest-scheduler';
-
-export type BacktestStorageQuery<V> = {
-  sync: <T extends QueryObjectType<K>, K extends QueryObject>(
-    query: Query<InferQueryObject<T>> & {
-      where: { timestamp: { type: 'between'; min: number; max: number } };
-    },
-    storage: { save: (objects: { timestamp: number; payload: V }[]) => Promise<void> }
-  ) => Promise<void>;
-};
-
-const storageIndexObject = Storage.createObject('index://range', {
-  timestamp: 'number',
-  uri: 'string',
-  min: 'number',
-  max: 'number'
-});
-
-export function useBacktestStorage<V, P extends Record<string, string | number>>(
-  uri: Uri<P>,
-  { sync }: BacktestStorageQuery<V>
-) {
-  const { watch } = useBacktestScheduler();
-  const storage = useStorage(['backtest']);
-  const storageObjectKey = uri.query;
-  const storageObject = Storage.createObject(storageObjectKey, {
-    timestamp: 'number',
-    payload: 'string'
-  });
-
-  const id = hashCode(storageObjectKey);
-
-  return {
-    watch: () =>
-      watch({
-        async query(query) {
-          const [index] = await storage.query(storageIndexObject, {
-            limit: 1,
-            where: { timestamp: eq(id) }
-          });
-
-          const { min, max } = query.where.timestamp;
-
-          if (!index || min < index.min || max > index.max) {
-            await sync(query, {
-              async save(objects) {
-                console.log('save');
-                await storage.save(
-                  storageObject,
-                  objects.map(it => ({
-                    timestamp: it.timestamp,
-                    payload: JSON.stringify(it.payload)
-                  }))
-                );
-              }
-            });
-
-            await storage.save(storageIndexObject, [
-              {
-                timestamp: id,
-                max,
-                min,
-                uri: storageObjectKey
-              }
-            ]);
-          }
-
-          return (await storage.query(storageObject, query)).map(it => ({
-            timestamp: it.timestamp,
-            payload: JSON.parse(it.payload) as V
-          }));
-        }
-      })
-  };
-}

package/src/backtest/use-backtest.ts

@@ -1,7 +0,0 @@
-import { useExecutionMode } from '@lib/use-execution-mode';
-
-export function useBacktest<T>(backtest: T, real: T) {
-  const { isReplay } = useExecutionMode();
-
-  return isReplay ? backtest : real;
-}

package/src/backtest/when-backtest-finished.ts

@@ -1,20 +0,0 @@
-import { from, last, map, Subject } from 'rxjs';
-
-import { useExecutionMode } from '@lib/use-execution-mode';
-
-import { useBacktestScheduler } from './use-backtest-scheduler';
-
-export function whenBacktestFinished() {
-  const { isReplay } = useExecutionMode();
-
-  if (!isReplay) {
-    return new Subject<boolean>().asObservable();
-  }
-
-  const { stream } = useBacktestScheduler();
-
-  return from(stream).pipe(
-    last(),
-    map(() => true)
-  );
-}

package/src/replay/replay-guard.ts

@@ -1,11 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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;
-    }
-  };
-});

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

@@ -1,44 +0,0 @@
-import { dependency, useHash } from '@lib/use-hash';
-import { useLogger } from '@lib/use-logger';
-import { withMemo } from '@lib/with-memo';
-
-import { useReplayStorageBuffer } from './use-replay-storage-buffer';
-
-export const useReplayStorageCursor = withMemo(() => {
-  const { info } = useLogger('useReplayStorageCursor');
-  const storages = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
-
-  return {
-    get<T>(dependencies: dependency[]) {
-      const storage = useReplayStorageBuffer<T>(dependencies);
-
-      if (!storages.includes(storage)) {
-        info('opening a new replay buffer', useHash(dependencies));
-        storages.push(storage);
-      }
-
-      return storage;
-    },
-    async cursor() {
-      let current: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
-
-      for (const storage of storages) {
-        if (storage.completed()) {
-          continue;
-        }
-
-        if (storage.size() == 0) {
-          await storage.fetchNextPage();
-        }
-
-        if (storage.peek()) {
-          if (!current || current.peek().timestamp > storage.peek().timestamp) {
-            current = storage;
-          }
-        }
-      }
-
-      return current;
-    }
-  };
-});