rastack 0.0.16 → 0.0.19

package/sync/transactions.ts

@@ -1,300 +1,300 @@
-import { AxiosInstance } from "axios";
-import { SyncPersistence } from "./persistence";
-import { SyncStore } from "./store";
-import {
-  EntityDescriptor,
-  EntityKey,
-  SyncTransaction,
-  TransactionOp,
-} from "./types";
-
-export function randomId(): string {
-  const cryptoObject =
-    typeof crypto !== "undefined" ? (crypto as Crypto) : undefined;
-  if (cryptoObject && typeof cryptoObject.randomUUID === "function") {
-    return cryptoObject.randomUUID();
-  }
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
-
-/** RFC 4122 v4 UUID — always a server-acceptable UUID (unlike randomId's fallback). */
-export function uuid4(): string {
-  const cryptoObject =
-    typeof crypto !== "undefined" ? (crypto as Crypto) : undefined;
-  if (cryptoObject && typeof cryptoObject.randomUUID === "function") {
-    return cryptoObject.randomUUID();
-  }
-  const bytes = new Uint8Array(16);
-  if (cryptoObject && typeof cryptoObject.getRandomValues === "function") {
-    cryptoObject.getRandomValues(bytes);
-  } else {
-    for (let i = 0; i < 16; i += 1) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-  bytes[6] = (bytes[6] & 0x0f) | 0x40;
-  bytes[8] = (bytes[8] & 0x3f) | 0x80;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
-  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex
-    .slice(6, 8)
-    .join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
-}
-
-export function tempId(): string {
-  return `tmp_${randomId()}`;
-}
-
-export function isTempId(id: string): boolean {
-  return id.startsWith("tmp_");
-}
-
-interface TransactionQueueDeps {
-  api: AxiosInstance;
-  persistence: SyncPersistence;
-  store: SyncStore;
-  getEntity: (key: EntityKey) => EntityDescriptor | undefined;
-  onError?: (error: unknown, txn: SyncTransaction) => void;
-}
-
-interface EnqueueInput {
-  entity: EntityKey;
-  op: TransactionOp;
-  id: string;
-  method: SyncTransaction["method"];
-  url: string;
-  payload: Record<string, any> | null;
-  original: Record<string, any> | null;
-}
-
-/**
- * The optimistic write path. Changes apply to the in-memory store
- * immediately, persist to the local transaction log (so offline writes
- * survive reload), then replay through the normal generated REST endpoints
- * in order. Server rejection (4xx) rolls the optimistic change back;
- * network failure retries with backoff and resumes on reconnect.
- */
-export class TransactionQueue {
-  private pending: SyncTransaction[] = [];
-  private idAliases = new Map<string, string>();
-  private settlers = new Map<
-    string,
-    { resolve: (data: any) => void; reject: (error: unknown) => void }
-  >();
-  private flushing = false;
-  private retryTimer: ReturnType<typeof setTimeout> | null = null;
-  private retryDelay = 1000;
-
-  constructor(private deps: TransactionQueueDeps) {}
-
-  /** Load persisted transactions after a reload and re-apply their optimistic effect. */
-  async resume(): Promise<void> {
-    const persisted = await this.deps.persistence.getTransactions();
-    for (const txn of persisted) {
-      if (txn.status === "completed") {
-        // Server already confirmed it before the reload; catch-up sync will
-        // deliver the authoritative row, so the log entry is done.
-        await this.deps.persistence.deleteTransaction(txn.txnId);
-        continue;
-      }
-      txn.status = "queued";
-      this.pending.push(txn);
-      this.applyOptimistic(txn);
-    }
-    void this.flush();
-  }
-
-  async enqueue(input: EnqueueInput): Promise<any> {
-    const txn: SyncTransaction = {
-      txnId: randomId(),
-      status: "queued",
-      createdAt: Date.now(),
-      ...input,
-    };
-    this.applyOptimistic(txn);
-    this.pending.push(txn);
-    await this.deps.persistence.putTransaction(txn);
-    const settled = new Promise<any>((resolve, reject) => {
-      this.settlers.set(txn.txnId, { resolve, reject });
-    });
-    void this.flush();
-    return settled;
-  }
-
-  /** Pending (not yet server-confirmed) transactions touching a row — used for rebase. */
-  pendingFor(entity: EntityKey, id: string): SyncTransaction[] {
-    return this.pending.filter(
-      (txn) =>
-        txn.entity === entity &&
-        (txn.id === id || this.idAliases.get(txn.id) === id) &&
-        txn.status !== "completed",
-    );
-  }
-
-  /** A server delta touched this row: confirmed transactions for it are fully synced. */
-  async resolveForRow(entity: EntityKey, id: string): Promise<void> {
-    const done = this.pending.filter(
-      (txn) =>
-        txn.entity === entity &&
-        (txn.id === id || this.idAliases.get(txn.id) === id) &&
-        txn.status === "completed",
-    );
-    for (const txn of done) {
-      this.pending = this.pending.filter((item) => item !== txn);
-      await this.deps.persistence.deleteTransaction(txn.txnId);
-    }
-  }
-
-  hasPending(): boolean {
-    return this.pending.some((txn) => txn.status !== "completed");
-  }
-
-  resolveAlias(id: string): string {
-    return this.idAliases.get(id) || id;
-  }
-
-  wake(): void {
-    this.retryDelay = 1000;
-    void this.flush();
-  }
-
-  private applyOptimistic(txn: SyncTransaction): void {
-    const { store, getEntity } = this.deps;
-    const entity = getEntity(txn.entity);
-    const idField = entity?.idField || "id";
-    if (txn.op === "create") {
-      store.upsert(txn.entity, txn.id, {
-        [idField]: txn.id,
-        ...(txn.payload || {}),
-      });
-    } else if (txn.op === "update") {
-      store.merge(txn.entity, txn.id, txn.payload || {});
-    } else if (txn.op === "delete") {
-      store.remove(txn.entity, txn.id);
-    }
-  }
-
-  private rollback(txn: SyncTransaction): void {
-    const { store } = this.deps;
-    if (txn.op === "create") {
-      store.remove(txn.entity, txn.id);
-    } else if (txn.op === "update" && txn.original) {
-      store.merge(txn.entity, txn.id, txn.original);
-    } else if (txn.op === "delete" && txn.original) {
-      store.upsert(txn.entity, txn.id, txn.original);
-    }
-  }
-
-  private rewriteTempIds(txn: SyncTransaction): void {
-    const realId = this.idAliases.get(txn.id);
-    if (!realId) {
-      return;
-    }
-    txn.url = txn.url.split(txn.id).join(realId);
-    if (txn.payload) {
-      Object.keys(txn.payload).forEach((key) => {
-        if (txn.payload![key] === txn.id) {
-          txn.payload![key] = realId;
-        }
-      });
-    }
-    txn.id = realId;
-  }
-
-  private async flush(): Promise<void> {
-    if (this.flushing) {
-      return;
-    }
-    this.flushing = true;
-    try {
-      for (;;) {
-        const txn = this.pending.find((item) => item.status === "queued");
-        if (!txn) {
-          break;
-        }
-        if (typeof navigator !== "undefined" && navigator.onLine === false) {
-          break;
-        }
-        this.rewriteTempIds(txn);
-        txn.status = "inflight";
-        await this.deps.persistence.putTransaction(txn);
-        try {
-          const response = await this.send(txn);
-          await this.confirm(txn, response);
-          this.retryDelay = 1000;
-        } catch (error: any) {
-          const status = error?.response?.status;
-          const isRejection =
-            typeof status === "number" &&
-            status >= 400 &&
-            status < 500 &&
-            status !== 408 &&
-            status !== 429;
-          if (isRejection) {
-            // The server refused the write (validation, permissions):
-            // roll the optimistic change back and surface the error.
-            this.rollback(txn);
-            this.pending = this.pending.filter((item) => item !== txn);
-            await this.deps.persistence.deleteTransaction(txn.txnId);
-            this.settlers.get(txn.txnId)?.reject(error);
-            this.settlers.delete(txn.txnId);
-            this.deps.onError?.(error, txn);
-          } else {
-            // Network failure or server trouble: keep the optimistic state,
-            // stay queued, retry with backoff.
-            txn.status = "queued";
-            await this.deps.persistence.putTransaction(txn);
-            this.scheduleRetry();
-            break;
-          }
-        }
-      }
-    } finally {
-      this.flushing = false;
-    }
-  }
-
-  private async send(txn: SyncTransaction): Promise<any> {
-    const { api } = this.deps;
-    switch (txn.method) {
-      case "post":
-        return (await api.post(txn.url, txn.payload)).data;
-      case "put":
-        return (await api.put(txn.url, txn.payload)).data;
-      case "patch":
-        return (await api.patch(txn.url, txn.payload)).data;
-      case "delete":
-        return (await api.delete(txn.url)).data;
-      default:
-        throw new Error(`Unsupported method: ${txn.method}`);
-    }
-  }
-
-  private async confirm(txn: SyncTransaction, response: any): Promise<void> {
-    const entity = this.deps.getEntity(txn.entity);
-    const idField = entity?.idField || "id";
-    if (txn.op === "create" && response && response[idField] !== undefined) {
-      const realId = String(response[idField]);
-      if (isTempId(txn.id) && realId !== txn.id) {
-        this.idAliases.set(txn.id, realId);
-        this.deps.store.replaceId(txn.entity, txn.id, realId);
-        this.deps.store.merge(txn.entity, realId, response);
-        txn.id = realId;
-      }
-    }
-    txn.status = "completed";
-    await this.deps.persistence.putTransaction(txn);
-    this.settlers.get(txn.txnId)?.resolve(response);
-    this.settlers.delete(txn.txnId);
-  }
-
-  private scheduleRetry(): void {
-    if (this.retryTimer) {
-      return;
-    }
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = null;
-      void this.flush();
-    }, this.retryDelay);
-    this.retryDelay = Math.min(this.retryDelay * 2, 30000);
-  }
-}
+import { AxiosInstance } from "axios";
+import { SyncPersistence } from "./persistence";
+import { SyncStore } from "./store";
+import {
+  EntityDescriptor,
+  EntityKey,
+  SyncTransaction,
+  TransactionOp,
+} from "./types";
+
+export function randomId(): string {
+  const cryptoObject =
+    typeof crypto !== "undefined" ? (crypto as Crypto) : undefined;
+  if (cryptoObject && typeof cryptoObject.randomUUID === "function") {
+    return cryptoObject.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** RFC 4122 v4 UUID — always a server-acceptable UUID (unlike randomId's fallback). */
+export function uuid4(): string {
+  const cryptoObject =
+    typeof crypto !== "undefined" ? (crypto as Crypto) : undefined;
+  if (cryptoObject && typeof cryptoObject.randomUUID === "function") {
+    return cryptoObject.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (cryptoObject && typeof cryptoObject.getRandomValues === "function") {
+    cryptoObject.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i += 1) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = (bytes[6] & 0x0f) | 0x40;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex
+    .slice(6, 8)
+    .join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+
+export function tempId(): string {
+  return `tmp_${randomId()}`;
+}
+
+export function isTempId(id: string): boolean {
+  return id.startsWith("tmp_");
+}
+
+interface TransactionQueueDeps {
+  api: AxiosInstance;
+  persistence: SyncPersistence;
+  store: SyncStore;
+  getEntity: (key: EntityKey) => EntityDescriptor | undefined;
+  onError?: (error: unknown, txn: SyncTransaction) => void;
+}
+
+interface EnqueueInput {
+  entity: EntityKey;
+  op: TransactionOp;
+  id: string;
+  method: SyncTransaction["method"];
+  url: string;
+  payload: Record<string, any> | null;
+  original: Record<string, any> | null;
+}
+
+/**
+ * The optimistic write path. Changes apply to the in-memory store
+ * immediately, persist to the local transaction log (so offline writes
+ * survive reload), then replay through the normal generated REST endpoints
+ * in order. Server rejection (4xx) rolls the optimistic change back;
+ * network failure retries with backoff and resumes on reconnect.
+ */
+export class TransactionQueue {
+  private pending: SyncTransaction[] = [];
+  private idAliases = new Map<string, string>();
+  private settlers = new Map<
+    string,
+    { resolve: (data: any) => void; reject: (error: unknown) => void }
+  >();
+  private flushing = false;
+  private retryTimer: ReturnType<typeof setTimeout> | null = null;
+  private retryDelay = 1000;
+
+  constructor(private deps: TransactionQueueDeps) {}
+
+  /** Load persisted transactions after a reload and re-apply their optimistic effect. */
+  async resume(): Promise<void> {
+    const persisted = await this.deps.persistence.getTransactions();
+    for (const txn of persisted) {
+      if (txn.status === "completed") {
+        // Server already confirmed it before the reload; catch-up sync will
+        // deliver the authoritative row, so the log entry is done.
+        await this.deps.persistence.deleteTransaction(txn.txnId);
+        continue;
+      }
+      txn.status = "queued";
+      this.pending.push(txn);
+      this.applyOptimistic(txn);
+    }
+    void this.flush();
+  }
+
+  async enqueue(input: EnqueueInput): Promise<any> {
+    const txn: SyncTransaction = {
+      txnId: randomId(),
+      status: "queued",
+      createdAt: Date.now(),
+      ...input,
+    };
+    this.applyOptimistic(txn);
+    this.pending.push(txn);
+    await this.deps.persistence.putTransaction(txn);
+    const settled = new Promise<any>((resolve, reject) => {
+      this.settlers.set(txn.txnId, { resolve, reject });
+    });
+    void this.flush();
+    return settled;
+  }
+
+  /** Pending (not yet server-confirmed) transactions touching a row — used for rebase. */
+  pendingFor(entity: EntityKey, id: string): SyncTransaction[] {
+    return this.pending.filter(
+      (txn) =>
+        txn.entity === entity &&
+        (txn.id === id || this.idAliases.get(txn.id) === id) &&
+        txn.status !== "completed",
+    );
+  }
+
+  /** A server delta touched this row: confirmed transactions for it are fully synced. */
+  async resolveForRow(entity: EntityKey, id: string): Promise<void> {
+    const done = this.pending.filter(
+      (txn) =>
+        txn.entity === entity &&
+        (txn.id === id || this.idAliases.get(txn.id) === id) &&
+        txn.status === "completed",
+    );
+    for (const txn of done) {
+      this.pending = this.pending.filter((item) => item !== txn);
+      await this.deps.persistence.deleteTransaction(txn.txnId);
+    }
+  }
+
+  hasPending(): boolean {
+    return this.pending.some((txn) => txn.status !== "completed");
+  }
+
+  resolveAlias(id: string): string {
+    return this.idAliases.get(id) || id;
+  }
+
+  wake(): void {
+    this.retryDelay = 1000;
+    void this.flush();
+  }
+
+  private applyOptimistic(txn: SyncTransaction): void {
+    const { store, getEntity } = this.deps;
+    const entity = getEntity(txn.entity);
+    const idField = entity?.idField || "id";
+    if (txn.op === "create") {
+      store.upsert(txn.entity, txn.id, {
+        [idField]: txn.id,
+        ...(txn.payload || {}),
+      });
+    } else if (txn.op === "update") {
+      store.merge(txn.entity, txn.id, txn.payload || {});
+    } else if (txn.op === "delete") {
+      store.remove(txn.entity, txn.id);
+    }
+  }
+
+  private rollback(txn: SyncTransaction): void {
+    const { store } = this.deps;
+    if (txn.op === "create") {
+      store.remove(txn.entity, txn.id);
+    } else if (txn.op === "update" && txn.original) {
+      store.merge(txn.entity, txn.id, txn.original);
+    } else if (txn.op === "delete" && txn.original) {
+      store.upsert(txn.entity, txn.id, txn.original);
+    }
+  }
+
+  private rewriteTempIds(txn: SyncTransaction): void {
+    const realId = this.idAliases.get(txn.id);
+    if (!realId) {
+      return;
+    }
+    txn.url = txn.url.split(txn.id).join(realId);
+    if (txn.payload) {
+      Object.keys(txn.payload).forEach((key) => {
+        if (txn.payload![key] === txn.id) {
+          txn.payload![key] = realId;
+        }
+      });
+    }
+    txn.id = realId;
+  }
+
+  private async flush(): Promise<void> {
+    if (this.flushing) {
+      return;
+    }
+    this.flushing = true;
+    try {
+      for (;;) {
+        const txn = this.pending.find((item) => item.status === "queued");
+        if (!txn) {
+          break;
+        }
+        if (typeof navigator !== "undefined" && navigator.onLine === false) {
+          break;
+        }
+        this.rewriteTempIds(txn);
+        txn.status = "inflight";
+        await this.deps.persistence.putTransaction(txn);
+        try {
+          const response = await this.send(txn);
+          await this.confirm(txn, response);
+          this.retryDelay = 1000;
+        } catch (error: any) {
+          const status = error?.response?.status;
+          const isRejection =
+            typeof status === "number" &&
+            status >= 400 &&
+            status < 500 &&
+            status !== 408 &&
+            status !== 429;
+          if (isRejection) {
+            // The server refused the write (validation, permissions):
+            // roll the optimistic change back and surface the error.
+            this.rollback(txn);
+            this.pending = this.pending.filter((item) => item !== txn);
+            await this.deps.persistence.deleteTransaction(txn.txnId);
+            this.settlers.get(txn.txnId)?.reject(error);
+            this.settlers.delete(txn.txnId);
+            this.deps.onError?.(error, txn);
+          } else {
+            // Network failure or server trouble: keep the optimistic state,
+            // stay queued, retry with backoff.
+            txn.status = "queued";
+            await this.deps.persistence.putTransaction(txn);
+            this.scheduleRetry();
+            break;
+          }
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+
+  private async send(txn: SyncTransaction): Promise<any> {
+    const { api } = this.deps;
+    switch (txn.method) {
+      case "post":
+        return (await api.post(txn.url, txn.payload)).data;
+      case "put":
+        return (await api.put(txn.url, txn.payload)).data;
+      case "patch":
+        return (await api.patch(txn.url, txn.payload)).data;
+      case "delete":
+        return (await api.delete(txn.url)).data;
+      default:
+        throw new Error(`Unsupported method: ${txn.method}`);
+    }
+  }
+
+  private async confirm(txn: SyncTransaction, response: any): Promise<void> {
+    const entity = this.deps.getEntity(txn.entity);
+    const idField = entity?.idField || "id";
+    if (txn.op === "create" && response && response[idField] !== undefined) {
+      const realId = String(response[idField]);
+      if (isTempId(txn.id) && realId !== txn.id) {
+        this.idAliases.set(txn.id, realId);
+        this.deps.store.replaceId(txn.entity, txn.id, realId);
+        this.deps.store.merge(txn.entity, realId, response);
+        txn.id = realId;
+      }
+    }
+    txn.status = "completed";
+    await this.deps.persistence.putTransaction(txn);
+    this.settlers.get(txn.txnId)?.resolve(response);
+    this.settlers.delete(txn.txnId);
+  }
+
+  private scheduleRetry(): void {
+    if (this.retryTimer) {
+      return;
+    }
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.flush();
+    }, this.retryDelay);
+    this.retryDelay = Math.min(this.retryDelay * 2, 30000);
+  }
+}