rastack 0.0.16 → 0.0.19

package/sync/index.ts

@@ -1,8 +1,8 @@
-export * from "./types";
-export * from "./registry";
-export * from "./store";
-export * from "./persistence";
-export * from "./transactions";
-export * from "./engine";
-export * from "./provider";
-export * from "./hooks";
+export * from "./types";
+export * from "./registry";
+export * from "./store";
+export * from "./persistence";
+export * from "./transactions";
+export * from "./engine";
+export * from "./provider";
+export * from "./hooks";

package/sync/persistence.ts

@@ -1,237 +1,237 @@
-import { EntityKey, SyncTransaction } from "./types";
-
-/**
- * Durable storage behind the sync engine: entity rows, the transaction
- * queue, and cursor metadata. IndexedDB in the browser; an in-memory
- * fallback everywhere else (SSR, tests, unsupported browsers) so the
- * engine still runs — it just re-bootstraps on reload.
- */
-export interface SyncPersistence {
-  getMeta(key: string): Promise<any | undefined>;
-  setMeta(key: string, value: any): Promise<void>;
-  getRecords(entity: EntityKey): Promise<Record<string, any>[]>;
-  putRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void>;
-  deleteRecord(entity: EntityKey, id: string): Promise<void>;
-  replaceRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void>;
-  getTransactions(): Promise<SyncTransaction[]>;
-  putTransaction(txn: SyncTransaction): Promise<void>;
-  deleteTransaction(txnId: string): Promise<void>;
-  clear(): Promise<void>;
-}
-
-const RECORDS = "records";
-const TRANSACTIONS = "transactions";
-const META = "meta";
-
-class IndexedDbPersistence implements SyncPersistence {
-  private db: Promise<IDBDatabase>;
-
-  constructor(databaseName: string) {
-    this.db = new Promise((resolve, reject) => {
-      const request = indexedDB.open(databaseName, 1);
-      request.onupgradeneeded = () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains(RECORDS)) {
-          const records = db.createObjectStore(RECORDS, {
-            keyPath: ["entity", "id"],
-          });
-          records.createIndex("entity", "entity", { unique: false });
-        }
-        if (!db.objectStoreNames.contains(TRANSACTIONS)) {
-          db.createObjectStore(TRANSACTIONS, { keyPath: "txnId" });
-        }
-        if (!db.objectStoreNames.contains(META)) {
-          db.createObjectStore(META, { keyPath: "key" });
-        }
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  private async transaction(
-    stores: string[],
-    mode: IDBTransactionMode,
-  ): Promise<IDBTransaction> {
-    const db = await this.db;
-    return db.transaction(stores, mode);
-  }
-
-  private request<T>(request: IDBRequest<T>): Promise<T> {
-    return new Promise((resolve, reject) => {
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  private done(txn: IDBTransaction): Promise<void> {
-    return new Promise((resolve, reject) => {
-      txn.oncomplete = () => resolve();
-      txn.onerror = () => reject(txn.error);
-      txn.onabort = () => reject(txn.error);
-    });
-  }
-
-  async getMeta(key: string): Promise<any | undefined> {
-    const txn = await this.transaction([META], "readonly");
-    const row = await this.request(txn.objectStore(META).get(key));
-    return row ? (row as any).value : undefined;
-  }
-
-  async setMeta(key: string, value: any): Promise<void> {
-    const txn = await this.transaction([META], "readwrite");
-    txn.objectStore(META).put({ key, value });
-    await this.done(txn);
-  }
-
-  async getRecords(entity: EntityKey): Promise<Record<string, any>[]> {
-    const txn = await this.transaction([RECORDS], "readonly");
-    const index = txn.objectStore(RECORDS).index("entity");
-    const rows = await this.request(index.getAll(entity));
-    return (rows as any[]).map((row) => row.data);
-  }
-
-  async putRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void> {
-    const txn = await this.transaction([RECORDS], "readwrite");
-    const store = txn.objectStore(RECORDS);
-    rows.forEach(({ id, data }) => store.put({ entity, id, data }));
-    await this.done(txn);
-  }
-
-  async deleteRecord(entity: EntityKey, id: string): Promise<void> {
-    const txn = await this.transaction([RECORDS], "readwrite");
-    txn.objectStore(RECORDS).delete([entity, id]);
-    await this.done(txn);
-  }
-
-  async replaceRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void> {
-    const txn = await this.transaction([RECORDS], "readwrite");
-    const store = txn.objectStore(RECORDS);
-    const index = store.index("entity");
-    const keys = await this.request(index.getAllKeys(entity));
-    (keys as IDBValidKey[]).forEach((key) => store.delete(key));
-    rows.forEach(({ id, data }) => store.put({ entity, id, data }));
-    await this.done(txn);
-  }
-
-  async getTransactions(): Promise<SyncTransaction[]> {
-    const txn = await this.transaction([TRANSACTIONS], "readonly");
-    const rows = await this.request(txn.objectStore(TRANSACTIONS).getAll());
-    return (rows as SyncTransaction[]).sort(
-      (a, b) => a.createdAt - b.createdAt,
-    );
-  }
-
-  async putTransaction(transaction: SyncTransaction): Promise<void> {
-    const txn = await this.transaction([TRANSACTIONS], "readwrite");
-    txn.objectStore(TRANSACTIONS).put(transaction);
-    await this.done(txn);
-  }
-
-  async deleteTransaction(txnId: string): Promise<void> {
-    const txn = await this.transaction([TRANSACTIONS], "readwrite");
-    txn.objectStore(TRANSACTIONS).delete(txnId);
-    await this.done(txn);
-  }
-
-  async clear(): Promise<void> {
-    const txn = await this.transaction(
-      [RECORDS, TRANSACTIONS, META],
-      "readwrite",
-    );
-    txn.objectStore(RECORDS).clear();
-    txn.objectStore(TRANSACTIONS).clear();
-    txn.objectStore(META).clear();
-    await this.done(txn);
-  }
-}
-
-export class MemoryPersistence implements SyncPersistence {
-  private meta = new Map<string, any>();
-  private records = new Map<EntityKey, Map<string, Record<string, any>>>();
-  private transactions = new Map<string, SyncTransaction>();
-
-  private entityRecords(entity: EntityKey): Map<string, Record<string, any>> {
-    let rows = this.records.get(entity);
-    if (!rows) {
-      rows = new Map();
-      this.records.set(entity, rows);
-    }
-    return rows;
-  }
-
-  async getMeta(key: string): Promise<any | undefined> {
-    return this.meta.get(key);
-  }
-
-  async setMeta(key: string, value: any): Promise<void> {
-    this.meta.set(key, value);
-  }
-
-  async getRecords(entity: EntityKey): Promise<Record<string, any>[]> {
-    return Array.from(this.entityRecords(entity).values());
-  }
-
-  async putRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void> {
-    const store = this.entityRecords(entity);
-    rows.forEach(({ id, data }) => store.set(id, data));
-  }
-
-  async deleteRecord(entity: EntityKey, id: string): Promise<void> {
-    this.entityRecords(entity).delete(id);
-  }
-
-  async replaceRecords(
-    entity: EntityKey,
-    rows: { id: string; data: Record<string, any> }[],
-  ): Promise<void> {
-    const store = this.entityRecords(entity);
-    store.clear();
-    rows.forEach(({ id, data }) => store.set(id, data));
-  }
-
-  async getTransactions(): Promise<SyncTransaction[]> {
-    return Array.from(this.transactions.values()).sort(
-      (a, b) => a.createdAt - b.createdAt,
-    );
-  }
-
-  async putTransaction(txn: SyncTransaction): Promise<void> {
-    this.transactions.set(txn.txnId, txn);
-  }
-
-  async deleteTransaction(txnId: string): Promise<void> {
-    this.transactions.delete(txnId);
-  }
-
-  async clear(): Promise<void> {
-    this.meta.clear();
-    this.records.clear();
-    this.transactions.clear();
-  }
-}
-
-export function createPersistence(
-  persist: boolean,
-  databaseName: string,
-): SyncPersistence {
-  if (persist && typeof indexedDB !== "undefined") {
-    return new IndexedDbPersistence(databaseName);
-  }
-  return new MemoryPersistence();
-}
+import { EntityKey, SyncTransaction } from "./types";
+
+/**
+ * Durable storage behind the sync engine: entity rows, the transaction
+ * queue, and cursor metadata. IndexedDB in the browser; an in-memory
+ * fallback everywhere else (SSR, tests, unsupported browsers) so the
+ * engine still runs — it just re-bootstraps on reload.
+ */
+export interface SyncPersistence {
+  getMeta(key: string): Promise<any | undefined>;
+  setMeta(key: string, value: any): Promise<void>;
+  getRecords(entity: EntityKey): Promise<Record<string, any>[]>;
+  putRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void>;
+  deleteRecord(entity: EntityKey, id: string): Promise<void>;
+  replaceRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void>;
+  getTransactions(): Promise<SyncTransaction[]>;
+  putTransaction(txn: SyncTransaction): Promise<void>;
+  deleteTransaction(txnId: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+const RECORDS = "records";
+const TRANSACTIONS = "transactions";
+const META = "meta";
+
+class IndexedDbPersistence implements SyncPersistence {
+  private db: Promise<IDBDatabase>;
+
+  constructor(databaseName: string) {
+    this.db = new Promise((resolve, reject) => {
+      const request = indexedDB.open(databaseName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(RECORDS)) {
+          const records = db.createObjectStore(RECORDS, {
+            keyPath: ["entity", "id"],
+          });
+          records.createIndex("entity", "entity", { unique: false });
+        }
+        if (!db.objectStoreNames.contains(TRANSACTIONS)) {
+          db.createObjectStore(TRANSACTIONS, { keyPath: "txnId" });
+        }
+        if (!db.objectStoreNames.contains(META)) {
+          db.createObjectStore(META, { keyPath: "key" });
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  private async transaction(
+    stores: string[],
+    mode: IDBTransactionMode,
+  ): Promise<IDBTransaction> {
+    const db = await this.db;
+    return db.transaction(stores, mode);
+  }
+
+  private request<T>(request: IDBRequest<T>): Promise<T> {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+
+  private done(txn: IDBTransaction): Promise<void> {
+    return new Promise((resolve, reject) => {
+      txn.oncomplete = () => resolve();
+      txn.onerror = () => reject(txn.error);
+      txn.onabort = () => reject(txn.error);
+    });
+  }
+
+  async getMeta(key: string): Promise<any | undefined> {
+    const txn = await this.transaction([META], "readonly");
+    const row = await this.request(txn.objectStore(META).get(key));
+    return row ? (row as any).value : undefined;
+  }
+
+  async setMeta(key: string, value: any): Promise<void> {
+    const txn = await this.transaction([META], "readwrite");
+    txn.objectStore(META).put({ key, value });
+    await this.done(txn);
+  }
+
+  async getRecords(entity: EntityKey): Promise<Record<string, any>[]> {
+    const txn = await this.transaction([RECORDS], "readonly");
+    const index = txn.objectStore(RECORDS).index("entity");
+    const rows = await this.request(index.getAll(entity));
+    return (rows as any[]).map((row) => row.data);
+  }
+
+  async putRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void> {
+    const txn = await this.transaction([RECORDS], "readwrite");
+    const store = txn.objectStore(RECORDS);
+    rows.forEach(({ id, data }) => store.put({ entity, id, data }));
+    await this.done(txn);
+  }
+
+  async deleteRecord(entity: EntityKey, id: string): Promise<void> {
+    const txn = await this.transaction([RECORDS], "readwrite");
+    txn.objectStore(RECORDS).delete([entity, id]);
+    await this.done(txn);
+  }
+
+  async replaceRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void> {
+    const txn = await this.transaction([RECORDS], "readwrite");
+    const store = txn.objectStore(RECORDS);
+    const index = store.index("entity");
+    const keys = await this.request(index.getAllKeys(entity));
+    (keys as IDBValidKey[]).forEach((key) => store.delete(key));
+    rows.forEach(({ id, data }) => store.put({ entity, id, data }));
+    await this.done(txn);
+  }
+
+  async getTransactions(): Promise<SyncTransaction[]> {
+    const txn = await this.transaction([TRANSACTIONS], "readonly");
+    const rows = await this.request(txn.objectStore(TRANSACTIONS).getAll());
+    return (rows as SyncTransaction[]).sort(
+      (a, b) => a.createdAt - b.createdAt,
+    );
+  }
+
+  async putTransaction(transaction: SyncTransaction): Promise<void> {
+    const txn = await this.transaction([TRANSACTIONS], "readwrite");
+    txn.objectStore(TRANSACTIONS).put(transaction);
+    await this.done(txn);
+  }
+
+  async deleteTransaction(txnId: string): Promise<void> {
+    const txn = await this.transaction([TRANSACTIONS], "readwrite");
+    txn.objectStore(TRANSACTIONS).delete(txnId);
+    await this.done(txn);
+  }
+
+  async clear(): Promise<void> {
+    const txn = await this.transaction(
+      [RECORDS, TRANSACTIONS, META],
+      "readwrite",
+    );
+    txn.objectStore(RECORDS).clear();
+    txn.objectStore(TRANSACTIONS).clear();
+    txn.objectStore(META).clear();
+    await this.done(txn);
+  }
+}
+
+export class MemoryPersistence implements SyncPersistence {
+  private meta = new Map<string, any>();
+  private records = new Map<EntityKey, Map<string, Record<string, any>>>();
+  private transactions = new Map<string, SyncTransaction>();
+
+  private entityRecords(entity: EntityKey): Map<string, Record<string, any>> {
+    let rows = this.records.get(entity);
+    if (!rows) {
+      rows = new Map();
+      this.records.set(entity, rows);
+    }
+    return rows;
+  }
+
+  async getMeta(key: string): Promise<any | undefined> {
+    return this.meta.get(key);
+  }
+
+  async setMeta(key: string, value: any): Promise<void> {
+    this.meta.set(key, value);
+  }
+
+  async getRecords(entity: EntityKey): Promise<Record<string, any>[]> {
+    return Array.from(this.entityRecords(entity).values());
+  }
+
+  async putRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void> {
+    const store = this.entityRecords(entity);
+    rows.forEach(({ id, data }) => store.set(id, data));
+  }
+
+  async deleteRecord(entity: EntityKey, id: string): Promise<void> {
+    this.entityRecords(entity).delete(id);
+  }
+
+  async replaceRecords(
+    entity: EntityKey,
+    rows: { id: string; data: Record<string, any> }[],
+  ): Promise<void> {
+    const store = this.entityRecords(entity);
+    store.clear();
+    rows.forEach(({ id, data }) => store.set(id, data));
+  }
+
+  async getTransactions(): Promise<SyncTransaction[]> {
+    return Array.from(this.transactions.values()).sort(
+      (a, b) => a.createdAt - b.createdAt,
+    );
+  }
+
+  async putTransaction(txn: SyncTransaction): Promise<void> {
+    this.transactions.set(txn.txnId, txn);
+  }
+
+  async deleteTransaction(txnId: string): Promise<void> {
+    this.transactions.delete(txnId);
+  }
+
+  async clear(): Promise<void> {
+    this.meta.clear();
+    this.records.clear();
+    this.transactions.clear();
+  }
+}
+
+export function createPersistence(
+  persist: boolean,
+  databaseName: string,
+): SyncPersistence {
+  if (persist && typeof indexedDB !== "undefined") {
+    return new IndexedDbPersistence(databaseName);
+  }
+  return new MemoryPersistence();
+}

package/sync/provider.tsx

@@ -1,91 +1,91 @@
-import React, {
-  createContext,
-  ReactNode,
-  useContext,
-  useEffect,
-  useMemo,
-} from "react";
-import { AxiosInstance } from "axios";
-import { API } from "../hooks/query/api";
-import { SyncEngine } from "./engine";
-import { SyncEngineConfig } from "./types";
-
-interface RadSyncContextValue {
-  engine: SyncEngine;
-}
-
-const RadSyncContext = createContext<RadSyncContextValue | null>(null);
-
-export interface RadSyncProviderProps extends SyncEngineConfig {
-  children: ReactNode;
-  /** Axios instance to sync through. Defaults to the shared rastack API client. */
-  api?: AxiosInstance;
-  /** When provided, a Bearer token is attached to every request on the instance. */
-  getToken?: () => string | Promise<string>;
-  /** Start the engine on mount (default true). */
-  autoStart?: boolean;
-}
-
-/**
- * Mounts the sync engine for the app. This is the only client-side
- * configuration a consumer does — every generated hook finds the engine
- * through this context.
- */
-export function RadSyncProvider({
-  children,
-  api,
-  getToken,
-  autoStart = true,
-  ...config
-}: RadSyncProviderProps) {
-  const instance = api || API;
-  const engine = useMemo(
-    () => new SyncEngine(instance, config),
-    // The engine is created once for the provider's lifetime.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [instance],
-  );
-
-  useEffect(() => {
-    let interceptor: number | undefined;
-    if (getToken) {
-      interceptor = instance.interceptors.request.use(async (request) => {
-        const token = await getToken();
-        request.headers = request.headers || ({} as any);
-        (request.headers as any).Authorization = `Bearer ${token}`;
-        return request;
-      });
-    }
-    if (autoStart) {
-      void engine.start().catch(() => {
-        // Reported through config.onError and engine status.
-      });
-    }
-    return () => {
-      engine.stop();
-      if (interceptor !== undefined) {
-        instance.interceptors.request.eject(interceptor);
-      }
-    };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [engine]);
-
-  const value = useMemo(() => ({ engine }), [engine]);
-  return (
-    <RadSyncContext.Provider value={value}>{children}</RadSyncContext.Provider>
-  );
-}
-
-export function useSyncEngine(): SyncEngine {
-  const context = useContext(RadSyncContext);
-  if (!context) {
-    throw new Error(
-      "No RadSyncProvider found. Wrap your app in <RadSyncProvider> to use sync-mode entity hooks.",
-    );
-  }
-  return context.engine;
-}
-
-export function useSyncEngineOptional(): SyncEngine | null {
-  return useContext(RadSyncContext)?.engine ?? null;
-}
+import React, {
+  createContext,
+  ReactNode,
+  useContext,
+  useEffect,
+  useMemo,
+} from "react";
+import { AxiosInstance } from "axios";
+import { API } from "../hooks/query/api";
+import { SyncEngine } from "./engine";
+import { SyncEngineConfig } from "./types";
+
+interface RadSyncContextValue {
+  engine: SyncEngine;
+}
+
+const RadSyncContext = createContext<RadSyncContextValue | null>(null);
+
+export interface RadSyncProviderProps extends SyncEngineConfig {
+  children: ReactNode;
+  /** Axios instance to sync through. Defaults to the shared rastack API client. */
+  api?: AxiosInstance;
+  /** When provided, a Bearer token is attached to every request on the instance. */
+  getToken?: () => string | Promise<string>;
+  /** Start the engine on mount (default true). */
+  autoStart?: boolean;
+}
+
+/**
+ * Mounts the sync engine for the app. This is the only client-side
+ * configuration a consumer does — every generated hook finds the engine
+ * through this context.
+ */
+export function RadSyncProvider({
+  children,
+  api,
+  getToken,
+  autoStart = true,
+  ...config
+}: RadSyncProviderProps) {
+  const instance = api || API;
+  const engine = useMemo(
+    () => new SyncEngine(instance, config),
+    // The engine is created once for the provider's lifetime.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [instance],
+  );
+
+  useEffect(() => {
+    let interceptor: number | undefined;
+    if (getToken) {
+      interceptor = instance.interceptors.request.use(async (request) => {
+        const token = await getToken();
+        request.headers = request.headers || ({} as any);
+        (request.headers as any).Authorization = `Bearer ${token}`;
+        return request;
+      });
+    }
+    if (autoStart) {
+      void engine.start().catch(() => {
+        // Reported through config.onError and engine status.
+      });
+    }
+    return () => {
+      engine.stop();
+      if (interceptor !== undefined) {
+        instance.interceptors.request.eject(interceptor);
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [engine]);
+
+  const value = useMemo(() => ({ engine }), [engine]);
+  return (
+    <RadSyncContext.Provider value={value}>{children}</RadSyncContext.Provider>
+  );
+}
+
+export function useSyncEngine(): SyncEngine {
+  const context = useContext(RadSyncContext);
+  if (!context) {
+    throw new Error(
+      "No RadSyncProvider found. Wrap your app in <RadSyncProvider> to use sync-mode entity hooks.",
+    );
+  }
+  return context.engine;
+}
+
+export function useSyncEngineOptional(): SyncEngine | null {
+  return useContext(RadSyncContext)?.engine ?? null;
+}