@quantform/core 0.6.7 → 0.7.0-beta.5

package/src/make-test-module.ts

@@ -0,0 +1,46 @@
+import { Observable, tap } from 'rxjs';
+
+import { core } from '@lib/core';
+import { Dependency, Module } from '@lib/module';
+
+export async function makeTestModule(dependencies: Dependency[]) {
+  const module = new Module([...core(), ...dependencies]);
+
+  const { act } = await module.awake();
+
+  return {
+    act,
+    get: module.get.bind(module)
+  };
+}
+
+type MockableFunction = (...args: any[]) => any;
+
+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 clone = (it: T): T => {
+    if (typeof it === 'symbol') {
+      return it;
+    }
+
+    if (Array.isArray(it)) {
+      return it.map(it => clone(it)) as T;
+    }
+
+    if (typeof it === 'object') {
+      return { ...it };
+    }
+
+    return it;
+  };
+
+  observable.pipe(tap(it => array.push(clone(it)))).subscribe();
+
+  return array;
+}
+
+export type InferObservableType<T> = T extends Observable<infer U> ? U : never;

package/src/module.spec.ts

@@ -0,0 +1,74 @@
+import { Dependency, Module, provider } from '@lib/module';
+
+describe(Module.name, () => {
+  let fixtures: ReturnType<typeof getFixtures>;
+
+  beforeEach(() => {
+    fixtures = getFixtures();
+  });
+
+  test('builds empty module', async () => {
+    const module = fixtures.givenModuleCreated([]);
+    fixtures.whenModuleBuilt(module);
+  });
+
+  test('builds module and resolves single value dependency', async () => {
+    const definition = fixtures.definitions.singleValue;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+
+  test('builds module and resolves single class dependency', async () => {
+    const definition = fixtures.definitions.singleClass;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+
+  test('builds module and resolves many class dependencies', async () => {
+    const definition = fixtures.definitions.manyClass;
+    const module = fixtures.givenModuleCreated(definition);
+    fixtures.whenModuleBuilt(module);
+    fixtures.thenCanResolveDependencies(module, definition);
+  });
+});
+
+function getFixtures() {
+  return {
+    definitions: {
+      singleClass: [
+        {
+          provide: FakeService,
+          useClass: FakeService
+        }
+      ],
+      manyClass: [
+        {
+          provide: FakeService,
+          useClass: FakeService
+        },
+        {
+          provide: FakeService,
+          useClass: FakeService
+        }
+      ],
+      singleValue: [
+        {
+          provide: FakeService,
+          useValue: new FakeService()
+        }
+      ]
+    },
+    givenModuleCreated: (dependencies: Dependency[]) => new Module(dependencies),
+    whenModuleBuilt: (module: Module) => module.awake(),
+    thenCanResolveDependencies: (module: Module, dependencies: Dependency[]) => {
+      dependencies.forEach(it => {
+        expect(module.get<FakeService>(it.provide)).toBeTruthy();
+      });
+    }
+  };
+}
+
+@provider()
+class FakeService {}

package/src/module.ts

@@ -0,0 +1,156 @@
+import 'reflect-metadata';
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+  container,
+  DependencyContainer,
+  inject,
+  injectable,
+  injectAll,
+  InjectionToken,
+  Lifecycle
+} from 'tsyringe';
+
+export const provider = injectable;
+export const provide = inject;
+export const provideAll = injectAll;
+
+export type Dependency = {
+  provide: InjectionToken;
+  useClass?: any;
+  useValue?: any;
+};
+
+function noModuleError() {
+  return new Error('Please do not use dependency injection outside of hooks context.');
+}
+
+function withModuleError() {
+  return new Error('Please do not use with hooks in context.');
+}
+
+function notInitializedModuleError() {
+  return new Error('You need to initialize a module before use.');
+}
+
+function missingInjectionTokenError(token: InjectionToken) {
+  return new Error(`Unable to resolve unregistered dependency: ${token.toString()}`);
+}
+
+/**
+ *
+ */
+const moduleLocalStorage = new AsyncLocalStorage();
+
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export const useContext = <T>(token: InjectionToken<T>) => {
+  const module = moduleLocalStorage.getStore() as Module | undefined;
+
+  if (!module) {
+    throw noModuleError();
+  }
+
+  return module.get<T>(token);
+};
+
+/**
+ * Hook to get access to current execution module dependencies.
+ */
+export const throwWithContext = () => {
+  if (moduleLocalStorage.getStore()) {
+    throw withModuleError();
+  }
+};
+
+/**
+ * A module is a collection of services, values, and factories that can be
+ * registered with a dependency container.
+ */
+export class Module {
+  private container?: DependencyContainer;
+
+  constructor(private readonly dependencies: Dependency[]) {}
+
+  /**
+   * Builds and initializes dependencies.
+   */
+  async awake(): Promise<{ act: <T>(func: () => T) => T }> {
+    this.container = this.buildContainer();
+
+    return {
+      /**
+       * Associate callback function with current executing module
+       */
+      act: <T>(func: () => T) => moduleLocalStorage.run(this, func)
+    };
+  }
+
+  /**
+   * Disposes all dependencies instantiated by this module.
+   * @returns
+   */
+  dispose() {
+    if (!this.container) {
+      return;
+    }
+
+    this.container = undefined;
+  }
+
+  /**
+   * Builds a new instance of dependency container based on module definition.
+   * @returns
+   */
+  protected buildContainer(): DependencyContainer {
+    const childContainer = container.createChildContainer();
+
+    this.dependencies.forEach(it => {
+      if (it.useValue) {
+        childContainer.register(it.provide, { useValue: it.useValue });
+      } else {
+        childContainer.register(it.provide, it.useClass ?? it.provide, {
+          lifecycle: Lifecycle.Singleton
+        });
+      }
+    });
+
+    return childContainer;
+  }
+
+  /**
+   * Resolves a dependency from the module.
+   * @param token represents the identifier for the dependency that you want to
+   * resolve from the container.
+   * @returns instance of the dependency.
+   */
+  get<T>(token: InjectionToken<T>): T {
+    if (!this.container) {
+      throw notInitializedModuleError();
+    }
+
+    if (!this.container.isRegistered(token)) {
+      throw missingInjectionTokenError(token);
+    }
+
+    return this.container.resolve<T>(token);
+  }
+
+  /**
+   * Resolves a collection of dependencies from the module.
+   * @param token
+   * @returns
+   */
+  getAll<T>(token: InjectionToken<T>): T[] {
+    if (!this.container) {
+      throw notInitializedModuleError();
+    }
+
+    if (!this.container.isRegistered(token)) {
+      throw missingInjectionTokenError(token);
+    }
+
+    return container.resolveAll<T>(token);
+  }
+}

package/src/not-found.ts

@@ -0,0 +1 @@
+export const notFound = Symbol.for('not-found');

package/src/replay/index.ts

@@ -0,0 +1,6 @@
+export * from './use-replay';
+export * from './use-replay-coordinator';
+export * from './use-replay-options';
+export * from './use-replay-reader';
+export * from './use-replay-writer';
+export * from './with-replay';

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