@quantform/core 0.7.0-beta.4 → 0.7.0-beta.41

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

@@ -0,0 +1,85 @@
+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/use-replay-storage.ts

@@ -1,8 +1,29 @@
-import { Storage, useStorage } from '@lib/storage';
+import { Query, QueryObject, Storage, useStorage } from '@lib/storage';
+import { dependency, useHash } from '@lib/use-hash';
 
-export const replaySerializableObject = (key: string) =>
-  Storage.createObject(key, { timestamp: 'number', json: 'string' });
+export function useReplayStorage<T>(dependencies: dependency[]) {
+  const storage = useStorage(['replay']);
+  const storageObjectKey = useHash(dependencies);
+  const storageObject = Storage.createObject(storageObjectKey, {
+    timestamp: 'number',
+    payload: 'string'
+  });
 
-export function useReplayStorage() {
-  return useStorage(['replay']);
+  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.spec.ts

@@ -1,15 +1,21 @@
+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 +136,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 { useReplayManager } from './use-replay-manager';
+import { useReplayStorage } from './use-replay-storage';
 
-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 { when } = useReplayManager();
 
-    return subscribe(dependencies).pipe(
-      map(it => it as unknown as { timestamp: number; payload: T })
-    );
+    return when<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/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,5 @@
-import { use } from '@lib/use';
+import { withMemo } from '@lib/with-memo';
 
-export const useSession = use(() => ({
+export const useSession = withMemo(() => ({
   id: 'ttt' //Date.now()
 }));

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.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/use-execution-mode.ts

@@ -3,28 +3,35 @@ import { 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
+    useValue: { mode: 'replay', recording: false } as ExecutionMode
   };
 }
 
 export function paperExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'PAPER', ...options } as ExecutionMode
+    useValue: { mode: 'paper', ...options } as ExecutionMode
   };
 }
 
 export function liveExecutionMode(options: { recording: boolean }) {
   return {
     provide: injectionToken,
-    useValue: { mode: 'LIVE', ...options } as ExecutionMode
+    useValue: { mode: 'live', ...options } as ExecutionMode
+  };
+}
+
+export function idleExecutionMode() {
+  return {
+    provide: injectionToken,
+    useValue: { mode: 'idle', recording: false } as ExecutionMode
   };
 }
 
@@ -32,10 +39,11 @@ 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',
+    isReplay: mode.mode === 'replay',
+    isPaper: mode.mode === 'paper',
+    isLive: mode.mode === 'live',
+    isIdle: mode.mode === 'idle',
+    isSimulation: mode.mode !== 'live',
     recording: mode.recording
   };
 };

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,7 +17,7 @@ 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)
@@ -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

@@ -13,16 +13,6 @@ export function memo() {
   };
 }
 
-/**
- * @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);

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/{use-socket.ts → when-socket.ts}

@@ -4,10 +4,11 @@ import { WebSocket } from 'ws';
 import { useLogger } from './use-logger';
 import { useTimestamp } from './use-timestamp';
 
-export function useSocket(
-  url: string
+export function whenSocket(
+  url: string,
+  options: { pingInterval?: number } = { pingInterval: 5000 }
 ): [Observable<{ timestamp: number; payload: unknown }>, (message: unknown) => void] {
-  const { debug } = useLogger('useSocket');
+  const { debug } = useLogger('whenSocket');
 
   const message = new Observable<{ timestamp: number; payload: unknown }>(stream => {
     const socket = new WebSocket(url);
@@ -18,6 +19,7 @@ export function useSocket(
       stream.next({ timestamp: useTimestamp(), payload: JSON.parse(it.data as string) });
     socket.onerror = it => {
       clearInterval(interval);
+      debug('errored', url);
       stream.error(it);
     };
     socket.onclose = () => {
@@ -37,7 +39,7 @@ export function useSocket(
           socket.terminate();
           clearInterval(interval);
         }
-      }, 5000);
+      }, options.pingInterval);
 
       socket.on('pong', () => {
         isAlive = true;

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();

package/src/with-request.ts

@@ -0,0 +1,83 @@
+import { randomUUID } from 'node:crypto';
+import { Observable } from 'rxjs';
+import { request } from 'undici';
+
+import { useLogger } from './use-logger';
+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 withRequest({
+  method,
+  url,
+  headers,
+  body
+}: {
+  method: RequestMethod;
+  url: string;
+  headers?: Record<string, any>;
+  body?: string;
+}) {
+  const { error, debug } = useLogger(withRequest.name);
+
+  return new Observable<{ timestamp: number; payload: unknown }>(subscriber => {
+    const correlationId = randomUUID();
+
+    debug('requesting', { correlationId, method, url, headers, body });
+
+    request(url, { method, headers, body })
+      .then(async ({ statusCode, body }) => {
+        const json = await body.json();
+
+        debug('received', {
+          correlationId,
+          method,
+          url,
+          headers,
+          body: json,
+          statusCode
+        });
+
+        if (statusCode !== 200) {
+          error(`errored`, {
+            method,
+            url,
+            headers,
+            body,
+            statusCode
+          });
+
+          subscriber.error(new RequestNetworkError(statusCode, () => json));
+        } else {
+          subscriber.next({ timestamp: useTimestamp(), payload: json });
+        }
+      })
+      .catch((e: Error) => {
+        error(`errored`, {
+          method,
+          url,
+          headers,
+          body,
+          error: e
+        });
+
+        subscriber.error(error);
+      })
+      .finally(() => subscriber.complete());
+  });
+}

package/dist/as-readonly.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-export declare function asReadonly<T>(): (input: Observable<T>) => Observable<Readonly<T>>;
-//# sourceMappingURL=as-readonly.d.ts.map

package/dist/as-readonly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"as-readonly.d.ts","sourceRoot":"","sources":["../src/as-readonly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC,wBAAgB,UAAU,CAAC,CAAC,aACX,WAAW,CAAC,CAAC,6BAC7B"}

package/dist/as-readonly.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asReadonly = void 0;
-const rxjs_1 = require("rxjs");
-function asReadonly() {
-    return (input) => input.pipe((0, rxjs_1.map)(it => it));
-}
-exports.asReadonly = asReadonly;

package/dist/defined.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-export declare function defined<T>(): (observable: Observable<T | undefined | null>) => Observable<T | null | undefined>;
-//# sourceMappingURL=defined.d.ts.map

package/dist/defined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defined.d.ts","sourceRoot":"","sources":["../src/defined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,UAAU,EAAE,MAAM,MAAM,CAAC;AAE1C,wBAAgB,OAAO,CAAC,CAAC,kBACH,WAAW,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,sCAErD"}

package/dist/defined.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defined = void 0;
-const rxjs_1 = require("rxjs");
-function defined() {
-    return (observable) => observable.pipe((0, rxjs_1.filter)(it => it !== undefined && it !== null));
-}
-exports.defined = defined;

package/dist/exclude.d.ts

@@ -1,3 +0,0 @@
-import { Observable } from 'rxjs';
-export declare function exclude<T, S extends symbol>(s: S): (observable: Observable<T | S>) => Observable<Exclude<T, S>>;
-//# sourceMappingURL=exclude.d.ts.map

package/dist/exclude.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exclude.d.ts","sourceRoot":"","sources":["../src/exclude.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,MAAM,CAAC;AAE/C,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,gBAC3B,WAAW,CAAC,GAAG,CAAC,CAAC,+BAKtC"}

package/dist/exclude.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exclude = void 0;
-const rxjs_1 = require("rxjs");
-function exclude(s) {
-    return (observable) => observable.pipe((0, rxjs_1.filter)(it => it !== s), (0, rxjs_1.map)(it => it));
-}
-exports.exclude = exclude;

package/dist/not-found.d.ts

@@ -1,2 +0,0 @@
-export declare const notFound: unique symbol;
-//# sourceMappingURL=not-found.d.ts.map

package/dist/not-found.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"not-found.d.ts","sourceRoot":"","sources":["../src/not-found.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,eAA0B,CAAC"}

package/dist/not-found.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notFound = void 0;
-exports.notFound = Symbol.for('not-found');

package/dist/replay/use-replay-coordinator.d.ts

@@ -1,10 +0,0 @@
-import { dependency } from '../use-hash';
-export declare function useReplayCoordinator(): {
-    timestamp: () => number;
-    stop: () => number;
-    tryContinue: () => void;
-    subscribe: (dependencies: dependency[]) => import("rxjs").Observable<{
-        timestamp: number;
-    }>;
-};
-//# sourceMappingURL=use-replay-coordinator.d.ts.map

package/dist/replay/use-replay-coordinator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-replay-coordinator.d.ts","sourceRoot":"","sources":["../../src/replay/use-replay-coordinator.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,wBAAgB,oBAAoB;;;;8BAUC,UAAU,EAAE;mBAFW,MAAM;;EAsFjE"}