botversion-sdk 2.2.2 → 2.3.0

package/undo/lib/capture-prisma-mongo.js

@@ -0,0 +1,297 @@
+// lib/capture-prisma-mongo.js
+"use strict";
+// PRISMA + MONGODB CAPTURE: saves before/after rows of a tagged write, then runs the host's write.
+// MongoDB has no transaction around Prisma's raw commands, so snapshots are saved just BEFORE the write.
+// Anything that fails before the write can still block it; after the write it is only logged (the write already ran).
+// Logs: model names, counts and reasons only.
+
+const log = require("./log");
+const store = require("./snapshot-store");
+const ms = require("./snapshot-store-prisma-mongo");
+
+const MAX_DEPTH = 5; // how many levels of linked rows a delete may reach
+
+// Same text for equal rows: sorted keys, dates as ISO text, big numbers as text.
+function canon(v) {
+  return JSON.stringify(v, (k, val) => {
+    if (typeof val === "bigint") return val.toString();
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const o = {};
+      for (const key of Object.keys(val).sort()) o[key] = val[key];
+      return o;
+    }
+    return val;
+  });
+}
+
+// Embedded (composite) types are not part of the saved columns, so a model that uses them cannot be restored fully.
+function hasComposite(base, model) {
+  const dm = base && base._runtimeDataModel;
+  const m = dm && dm.models && dm.models[model];
+  return !m || m.fields.some((f) => f.kind === "object" && !f.relationName);
+}
+
+// Works out every row a delete will remove or change (through links). Saves nothing. Throws Skip when unsafe.
+async function planDelete(ctx) {
+  const { base, model, operation, args, info, h } = ctx;
+  const { Skip } = h;
+  const acc = h.lower(model);
+  const g = h.getGraph();
+  if (!g) throw new Skip("foreign-key links could not be read");
+
+  let roots;
+  if (operation === "delete") {
+    const row = await base[acc].findUnique({ where: args.where });
+    roots = row ? [row] : [];
+  } else {
+    roots = await base[acc].findMany({
+      where: args && args.where,
+      take: store.ROW_LIMIT + 1,
+    });
+  }
+  const c = store.checkCapturable({
+    rowCount: roots.length,
+    primaryKeyColumns: info.pkFields,
+  });
+  if (!c.ok) throw new Skip(c.reason);
+
+  // kind "delete" = removed (Cascade); kind "update" = link cleared (SetNull / SetDefault).
+  const groups = [{ model, info, rows: roots, depth: 0, kind: "delete" }];
+  const tag = (m, i, r) => m + "\u0002" + h.keyOf(r, i.pkFields);
+  const deletedAt = new Map();
+  const cleared = new Set();
+  for (const r of roots) deletedAt.set(tag(model, info, r), 0);
+  let frontier = roots.length ? [groups[0]] : [];
+  let total = roots.length;
+  for (let depth = 1; frontier.length; depth++) {
+    const next = [];
+    for (const parent of frontier) {
+      for (const link of g.get(parent.model) || []) {
+        const cascades = link.rule === "Cascade";
+        if (!cascades && link.rule !== "SetNull" && link.rule !== "SetDefault")
+          continue; // Restrict / NoAction: refused by Prisma itself
+        const cInfo = h.modelInfo(base, link.child);
+        if (!cInfo) throw new Skip("model information not available");
+        if (hasComposite(base, link.child))
+          throw new Skip(
+            "a linked model uses embedded (composite) types, which cannot be saved yet",
+          );
+        const found = await base[h.lower(link.child)].findMany({
+          where: {
+            OR: parent.rows.map((r) => {
+              const w = {};
+              link.fromFields.forEach((n, i) => {
+                w[n] = r[link.toFields[i]];
+              });
+              return w;
+            }),
+          },
+          take: store.ROW_LIMIT + 1,
+        });
+        if (!found.length) continue;
+        if (depth > MAX_DEPTH) throw new Skip("links go too deep");
+        const cc = store.checkCapturable({
+          rowCount: found.length,
+          primaryKeyColumns: cInfo.pkFields,
+        });
+        if (!cc.ok) throw new Skip(cc.reason);
+        const fresh = [];
+        for (const r of found) {
+          const k = tag(link.child, cInfo, r);
+          if (cascades) {
+            if (deletedAt.has(k)) {
+              if (deletedAt.get(k) !== depth)
+                throw new Skip(
+                  "a row is reached through links of different depth",
+                );
+              continue;
+            }
+            deletedAt.set(k, depth);
+          } else {
+            if (cleared.has(k)) continue;
+            cleared.add(k);
+          }
+          fresh.push(r);
+        }
+        total += fresh.length;
+        if (total > store.ROW_LIMIT) throw new Skip("too-many-rows");
+        if (!fresh.length) continue;
+        const grp = {
+          model: link.child,
+          info: cInfo,
+          rows: fresh,
+          depth,
+          kind: cascades ? "delete" : "update",
+        };
+        groups.push(grp);
+        if (cascades) next.push(grp);
+      }
+    }
+    frontier = next;
+  }
+  // A row that is deleted does not also need its link cleared.
+  for (const gr of groups) {
+    if (gr.kind === "update")
+      gr.rows = gr.rows.filter(
+        (r) => !deletedAt.has(tag(gr.model, gr.info, r)),
+      );
+  }
+  return groups.filter((gr) => gr.rows.length);
+}
+
+// After the write: keep only the snapshots of rows this write really changed or removed. Returns how many were kept.
+async function settleGroup(base, h, model, gInfo, items, kind) {
+  const now = await base[h.lower(model)].findMany({
+    where: { OR: items.map((s) => h.pkWhere(gInfo, s.row)) },
+  });
+  const byKey = new Map(now.map((r) => [h.keyOf(r, gInfo.pkFields), r]));
+  const drop = [];
+  let kept = 0;
+  for (const s of items) {
+    const cur = byKey.get(h.keyOf(s.row, gInfo.pkFields));
+    if (kind === "delete") {
+      if (cur)
+        drop.push(s.id); // still there: this write did not delete it
+      else kept++;
+      continue;
+    }
+    if (
+      !cur ||
+      canon(h.toColumns(gInfo, cur)) === canon(h.toColumns(gInfo, s.row))
+    ) {
+      drop.push(s.id); // unchanged (or gone): nothing of this write to undo
+      continue;
+    }
+    const r = await ms.saveAfter(base, s.id, h.toColumns(gInfo, cur));
+    if (r.ok) kept++;
+  }
+  await ms.deleteByIds(base, drop);
+  return kept;
+}
+
+// Returns { result, rows }. Throws h.Skip before the write when it cannot be saved; rethrows the host's own error.
+async function run(ctx) {
+  const { base, model, operation, args, info, st, h } = ctx;
+  const { Skip } = h;
+  const acc = h.lower(model);
+
+  if (hasComposite(base, model))
+    throw new Skip(
+      "this model uses embedded (composite) types, which cannot be saved yet",
+    );
+  const ready = await ms.ensureReady(base);
+  if (!ready.ok) throw new Skip(ready.reason);
+
+  const hostWrite = async () => {
+    try {
+      return await base[acc][operation](args);
+    } catch (e) {
+      h.onHostError(e); // the host must see its own error
+      throw e;
+    }
+  };
+  const afterFailed = (why) => {
+    st.unsaved = true; // the write already ran without a complete snapshot
+  };
+
+  // Saves one snapshot. If it cannot be saved, removes what was saved so far (a half-saved set could restore only part of the data).
+  const savedIds = [];
+  const save = async (gInfo, row, kind, linked, after) => {
+    const r = await ms.saveSnapshot(base, st, {
+      table: gInfo.table,
+      operation: kind,
+      primaryKey: h.pkObject(gInfo, row),
+      before: kind === "insert" ? null : h.toColumns(gInfo, row),
+      after: after || null,
+      isLinked: linked,
+    });
+    if (!r.ok) {
+      await ms.deleteByIds(base, savedIds);
+      throw new Skip(r.reason);
+    }
+    savedIds.push(r.id);
+    return r.id;
+  };
+
+  // Runs the host's write, then settle(result). Problems after the write are only logged.
+  const finish = async (settle, runOnError) => {
+    let result;
+    let hostErr = null;
+    try {
+      result = await hostWrite();
+    } catch (e) {
+      hostErr = e;
+    }
+    let rows = 0;
+    if (!hostErr || runOnError) {
+      try {
+        rows = await settle(result);
+      } catch (e) {
+        afterFailed("capture error " + ((e && e.code) || "unknown"));
+      }
+    }
+    if (hostErr) throw hostErr;
+    return { result, rows };
+  };
+
+  // ---- CREATE: the new row is saved after the write (its key is only known then) ----
+  if (operation === "create") {
+    return finish(async (result) => {
+      if (!result || !info.pkFields.every((n) => result[n] !== undefined))
+        throw new Error("new row primary key not in the result");
+      const full = await base[acc].findFirst({
+        where: h.pkWhere(info, result),
+      });
+      if (!full) throw new Error("new row could not be read back");
+      await save(info, result, "insert", false, h.toColumns(info, full));
+      return 1;
+    }, false);
+  }
+
+  // ---- UPDATE / UPDATEMANY ----
+  if (operation === "update" || operation === "updateMany") {
+    let rows;
+    if (operation === "update") {
+      const r = await base[acc].findUnique({ where: args.where });
+      rows = r ? [r] : [];
+    } else {
+      rows = await base[acc].findMany({
+        where: args && args.where,
+        take: store.ROW_LIMIT + 1,
+      });
+    }
+    const c = store.checkCapturable({
+      rowCount: rows.length,
+      primaryKeyColumns: info.pkFields,
+    });
+    if (!c.ok) throw new Skip(c.reason);
+    const items = [];
+    for (const row of rows)
+      items.push({ id: await save(info, row, "update", false), row });
+    return finish(
+      async () =>
+        items.length ? settleGroup(base, h, model, info, items, "update") : 0,
+      true,
+    );
+  }
+
+  // ---- DELETE / DELETEMANY (with rows reached through links) ----
+  const groups = await planDelete(ctx);
+  const ordered = groups.slice().sort((a, b) => b.depth - a.depth); // deepest first, deleted rows last (Undo goes last to first)
+  for (const gr of ordered) {
+    gr.items = [];
+    for (const row of gr.rows)
+      gr.items.push({
+        id: await save(gr.info, row, gr.kind, gr.depth > 0),
+        row,
+      });
+  }
+  return finish(async () => {
+    let n = 0;
+    for (const gr of ordered)
+      n += await settleGroup(base, h, gr.model, gr.info, gr.items, gr.kind);
+    return n;
+  }, true);
+}
+
+module.exports = { run };