@quantform/core 0.6.6 → 0.7.0-beta.4

package/src/session/use-session-object.ts

@@ -0,0 +1,26 @@
+import { from } from 'rxjs';
+
+import {
+  InferQueryObject,
+  Query,
+  QueryMappingType,
+  QueryObject,
+  Storage
+} from '@lib/storage';
+
+import { useSessionStorage } from './use-session-storage';
+
+export const useSessionObject = <
+  K extends QueryObject,
+  T extends { [key in keyof K]: QueryMappingType }
+>(
+  object: ReturnType<typeof Storage.createObject<K, T>>
+) => {
+  const storage = useSessionStorage();
+
+  return {
+    query: (query: Query<InferQueryObject<typeof object>>) =>
+      from(storage.query(object, query)),
+    save: (objects: InferQueryObject<typeof object>[]) => storage.save(object, objects)
+  };
+};

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

@@ -0,0 +1,9 @@
+import { useSession } from '@lib/session';
+import { useStorage } from '@lib/storage';
+import { use } from '@lib/use';
+
+export const useSessionStorage = use(() => {
+  const { id } = useSession();
+
+  return useStorage(['session', id]);
+});

package/src/session/use-session.ts

@@ -0,0 +1,5 @@
+import { use } from '@lib/use';
+
+export const useSession = use(() => ({
+  id: 'ttt' //Date.now()
+}));

package/src/shared/decimals.spec.ts

@@ -1,4 +1,4 @@
-import { d } from './decimals';
+import { d } from '@lib/shared';
 
 describe('decimals', () => {
   test('get precision tests', () => {

package/src/shared/decimals.ts

@@ -16,6 +16,11 @@ 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);

package/src/shared/index.ts

@@ -1,7 +1,3 @@
-export * from './datetime';
-export * from './decimals';
-export * from './environment';
-export * from './logger';
-export * from './policy';
-export * from './collections';
-export * from './pipe';
+export * from '@lib/shared/datetime';
+export * from '@lib/shared/decimals';
+export * from '@lib/shared/environment';

package/src/simulator/index.ts

@@ -0,0 +1 @@
+export * from './use-simulator';

package/src/simulator/use-simulator.spec.ts

@@ -0,0 +1,54 @@
+import { makeTestModule, mockedFunc } 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>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  afterEach(() => fixtures.clear());
+
+  test('get real value when simulator mode disabled', () => {
+    const { act } = fixtures;
+
+    fixtures.givenSimulationEnabled(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);
+
+    const value = act(() => useSimulator('simulator', 'real'));
+
+    expect(value).toBe('simulator');
+  });
+});
+
+async function getFixtures() {
+  const { act } = await makeTestModule([]);
+
+  return {
+    act,
+    givenSimulationEnabled(isSimulation: boolean) {
+      mockedFunc(useExecutionMode).mockReturnValue({
+        isSimulation,
+        recording: false
+      } as any);
+    },
+    clear: jest.clearAllMocks
+  };
+}

package/src/simulator/use-simulator.ts

@@ -0,0 +1,7 @@
+import { useExecutionMode } from '@lib/use-execution-mode';
+
+export function useSimulator<T>(simulator: T, real: T) {
+  const { isSimulation } = useExecutionMode();
+
+  return isSimulation ? simulator : real;
+}

package/src/storage/in-memory/in-memory-storage.factory.ts

@@ -0,0 +1,16 @@
+import { provider } from '@lib/module';
+import { Storage, StorageFactory } from '@lib/storage';
+
+import { InMemoryStorage } from './in-memory-storage';
+
+@provider()
+export class InMemoryStorageFactory implements StorageFactory {
+  private static storage: Record<string, Storage> = {};
+
+  for(key: string): Storage {
+    return (
+      InMemoryStorageFactory.storage[key] ??
+      (InMemoryStorageFactory.storage[key] = new InMemoryStorage())
+    );
+  }
+}

package/src/storage/in-memory/in-memory-storage.spec.ts

@@ -0,0 +1,193 @@
+import { d } from '@lib/shared';
+import { eq, gt, lt, Storage } from '@lib/storage';
+
+import { InMemoryStorage } from './in-memory-storage';
+
+describe(InMemoryStorage.name, () => {
+  let fixtures: Awaited<ReturnType<typeof getFixtures>>;
+
+  beforeEach(async () => {
+    fixtures = await getFixtures();
+  });
+
+  test('read empty storage', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    const set = await sut.query(pricing, {});
+
+    expect(set).toEqual([]);
+  });
+
+  test('save and read full data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {});
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+  });
+
+  test('save and read limited data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, { limit: 3 });
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) }
+    ]);
+  });
+
+  test('save and read desc ordered data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, { orderBy: 'DESC' });
+
+    expect(set).toEqual([
+      { timestamp: 5, rate: d(5) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 1, rate: d(1) }
+    ]);
+  });
+
+  test('save and read filtered eq data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: eq(4)
+      }
+    });
+
+    expect(set).toEqual([{ timestamp: 4, rate: d(4) }]);
+  });
+
+  test('save and read filtered lt data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: lt(3)
+      }
+    });
+
+    expect(set).toEqual([
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) }
+    ]);
+  });
+
+  test('save and read filtered gt data', async () => {
+    const { sut } = fixtures;
+
+    const pricing = Storage.createObject('pricing', {
+      timestamp: 'number',
+      rate: 'decimal'
+    });
+
+    await sut.save(pricing, [
+      { timestamp: 1, rate: d(1) },
+      { timestamp: 2, rate: d(2) },
+      { timestamp: 3, rate: d(3) },
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+
+    const set = await sut.query(pricing, {
+      where: {
+        timestamp: gt(3)
+      }
+    });
+
+    expect(set).toEqual([
+      { timestamp: 4, rate: d(4) },
+      { timestamp: 5, rate: d(5) }
+    ]);
+  });
+});
+
+async function getFixtures() {
+  const sut = new InMemoryStorage();
+
+  return {
+    sut
+  };
+}

package/src/storage/in-memory/in-memory-storage.ts

@@ -0,0 +1,80 @@
+import {
+  InferQueryObject,
+  Query,
+  QueryObject,
+  QueryObjectType,
+  Storage
+} from '@lib/storage';
+
+export class InMemoryStorage implements Storage {
+  private tables: Record<string, QueryObject[]> = {};
+
+  async index(): Promise<Array<string>> {
+    return Object.keys(this.tables);
+  }
+
+  async query<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    query: Query<InferQueryObject<T>>
+  ): Promise<InferQueryObject<T>[]> {
+    if (!this.tables[type.discriminator]) {
+      return [];
+    }
+
+    let set = this.tables[type.discriminator];
+
+    if (query.where) {
+      for (const prop of Object.keys(query.where)) {
+        const expression = query.where[prop];
+
+        switch (expression?.type) {
+          case 'eq':
+            set = set.filter(it => it[prop] === expression.value);
+            break;
+          case 'gt':
+            set = set.filter(it => +it[prop] > expression.value);
+            break;
+          case 'lt':
+            set = set.filter(it => +it[prop] < expression.value);
+            break;
+          case 'between':
+            set = set.filter(
+              it => +it[prop] > expression.min && +it[prop] < expression.max
+            );
+            break;
+        }
+      }
+    }
+
+    if (query.limit) {
+      set = set.slice(0, query.limit);
+    }
+
+    if (query.orderBy === 'DESC') {
+      set = set.reverse();
+    }
+
+    return set as InferQueryObject<T>[];
+  }
+
+  async save<T extends QueryObjectType<K>, K extends QueryObject>(
+    type: T,
+    objects: InferQueryObject<T>[]
+  ): Promise<void> {
+    if (!this.tables[type.discriminator]) {
+      this.tables[type.discriminator] = [];
+    }
+
+    const buffer = this.tables[type.discriminator];
+
+    for (const document of objects) {
+      buffer.push(document);
+    }
+
+    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+  }
+
+  clear() {
+    this.tables = {};
+  }
+}

package/src/storage/in-memory/index.ts

@@ -0,0 +1,2 @@
+export * from './in-memory-storage';
+export * from './in-memory-storage.factory';

package/src/storage/index.ts

@@ -1,4 +1,4 @@
-export * from './feed';
-export * from './measurement';
 export * from './storage';
-export * from './cache';
+export * from './use-storage';
+export * from './use-storage-factory';
+export * from './in-memory';

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