@quantform/core 0.7.0-beta.5 → 0.7.0-beta.51

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

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

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

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

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

@@ -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 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

@@ -0,0 +1,83 @@
+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,15 +1,20 @@
+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 +135,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 { useReplayStorage } from './storage/use-replay-storage';
+import { useReplayManager } from './use-replay-manager';
 
-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 { watch } = useReplayManager();
 
-    return subscribe(dependencies).pipe(
-      map(it => it as unknown as { timestamp: number; payload: T })
-    );
+    return watch<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/replay/when-replay-finished.ts

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

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

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

package/src/session/use-session.ts

@@ -1,5 +1,17 @@
-import { use } from '@lib/use';
+import { Dependency, useContext } from '@lib/module';
 
-export const useSession = use(() => ({
-  id: 'ttt' //Date.now()
-}));
+const token = Symbol('session-options');
+
+type SessionOptions = {
+  id: string;
+};
+
+/**
+ * Will return current replay execution options.
+ */
+export const useSession = () => useContext<SessionOptions>(token);
+
+useSession.options = (options: SessionOptions): Dependency => ({
+  provide: token,
+  useValue: options
+});

package/src/shared/decimals.ts

@@ -16,54 +16,9 @@ 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);
 }
 
 d.Zero = new decimal(0);
-
-export function weightedMean(values: decimal[], weights: decimal[]): decimal {
-  const result = values
-    .map((value, i) => {
-      const weight = weights[i];
-      const sum = value.mul(weight);
-      return [sum, weight];
-    })
-    .reduce((p, c) => [p[0].add(c[0]), p[1].add(c[1])], [d.Zero, d.Zero]);
-
-  if (!result[1]) {
-    return d.Zero;
-  }
-
-  return result[0].div(result[1]);
-}
-
-export function pnl(entryRate: decimal, exitRate: decimal, amount: decimal) {
-  return exitRate.div(entryRate).minus(1).mul(amount);
-}
-
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export function candledown(timestamp: number, timeframe: number): number {
-  return timestamp - (timestamp % timeframe);
-}
-
-/**
- *
- * @param timestamp
- * @param timeframe
- * @returns nearest timestamp to the given timeframe
- */
-export function candleup(timestamp: number, timeframe: number): number {
-  return candledown(timestamp, timeframe) + timeframe;
-}

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

@@ -1,13 +1,8 @@
-import { makeTestModule, mockedFunc } from '@lib/make-test-module';
+import { makeTestModule } 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>>;
 
@@ -15,22 +10,16 @@ describe(useSimulator.name, () => {
     fixtures = await getFixtures();
   });
 
-  afterEach(() => fixtures.clear());
-
-  test('get real value when simulator mode disabled', () => {
-    const { act } = fixtures;
-
-    fixtures.givenSimulationEnabled(false);
+  test('get real value when simulator mode disabled', async () => {
+    const { act } = await fixtures.givenModule(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);
+  test('get simulation value when simulator mode enabled', async () => {
+    const { act } = await fixtures.givenModule(true);
 
     const value = act(() => useSimulator('simulator', 'real'));
 
@@ -39,16 +28,11 @@ describe(useSimulator.name, () => {
 });
 
 async function getFixtures() {
-  const { act } = await makeTestModule([]);
-
   return {
-    act,
-    givenSimulationEnabled(isSimulation: boolean) {
-      mockedFunc(useExecutionMode).mockReturnValue({
-        isSimulation,
-        recording: false
-      } as any);
-    },
-    clear: jest.clearAllMocks
+    async givenModule(isSimulation: boolean) {
+      return isSimulation
+        ? await makeTestModule([useExecutionMode.paperOptions({ recording: false })])
+        : await makeTestModule([useExecutionMode.liveOptions({ recording: false })]);
+    }
   };
 }

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/storage/use-storage-factory.ts

@@ -1,4 +1,4 @@
-import { useContext } from '@lib/module';
+import { Dependency, useContext } from '@lib/module';
 import { Storage } from '@lib/storage';
 
 const token = Symbol('storage-factory-token');
@@ -7,11 +7,11 @@ export interface StorageFactory {
   for(key: string): Storage;
 }
 
-export function storage(factory: StorageFactory) {
-  return {
-    provide: token,
-    useValue: factory
-  };
+export function useStorageFactory() {
+  return useContext<StorageFactory>(token);
 }
 
-export const useStorageFactory = () => useContext<StorageFactory>(token);
+useStorageFactory.options = (factory: StorageFactory): Dependency => ({
+  provide: token,
+  useValue: factory
+});

package/src/storage/use-storage.ts

@@ -1,9 +1,9 @@
-import { use } from '@lib/use';
 import { dependency, useHash } from '@lib/use-hash';
+import { withMemo } from '@lib/with-memo';
 
 import { useStorageFactory } from './use-storage-factory';
 
-export const useStorage = use((dependencies: dependency[]) => {
+export const useStorage = withMemo((dependencies: dependency[]) => {
   const key = useHash(dependencies);
   const factory = useStorageFactory();
 

package/src/strategy.spec.ts

@@ -0,0 +1,42 @@
+import { of } from 'rxjs';
+
+import { Dependency } from './module';
+import { after, before, behavior, strategy } from './strategy';
+
+describe(strategy.name, () => {
+  let fixtures: ReturnType<typeof getFixtures>;
+
+  beforeEach(() => {
+    fixtures = getFixtures();
+  });
+
+  test('happy path', () => {
+    const sut = strategy(() => {
+      before(() => of('before'));
+      behavior(() => of('behavior 1'));
+      behavior(() => of('behavior 2'));
+      after(() => of('after'));
+
+      return fixtures.given.dependencies();
+    });
+
+    expect(sut.dependencies).toEqual(
+      expect.arrayContaining(fixtures.given.dependencies())
+    );
+    expect(sut.description).toEqual({
+      before: [expect.any(Function)],
+      behavior: [expect.any(Function), expect.any(Function)],
+      after: [expect.any(Function)]
+    });
+  });
+});
+
+function getFixtures() {
+  return {
+    given: {
+      dependencies(): Dependency[] {
+        return [];
+      }
+    }
+  };
+}

package/src/strategy.ts

@@ -0,0 +1,36 @@
+import { Observable, of } from 'rxjs';
+
+import { Dependency } from './module';
+
+export type Descriptor = () => Observable<unknown>;
+
+export let before: (descriptor: Descriptor) => void;
+export let behavior: (descriptor: Descriptor) => void;
+export let after: (descriptor: Descriptor) => void;
+
+export function strategy(descriptor: () => Dependency[]) {
+  const description = {
+    before: Array.of<Descriptor>(),
+    behavior: Array.of<Descriptor>(),
+    after: Array.of<Descriptor>()
+  };
+
+  before = descriptor => description.before.push(descriptor);
+  behavior = descriptor => description.behavior.push(descriptor);
+  after = descriptor => description.after.push(descriptor);
+
+  const dependencies = descriptor();
+
+  if (!description.before.length) {
+    description.before.push(() => of(true));
+  }
+
+  if (!description.after.length) {
+    description.after.push(() => of(true));
+  }
+
+  return {
+    dependencies,
+    description
+  };
+}