@quantform/core 0.7.22 → 0.7.25

package/src/make-test-module.ts

@@ -1,10 +1,20 @@
-import { Observable, Subject } from 'rxjs';
+import { Observable } from 'rxjs';
 
-import { core } from '@lib/core';
 import { Dependency, Module } from '@lib/module';
 
+import { InMemoryStorageFactory, useStorageFactory } from './storage';
+import { useExecutionMode } from './use-execution-mode';
+import { ConsoleLoggerFactory, logger } from './use-logger';
+import { useMemo } from './use-memo';
+
 export async function makeTestModule(dependencies: Dependency[]) {
-  const module = new Module([...core(), ...dependencies]);
+  const module = new Module([
+    useMemo.options(),
+    logger(new ConsoleLoggerFactory()),
+    useExecutionMode.paperOptions({ recording: false }),
+    useStorageFactory.options(new InMemoryStorageFactory()),
+    ...dependencies
+  ]);
 
   const { act } = await module.awake();
 
@@ -14,11 +24,6 @@ export async function makeTestModule(dependencies: Dependency[]) {
   };
 }
 
-type MockableFunction = (...args: any[]) => any;
-
-export const mockedFunc = <Func extends MockableFunction>(mockedFunc: Func) =>
-  mockedFunc as jest.MockedFunction<typeof mockedFunc>;
-
 export function toArray<T>(observable: Observable<T>) {
   const array = Array.of<T | Error>();
 
@@ -47,16 +52,3 @@ export function toArray<T>(observable: Observable<T>) {
 }
 
 export type InferObservableType<T> = T extends Observable<infer U> ? U : never;
-
-export function mockSubject<
-  T extends jest.FunctionProperties<Required<T>>,
-  M extends keyof jest.FunctionProperties<Required<T>>
->(object: T, method: M) {
-  const subject = new Subject<
-    InferObservableType<ReturnType<jest.FunctionProperties<Required<T>>[M]>>
-  >();
-
-  jest.spyOn<T, M>(object, method).mockReturnValue(subject.asObservable() as any);
-
-  return subject;
-}

package/src/module.ts

@@ -37,9 +37,6 @@ function missingInjectionTokenError(token: InjectionToken) {
   return new Error(`Unable to resolve unregistered dependency: ${token.toString()}`);
 }
 
-/**
- *
- */
 let moduleLocalStorage = new AsyncLocalStorage<Module>();
 
 export function setAsyncLocalStorage(als: AsyncLocalStorage<Module>) {

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

@@ -1,10 +1,11 @@
 import { Dependency, useContext } from '@lib/module';
+import { Timestamp } from '@lib/use-timestamp';
 
 const injectionToken = Symbol('replay-options');
 
 type ReplayOptions = {
-  from: number;
-  to: number;
+  from: Timestamp<'ns'>;
+  to: Timestamp<'ns'>;
   limit?: number;
   storage?: string;
 };
@@ -13,7 +14,10 @@ type ReplayOptions = {
  *
  */
 export function replayOptions(
-  options: Omit<ReplayOptions, 'from' | 'to'> & { from: number; to: number }
+  options: Omit<ReplayOptions, 'from' | 'to'> & {
+    from: Timestamp<'ns'>;
+    to: Timestamp<'ns'>;
+  }
 ): Dependency {
   return {
     provide: injectionToken,

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';