botversion-sdk 2.2.3 → 2.3.1

package/undo/lib/capture-prisma.js

@@ -0,0 +1,753 @@
+// lib/capture-prisma.js
+"use strict";
+// PRISMA CAPTURE (Phase 2): runs a tagged write inside our own transaction with its snapshot,
+// so the snapshot and the write succeed or fail together. Postgres only for now.
+// Logs: model names, counts and reasons only.
+
+const log = require("./log");
+const tagger = require("./tagger");
+
+const gate = require("./gate");
+const mongoCapture = require("./capture-prisma-mongo");
+
+// Writes this package can never save: they are blocked until the user confirms.
+const UNSAVABLE = new Set([
+  "createMany",
+  "createManyAndReturn",
+  "updateManyAndReturn",
+  "upsert",
+  "$executeRaw",
+  "$executeRawUnsafe",
+]);
+
+const store = require("./snapshot-store");
+
+const schemaReader = require("./schema-reader");
+const { findHostRoot, dialectFromPrismaClient } = require("./scanner");
+const structure = require("./prisma-structure");
+
+const MAX_DEPTH = 5; // how many levels of linked rows a delete may reach
+let graph; // undefined = not read yet, null = could not be read
+function getGraph(base) {
+  if (graph === undefined) graph = schemaReader.readDeleteGraph(findHostRoot());
+  // FIX: when the client's data model cannot be read, use the delete links read from the database itself.
+  if (!graph && base) return structure.deleteGraph(base);
+  return graph;
+}
+
+const OPS = new Set(["create", "update", "updateMany", "delete", "deleteMany"]);
+class Skip extends Error {}
+let keysLogged = false;
+
+// A raw MongoDB command that only reads. Anything else (or anything not recognised) is treated as a write.
+const MONGO_READ = new Set([
+  "find",
+  "count",
+  "distinct",
+  "aggregate",
+  "listCollections",
+  "listIndexes",
+  "dbStats",
+  "collStats",
+  "ping",
+  "hello",
+  "isMaster",
+  "buildInfo",
+]);
+function isMongoRead(command) {
+  try {
+    const name =
+      command && typeof command === "object" ? Object.keys(command)[0] : null;
+    if (!name || !MONGO_READ.has(name)) return false;
+    if (
+      name === "aggregate" &&
+      /"\$(out|merge)"/.test(JSON.stringify(command.pipeline || []))
+    )
+      return false;
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+const lower = (s) => s.charAt(0).toLowerCase() + s.slice(1);
+const keyOf = (row, names) =>
+  names
+    .map((n) => {
+      const v = row[n];
+      return v instanceof Date ? v.toISOString() : String(v);
+    })
+    .join("\u0001");
+
+// Table, primary key and column names from the client's own data model.
+function modelInfo(base, model) {
+  const dm = base && base._runtimeDataModel;
+  const m = dm && dm.models && dm.models[model];
+  if (!m || !Array.isArray(m.fields)) return null;
+  const scalars = m.fields.filter(
+    (f) => f.kind === "scalar" || f.kind === "enum",
+  );
+  const pkFields =
+    m.primaryKey &&
+    Array.isArray(m.primaryKey.fields) &&
+    m.primaryKey.fields.length
+      ? m.primaryKey.fields.slice()
+      : m.fields.filter((f) => f.isId).map((f) => f.name);
+  // FIX: when the client carries no key markers, use the primary key read from the database itself.
+  const keys = pkFields.length
+    ? pkFields
+    : structure.primaryKeyFields(base, m.dbName || model, scalars);
+  return { table: m.dbName || model, scalars, pkFields: keys };
+}
+const colOf = (info, name) => {
+  const f = info.scalars.find((x) => x.name === name);
+  return (f && (f.dbName || f.name)) || name;
+};
+const toColumns = (info, row) => {
+  const o = {};
+  for (const f of info.scalars) o[f.dbName || f.name] = row[f.name];
+  return o;
+};
+const pkObject = (info, row) => {
+  const o = {};
+  for (const n of info.pkFields) o[colOf(info, n)] = row[n];
+  return o;
+};
+const pkWhere = (info, row) => {
+  const o = {};
+  for (const n of info.pkFields) o[n] = row[n];
+  return o;
+};
+
+// A top-level create or update whose relation fields only use connect (or disconnect, update only), and whose
+// links the database undoes by itself or that are plain columns on the written row. Anything unclear = false.
+// A top-level create or update whose relation fields only use connect (or disconnect, update only), where the
+// link is a plain column on the written row, or (create only) a hidden join table that cascades away. Anything unclear = false.
+async function nestedConnectOnly(
+  base,
+  model,
+  operation,
+  args,
+  internal,
+  dialect,
+) {
+  try {
+    if (operation !== "create" && operation !== "update") return false;
+    if (
+      !(
+        internal &&
+        Array.isArray(internal.dataPath) &&
+        internal.dataPath.length === 0
+      )
+    )
+      return false;
+    const models = base._runtimeDataModel.models;
+    const d = args && args.data;
+    if (!d || typeof d !== "object" || Array.isArray(d)) return false;
+    const rels = models[model].fields.filter(
+      (f) => f.kind === "object" && d[f.name] !== undefined,
+    );
+    if (!rels.length) return false;
+    await structure.load(base, dialect);
+    const g = getGraph(base);
+    if (!g) return false;
+    const tableOf = (n) => (models[n] && (models[n].dbName || n)) || n;
+    for (const f of rels) {
+      const v = d[f.name];
+      if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+      const keys = Object.keys(v);
+      if (keys.length !== 1) return false;
+      // connect works for create and update; disconnect only for update (it just empties the link column).
+      if (
+        keys[0] !== "connect" &&
+        !(operation === "update" && keys[0] === "disconnect")
+      )
+        return false;
+      // Decided per relation: a hidden join table (or an unknown answer) is safe only for a create whose join rows cascade away.
+      const joined = structure.hasHiddenJoin(base, f.relationName);
+      if (joined !== false) {
+        if (
+          joined === true &&
+          operation === "create" &&
+          structure.hiddenJoinIsCascade(
+            base,
+            f.relationName,
+            tableOf(model),
+            tableOf(f.type),
+          )
+        )
+          continue;
+        return false;
+      }
+      const here = (g.get(f.type) || []).some((l) => l.child === model);
+      const there = (g.get(model) || []).some((l) => l.child === f.type);
+      if (here && !there) continue; // link is only a column on the written row
+      return false;
+    }
+    log.debug(
+      "prisma nested connect-only write allowed:",
+      "model=" + model,
+      "op=" + operation,
+    );
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+// Returns { result } when the write was run here, or null (the caller then runs it normally).
+async function capture({
+  base,
+  model,
+  operation,
+  args,
+  nested,
+  dialect,
+  internal,
+}) {
+  const st = tagger.getCurrent();
+  if (!st) return null;
+  // FIX: take the database type from the live client when the hook did not supply one (a schema file read from disk can be missing or elsewhere).
+  if (!dialect) dialect = dialectFromPrismaClient(base);
+  // FIX: some Prisma versions carry no key markers or delete rules at runtime; ask the database (once per client) for them.
+  if (OPS.has(operation) && dialect) {
+    const m0 = modelInfo(base, model);
+    const isDelete = operation === "delete" || operation === "deleteMany";
+    if ((m0 && m0.pkFields.length === 0) || (isDelete && !getGraph(base))) {
+      const loadedOk = await structure.load(base, dialect);
+    }
+  }
+  // TEMP DEBUG: writes only, to avoid noise. Shows the type finally used, and whether relation rules exist on the live client.
+  if (OPS.has(operation)) {
+    const rm =
+      base &&
+      base._runtimeDataModel &&
+      base._runtimeDataModel.models &&
+      base._runtimeDataModel.models[model];
+    const rel =
+      rm && Array.isArray(rm.fields)
+        ? rm.fields.find((f) => f.kind === "object")
+        : null;
+    // Logs the hook's nested flag next to the shape of the call (names only, never values).
+    try {
+      const d1 = args && args.data;
+      const relKeys =
+        rm &&
+        Array.isArray(rm.fields) &&
+        d1 &&
+        typeof d1 === "object" &&
+        !Array.isArray(d1)
+          ? rm.fields
+              .filter(
+                (f) =>
+                  f.kind === "object" &&
+                  f.name in d1 &&
+                  d1[f.name] !== undefined,
+              )
+              .map((f) => f.name)
+          : [];
+    } catch (_) {
+      /* never break the host */
+    }
+    // TEMP DEBUG: why the primary key could not be found for this model (names and counts only, never row values)
+    const fields = rm && Array.isArray(rm.fields) ? rm.fields : [];
+    const idNamed = fields.find((f) => f.name === "id");
+    const scalarFields = fields.filter(
+      (f) => f.kind === "scalar" || f.kind === "enum",
+    );
+    const mi = modelInfo(base, model);
+    // TEMP DEBUG (once per process): primary-key detection for EVERY model, so no second model blocks the same action later
+    if (!capture.audited) {
+      capture.audited = true;
+      const all =
+        (base && base._runtimeDataModel && base._runtimeDataModel.models) || {};
+      const names = Object.keys(all);
+      const noPk = names.filter((n) => {
+        const info2 = modelInfo(base, n);
+        return !info2 || info2.pkFields.length === 0;
+      });
+    }
+    // TEMP DEBUG: does the Undo side find the same primary key for this table?
+    try {
+      const ui = require("./undo-prisma").infoFor(mi ? mi.table : model);
+    } catch (e) {}
+  }
+  if (
+    UNSAVABLE.has(operation) ||
+    (operation === "$runCommandRaw" && !isMongoRead(args))
+  ) {
+    if (st.confirmed) st.unsaved = true; // runs without a saved snapshot, so Undo will not cover it
+    if (!st.confirmed)
+      await gate.block(
+        st,
+        `${model || "-"} ${operation}`,
+        "this kind of write cannot be saved",
+      );
+    return null;
+  }
+  if (!model || !OPS.has(operation)) {
+    return null;
+  }
+  const skip = async (why) => {
+    if (st.confirmed) st.unsaved = true; // runs without a saved snapshot, so Undo will not cover it
+    if (!st.confirmed) await gate.block(st, `${model} ${operation}`, why);
+    return null;
+  };
+  let hostError = null;
+  try {
+    if (!dialect)
+      return skip(
+        "snapshots are not supported for this database type yet, or the database type is unknown",
+      );
+    if (nested) {
+      // Logs which relation fields and verbs a nested write uses (names only, never values).
+      try {
+        const verbs = [
+          "create",
+          "createMany",
+          "connect",
+          "connectOrCreate",
+          "upsert",
+          "set",
+          "update",
+          "updateMany",
+          "delete",
+          "deleteMany",
+          "disconnect",
+        ];
+        const d = (args && args.data) || {};
+        const shape = Object.keys(d)
+          .filter(
+            (k) =>
+              d[k] &&
+              typeof d[k] === "object" &&
+              !Array.isArray(d[k]) &&
+              !(d[k] instanceof Date) &&
+              Object.keys(d[k]).some((v) => verbs.includes(v)),
+          )
+          .map((k) => k + ":" + Object.keys(d[k]).join("+"));
+      } catch (_) {
+        /* never break the host */
+      }
+      // Logs, per relation field in the write, where the foreign key lives (names only, never values).
+      try {
+        const mdl = base._runtimeDataModel.models[model];
+        const g = getGraph(base);
+        const d = (args && args.data) || {};
+        const rels = mdl.fields.filter(
+          (f) => f.kind === "object" && f.name in d,
+        );
+        const out = rels.map((f) => {
+          const onThis = !!(
+            g && (g.get(f.type) || []).some((l) => l.child === model)
+          );
+          const onOther = !!(
+            g && (g.get(model) || []).some((l) => l.child === f.type)
+          );
+          return (
+            f.name +
+            "->" +
+            f.type +
+            " fkOnThisTable=" +
+            onThis +
+            " fkOnOtherTable=" +
+            onOther
+          );
+        });
+      } catch (_) {
+        /* never break the host */
+      }
+      // Logs how each relation field in the write is stored in the database (names and counts only, never values).
+      try {
+        const models = base._runtimeDataModel.models;
+        const mdl = models[model];
+        const g = getGraph(base);
+        const d = (args && args.data) || {};
+        const plain = (o) =>
+          o &&
+          typeof o === "object" &&
+          !Array.isArray(o) &&
+          !(o instanceof Date);
+        const modelTables = new Set(
+          Object.keys(models).map((n) => models[n].dbName || n),
+        );
+        const rels = mdl.fields.filter(
+          (f) => f.kind === "object" && f.name in d,
+        );
+        const lines = rels.map((f) => {
+          const v = d[f.name];
+          // what the write does with this field: each key inside it, and how many items it holds
+          const ops = plain(v)
+            ? Object.keys(v).map(
+                (k) =>
+                  k +
+                  "(" +
+                  (Array.isArray(v[k])
+                    ? "list " + v[k].length
+                    : plain(v[k])
+                      ? "obj keys=" + Object.keys(v[k]).join("+")
+                      : typeof v[k]) +
+                  ")",
+              )
+            : [typeof v];
+          // the same relation seen from the other model
+          const other = models[f.type];
+          const back = other
+            ? other.fields
+                .filter(
+                  (x) =>
+                    x.kind === "object" &&
+                    x.type === model &&
+                    x.relationName === f.relationName,
+                )
+                .map((x) => x.name)
+            : [];
+          // every foreign key between the two models, with the column names it uses
+          const fkHere = g
+            ? (g.get(f.type) || [])
+                .filter((l) => l.child === model)
+                .map((l) => l.fromFields.join("+"))
+            : [];
+          const fkThere = g
+            ? (g.get(model) || [])
+                .filter((l) => l.child === f.type)
+                .map((l) => l.fromFields.join("+"))
+            : [];
+          // database tables whose name contains this relation's name (a hidden join table would show up here)
+          const joins = structure
+            .tablesMentioning(base, f.relationName)
+            .map((t) => t + "(isModel=" + modelTables.has(t) + ")");
+          return (
+            f.name +
+            "->" +
+            f.type +
+            " relationName=" +
+            f.relationName +
+            " ops=" +
+            ops.join(",") +
+            " backFields=[" +
+            back.join(",") +
+            "]" +
+            " fkColumnsOnThisTable=[" +
+            fkHere.join(",") +
+            "]" +
+            " fkColumnsOnOtherTable=[" +
+            fkThere.join(",") +
+            "]" +
+            " tablesNamedLikeRelation=[" +
+            joins.join(",") +
+            "]"
+          );
+        });
+        lines.forEach((l) => log.debug("prisma nested relation field:", l));
+      } catch (e) {}
+      // Logs the foreign keys of any hidden join table behind each relation field in the write (names and rules only).
+      try {
+        const relFields = base._runtimeDataModel.models[model].fields.filter(
+          (f) =>
+            f.kind === "object" &&
+            args &&
+            args.data &&
+            args.data[f.name] !== undefined,
+        );
+        relFields.forEach((f) => {
+          const links = structure.linksOfTablesMentioning(base, f.relationName);
+        });
+      } catch (e) {}
+      if (
+        !(await nestedConnectOnly(
+          base,
+          model,
+          operation,
+          args,
+          internal,
+          dialect,
+        ))
+      )
+        return skip("nested writes touch other models");
+    }
+    if (!internal || typeof internal !== "object")
+      return skip("cannot tell whether this is inside a host transaction");
+    if (!keysLogged) {
+      keysLogged = true;
+    }
+    if (internal.transaction) return skip("inside a host transaction");
+    const info = modelInfo(base, model);
+    if (!info) return skip("model information not available");
+    const chk = store.checkCapturable({
+      rowCount: 0,
+      primaryKeyColumns: info.pkFields,
+    });
+    if (!chk.ok) return skip(chk.reason);
+
+    // MongoDB has no SQL and no transaction around raw commands: its own capture path runs the write.
+    if (dialect === "mongodb") {
+      const done = await mongoCapture.run({
+        base,
+        model,
+        operation,
+        args,
+        info,
+        st,
+        h: {
+          Skip,
+          lower,
+          keyOf,
+          pkWhere,
+          pkObject,
+          toColumns,
+          modelInfo,
+          getGraph,
+          onHostError: (e) => {
+            hostError = e;
+          },
+        },
+      });
+      return { result: done.result };
+    }
+
+    const acc = lower(model);
+    let rowsSaved = 0;
+    const out = await base.$transaction(
+      async (tx) => {
+        // Same job as pg's query function: reads use queryRaw, everything else executeRaw.
+        const run = async (sql, params) => {
+          if (/^\s*(SELECT|WITH)\b/i.test(sql))
+            return { rows: await tx.$queryRawUnsafe(sql, ...params) };
+          await tx.$executeRawUnsafe(sql, ...params);
+          return { rows: [] };
+        };
+        run.dialect = dialect; // tells the snapshot store which SQL to use
+        const hostWrite = async () => {
+          try {
+            return await tx[acc][operation](args);
+          } catch (e) {
+            hostError = e;
+            throw e;
+          }
+        };
+
+        if (operation === "create") {
+          const result = await hostWrite();
+          if (!result || !info.pkFields.every((n) => result[n] !== undefined)) {
+            throw new Skip("new row primary key not in the result");
+          }
+          const full = await tx[acc].findFirst({
+            where: pkWhere(info, result),
+          });
+          const r = await store.saveSnapshot(run, st, {
+            table: info.table,
+            operation: "insert",
+            primaryKey: pkObject(info, result),
+            before: null,
+            after: full ? toColumns(info, full) : null,
+            isLinked: false,
+          });
+          if (!r.ok) throw new Skip(r.reason);
+          rowsSaved = 1;
+          return result;
+        }
+
+        if (operation === "delete" || operation === "deleteMany") {
+          const g = getGraph(base);
+          if (!g) throw new Skip("foreign-key links could not be read");
+
+          // 1. The rows the host is deleting.
+          let roots;
+          if (operation === "delete") {
+            const row = await tx[acc].findUnique({ where: args.where });
+            roots = row ? [row] : [];
+          } else {
+            roots = await tx[acc].findMany({
+              where: args && args.where,
+              take: store.ROW_LIMIT + 1,
+            });
+          }
+          const c3 = store.checkCapturable({
+            rowCount: roots.length,
+            primaryKeyColumns: info.pkFields,
+          });
+          if (!c3.ok) throw new Skip(c3.reason);
+
+          // 2. Rows reached through foreign-key links, level by level.
+          //    kind "delete" = removed by the database (Cascade); kind "update" = link cleared (SetNull / SetDefault).
+          const groups = [
+            { model, info, rows: roots, depth: 0, kind: "delete" },
+          ];
+          const tag = (m, i, r) => m + "\u0002" + keyOf(r, i.pkFields);
+          const deletedAt = new Map(); // row -> level it is deleted at
+          const clearedKeys = 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: the database refuses the delete itself
+                const cInfo = modelInfo(base, link.child);
+                if (!cInfo) throw new Skip("model information not available");
+                const found = await tx[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)) {
+                      // Same row reached at another level would be restored in the wrong order: do not guess.
+                      if (deletedAt.get(k) !== depth)
+                        throw new Skip(
+                          "a row is reached through links of different depth",
+                        );
+                      continue;
+                    }
+                    deletedAt.set(k, depth);
+                  } else {
+                    if (clearedKeys.has(k)) continue;
+                    clearedKeys.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)),
+              );
+          }
+
+          // 3. Save deepest rows first and the deleted rows last (Undo goes last to first, so parents come back first).
+          const ordered = groups
+            .filter((gr) => gr.rows.length)
+            .sort((a, b) => b.depth - a.depth);
+          const toFill = [];
+          for (const gr of ordered) {
+            const saved = new Map();
+            for (const row of gr.rows) {
+              const r = await store.saveSnapshot(run, st, {
+                table: gr.info.table,
+                operation: gr.kind,
+                primaryKey: pkObject(gr.info, row),
+                before: toColumns(gr.info, row),
+                after: null,
+                isLinked: gr.depth > 0,
+              });
+              if (!r.ok) throw new Skip(r.reason);
+              saved.set(keyOf(row, gr.info.pkFields), r.id);
+            }
+            if (gr.kind === "update") toFill.push({ gr, saved });
+          }
+
+          // 4. The host's own delete.
+          const result = await hostWrite();
+
+          // 5. Rows whose link was cleared: save how they look now (needed for the safety check in Undo).
+          for (const { gr, saved } of toFill) {
+            const after = await tx[lower(gr.model)].findMany({
+              where: { OR: gr.rows.map((r) => pkWhere(gr.info, r)) },
+            });
+            for (const row of after) {
+              const id = saved.get(keyOf(row, gr.info.pkFields));
+              if (!id) continue;
+              const r = await store.saveAfter(run, id, toColumns(gr.info, row));
+              if (!r.ok) throw new Skip(r.reason);
+            }
+          }
+          rowsSaved = ordered.reduce((n, gr) => n + gr.rows.length, 0);
+          return result;
+        }
+
+        // update / updateMany: save the old rows first
+        let before;
+        if (operation === "update") {
+          const row = await tx[acc].findUnique({ where: args.where });
+          before = row ? [row] : [];
+        } else {
+          before = await tx[acc].findMany({
+            where: args && args.where,
+            take: store.ROW_LIMIT + 1,
+          });
+        }
+        const c2 = store.checkCapturable({
+          rowCount: before.length,
+          primaryKeyColumns: info.pkFields,
+        });
+        if (!c2.ok) throw new Skip(c2.reason);
+        const saved = new Map();
+        for (const row of before) {
+          const r = await store.saveSnapshot(run, st, {
+            table: info.table,
+            operation: "update",
+            primaryKey: pkObject(info, row),
+            before: toColumns(info, row),
+            after: null,
+            isLinked: false,
+          });
+          if (!r.ok) throw new Skip(r.reason);
+          saved.set(keyOf(row, info.pkFields), r.id);
+        }
+        const result = await hostWrite();
+        if (before.length) {
+          const after = await tx[acc].findMany({
+            where: { OR: before.map((r) => pkWhere(info, r)) },
+          });
+          for (const row of after) {
+            const id = saved.get(keyOf(row, info.pkFields));
+            if (!id) continue;
+            const r = await store.saveAfter(run, id, toColumns(info, row));
+            if (!r.ok) throw new Skip(r.reason);
+          }
+        }
+        rowsSaved = before.length;
+        return result;
+      },
+      { maxWait: 5000, timeout: 30000 },
+    );
+
+    return { result: out };
+  } catch (e) {
+    if (hostError) throw hostError; // the host's own write failed: the host must see its own error
+    return skip(e instanceof Skip ? e.message : "capture error");
+  }
+}
+
+module.exports = { capture };