@quantform/core 0.7.0-beta.8 → 0.7.9

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

@@ -1,64 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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)
-      }))
-    );
-}

package/src/replay/with-replay.ts

@@ -1,10 +0,0 @@
-import { Observable } from 'rxjs';
-
-import { use } from '@lib/use';
-import { dependency } from '@lib/use-hash';
-
-export function withReplay<T extends Array<dependency>, U extends Observable<K>, K>(
-  fn: (...args: T) => U
-): (...args: T) => U {
-  return use(fn);
-}

package/src/strat.ts

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

package/src/use-lock.ts

@@ -1,52 +0,0 @@
-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-request.ts

@@ -1,47 +0,0 @@
-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-state.spec.ts

@@ -1,31 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/{dist → lib}/cli/build.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
 const child_process_1 = require("child_process");
 const workspace_1 = require("../cli/internal/workspace");
 function default_1() {
@@ -23,4 +24,3 @@ function default_1() {
         });
     });
 }
-exports.default = default_1;