@quantform/core 0.7.0-beta.8 → 0.7.9

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

package/src/use-execution-mode.ts

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

package/src/use-logger.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 
-import { use } from './use';
 import { useTimestamp } from './use-timestamp';
+import { withMemo } from './with-memo';
 
 const colorize = (content: string) => {
   let hash = 0x811c9dc5;
@@ -17,11 +17,11 @@ const colorize = (content: string) => {
 /**
  *
  */
-export const useLogger = use((context: string, tint?: string) => {
+export const useLogger = withMemo((context: string, tint?: string) => {
   const prefix = () =>
-    `${chalk.gray(new Date(useTimestamp()).toISOString())} ${chalk.hex(
-      tint ?? colorize(context)
-    )(context)}`;
+    `${chalk.hex(tint ?? colorize(context))(
+      new Date(useTimestamp()).toISOString()
+    )} ${chalk.hex(tint ?? colorize(context))(context)}`;
 
   return {
     info: (message: any, ...params: unknown[]) =>
@@ -41,7 +41,7 @@ export const useLogger = use((context: string, tint?: string) => {
 
     error: (message: any, ...params: unknown[]) =>
       params?.length
-        ? console.error(`${prefix()}: ${message}`, params)
-        : console.error(`${prefix()}: ${message}`)
+        ? console.error(`${prefix()}: ${chalk.red(message)}`, params)
+        : console.error(`${prefix()}: ${chalk.red(message)}`)
   };
 });

package/src/use-memo.ts

@@ -1,28 +1,8 @@
-import { useContext } from '@lib/module';
+import { Dependency, 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);
@@ -33,3 +13,8 @@ export function useMemo<T>(calculateValue: () => T, dependencies: dependency[])
 
   return (memory[hash] = calculateValue()) as T;
 }
+
+useMemo.options = (): Dependency => ({
+  provide: token,
+  useValue: {}
+});

package/src/use-socket.ts

@@ -1,59 +1,97 @@
-import { Observable } from 'rxjs';
+import { defer, Observable, of, ReplaySubject } 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] {
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
+) {
   const { debug } = useLogger('useSocket');
+  const socket = new WebSocket(url);
+  const monitor = new ReplaySubject<'opened' | 'closed' | 'errored'>();
 
-  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();
+  socket.on('error', e => {
+    debug('errored', url, e);
+    monitor.next('errored');
+  });
+
+  socket.on('close', () => {
+    debug('closed', url);
+    monitor.next('closed');
+  });
+
+  socket.on('open', () => {
+    debug('opened', url);
+    monitor.next('opened');
+  });
+
+  return {
+    /**
+     * Observes socket events and handles connection health monitoring via ping/pong
+     * @returns observable emitting message events with timestamps and parsed payloads
+     */
+    watch(): Observable<{ timestamp: number; payload: unknown }> {
+      let isAlive = false;
+      let interval: NodeJS.Timeout | undefined;
+
+      return new Observable(stream => {
+        socket.onmessage = it =>
+          stream.next({
+            timestamp: useTimestamp(),
+            payload: JSON.parse(it.data as string)
+          });
+        socket.onerror = it => {
+          clearInterval(interval);
+          stream.error(it);
+        };
+        socket.onclose = () => {
           clearInterval(interval);
-        }
-      }, 5000);
+          stream.error();
+        };
+        socket.onopen = () => {
+          isAlive = true;
+          interval = setInterval(() => {
+            if (isAlive) {
+              isAlive = false;
 
-      socket.on('pong', () => {
-        isAlive = true;
-      });
+              socket.ping();
+            } else {
+              socket.terminate();
+              clearInterval(interval);
+            }
+          }, options.pingInterval);
+
+          socket.on('pong', () => {
+            isAlive = true;
+          });
+
+          socket.on('ping', () => {
+            isAlive = true;
+            socket.pong();
+          });
+        };
 
-      socket.on('ping', () => {
-        isAlive = true;
-        socket.pong();
+        return () => {
+          clearInterval(interval);
+          socket.terminate();
+        };
       });
-    };
+    },
 
-    return () => {
-      socket.terminate();
-      clearInterval(interval);
-    };
-  });
+    send(message: { payload: unknown }): Observable<{ timestamp: number }> {
+      return defer(() => {
+        debug('sent', url, message.payload);
+
+        socket.send(JSON.stringify(message.payload));
+
+        return of({ timestamp: useTimestamp() });
+      });
+    },
 
-  return [message, (message: unknown) => JSON.stringify(message)];
+    monitor() {
+      return monitor.asObservable();
+    }
+  };
 }

package/src/use-timestamp.ts

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

package/src/when-socket.ts

@@ -0,0 +1,61 @@
+import { Observable } from 'rxjs';
+import { WebSocket } from 'ws';
+
+import { useLogger } from './use-logger';
+import { useTimestamp } from './use-timestamp';
+
+export function whenSocket(
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
+): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
+  const { debug } = useLogger('whenSocket');
+
+  const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
+    const socket = new WebSocket(url);
+    let isAlive = false;
+    let interval: NodeJS.Timeout | undefined;
+
+    socket.onmessage = it =>
+      stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
+    socket.onerror = it => {
+      clearInterval(interval);
+      debug('errored', url);
+      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);
+        }
+      }, options.pingInterval);
+
+      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.spec.ts → with-memo.spec.ts}

@@ -1,9 +1,9 @@
 import { makeTestModule } from '@lib/make-test-module';
 
 import { instrumentOf, InstrumentSelector } from './instrument';
-import { use } from './use';
+import { withMemo } from './with-memo';
 
-describe(use.name, () => {
+describe(withMemo.name, () => {
   let fixtures: Awaited<ReturnType<typeof getFixtures>>;
 
   beforeEach(async () => {
@@ -37,7 +37,7 @@ describe(use.name, () => {
 async function getFixtures() {
   const { act } = await makeTestModule([]);
 
-  const getValue = use((instrument: InstrumentSelector) => instrument.id);
+  const getValue = withMemo((instrument: InstrumentSelector) => instrument.id);
 
   return {
     act,

package/src/{use.ts → with-memo.ts}

@@ -1,19 +1,19 @@
 import { isObservable, Observable, shareReplay } from 'rxjs';
 import { v4 } from 'uuid';
 
-import { asReadonly } from './as-readonly';
 import { throwWithContext } from './module';
+import { asReadonly } from './operators';
 import { dependency } from './use-hash';
 import { useMemo } from './use-memo';
 
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => U
 ): (...args: T) => U;
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => Observable<U>
 ): (...args: T) => Observable<U>;
 
-export function use<T extends Array<dependency>, U>(
+export function withMemo<T extends Array<dependency>, U>(
   fn: (...args: T) => U | Observable<U>
 ): (...args: T) => U | Observable<U> {
   throwWithContext();