@quantform/core 0.6.7 → 0.7.0-beta.5

package/src/storage/storage.ts

@@ -1,126 +1,70 @@
-export type StorageDocument = {
-  timestamp: number;
-  kind: string;
-  json: string;
+import { decimal } from '@lib/shared';
+
+type Types = string | number | decimal;
+
+export const eq = <T extends Types>(value: T) => ({ type: 'eq' as const, value });
+export const gt = <T extends number>(value: T) => ({ type: 'gt' as const, value });
+export const lt = <T extends number>(value: T) => ({ type: 'lt' as const, value });
+export const between = <T extends number>(min: T, max: T) => ({
+  type: 'between' as const,
+  min,
+  max
+});
+
+export type QueryObject = Record<string, Types> & { timestamp: number };
+export type QueryObjectType<T extends QueryObject> = {
+  discriminator: string;
+  type: {
+    [key in keyof T]: QueryMappingType;
+  };
 };
 
-export type StorageQueryOptions = {
-  from?: number;
-  to?: number;
-  kind?: string;
-  count: number;
+export type QueryWhere =
+  | ReturnType<typeof eq>
+  | ReturnType<typeof gt>
+  | ReturnType<typeof lt>
+  | ReturnType<typeof between>;
+
+export type Query<T extends QueryObject> = {
+  where?: Partial<{
+    [key in keyof T]: QueryWhere;
+  }>;
+  orderBy?: 'ASC' | 'DESC';
+  limit?: number;
+  offset?: number;
 };
 
-/**
- *
- */
-export type StorageFactory = (type: string) => Storage;
-
-/**
- *
- */
-export interface Storage {
-  /**
-   *
-   */
-  index(): Promise<Array<string>>;
-
-  /**
-   *
-   * @param library
-   * @param documents
-   */
-  save(library: string, documents: StorageDocument[]): Promise<void>;
-
-  /**
-   *
-   * @param library
-   * @param options
-   */
-  query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]>;
-}
-
-export function inMemoryStorageFactory(): StorageFactory {
-  const storage: Record<string, Storage> = {};
-
-  return (type: string) => storage[type] ?? (storage[type] = new InMemoryStorage());
-}
-
-/**
- *
- */
-export class InMemoryStorage implements Storage {
-  private tables: Record<string, StorageDocument[]> = {};
-
-  /**
-   *
-   * @returns
-   */
-  async index(): Promise<Array<string>> {
-    return Object.keys(this.tables);
+export type QueryMappingType = 'number' | 'string' | 'decimal';
+export type InferQueryObject<T> = T extends QueryObjectType<infer U>
+  ? {
+      [key in keyof T['type']]: T['type'][key] extends 'number'
+        ? number
+        : T['type'][key] extends 'string'
+        ? string
+        : T['type'][key] extends 'decimal'
+        ? decimal
+        : never;
+    } & { timestamp: number }
+  : never;
+
+export abstract class Storage {
+  static createObject<
+    K extends QueryObject,
+    T extends { [key in keyof K]: QueryMappingType }
+  >(discriminator: string, type: T) {
+    return {
+      discriminator,
+      type
+    };
   }
 
-  /**
-   *
-   * @param library
-   * @param options
-   * @returns
-   */
-  async query(library: string, options: StorageQueryOptions): Promise<StorageDocument[]> {
-    if (!this.tables[library]) {
-      return [];
-    }
-
-    let query = this.tables[library];
-
-    const { from, to, kind, count } = options;
-
-    if (from) {
-      query = query.filter(it => it.timestamp > from);
-    }
-
-    if (to) {
-      query = query.filter(it => it.timestamp < to);
-    }
-
-    if (kind) {
-      query = query.filter(it => it.kind == kind);
-    }
-
-    if (from == undefined && to) {
-      query = query.reverse();
-    }
-
-    if (count) {
-      query = query.slice(0, options.count);
-    }
-
-    return query;
-  }
-
-  /**
-   *
-   * @param library
-   * @param documents
-   */
-  async save(library: string, documents: StorageDocument[]): Promise<void> {
-    if (!this.tables[library]) {
-      this.tables[library] = [];
-    }
-
-    const buffer = this.tables[library];
-
-    for (const document of documents) {
-      buffer.push(document);
-    }
-
-    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
-  }
-
-  /**
-   *
-   */
-  clear() {
-    this.tables = {};
-  }
+  abstract index(): Promise<Array<string>>;
+  abstract save<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    objects: InferQueryObject<T>[]
+  ): Promise<void>;
+  abstract query<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    query: Query<InferQueryObject<T>>
+  ): Promise<InferQueryObject<T>[]>;
 }

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

@@ -0,0 +1,31 @@
+import { firstValueFrom, Observable, of } from 'rxjs';
+
+import { makeTestModule } from '@lib/make-test-module';
+import { useCache } from '@lib/storage/use-cache';
+import { dependency } from '@lib/use-hash';
+
+describe(useCache.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('cache value for dependencies', async () => {
+    const value1 = await firstValueFrom(fixtures.givenCacheValue(of(1), ['val']));
+    const value2 = await firstValueFrom(fixtures.givenCacheValue(of(2), ['val']));
+
+    expect(value1).toEqual(1);
+    expect(value2).toEqual(1);
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  return {
+    givenCacheValue<T>(value: Observable<T>, dependencies: dependency[]) {
+      return act(() => useCache(value, dependencies));
+    }
+  };
+}

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