@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/storage/use-cache.ts

@@ -0,0 +1,50 @@
+import { from, map, Observable, of, switchMap } from 'rxjs';
+
+import { now } from '@lib/shared';
+import { useStorage } from '@lib/storage/use-storage';
+import { dependency, useHash } from '@lib/use-hash';
+
+import { eq, gt, Storage } from './storage';
+
+const object = Storage.createObject('keyValue', {
+  timestamp: 'number',
+  forKey: 'string',
+  rawJson: 'string'
+});
+
+export const useCache = <T>(
+  calculateValue: Observable<T>,
+  dependencies: dependency[],
+  ttl: number = 60 * 60 * 24 * 1000
+): Observable<T> => {
+  const storage = useStorage(['cache']);
+  const key = useHash(dependencies);
+  const timestamp = now();
+
+  return from(
+    storage.query(object, {
+      where: {
+        timestamp: gt(timestamp - ttl),
+        forKey: eq(key)
+      },
+      limit: 1,
+      orderBy: 'DESC'
+    })
+  ).pipe(
+    switchMap(([value]) => {
+      if (value) {
+        return of(JSON.parse(value.rawJson));
+      }
+
+      return calculateValue.pipe(
+        switchMap(newValue =>
+          from(
+            storage.save(object, [
+              { timestamp, forKey: key, rawJson: JSON.stringify(newValue) }
+            ])
+          ).pipe(map(() => newValue))
+        )
+      );
+    })
+  );
+};

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

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

package/src/storage/use-storage.ts

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

package/src/strat.ts

@@ -0,0 +1,7 @@
+import { Observable } from 'rxjs';
+
+import { Dependency } from './module';
+
+export function strat(fn: () => Observable<unknown>, dependencies: Dependency[]) {
+  return { fn, dependencies };
+}

package/src/use-execution-mode.ts

@@ -0,0 +1,41 @@
+import { useContext } from '@lib/module';
+
+const injectionToken = Symbol('execution-mode');
+
+type ExecutionMode = {
+  mode: 'REPLAY' | 'PAPER' | 'LIVE';
+  recording: boolean;
+};
+
+export function replayExecutionMode() {
+  return {
+    provide: injectionToken,
+    useValue: { mode: 'REPLAY', recording: false } as ExecutionMode
+  };
+}
+
+export function paperExecutionMode(options: { recording: boolean }) {
+  return {
+    provide: injectionToken,
+    useValue: { mode: 'PAPER', ...options } as ExecutionMode
+  };
+}
+
+export function liveExecutionMode(options: { recording: boolean }) {
+  return {
+    provide: injectionToken,
+    useValue: { mode: 'LIVE', ...options } as ExecutionMode
+  };
+}
+
+export const useExecutionMode = () => {
+  const mode = useContext<ExecutionMode>(injectionToken);
+
+  return {
+    isReplay: mode.mode === 'REPLAY',
+    isPaper: mode.mode === 'PAPER',
+    isLive: mode.mode === 'LIVE',
+    isSimulation: mode.mode !== 'LIVE',
+    recording: mode.recording
+  };
+};

package/src/use-hash.spec.ts

@@ -0,0 +1,16 @@
+import { assetOf } from './asset';
+import { instrumentOf } from './instrument';
+import { dependency, useHash } from './use-hash';
+
+describe(useHash.name, () => {
+  it.each<[dependency[], string]>([
+    [[assetOf('binance:btc')], 'binance:btc'],
+    [[assetOf('binance:btc'), 'test'], 'binance:btc/test'],
+    [[instrumentOf('binance:btc-usdt')], 'binance:btc-usdt'],
+    [[instrumentOf('binance:btc-usdt'), 123], 'binance:btc-usdt/123']
+  ])('hash list of dependencies from %p to %p', (dependencies, hashed) => {
+    const hash = useHash(dependencies);
+
+    expect(hash).toEqual(hashed);
+  });
+});

package/src/use-hash.ts

@@ -0,0 +1,5 @@
+export type dependency = { toString(): string } | undefined;
+
+export function useHash(dependencies: dependency[]) {
+  return dependencies.join('/');
+}

package/src/use-lock.ts

@@ -0,0 +1,52 @@
+import { filter, finalize, Observable } from 'rxjs';
+
+import { use } from '@lib/use';
+import { dependency, useHash } from '@lib/use-hash';
+
+export const useExclusiveLock = use(() => {
+  const locking = {} as Record<string, boolean>;
+  const acquire = (dependencies: dependency[]) => {
+    const hash = useHash(dependencies);
+
+    if (locking[hash]) {
+      throw Error('nested locks not allowed');
+    }
+
+    locking[hash] = true;
+  };
+
+  const release = (dependencies: dependency[]) => {
+    const hash = useHash(dependencies);
+
+    if (!locking[hash]) {
+      throw Error('nested locks not allowed');
+    }
+
+    locking[hash] = false;
+  };
+
+  const alreadyAcquired = (dependencies: dependency[]) => {
+    const hash = useHash(dependencies);
+
+    return locking[hash] == true;
+  };
+
+  return {
+    acquire,
+    release,
+    alreadyAcquired
+  };
+});
+
+export function exclusive<T>(dependencies: dependency[]) {
+  return (input: Observable<T>) => {
+    const { acquire, release, alreadyAcquired } = useExclusiveLock();
+
+    acquire(dependencies);
+
+    return input.pipe(
+      filter(() => alreadyAcquired(dependencies)),
+      finalize(() => release(dependencies))
+    );
+  };
+}

package/src/use-logger.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+
+import { use } from './use';
+import { useTimestamp } from './use-timestamp';
+
+const colorize = (content: string) => {
+  let hash = 0x811c9dc5;
+
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+
+  return chalk.hex('#' + (hash * 0xfffff * 1000000).toString(16).slice(0, 6))(content);
+};
+
+/**
+ *
+ */
+export const useLogger = use((context: string, tint?: string) => {
+  const prefix = () =>
+    `${chalk.gray(new Date(useTimestamp()).toISOString())} ${chalk.hex(
+      tint ?? colorize(context)
+    )(context)}`;
+
+  return {
+    info: (message: any, ...params: unknown[]) =>
+      params?.length
+        ? console.info(`${prefix()}: ${message}`, params)
+        : console.info(`${prefix()}: ${message}`),
+
+    debug: (message: any, ...params: unknown[]) =>
+      params?.length
+        ? console.debug(`${prefix()}: ${message}`, params)
+        : console.debug(`${prefix()}: ${message}`),
+
+    warn: (message: any, ...params: unknown[]) =>
+      params?.length
+        ? console.warn(`${prefix()}: ${message}`, params)
+        : console.warn(`${prefix()}: ${message}`),
+
+    error: (message: any, ...params: unknown[]) =>
+      params?.length
+        ? console.error(`${prefix()}: ${message}`, params)
+        : console.error(`${prefix()}: ${message}`)
+  };
+});

package/src/use-memo.spec.ts

@@ -0,0 +1,30 @@
+import { makeTestModule } from '@lib/make-test-module';
+import { useMemo } from '@lib/use-memo';
+
+import { dependency } from './use-hash';
+
+describe(useMemo.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('memorize value for dependencies', async () => {
+    const value1 = await fixtures.givenMemoValue(() => 1, [useMemo.name]);
+    const value2 = await fixtures.givenMemoValue(() => 2, [useMemo.name]);
+
+    expect(value1).toEqual(1);
+    expect(value2).toEqual(1);
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  return {
+    givenMemoValue<T>(value: () => T, dependencies: dependency[]) {
+      return act(() => useMemo(value, dependencies));
+    }
+  };
+}

package/src/use-memo.ts

@@ -0,0 +1,35 @@
+import { useContext } from '@lib/module';
+import { dependency, useHash } from '@lib/use-hash';
+
+export const token = Symbol('memo-token');
+
+/**
+ *
+ */
+export function memo() {
+  return {
+    provide: token,
+    useValue: {}
+  };
+}
+
+/**
+ * @name useMemo
+ * @description
+ * A hook that caches the result of an expensive calculation, based on a set of dependencies.
+ *
+ * @template T The type of the value that is memoized.
+ * @param {() => T} calculateValue A function that returns the value to memoize.
+ * @param {dependency[]} dependencies An array of dependencies that determine when the value should be recalculated.
+ * @returns {T} The memoized value.
+ */
+export function useMemo<T>(calculateValue: () => T, dependencies: dependency[]) {
+  const memory = useContext<Record<string, any>>(token);
+  const hash = useHash(dependencies);
+
+  if (memory[hash]) {
+    return memory[hash] as T;
+  }
+
+  return (memory[hash] = calculateValue()) as T;
+}

package/src/use-request.ts

@@ -0,0 +1,47 @@
+import { from, map, switchMap, throwError } from 'rxjs';
+import { request } from 'undici';
+
+import { useTimestamp } from './use-timestamp';
+
+export type RequestMethod =
+  | 'GET'
+  | 'HEAD'
+  | 'POST'
+  | 'PUT'
+  | 'DELETE'
+  | 'CONNECT'
+  | 'OPTIONS'
+  | 'TRACE'
+  | 'PATCH';
+
+export class RequestNetworkError extends Error {
+  constructor(readonly statusCode: number, readonly json: () => Promise<string>) {
+    super(`Request network error, received status code: ${statusCode}`);
+  }
+}
+
+export function useRequest(args: {
+  method: RequestMethod;
+  url: string;
+  headers?: Record<string, any>;
+  body?: string;
+}) {
+  return from(
+    request(args.url, {
+      method: args.method,
+      headers: args.headers,
+      body: args.body
+    })
+  ).pipe(
+    switchMap(it => {
+      if (it.statusCode !== 200) {
+        return throwError(
+          () => new RequestNetworkError(it.statusCode, () => it.body.json())
+        );
+      }
+
+      return from(it.body.json());
+    }),
+    map(payload => ({ timestamp: useTimestamp(), payload }))
+  );
+}

package/src/use-socket.ts

@@ -0,0 +1,59 @@
+import { Observable } from 'rxjs';
+import { WebSocket } from 'ws';
+
+import { useLogger } from './use-logger';
+import { useTimestamp } from './use-timestamp';
+
+export function useSocket(
+  url: string
+): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
+  const { debug } = useLogger('useSocket');
+
+  const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
+    const socket = new WebSocket(url);
+    let isAlive = false;
+    let interval: NodeJS.Timer | undefined;
+
+    socket.onmessage = it =>
+      stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
+    socket.onerror = it => {
+      clearInterval(interval);
+      stream.error(it);
+    };
+    socket.onclose = () => {
+      debug('closed', url);
+      clearInterval(interval);
+      stream.error();
+    };
+    socket.onopen = () => {
+      debug('opened', url);
+      isAlive = true;
+      interval = setInterval(() => {
+        if (isAlive) {
+          isAlive = false;
+
+          socket.ping();
+        } else {
+          socket.terminate();
+          clearInterval(interval);
+        }
+      }, 5000);
+
+      socket.on('pong', () => {
+        isAlive = true;
+      });
+
+      socket.on('ping', () => {
+        isAlive = true;
+        socket.pong();
+      });
+    };
+
+    return () => {
+      socket.terminate();
+      clearInterval(interval);
+    };
+  });
+
+  return [message, (message: unknown) => JSON.stringify(message)];
+}

package/src/use-state.spec.ts

@@ -0,0 +1,31 @@
+import { makeTestModule } from '@lib/make-test-module';
+import { useState } from '@lib/use-state';
+
+import { dependency } from './use-hash';
+
+describe(useState.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('keep same state between multiple requests for the same dependency', async () => {
+    const state1 = await fixtures.givenState({ text: 'Hello my state' }, ['my-state']);
+    const state2 = await fixtures.givenState({ text: 'Hello my override state' }, [
+      'my-state'
+    ]);
+
+    expect(Object.is(state1, state2)).toBeTruthy();
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  return {
+    givenState<T>(value: T, dependencies: dependency[]) {
+      return act(() => useState(value, dependencies));
+    }
+  };
+}

package/src/use-state.ts

@@ -0,0 +1,30 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+
+import { useMemo } from '@lib/use-memo';
+
+import { dependency } from './use-hash';
+
+export function useState<T>(
+  initialValue: T,
+  dependencies: dependency[]
+): [Observable<Readonly<T>>, (value: T | ((p: T) => T)) => Readonly<T>] {
+  return useMemo(() => {
+    const state = new BehaviorSubject<T>(initialValue);
+
+    const setState = (newState: T | ((prevState: T) => T | undefined)) => {
+      if (newState instanceof Function) {
+        const value = newState(state.value);
+
+        if (value) {
+          state.next(value);
+        }
+      } else {
+        state.next(newState);
+      }
+
+      return state.value;
+    };
+
+    return [state.asObservable(), setState];
+  }, dependencies);
+}

package/src/use-timestamp.ts

@@ -0,0 +1,12 @@
+import { useReplayCoordinator } from '@lib/replay/use-replay-coordinator';
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+export function useTimestamp() {
+  const { isReplay } = useExecutionMode();
+
+  if (isReplay) {
+    return useReplayCoordinator().timestamp();
+  }
+
+  return Date.now();
+}

package/src/use.spec.ts

@@ -0,0 +1,46 @@
+import { makeTestModule } from '@lib/make-test-module';
+
+import { instrumentOf, InstrumentSelector } from './instrument';
+import { use } from './use';
+
+describe(use.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('memorize same values for same arguments', () => {
+    const { act, getValue } = fixtures;
+
+    act(() => {
+      const value1 = getValue(instrumentOf('binance:btc-usdt'));
+      const value2 = getValue(instrumentOf('binance:btc-usdt'));
+
+      expect(Object.is(value1, value2)).toBeTruthy();
+    });
+  });
+
+  test('memorize different values for different arguments', () => {
+    const { act, getValue } = fixtures;
+
+    act(() => {
+      const value1 = getValue(instrumentOf('binance:btc-usdt'));
+      const value2 = getValue(instrumentOf('binance:btc-busd'));
+
+      expect(value1).toEqual('binance:btc-usdt');
+      expect(value2).toEqual('binance:btc-busd');
+    });
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  const getValue = use((instrument: InstrumentSelector) => instrument.id);
+
+  return {
+    act,
+    getValue: act(() => (instrument: InstrumentSelector) => getValue(instrument))
+  };
+}

package/src/use.ts

@@ -0,0 +1,33 @@
+import { isObservable, Observable, shareReplay } from 'rxjs';
+import { v4 } from 'uuid';
+
+import { asReadonly } from './as-readonly';
+import { throwWithContext } from './module';
+import { dependency } from './use-hash';
+import { useMemo } from './use-memo';
+
+export function use<T extends Array<dependency>, U>(
+  fn: (...args: T) => U
+): (...args: T) => U;
+export function use<T extends Array<dependency>, U>(
+  fn: (...args: T) => Observable<U>
+): (...args: T) => Observable<U>;
+
+export function use<T extends Array<dependency>, U>(
+  fn: (...args: T) => U | Observable<U>
+): (...args: T) => U | Observable<U> {
+  throwWithContext();
+
+  const uniqueId = v4();
+
+  return (...args: T): U | Observable<U> =>
+    useMemo(() => {
+      const value = fn(...args);
+
+      if (isObservable(value)) {
+        return value.pipe(asReadonly(), shareReplay(1));
+      }
+
+      return value;
+    }, [uniqueId, ...args]);
+}

package/tsconfig.json

@@ -1,15 +1,18 @@
 {
   "extends": "../../tsconfig.lib.json",
   "compilerOptions": {
-    "outDir": "dist"
+    "rootDir": "src",
+    "baseUrl": ".",
+    "outDir": "dist",
+    "paths": {
+      "@lib/*": ["src/*"]
+    }
   },
   "include": [
     "src/**/*",
   ],
   "exclude": [
     "jest.config.js",
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "lib/**/*"
+    "dist/**/*"
   ]
 }

package/dist/adapter/adapter-aggregate.d.ts

@@ -1,57 +0,0 @@
-import { InstrumentSelector, Ohlc, Order } from '../domain';
-import { timestamp } from '../shared';
-import { Cache } from '../storage';
-import { Store } from '../store';
-import { Adapter } from '.';
-import { AdapterFactory, AdapterTimeProvider, FeedAsyncCallback } from './adapter';
-/**
- * Manages instances of all adapters provided in session descriptor.
- * Awakes and disposes adapters, routes and executes commands.
- */
-export declare class AdapterAggregate {
-    private readonly factories;
-    private readonly timeProvider;
-    private readonly store;
-    private readonly cache;
-    private readonly adapter;
-    constructor(factories: AdapterFactory[], timeProvider: AdapterTimeProvider, store: Store, cache: Cache);
-    /**
-     * Returns adapter by name.
-     * @param adapterName adapter name.
-     * @returns
-     */
-    get(adapterName: string): Adapter;
-    /**
-     * Sets up all adapters.
-     */
-    awake(): Promise<void>;
-    /**
-     * Disposes all adapters.
-     */
-    dispose(): Promise<void>;
-    /**
-     * Subscribe to collection of instruments.
-     * @param selectors
-     */
-    subscribe(selectors: InstrumentSelector[]): Promise<void>;
-    /**
-     * Opens new order.
-     * @param order an order to open.
-     */
-    open(order: Order): Promise<void>;
-    /**
-     * Cancels specific order.
-     */
-    cancel(order: Order): Promise<void>;
-    /**
-     *
-     * @returns
-     */
-    history(instrument: InstrumentSelector, timeframe: number, length: number): Promise<Ohlc[]>;
-    /**
-     * Feeds a storage with historical instrument data.
-     * @returns
-     */
-    feed(instrument: InstrumentSelector, from: timestamp, to: timestamp, callback: FeedAsyncCallback): Promise<void>;
-}
-//# sourceMappingURL=adapter-aggregate.d.ts.map

package/dist/adapter/adapter-aggregate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-aggregate.d.ts","sourceRoot":"","sources":["../../src/adapter/adapter-aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAC5D,OAAO,EAAU,SAAS,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAGnF;;;GAGG;AACH,qBAAa,gBAAgB;IAIzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IANxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;gBAGpC,SAAS,EAAE,cAAc,EAAE,EAC3B,YAAY,EAAE,mBAAmB,EACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,KAAK;IAG/B;;;;OAIG;IACH,GAAG,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAUjC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAe5B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;;OAGG;IACG,SAAS,CAAC,SAAS,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB/D;;;OAGG;IACG,IAAI,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBvC;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAcnC;;;OAGG;IACH,OAAO,CACL,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,EAAE,CAAC;IAUlB;;;OAGG;IACH,IAAI,CACF,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,SAAS,EACf,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,IAAI,CAAC;CASjB"}