@marktiderman/genesis-core 1.5.0 → 1.6.0

package/dist/chunk-OBUBP4BY.js

@@ -0,0 +1,556 @@
+import { capabilitiesQueryKey } from './chunk-BQOJX67X.js';
+
+// src/hooks/mutation-mode.ts
+var DEFAULT_UNDO_DELAY_MS = 5e3;
+function sameId(a, b) {
+  return a != null && b != null && String(a) === String(b);
+}
+function isListResult(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.data);
+}
+function isInfiniteLists(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.pages) && Array.isArray(value.pageParams);
+}
+function mapLists(key, hash, value, fn) {
+  if (key[1] === "list") return isListResult(value) ? fn(value, hash) : value;
+  if (key[1] !== "infinite" || !isInfiniteLists(value)) return value;
+  let changed = false;
+  let rowDelta = 0;
+  const pages = value.pages.map((page, i) => {
+    if (!isListResult(page)) return page;
+    const next = fn(page, `${hash}#${i}`);
+    if (next !== page) {
+      changed = true;
+      rowDelta += next.data.length - page.data.length;
+    }
+    return next;
+  });
+  if (!changed) return value;
+  const withTotals = value.pages.map((orig, i) => {
+    const page = pages[i];
+    if (!isListResult(page) || !isListResult(orig) || typeof orig.total !== "number") return page;
+    return { ...page, total: orig.total < 0 ? orig.total : Math.max(0, orig.total + rowDelta) };
+  });
+  return { ...value, pages: withTotals };
+}
+function listsIn(key, value) {
+  if (key[1] === "list") return isListResult(value) ? [value] : [];
+  if (key[1] === "infinite" && isInfiniteLists(value)) return value.pages.filter(isListResult);
+  return [];
+}
+function isDetailKeyFor(key, resource, id) {
+  return key[0] === resource && key[1] === "detail" && sameId(key[2], id);
+}
+function sameValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b;
+    return a.length === other.length && a.every((item, i) => sameValue(item, other[i]));
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every(
+    (k) => Object.prototype.hasOwnProperty.call(b, k) && sameValue(a[k], b[k])
+  );
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function cachedRecord(queryClient, resource, id) {
+  for (const [key, value] of queryClient.getQueriesData({ queryKey: [resource, "detail"] })) {
+    if (isDetailKeyFor(key, resource, id) && value && typeof value === "object") return value;
+  }
+  for (const [key, value] of queryClient.getQueriesData({ queryKey: [resource] })) {
+    for (const list of listsIn(key, value)) {
+      const found = list.data.find((row) => sameId(row.id, id));
+      if (found) return found;
+    }
+  }
+  return void 0;
+}
+var registries = /* @__PURE__ */ new WeakMap();
+var nextSeq = 0;
+function registryFor(queryClient) {
+  let reg = registries.get(queryClient);
+  if (!reg) {
+    reg = {
+      pending: /* @__PURE__ */ new Map(),
+      patches: [],
+      writes: [],
+      rowTails: /* @__PURE__ */ new Map(),
+      produced: /* @__PURE__ */ new WeakSet(),
+      writing: false
+    };
+    registries.set(queryClient, reg);
+  }
+  return reg;
+}
+function pendingWriteCount(queryClient, resource) {
+  return registries.get(queryClient)?.pending.get(resource) ?? 0;
+}
+function beginPending(reg, resource) {
+  reg.pending.set(resource, (reg.pending.get(resource) ?? 0) + 1);
+}
+function endPending(reg, resource) {
+  const left = Math.max(0, (reg.pending.get(resource) ?? 0) - 1);
+  if (left === 0) reg.pending.delete(resource);
+  else reg.pending.set(resource, left);
+}
+function invalidateResource(queryClient, resource) {
+  return queryClient.invalidateQueries({ queryKey: [resource] });
+}
+function setProduced(reg, queryClient, key, value) {
+  const wasWriting = reg.writing;
+  reg.writing = true;
+  try {
+    queryClient.setQueryData(key, value);
+  } finally {
+    reg.writing = wasWriting;
+  }
+  const stored = queryClient.getQueryData(key);
+  if (stored && typeof stored === "object") reg.produced.add(stored);
+}
+function applyUpdate(row, data) {
+  return { ...row, ...data, id: row.id };
+}
+function revertFields(row, data, before) {
+  const out = { ...row };
+  for (const k of Object.keys(data)) {
+    if (k === "id") continue;
+    if (k in before) out[k] = before[k];
+    else delete out[k];
+  }
+  return out;
+}
+function applyPatches(key, hash, value, patches) {
+  if (key[1] === "list" || key[1] === "infinite") {
+    return mapLists(key, hash, value, (list, listHash) => {
+      let rows = list.data;
+      let total = list.total;
+      let changed = false;
+      for (const p of patches) {
+        const index = rows.findIndex((row) => sameId(row.id, p.id));
+        if (index < 0) continue;
+        p.before.set(listHash, { row: rows[index], index });
+        if (p.kind === "update") {
+          rows = rows.slice();
+          rows[index] = applyUpdate(rows[index], p.data ?? {});
+        } else {
+          rows = rows.filter((_, i) => i !== index);
+          if (typeof total === "number" && total >= 0) total = Math.max(0, total - 1);
+        }
+        changed = true;
+      }
+      if (!changed) return list;
+      return typeof total === "number" ? { ...list, data: rows, total } : { ...list, data: rows };
+    });
+  }
+  if (key[1] === "detail" && value && typeof value === "object") {
+    let row = value;
+    let changed = false;
+    for (const p of patches) {
+      if (p.kind !== "update" || !sameId(key[2], p.id)) continue;
+      p.before.set(hash, { row, index: -1 });
+      row = applyUpdate(row, p.data ?? {});
+      changed = true;
+    }
+    return changed ? row : value;
+  }
+  return value;
+}
+function ensureListener(reg, queryClient) {
+  if (reg.unsubscribe) return;
+  reg.unsubscribe = queryClient.getQueryCache().subscribe((event) => {
+    if (reg.writing || event.type !== "updated" || event.action.type !== "success") return;
+    const { queryKey: key, queryHash: hash } = event.query;
+    const resource = key[0];
+    if (typeof resource !== "string") return;
+    const data = event.query.state.data;
+    if (!data || typeof data !== "object" || reg.produced.has(data)) return;
+    const patches = reg.patches.filter((p) => p.resource === resource);
+    if (patches.length === 0) return;
+    const next = applyPatches(key, hash, data, patches);
+    if (next !== data) setProduced(reg, queryClient, key, next);
+  });
+}
+function addPatch(reg, queryClient, patch) {
+  reg.patches.push(patch);
+  ensureListener(reg, queryClient);
+  for (const query of queryClient.getQueryCache().findAll({ queryKey: [patch.resource] })) {
+    const value = query.state.data;
+    const next = applyPatches(query.queryKey, query.queryHash, value, [patch]);
+    if (next !== value) setProduced(reg, queryClient, query.queryKey, next);
+  }
+}
+function dropPatchRecord(reg, patch) {
+  const index = reg.patches.indexOf(patch);
+  if (index >= 0) reg.patches.splice(index, 1);
+  if (reg.patches.length === 0 && reg.unsubscribe) {
+    reg.unsubscribe();
+    reg.unsubscribe = void 0;
+  }
+  return index;
+}
+function firstBefore(patch) {
+  for (const value of patch.before.values()) return value;
+  return void 0;
+}
+function retractPatch(reg, queryClient, patch) {
+  const index = dropPatchRecord(reg, patch);
+  if (index < 0) return;
+  const onRow = (p) => p.resource === patch.resource && sameId(p.id, patch.id);
+  const remaining = reg.patches.filter(onRow);
+  if (patch.kind === "update" && patch.data) {
+    for (const later of reg.patches.slice(index).filter(onRow)) {
+      for (const [hash, b] of later.before) {
+        const src = patch.before.get(hash) ?? firstBefore(patch);
+        if (src) later.before.set(hash, { ...b, row: revertFields(b.row, patch.data, src.row) });
+      }
+    }
+  }
+  const reapply = (row) => remaining.reduce((r, p) => p.kind === "update" ? applyUpdate(r, p.data ?? {}) : r, row);
+  for (const query of queryClient.getQueryCache().findAll({ queryKey: [patch.resource] })) {
+    const key = query.queryKey;
+    const value = query.state.data;
+    let next = value;
+    if (key[1] === "list" || key[1] === "infinite") {
+      next = mapLists(key, query.queryHash, value, (list, listHash) => {
+        const b = patch.before.get(listHash);
+        const at = list.data.findIndex((row) => sameId(row.id, patch.id));
+        if (patch.kind === "update") {
+          const src = b ?? firstBefore(patch);
+          if (at < 0 || !src || !patch.data) return list;
+          const rows2 = list.data.slice();
+          rows2[at] = reapply(revertFields(rows2[at], patch.data, src.row));
+          return { ...list, data: rows2 };
+        }
+        if (at >= 0 || !b || remaining.some((p) => p.kind === "delete")) return list;
+        const rows = list.data.slice();
+        rows.splice(Math.min(b.index, rows.length), 0, reapply(b.row));
+        return {
+          ...list,
+          data: rows,
+          ...typeof list.total === "number" && list.total >= 0 ? { total: list.total + 1 } : {}
+        };
+      });
+    } else if (key[1] === "detail" && patch.kind === "update" && patch.data && sameId(key[2], patch.id) && value && typeof value === "object") {
+      const src = patch.before.get(query.queryHash) ?? firstBefore(patch);
+      if (!src) continue;
+      next = reapply(revertFields(value, patch.data, src.row));
+    }
+    if (next !== value) setProduced(reg, queryClient, key, next);
+  }
+}
+function takeBack(reg, write) {
+  if (write.patch) retractPatch(reg, write.queryClient, write.patch);
+  if (!write.rowKey || write.kind !== "update" || !write.patch?.data) return;
+  const undone = write.patch.data;
+  const before = write.baseline ?? firstBefore(write.patch)?.row ?? {};
+  const later = reg.writes.filter(
+    (w) => w.seq > write.seq && w.rowKey === write.rowKey && w.kind === "update" && (w.state === "waiting" || w.state === "queued")
+  );
+  for (const w of later) {
+    if (!w.data) {
+      w.drop();
+      continue;
+    }
+    const rebased = {};
+    const removed = [];
+    for (const k of Object.keys(undone)) {
+      if (k === "id" || !(k in w.data)) continue;
+      const kept = sameValue(w.data[k], undone[k]) && w.baseline != null && sameValue(w.baseline[k], undone[k]);
+      if (!kept) continue;
+      if (k in before) rebased[k] = before[k];
+      else removed.push(k);
+    }
+    if (Object.keys(rebased).length === 0 && removed.length === 0) continue;
+    Object.assign(w.data, rebased);
+    for (const k of removed) delete w.data[k];
+    if (w.baseline) w.baseline = revertFields(w.baseline, undone, before);
+    if (w.patch) refreshFields(reg, w.queryClient, w.patch, [...Object.keys(rebased), ...removed]);
+  }
+}
+function refreshFields(reg, queryClient, patch, keys) {
+  const index = reg.patches.indexOf(patch);
+  if (index < 0 || !patch.data) return;
+  const data = patch.data;
+  const overridden = /* @__PURE__ */ new Set();
+  for (const p of reg.patches.slice(index + 1)) {
+    if (p.resource === patch.resource && sameId(p.id, patch.id) && p.data) {
+      for (const k of Object.keys(p.data)) overridden.add(k);
+    }
+  }
+  const fields = keys.filter((k) => !overridden.has(k));
+  if (fields.length === 0) return;
+  const fix = (row, hash) => {
+    const out = { ...row };
+    const before = (patch.before.get(hash) ?? firstBefore(patch))?.row;
+    for (const k of fields) {
+      if (k in data) out[k] = data[k];
+      else if (before && k in before) out[k] = before[k];
+      else delete out[k];
+    }
+    return out;
+  };
+  for (const query of queryClient.getQueryCache().findAll({ queryKey: [patch.resource] })) {
+    const key = query.queryKey;
+    const value = query.state.data;
+    let next = value;
+    if (key[1] === "list" || key[1] === "infinite") {
+      next = mapLists(key, query.queryHash, value, (list, listHash) => {
+        const at = list.data.findIndex((row) => sameId(row.id, patch.id));
+        if (at < 0) return list;
+        const rows = list.data.slice();
+        rows[at] = fix(rows[at], listHash);
+        return { ...list, data: rows };
+      });
+    } else if (key[1] === "detail" && sameId(key[2], patch.id) && value && typeof value === "object") {
+      next = fix(value, query.queryHash);
+    }
+    if (next !== value) setProduced(reg, queryClient, key, next);
+  }
+}
+var allWrites = /* @__PURE__ */ new Set();
+function servesKeepalive(write) {
+  const caps = write.queryClient.getQueryData(
+    capabilitiesQueryKey(write.provider, write.resource)
+  );
+  return caps?.keepaliveWrites === true;
+}
+function flushForUnload() {
+  const writes = [...allWrites].sort((a, b) => a.seq - b.seq);
+  for (const write of writes) {
+    if (write.state === "waiting" || write.state === "queued") write.flush(true);
+  }
+}
+function onBeforeUnload(event) {
+  flushForUnload();
+  const atRisk = [...allWrites].some((w) => w.state === "sending" && !(w.keepalive && servesKeepalive(w)));
+  if (!atRisk) return;
+  event.preventDefault();
+  event.returnValue = "";
+}
+function onPageHide() {
+  flushForUnload();
+}
+function track(write) {
+  allWrites.add(write);
+  if (allWrites.size === 1 && typeof window !== "undefined") {
+    window.addEventListener("beforeunload", onBeforeUnload);
+    window.addEventListener("pagehide", onPageHide);
+  }
+}
+function untrack(write) {
+  if (!allWrites.delete(write)) return;
+  if (allWrites.size === 0 && typeof window !== "undefined") {
+    window.removeEventListener("beforeunload", onBeforeUnload);
+    window.removeEventListener("pagehide", onPageHide);
+  }
+}
+var CAPABILITIES_QUERY = (provider, resource) => ({
+  // The same key as useCapabilities, so the answer is shared.
+  queryKey: capabilitiesQueryKey(provider, resource),
+  queryFn: () => provider.capabilities(resource),
+  staleTime: Infinity,
+  // A write may wait on this answer; an app's default retries would hold
+  // it for seconds.
+  retry: false
+});
+async function providerServesUndo(queryClient, provider, resource) {
+  if (!provider.undo || !provider.capabilities) return false;
+  try {
+    const caps = await queryClient.fetchQuery(CAPABILITIES_QUERY(provider, resource));
+    return caps?.undo === true;
+  } catch {
+    return false;
+  }
+}
+var DROPPED_WRITE_MESSAGE = "This change was not saved: it was made on top of an earlier change that was undone or failed. Please make it again.";
+async function executeWrite(args) {
+  const { queryClient, provider, resource, kind, id, mode, send, committed, failedLater } = args;
+  if (mode === "pessimistic") {
+    const { record } = await send({ data: args.data, keepalive: false });
+    await committed(record);
+    return { status: "committed", record };
+  }
+  const viaProviderUndo = mode === "undoable" && await providerServesUndo(queryClient, provider, resource);
+  if (provider.capabilities && !queryClient.getQueryData(capabilitiesQueryKey(provider, resource))) {
+    void queryClient.prefetchQuery(CAPABILITIES_QUERY(provider, resource));
+  }
+  const reg = registryFor(queryClient);
+  const hasRow = kind !== "create" && id != null;
+  const data = args.data ? { ...args.data } : void 0;
+  let patch;
+  if (hasRow && kind === "update" && data) patch = { resource, id, kind: "update", data, before: /* @__PURE__ */ new Map() };
+  else if (hasRow && kind === "delete") patch = { resource, id, kind: "delete", before: /* @__PURE__ */ new Map() };
+  const delayMs = Math.max(0, args.undoDelayMs ?? DEFAULT_UNDO_DELAY_MS);
+  let timer;
+  let resolveSent = () => {
+  };
+  const sent = new Promise((resolve) => {
+    resolveSent = resolve;
+  });
+  const write = {
+    seq: ++nextSeq,
+    queryClient,
+    provider,
+    resource,
+    kind,
+    rowKey: hasRow ? `${resource}\0${String(id)}` : void 0,
+    patch,
+    data: kind === "update" ? data : void 0,
+    baseline: hasRow ? cachedRecord(queryClient, resource, id) : void 0,
+    state: "queued",
+    keepalive: false,
+    dropped: false,
+    flush: () => {
+    },
+    drop: () => {
+    }
+  };
+  const settle = () => {
+    write.state = "done";
+    clearTimeout(timer);
+    const at = reg.writes.indexOf(write);
+    if (at >= 0) reg.writes.splice(at, 1);
+    untrack(write);
+    endPending(reg, resource);
+  };
+  const sendNow = async (keepalive) => {
+    if (write.state !== "queued") return;
+    write.state = "sending";
+    write.keepalive = keepalive;
+    let result;
+    try {
+      result = await send({ data: write.data, keepalive });
+    } catch (error) {
+      settle();
+      takeBack(reg, write);
+      void invalidateResource(queryClient, resource);
+      failedLater(asError(error));
+      resolveSent(void 0);
+      return;
+    }
+    if (patch) dropPatchRecord(reg, patch);
+    settle();
+    try {
+      await committed(result.record);
+    } catch (error) {
+      console.error(`[genesis] after-write callback failed for "${resource}":`, error);
+    }
+    resolveSent(result);
+  };
+  const enqueue = () => {
+    if (!write.rowKey) {
+      void sendNow(false);
+      return;
+    }
+    const key = write.rowKey;
+    const previous = reg.rowTails.get(key);
+    const run = () => sendNow(false);
+    const next = previous ? previous.then(run, run) : run();
+    reg.rowTails.set(key, next);
+    void next.finally(() => {
+      if (reg.rowTails.get(key) === next) reg.rowTails.delete(key);
+    });
+  };
+  write.flush = (unloading = false) => {
+    if (write.state === "waiting") {
+      clearTimeout(timer);
+      if (!unloading) {
+        for (const earlier of reg.writes) {
+          if (earlier.seq < write.seq && earlier.rowKey === write.rowKey && earlier.rowKey && earlier.state === "waiting") {
+            earlier.flush();
+          }
+        }
+      }
+      write.state = "queued";
+      if (unloading) void sendNow(true);
+      else enqueue();
+    } else if (write.state === "queued" && unloading) {
+      void sendNow(true);
+    }
+  };
+  write.drop = () => {
+    if (write.state !== "waiting" && write.state !== "queued") return;
+    write.dropped = true;
+    settle();
+    takeBack(reg, write);
+    void invalidateResource(queryClient, resource);
+    failedLater(new Error(DROPPED_WRITE_MESSAGE));
+    resolveSent(void 0);
+  };
+  beginPending(reg, resource);
+  reg.writes.push(write);
+  track(write);
+  if (patch) addPatch(reg, queryClient, patch);
+  if (mode === "optimistic") {
+    enqueue();
+    return { status: "applied" };
+  }
+  if (viaProviderUndo) {
+    enqueue();
+    void sent.then((result) => {
+      const auditId = result?.audit?.id;
+      if (!result || !args.onUndoable) return;
+      if (!auditId) {
+        console.warn(
+          `[genesis] "${resource}" serves undo, but its ${kind} returned no audit entry; no undo offered.`
+        );
+        return;
+      }
+      let undone = false;
+      args.onUndoable({
+        resource,
+        kind,
+        id: id ?? result.record?.id,
+        strategy: "provider",
+        delayMs,
+        commit: () => {
+        },
+        undo: async () => {
+          if (undone) return false;
+          undone = true;
+          let ok = true;
+          try {
+            await provider.undo(resource, { auditId });
+          } catch (error) {
+            ok = false;
+            failedLater(asError(error));
+          }
+          await invalidateResource(queryClient, resource);
+          return ok;
+        }
+      });
+    });
+    return { status: "applied" };
+  }
+  write.state = "waiting";
+  timer = setTimeout(() => write.flush(), delayMs);
+  args.onUndoable?.({
+    resource,
+    kind,
+    id,
+    strategy: "delay",
+    delayMs,
+    commit: () => write.flush(),
+    undo: async () => {
+      if (write.dropped) return true;
+      if (write.state !== "waiting") return false;
+      settle();
+      takeBack(reg, write);
+      void invalidateResource(queryClient, resource);
+      resolveSent(void 0);
+      return true;
+    }
+  });
+  return { status: "applied" };
+}
+
+export { DEFAULT_UNDO_DELAY_MS, DROPPED_WRITE_MESSAGE, cachedRecord, executeWrite, invalidateResource, pendingWriteCount, providerServesUndo, sameValue };
+//# sourceMappingURL=chunk-OBUBP4BY.js.map
+//# sourceMappingURL=chunk-OBUBP4BY.js.map