@quantform/core 0.7.21 → 0.7.24

package/src/replay/use-replay-scheduler.ts

@@ -1,97 +1,105 @@
 import { defer, filter, map, Observable, Subject } from 'rxjs';
 
-import { withMemo } from '@lib/with-memo';
+import { useMemo } from '@lib/use-memo';
+import { Timestamp } from '@lib/use-timestamp';
 
 import { useReplayOptions } from './use-replay-options';
 import { useReplayStorageBuffer } from './use-replay-storage-buffer';
 import { ReplayQuery, useReplayStorageCursor } from './use-replay-storage-cursor';
 
-export const useReplayScheduler = withMemo(() => {
-  const { from } = useReplayOptions();
-  const { get, cursor } = useReplayStorageCursor();
+export function useReplayScheduler() {
+  return useMemo(() => {
+    const { from } = useReplayOptions();
+    const { get, cursor } = useReplayStorageCursor();
 
-  let timestamp = from;
-  let stopAcquire = 1;
-  let processing = false;
+    let timestamp = from;
+    let stopAcquire = 1;
+    let processing = false;
 
-  const stream$ = new Subject<
-    [ReturnType<typeof useReplayStorageBuffer<any>>, { timestamp: number; payload: any }]
-  >();
+    const stream$ = new Subject<
+      [
+        ReturnType<typeof useReplayStorageBuffer<any>>,
+        { timestamp: Timestamp<'ns'>; payload: any }
+      ]
+    >();
 
-  const processNext = async () => {
-    const storage = await cursor();
+    const processNext = async () => {
+      const storage = await cursor();
 
-    if (!storage || !storage.peek()) {
-      stream$.complete();
-      return false;
-    }
+      if (!storage || !storage.peek()) {
+        stream$.complete();
+        return false;
+      }
+
+      const sample = storage.dequeue();
 
-    const sample = storage.dequeue();
+      timestamp = sample.timestamp;
 
-    timestamp = sample.timestamp;
+      stream$.next([storage, sample]);
 
-    stream$.next([storage, sample]);
+      return true;
+    };
 
-    return true;
-  };
+    const next = async () => {
+      if (processing) {
+        return;
+      }
 
-  const next = async () => {
-    if (processing) {
-      return;
-    }
+      processing = true;
 
-    processing = true;
+      while (stopAcquire === 0) {
+        if (!(await processNext())) {
+          break;
+        }
 
-    while (stopAcquire === 0) {
-      if (!(await processNext())) {
-        break;
+        await new Promise(it => setImmediate(it));
       }
 
-      await new Promise(it => setImmediate(it));
-    }
-
-    processing = false;
-  };
+      processing = false;
+    };
 
-  const tryContinue = () => {
-    if (stopAcquire === 0) {
-      return;
-    }
+    const tryContinue = () => {
+      if (stopAcquire === 0) {
+        return;
+      }
 
-    stopAcquire--;
+      stopAcquire--;
 
-    if (stopAcquire === 0) {
-      next();
-    }
-  };
+      if (stopAcquire === 0) {
+        next();
+      }
+    };
 
-  return {
-    stream: stream$.asObservable(),
+    return {
+      stream: stream$.asObservable(),
 
-    timestamp() {
-      return timestamp;
-    },
+      timestamp() {
+        return timestamp;
+      },
 
-    stop() {
-      stopAcquire++;
-    },
+      stop() {
+        stopAcquire++;
+      },
 
-    tryContinue,
+      tryContinue,
 
-    watch<T>(query: ReplayQuery<T>): Observable<{ timestamp: number; payload: T }> {
-      const storage = get<T>(query);
+      watch<T>(
+        query: ReplayQuery<T>
+      ): Observable<{ timestamp: Timestamp<'ns'>; payload: T }> {
+        const storage = get<T>(query);
 
-      return defer(() => {
-        tryContinue();
+        return defer(() => {
+          tryContinue();
 
-        return stream$.pipe(
-          filter(([cur]) => cur === storage),
-          map(([, it]) => ({
-            timestamp: it.timestamp,
-            payload: it.payload as T
-          }))
-        );
-      });
-    }
-  };
-});
+          return stream$.pipe(
+            filter(([cur]) => cur === storage),
+            map(([, it]) => ({
+              timestamp: it.timestamp,
+              payload: it.payload as T
+            }))
+          );
+        });
+      }
+    };
+  }, [useReplayScheduler.name]);
+}

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

@@ -1,4 +1,5 @@
 import { between } from '@lib/storage';
+import { Timestamp } from '@lib/use-timestamp';
 
 import { useReplayOptions } from './use-replay-options';
 import { ReplayQuery } from './use-replay-storage-cursor';
@@ -6,7 +7,7 @@ import { ReplayQuery } from './use-replay-storage-cursor';
 export function useReplayStorageBuffer<T>(storage: ReplayQuery<T>) {
   const { from, to, limit } = useReplayOptions();
 
-  let page: Array<{ timestamp: number; payload: T }> = [];
+  let page: Array<{ timestamp: Timestamp<'ns'>; payload: T }> = [];
   let index = 0;
   let completed = false;
   let count = 0;

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

@@ -1,48 +1,53 @@
 import { Query, QueryObject } from '@lib/storage';
-import { withMemo } from '@lib/with-memo';
+import { useMemo } from '@lib/use-memo';
+import { Timestamp } from '@lib/use-timestamp';
 
 import { useReplayStorageBuffer } from './use-replay-storage-buffer';
 
 export interface ReplayQuery<V> {
   query(
     query: Query<QueryObject> & {
-      where: { timestamp: { type: 'between'; min: number; max: number } };
+      where: {
+        timestamp: { type: 'between'; min: Timestamp<'ns'>; max: Timestamp<'ns'> };
+      };
     }
-  ): Promise<{ timestamp: number; payload: V }[]>;
+  ): Promise<{ timestamp: Timestamp<'ns'>; payload: V }[]>;
 }
 
-export const useReplayStorageCursor = withMemo(() => {
-  const cursors = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
+export function useReplayStorageCursor() {
+  return useMemo(() => {
+    const cursors = Array.of<ReturnType<typeof useReplayStorageBuffer<any>>>();
 
-  return {
-    get<T>(query: ReplayQuery<T>) {
-      const buffer = useReplayStorageBuffer<T>(query);
+    return {
+      get<T>(query: ReplayQuery<T>) {
+        const buffer = useReplayStorageBuffer<T>(query);
 
-      cursors.push(buffer);
+        cursors.push(buffer);
 
-      return buffer;
-    },
+        return buffer;
+      },
 
-    async cursor() {
-      let current: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
+      async cursor() {
+        let current: ReturnType<typeof useReplayStorageBuffer<any>> | undefined;
 
-      for (const cursor of cursors) {
-        if (cursor.completed()) {
-          continue;
-        }
+        for (const cursor of cursors) {
+          if (cursor.completed()) {
+            continue;
+          }
 
-        if (cursor.size() == 0) {
-          await cursor.fetchNextPage();
-        }
+          if (cursor.size() == 0) {
+            await cursor.fetchNextPage();
+          }
 
-        if (cursor.peek()) {
-          if (!current || current.peek().timestamp > cursor.peek().timestamp) {
-            current = cursor;
+          if (cursor.peek()) {
+            if (!current || current.peek().timestamp > cursor.peek().timestamp) {
+              current = cursor;
+            }
           }
         }
-      }
 
-      return current;
-    }
-  };
-});
+        return current;
+      }
+    };
+  }, [useReplayStorageCursor.name]);
+}

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

@@ -13,6 +13,7 @@ import {
 import { Uri } from '@lib/uri';
 import { useLogger } from '@lib/use-logger';
 import { useMemo } from '@lib/use-memo';
+import { ns, Timestamp } from '@lib/use-timestamp';
 
 import { useReplayOptions } from './use-replay-options';
 import { useReplayScheduler } from './use-replay-scheduler';
@@ -20,17 +21,21 @@ import { useReplayScheduler } from './use-replay-scheduler';
 export type ReplayStorageQuery<V> = {
   sync: <T extends QueryObjectType<K>, K extends QueryObject>(
     query: Query<InferQueryObject<T>> & {
-      where: { timestamp: { type: 'between'; min: number; max: number } };
+      where: {
+        timestamp: { type: 'between'; min: Timestamp<'ns'>; max: Timestamp<'ns'> };
+      };
     },
-    storage: { save: (objects: { timestamp: number; payload: V }[]) => Promise<void> }
+    storage: {
+      save: (objects: { timestamp: Timestamp<'ns'>; payload: V }[]) => Promise<void>;
+    }
   ) => Promise<void>;
 };
 
 const storageIndexObject = Storage.createObject('index://range', {
-  timestamp: 'number',
+  timestamp: 'bigint',
   uri: 'string',
-  min: 'number',
-  max: 'number'
+  min: 'bigint',
+  max: 'bigint'
 });
 
 export function useReplayStorage<V, P extends Record<string, string | number>>(
@@ -38,16 +43,16 @@ export function useReplayStorage<V, P extends Record<string, string | number>>(
   { sync }: ReplayStorageQuery<V>
 ) {
   const { watch } = useReplayScheduler();
-  const { info } = useLogger(useReplayStorage.name);
+  const { info, error } = useLogger(useReplayStorage.name);
   const options = useReplayOptions();
   const storage = useStorage([options.storage]);
   const storageObjectKey = uri.query;
   const storageObject = Storage.createObject(storageObjectKey, {
-    timestamp: 'number',
+    timestamp: 'bigint',
     payload: 'string'
   });
 
-  const id = hashCode(storageObjectKey);
+  const id = ns(hashCode(storageObjectKey));
 
   return {
     watch: () =>
@@ -65,26 +70,30 @@ export function useReplayStorage<V, P extends Record<string, string | number>>(
               if (!index || min < index.min || max > index.max) {
                 info(`fetching replay for ${storageObjectKey} started`);
 
-                await sync(query, {
-                  async save(objects) {
-                    await storage.save(
-                      storageObject,
-                      objects.map(it => ({
-                        timestamp: it.timestamp,
-                        payload: JSON.stringify(it.payload)
-                      }))
-                    );
-                  }
-                });
+                try {
+                  await sync(query, {
+                    async save(objects) {
+                      await storage.save(
+                        storageObject,
+                        objects.map(it => ({
+                          timestamp: it.timestamp,
+                          payload: JSON.stringify(it.payload)
+                        }))
+                      );
+                    }
+                  });
 
-                await storage.save(storageIndexObject, [
-                  {
-                    timestamp: id,
-                    max,
-                    min,
-                    uri: storageObjectKey
-                  }
-                ]);
+                  await storage.save(storageIndexObject, [
+                    {
+                      timestamp: id,
+                      max,
+                      min,
+                      uri: storageObjectKey
+                    }
+                  ]);
+                } catch (err) {
+                  error(`fetching replay for ${storageObjectKey} failed: ${err}`);
+                }
 
                 info(`fetching replay for ${storageObjectKey} finished`);
               }

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

@@ -1,9 +1,11 @@
 import { useSession } from '@lib/session';
 import { useStorage } from '@lib/storage';
-import { withMemo } from '@lib/with-memo';
+import { useMemo } from '@lib/use-memo';
 
-export const useSessionStorage = withMemo(() => {
-  const { id } = useSession();
+export function useSessionStorage() {
+  return useMemo(() => {
+    const { id } = useSession();
 
-  return useStorage(['session', id]);
-});
+    return useStorage(['session', id]);
+  }, [useSessionStorage.name]);
+}

package/src/shared/index.ts

@@ -1,3 +1,2 @@
-export * from '@lib/shared/datetime';
 export * from '@lib/shared/decimals';
 export * from '@lib/shared/environment';

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

@@ -1,5 +1,6 @@
 import { d } from '@lib/shared';
 import { eq, gt, lt, Storage } from '@lib/storage';
+import { ns } from '@lib/use-timestamp';
 
 import { InMemoryStorage } from './in-memory-storage';
 
@@ -27,26 +28,26 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
   });
 
@@ -54,24 +55,24 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) }
     ]);
   });
 
@@ -79,26 +80,26 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(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) }
+      { timestamp: ns(5), rate: d(5) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(1), rate: d(1) }
     ]);
   });
 
@@ -106,16 +107,16 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -124,23 +125,23 @@ describe(InMemoryStorage.name, () => {
       }
     });
 
-    expect(set).toEqual([{ timestamp: 4, rate: d(4) }]);
+    expect(set).toEqual([{ timestamp: ns(4), rate: d(4) }]);
   });
 
   test('save and read filtered lt data', async () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -150,8 +151,8 @@ describe(InMemoryStorage.name, () => {
     });
 
     expect(set).toEqual([
-      { timestamp: 1, rate: d(1) },
-      { timestamp: 2, rate: d(2) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) }
     ]);
   });
 
@@ -159,16 +160,16 @@ describe(InMemoryStorage.name, () => {
     const { sut } = fixtures;
 
     const pricing = Storage.createObject('pricing', {
-      timestamp: 'number',
+      timestamp: 'bigint',
       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) }
+      { timestamp: ns(1), rate: d(1) },
+      { timestamp: ns(2), rate: d(2) },
+      { timestamp: ns(3), rate: d(3) },
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
 
     const set = await sut.query(pricing, {
@@ -178,8 +179,8 @@ describe(InMemoryStorage.name, () => {
     });
 
     expect(set).toEqual([
-      { timestamp: 4, rate: d(4) },
-      { timestamp: 5, rate: d(5) }
+      { timestamp: ns(4), rate: d(4) },
+      { timestamp: ns(5), rate: d(5) }
     ]);
   });
 });

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

@@ -29,18 +29,35 @@ export class InMemoryStorage implements Storage {
 
         switch (expression?.type) {
           case 'eq':
-            set = set.filter(it => it[prop] === expression.value);
+            set = set.filter(it => it[prop] == expression.value);
             break;
           case 'gt':
-            set = set.filter(it => +it[prop] > expression.value);
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) > expression.value
+                : Number(value) > Number(expression.value);
+            });
             break;
           case 'lt':
-            set = set.filter(it => +it[prop] < expression.value);
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) < expression.value
+                : Number(value) < Number(expression.value);
+            });
             break;
           case 'between':
-            set = set.filter(
-              it => +it[prop] > expression.min && +it[prop] < expression.max
-            );
+            set = set.filter(it => {
+              const value = it[prop];
+
+              return typeof value === 'bigint'
+                ? BigInt(value) > expression.min && BigInt(value) < expression.max
+                : Number(value) > Number(expression.min) &&
+                    Number(value) < Number(expression.max);
+            });
             break;
         }
       }
@@ -71,7 +88,7 @@ export class InMemoryStorage implements Storage {
       buffer.push(document);
     }
 
-    buffer.sort((lhs, rhs) => lhs.timestamp - rhs.timestamp);
+    buffer.sort((lhs, rhs) => Number(lhs.timestamp - rhs.timestamp));
   }
 
   clear() {