@quantform/core 0.7.0-beta.9 → 0.7.9

package/src/cli/replay.ts

@@ -1,31 +1,27 @@
-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 { replayOptions } from '@lib/replay';
-import { replayExecutionMode } from '@lib/use-execution-mode';
+import { useSession } from '@lib/session';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+import { Script } from './internal/script';
 
-export default async function (name: string, options: any) {
+export default async function (
+  name: string,
+  options: { id?: string; from?: string; to?: string }
+) {
   if (await build()) {
     return;
   }
 
-  const script = await import(join(buildDirectory(), name));
-  const dependencies = script.module2 as Dependency[];
+  const from = options.from ? new Date(options.from).getTime() : 0;
+  const to = options.to ? new Date(options.to).getTime() : Number.MAX_VALUE;
 
-  const module = new Module([
-    ...core(),
-    ...dependencies,
-    replayOptions({ from: 0, to: Number.MAX_VALUE }),
-    replayExecutionMode()
+  const script = new Script(name, [
+    useSession.options({ id: options.id ?? Date.now().toString() }),
+    replayOptions({ from, to }),
+    useExecutionMode.replayOptions()
   ]);
-
-  const { act } = await module.awake();
-
-  const output = await act(() => lastValueFrom(script.default(options)));
+  const output = await script.run();
 
   console.log(output);
 }

package/src/core.ts

@@ -1,14 +1,14 @@
 import { Dependency } from '@lib/module';
-import { memo } from '@lib/use-memo';
+import { useMemo } from '@lib/use-memo';
 
 import { InMemoryStorageFactory } from './storage';
-import { storage } from './storage/use-storage-factory';
-import { paperExecutionMode } from './use-execution-mode';
+import { useStorageFactory } from './storage/use-storage-factory';
+import { useExecutionMode } from './use-execution-mode';
 
 export function core(): Dependency[] {
   return [
-    memo(),
-    paperExecutionMode({ recording: false }),
-    storage(new InMemoryStorageFactory())
+    useMemo.options(),
+    useExecutionMode.paperOptions({ recording: false }),
+    useStorageFactory.options(new InMemoryStorageFactory())
   ];
 }

package/src/index.ts

@@ -7,21 +7,14 @@ export * from '@lib/use-timestamp';
 export * from '@lib/simulator';
 export * from '@lib/make-test-module';
 export * from '@lib/core';
-export * from '@lib/use-state';
-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/use-socket';
-export * from '@lib/use-request';
-export * from '@lib/defined';
-export * from '@lib/as-readonly';
-export * from '@lib/use';
+export * from '@lib/when-socket';
+export * from '@lib/with-request';
+export * from '@lib/with-memo';
 export * from '@lib/session';
-export * from '@lib/exclude';
-export * from '@lib/use-lock';
-export * from '@lib/strat';
-export * from '@lib/errored';
+export * from '@lib/strategy';
+export * from '@lib/operators';

package/src/instrument/instrument.ts

@@ -5,6 +5,12 @@ import { Commission } from './commission/commission';
 
 export const InstrumentSelectorSeparator = '-';
 
+export class MissingInstrumentError extends Error {
+  constructor(instrument: InstrumentSelector) {
+    super(`Missing instrument: ${instrument}`);
+  }
+}
+
 export class InstrumentSelector {
   readonly id: string;
   readonly base: AssetSelector;

package/src/make-test-module.ts

@@ -1,4 +1,4 @@
-import { Observable, tap } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 
 import { core } from '@lib/core';
 import { Dependency, Module } from '@lib/module';
@@ -20,9 +20,9 @@ export const mockedFunc = <Func extends MockableFunction>(mockedFunc: Func) =>
   mockedFunc as jest.MockedFunction<typeof mockedFunc>;
 
 export function toArray<T>(observable: Observable<T>) {
-  const array = Array.of<T>();
+  const array = Array.of<T | Error>();
 
-  const clone = (it: T): T => {
+  const clone = (it: T | Error): T | Error => {
     if (typeof it === 'symbol') {
       return it;
     }
@@ -38,9 +38,25 @@ export function toArray<T>(observable: Observable<T>) {
     return it;
   };
 
-  observable.pipe(tap(it => array.push(clone(it)))).subscribe();
+  observable.subscribe({
+    next: it => array.push(clone(it)),
+    error: it => array.push(it)
+  });
 
   return array;
 }
 
 export type InferObservableType<T> = T extends Observable<infer U> ? U : never;
+
+export function mockSubject<
+  T extends jest.FunctionProperties<Required<T>>,
+  M extends keyof jest.FunctionProperties<Required<T>>
+>(object: T, method: M) {
+  const subject = new Subject<
+    InferObservableType<ReturnType<jest.FunctionProperties<Required<T>>[M]>>
+  >();
+
+  jest.spyOn<T, M>(object, method).mockReturnValue(subject.asObservable() as any);
+
+  return subject;
+}

package/src/operators.ts

@@ -0,0 +1,18 @@
+import { filter, map, Observable } from 'rxjs';
+
+export function asReadonly<T>() {
+  return (input: Observable<T>) => input.pipe(map(it => it as Readonly<T>));
+}
+
+export function defined<T>() {
+  return (observable: Observable<T | undefined | null>) =>
+    observable.pipe(filter(it => it !== undefined && it !== null));
+}
+
+export function exclude<T, S extends symbol>(s: S) {
+  return (observable: Observable<T | S>) =>
+    observable.pipe(
+      filter(it => it !== s),
+      map(it => it as Exclude<T, typeof s>)
+    );
+}

package/src/replay/index.ts

@@ -1,6 +1,9 @@
 export * from './use-replay';
-export * from './use-replay-coordinator';
+export * from './use-replay-lock';
 export * from './use-replay-options';
-export * from './use-replay-reader';
-export * from './use-replay-writer';
-export * from './with-replay';
+export * from './storage/use-replay-storage';
+export * from './storage/use-replay-storage-buffer';
+export * from './use-replay-manager';
+export * from './when-replay-finished';
+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 { 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

@@ -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/storage/use-replay-storage-buffer.ts

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

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