@quantform/core 0.6.6 → 0.7.0-beta.10

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

@@ -0,0 +1,142 @@
+import { defer, filter, map, Subject } from 'rxjs';
+
+import { dependency } from '@lib/use-hash';
+import { useMemo } from '@lib/use-memo';
+
+import { between } from '..';
+import { useReplayOptions } from './use-replay-options';
+import { useReplayReader } from './use-replay-reader';
+
+export function useReplayCoordinator() {
+  const options = useReplayOptions();
+
+  return useMemo(() => {
+    let timestamp = options.from;
+    let stopAcquire = 1;
+    let sequence = 0;
+    const subscriptions = Array.of<SampleCursor>();
+    const stream$ = new Subject<[SampleCursor, { timestamp: number }]>();
+
+    const subscribe = (dependencies: dependency[]) => {
+      const cursor = useSampleCursor(dependencies);
+
+      if (!subscriptions.includes(cursor)) {
+        subscriptions.push(cursor);
+      }
+
+      return defer(() => {
+        tryContinue();
+
+        return stream$.pipe(
+          filter(([cur]) => cur === cursor),
+          map(([, it]) => it)
+        );
+      });
+    };
+
+    const current = async () => {
+      let next: SampleCursor | undefined;
+
+      for (const cursor of subscriptions) {
+        if (cursor.size() == 0 && !cursor.completed) {
+          await cursor.fetchNextPage(timestamp, options.to + 1);
+        }
+
+        if (cursor.peek()) {
+          if (!next || next.peek().timestamp > cursor.peek().timestamp) {
+            next = cursor;
+          }
+        }
+      }
+
+      return next;
+    };
+
+    const processNext = async () => {
+      const cursor = await 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 = async () => {
+      if (await 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]);
+}
+
+type SampleCursor = Awaited<ReturnType<typeof useSampleCursor>>;
+
+function useSampleCursor<T>(dependencies: dependency[]) {
+  return useMemo(() => {
+    const read = useReplayReader<T>(dependencies);
+    let page = new Array<{ timestamp: number; payload: T }>();
+    let index = 0;
+    let completed = false;
+
+    const size = () => page.length - index;
+    const peek = () => page[index];
+    const dequeue = () => page[index++];
+    const fetchNextPage = async (from: number, to: number) => {
+      if (completed) {
+        return;
+      }
+
+      index = 0;
+
+      page = await read({
+        where: {
+          timestamp: between(from, to)
+        },
+        limit: 10000
+      });
+      completed = page.length == 0;
+    };
+
+    return {
+      size,
+      peek,
+      dequeue,
+      fetchNextPage,
+      completed
+    };
+  }, [useSampleCursor.name, ...dependencies]);
+}

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

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

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

@@ -0,0 +1,64 @@
+import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { gt, Storage } from '@lib/storage';
+
+import { useReplayReader } from './use-replay-reader';
+import { useReplayStorage } from './use-replay-storage';
+
+jest.mock('./use-replay-storage', () => ({
+  ...jest.requireActual('./use-replay-storage'),
+  useReplayStorage: jest.fn()
+}));
+
+describe(useReplayReader.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('read sample candle data from storage', async () => {
+    await fixtures.givenDataStored(fixtures.sample);
+    const data = await fixtures.whenDataRequested();
+
+    expect(data).toEqual(fixtures.sample);
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+  const query: jest.MockedFunction<Storage['query']> = jest.fn();
+
+  mockedFunc(useReplayStorage).mockReturnValue({ 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 } }
+    ],
+
+    givenDataStored<T>(data: { timestamp: number; payload: T }[]) {
+      return query.mockReturnValue(
+        Promise.resolve(
+          data.map(it => ({
+            kind: 'sample',
+            timestamp: it.timestamp,
+            json: JSON.stringify(it.payload)
+          }))
+        )
+      );
+    },
+
+    async whenDataRequested<T>() {
+      return await act(() =>
+        useReplayReader<T>(dependencies)({
+          where: {
+            timestamp: gt(0)
+          }
+        })
+      );
+    }
+  };
+}

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

@@ -0,0 +1,23 @@
+import { Query, QueryObject } from '@lib/storage';
+import { dependency, useHash } from '@lib/use-hash';
+
+import { replaySerializableObject, useReplayStorage } from './use-replay-storage';
+
+export function useReplayReader<T>(dependencies: dependency[]) {
+  const storage = useReplayStorage();
+  const key = useHash(dependencies);
+
+  return async (query: Query<QueryObject>) =>
+    (
+      await storage.query(replaySerializableObject(key), {
+        where: {
+          timestamp: query.where?.timestamp
+        },
+        limit: query.limit,
+        orderBy: query.orderBy
+      })
+    ).map(it => ({
+      timestamp: it.timestamp,
+      payload: JSON.parse(it.json) as T
+    }));
+}

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

@@ -0,0 +1,8 @@
+import { Storage, useStorage } from '@lib/storage';
+
+export const replaySerializableObject = (key: string) =>
+  Storage.createObject(key, { timestamp: 'number', json: 'string' });
+
+export function useReplayStorage() {
+  return useStorage(['replay']);
+}

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

@@ -0,0 +1,56 @@
+import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { Storage } from '@lib/storage';
+import { useHash } from '@lib/use-hash';
+
+import { useReplayStorage } from './use-replay-storage';
+import { useReplayWriter } from './use-replay-writer';
+
+jest.mock('./use-replay-storage', () => ({
+  ...jest.requireActual('./use-replay-storage'),
+  useReplayStorage: jest.fn()
+}));
+
+describe.skip(useReplayWriter.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('write sample candle data to storage', async () => {
+    await fixtures.whenReplayDataWritten(fixtures.sample);
+    await fixtures.thenReplayDataSaved(fixtures.sample);
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  const dependencies = ['binance:btc-usdt', 'candle', 'h1'];
+  const save: Storage['save'] = jest.fn();
+
+  mockedFunc(useReplayStorage).mockReturnValue({ save } 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 } }
+    ],
+
+    whenReplayDataWritten<T>(data: { timestamp: number; payload: T }[]) {
+      return act(() => useReplayWriter(dependencies)(data));
+    },
+
+    async thenReplayDataSaved<T>(data: { timestamp: number; payload: T }[]) {
+      expect(save).toHaveBeenCalledWith(
+        useHash(dependencies),
+        data.map(it => ({
+          kind: 'sample',
+          timestamp: it.timestamp,
+          json: JSON.stringify(it.payload)
+        }))
+      );
+    }
+  };
+}

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

@@ -0,0 +1,17 @@
+import { dependency, useHash } from '@lib/use-hash';
+
+import { replaySerializableObject, useReplayStorage } from './use-replay-storage';
+
+export function useReplayWriter<T>(dependencies: dependency[]) {
+  const storage = useReplayStorage();
+  const key = useHash(dependencies);
+
+  return (samples: { timestamp: number; payload: T }[]) =>
+    storage.save(
+      replaySerializableObject(key),
+      samples.map(it => ({
+        timestamp: it.timestamp,
+        json: JSON.stringify(it.payload)
+      }))
+    );
+}

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

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

@@ -0,0 +1,34 @@
+import { concatMap, map, Observable } 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';
+
+export const useReplay = <T>(
+  input: Observable<{ timestamp: number; payload: T }>,
+  dependencies: dependency[]
+) => {
+  const { isReplay, recording } = useExecutionMode();
+
+  if (isReplay) {
+    const { subscribe } = useReplayCoordinator();
+
+    return subscribe(dependencies).pipe(
+      map(it => it as unknown as { timestamp: number; payload: T })
+    );
+  }
+
+  if (recording) {
+    const writer = useReplayWriter(dependencies);
+    return input.pipe(
+      concatMap(async it => {
+        await writer([it]);
+        return it;
+      })
+    );
+  }
+
+  return input;
+};

package/src/replay/with-replay.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+
+import { use } from '@lib/use';
+import { dependency } from '@lib/use-hash';
+
+export function withReplay<T extends Array<dependency>, U extends Observable<K>, K>(
+  fn: (...args: T) => U
+): (...args: T) => U {
+  return use(fn);
+}

package/src/session/index.ts

@@ -0,0 +1,3 @@
+export * from './use-session';
+export * from './use-session-object';
+export * from './use-session-storage';

package/src/session/use-session-object.ts

@@ -0,0 +1,26 @@
+import { from } from 'rxjs';
+
+import {
+  InferQueryObject,
+  Query,
+  QueryMappingType,
+  QueryObject,
+  Storage
+} from '@lib/storage';
+
+import { useSessionStorage } from './use-session-storage';
+
+export const useSessionObject = <
+  K extends QueryObject,
+  T extends { [key in keyof K]: QueryMappingType }
+>(
+  object: ReturnType<typeof Storage.createObject<K, T>>
+) => {
+  const storage = useSessionStorage();
+
+  return {
+    query: (query: Query<InferQueryObject<typeof object>>) =>
+      from(storage.query(object, query)),
+    save: (objects: InferQueryObject<typeof object>[]) => storage.save(object, objects)
+  };
+};

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

@@ -0,0 +1,9 @@
+import { useSession } from '@lib/session';
+import { useStorage } from '@lib/storage';
+import { use } from '@lib/use';
+
+export const useSessionStorage = use(() => {
+  const { id } = useSession();
+
+  return useStorage(['session', id]);
+});

package/src/session/use-session.ts

@@ -0,0 +1,5 @@
+import { use } from '@lib/use';
+
+export const useSession = use(() => ({
+  id: 'ttt' //Date.now()
+}));

package/src/shared/decimals.spec.ts

@@ -1,4 +1,4 @@
-import { d } from './decimals';
+import { d } from '@lib/shared';
 
 describe('decimals', () => {
   test('get precision tests', () => {

package/src/shared/decimals.ts

@@ -16,6 +16,11 @@ Decimal.prototype.toCeil = function (decimalPlaces: number) {
 };
 
 export class decimal extends Decimal {}
+/*
+decimal.prototype.toJSON = function () {
+  return '444';
+};
+*/
 
 export function d(value: Decimal.Value) {
   return new decimal(value);

package/src/shared/index.ts

@@ -1,7 +1,3 @@
-export * from './datetime';
-export * from './decimals';
-export * from './environment';
-export * from './logger';
-export * from './policy';
-export * from './collections';
-export * from './pipe';
+export * from '@lib/shared/datetime';
+export * from '@lib/shared/decimals';
+export * from '@lib/shared/environment';

package/src/simulator/index.ts

@@ -0,0 +1 @@
+export * from './use-simulator';

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

@@ -0,0 +1,54 @@
+import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { useSimulator } from './use-simulator';
+
+jest.mock('@lib/use-execution-mode', () => ({
+  ...jest.requireActual('@lib/use-execution-mode'),
+  useExecutionMode: jest.fn()
+}));
+
+describe(useSimulator.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  afterEach(() => fixtures.clear());
+
+  test('get real value when simulator mode disabled', () => {
+    const { act } = fixtures;
+
+    fixtures.givenSimulationEnabled(false);
+
+    const value = act(() => useSimulator('simulator', 'real'));
+
+    expect(value).toBe('real');
+  });
+
+  test('get simulation value when simulator mode enabled', () => {
+    const { act } = fixtures;
+
+    fixtures.givenSimulationEnabled(true);
+
+    const value = act(() => useSimulator('simulator', 'real'));
+
+    expect(value).toBe('simulator');
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  return {
+    act,
+    givenSimulationEnabled(isSimulation: boolean) {
+      mockedFunc(useExecutionMode).mockReturnValue({
+        isSimulation,
+        recording: false
+      } as any);
+    },
+    clear: jest.clearAllMocks
+  };
+}

package/src/simulator/use-simulator.ts

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

package/src/storage/in-memory/in-memory-storage.factory.ts

@@ -0,0 +1,16 @@
+import { provider } from '@lib/module';
+import { Storage, StorageFactory } from '@lib/storage';
+
+import { InMemoryStorage } from './in-memory-storage';
+
+@provider()
+export class InMemoryStorageFactory implements StorageFactory {
+  private static storage: Record<string, Storage> = {};
+
+  for(key: string): Storage {
+    return (
+      InMemoryStorageFactory.storage[key] ??
+      (InMemoryStorageFactory.storage[key] = new InMemoryStorage())
+    );
+  }
+}