@quantform/core 0.7.20 → 0.7.22

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

@@ -1,84 +0,0 @@
-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/storage/use-replay-storage.ts

@@ -1,29 +0,0 @@
-import { Query, QueryObject, Storage, useStorage } from '@lib/storage';
-import { dependency, useHash } from '@lib/use-hash';
-
-export function useReplayStorage<T>(dependencies: dependency[]) {
-  const storage = useStorage(['replay']);
-  const storageObjectKey = useHash(dependencies);
-  const storageObject = Storage.createObject(storageObjectKey, {
-    timestamp: 'number',
-    payload: 'string'
-  });
-
-  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-lock.ts

@@ -1,29 +0,0 @@
-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 useReplayLock<T>(input: Observable<T>): Observable<T> {
-  const { isReplay } = useExecutionMode();
-
-  if (!isReplay) {
-    return input;
-  }
-
-  const { info } = useLogger('replay');
-  const { stop, tryContinue } = useReplayManager();
-
-  info('lock acquired');
-
-  stop();
-
-  return input.pipe(
-    finalize(() => {
-      info('lock released');
-
-      tryContinue();
-    })
-  );
-}

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

@@ -1,83 +0,0 @@
-import { defer, filter, map, Observable, Subject } from 'rxjs';
-
-import { dependency } from '@lib/use-hash';
-import { withMemo } from '@lib/with-memo';
-
-import { useReplayStorageBuffer } from './storage/use-replay-storage-buffer';
-import { useReplayStorageCursor } from './storage/use-replay-storage-cursor';
-import { useReplayOptions } from './use-replay-options';
-
-export const useReplayManager = withMemo(() => {
-  const { from } = useReplayOptions();
-  const { get, cursor } = useReplayStorageCursor();
-
-  let timestamp = from;
-  let stopAcquire = 1;
-
-  const stream$ = new Subject<
-    [ReturnType<typeof useReplayStorageBuffer<any>>, { timestamp: number; payload: any }]
-  >();
-
-  const processNext = async () => {
-    const storage = await cursor();
-
-    if (!storage || !storage.peek()) {
-      stream$.complete();
-
-      return false;
-    }
-
-    const sample = storage.dequeue();
-
-    timestamp = sample.timestamp;
-
-    stream$.next([storage, 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 {
-    stream: stream$.asObservable(),
-    timestamp() {
-      return timestamp;
-    },
-    stop() {
-      stopAcquire++;
-    },
-    tryContinue,
-    watch<T>(dependencies: dependency[]): Observable<{ timestamp: number; payload: T }> {
-      const storage = get<T>(dependencies);
-
-      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.spec.ts

@@ -1,138 +0,0 @@
-import exp from 'constants';
-import { from, lastValueFrom, tap } from 'rxjs';
-
-import { makeTestModule } from '@lib/make-test-module';
-import { dependency } from '@lib/use-hash';
-
-import { between } from '..';
-import { useReplay } from './use-replay';
-import { replayOptions } from './use-replay-options';
-
-describe(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);
-    }
-  };
-}
-*/