botversion-sdk 2.2.2 → 2.3.0

package/undo/lib/hooks/prisma.js

@@ -0,0 +1,335 @@
+// lib/hooks/prisma.js
+"use strict";
+// DATABASE HOOK: Prisma (model level).
+// Prisma's own engine talks to the database itself, so the `pg` hook cannot see it.
+// This hook watches Prisma at the level the host's code uses it: "create a Project",
+// "update a Task", "delete many Users"... (the plan's "Prisma's own extension mechanism").
+//
+// How it gets in without the host changing anything:
+//  1. It watches Node's module loader for Prisma's runtime file (wherever it lives).
+//  2. It hands back a version whose getPrismaClient() returns a PrismaClient class that,
+//     for every new client, adds a Prisma "query extension" that reports each operation.
+//  This works for any generated client location (custom `output` paths included),
+//  because every generated client is built by that same Prisma runtime function.
+//
+// EXPERIMENT: this hook only LOGS writes of AI-tagged requests. It never changes
+// the operation, its arguments or its result. Argument VALUES are never read or logged.
+
+const log = require("../log");
+const loader = require("../loader-watch");
+const tagger = require("../tagger");
+const { classify, wouldBeNonCapturable } = require("../sql-classify");
+const guard = require("../capture-guard");
+const capturePrisma = require("../capture-prisma");
+const undoPrisma = require("../undo-prisma");
+
+const CLASS_MARK = Symbol.for("botversion.undoExp.prismaClassWrapped");
+const proxies = new WeakMap(); // original runtime exports -> our wrapped version (keeps identity stable)
+const state = {
+  watching: false,
+  loadedEarly: false,
+  classes: 0,
+  clients: 0,
+  skipped: 0,
+  dialect: null, // database type snapshots are written for (null = not supported)
+};
+let warnedOnce = new Set();
+
+function warnOnce(key, msg) {
+  if (warnedOnce.has(key)) return;
+  warnedOnce.add(key);
+}
+
+// Prisma operation name -> kind of write (reads are not listed, so they are ignored).
+const KIND = {
+  create: "insert",
+  createMany: "insert",
+  createManyAndReturn: "insert",
+  update: "update",
+  updateMany: "update",
+  updateManyAndReturn: "update",
+  delete: "delete",
+  deleteMany: "delete",
+  upsert: "upsert",
+  $executeRaw: "raw-write",
+  $executeRawUnsafe: "raw-write",
+  $runCommandRaw: "raw-write",
+  $queryRaw: "raw",
+  $queryRawUnsafe: "raw",
+  $queryRawTyped: "raw", // may or may not write; cannot tell without reading SQL
+};
+
+// Keys that mean "this write also touches another model" (nested writes).
+const NESTED_KEYS = new Set([
+  "create",
+  "createMany",
+  "connect",
+  "connectOrCreate",
+  "update",
+  "updateMany",
+  "upsert",
+  "delete",
+  "deleteMany",
+  "disconnect",
+]);
+
+// Looks only at the SHAPE (key names) of the data, never at values.
+function hasNestedWrites(node, depth) {
+  if (!node || typeof node !== "object" || depth > 5) return false;
+  for (const key of Object.keys(node)) {
+    const v = node[key];
+    if (NESTED_KEYS.has(key) && v && typeof v === "object") return true;
+    if (
+      v &&
+      typeof v === "object" &&
+      !(v instanceof Date) &&
+      hasNestedWrites(v, depth + 1)
+    )
+      return true;
+  }
+  return false;
+}
+
+function isEmptyFilter(where) {
+  return (
+    where === undefined ||
+    where === null ||
+    (typeof where === "object" && Object.keys(where).length === 0)
+  );
+}
+
+// Finds the SQL text of a raw query without reading any values.
+// Prisma passes either an object with .text/.sql (tagged template) or an array whose first item is the SQL.
+function rawSqlText(args) {
+  try {
+    if (Array.isArray(args))
+      return typeof args[0] === "string" ? args[0] : null;
+    if (args && typeof args.text === "string") return args.text;
+    if (args && typeof args.sql === "string") return args.sql;
+  } catch (_) {
+    /* ignore */
+  }
+  return null;
+}
+
+// Raw SQL: read it with the real parser. A raw SELECT is just a read; anything we cannot read is flagged, never ignored.
+function observeRaw(store, operation, args, kind) {
+  const text = rawSqlText(args);
+  const result = text ? classify(text) : null;
+
+  if (result && !result.parseFailed) {
+    for (const w of result.writes) {
+      store.writes++;
+      const tables = w.tables.filter(Boolean).join(", ") || "?";
+    }
+    if (result.writes.length === 0 && kind === "raw-write") {
+      store.writes++;
+    }
+    return; // a raw read (select) is not a write
+  }
+
+  store.writes++;
+}
+
+// Called for every Prisma operation. Must never throw and never alter anything.
+function observe(model, operation, args) {
+  const store = tagger.getCurrent();
+  if (!store) return; // normal (untagged) request: do nothing at all
+
+  store.queries++;
+  const kind = KIND[operation];
+  if (!kind) return; // a read
+
+  if (kind === "raw" || kind === "raw-write") {
+    observeRaw(store, operation, args, kind);
+    return;
+  }
+
+  store.writes++;
+  const notes = [];
+  let nonCapturable = false;
+
+  if (kind === "upsert") {
+    notes.push("upsert");
+    nonCapturable = true;
+  }
+  if (
+    args &&
+    typeof args === "object" &&
+    args.data &&
+    hasNestedWrites(args.data, 0)
+  ) {
+    notes.push("nested-writes-touch-other-models");
+    nonCapturable = true;
+  }
+  if (
+    (operation === "updateMany" ||
+      operation === "deleteMany" ||
+      operation === "updateManyAndReturn") &&
+    args &&
+    isEmptyFilter(args.where)
+  ) {
+    notes.push("no-where");
+  }
+}
+
+// Adds the reporting extension to one new PrismaClient. Returns the client the host should get.
+function extendClient(base, options) {
+  // Extended clients do not support client.$on(...). If the host listens to Prisma
+  // events, leave that client alone rather than break it (fail safely).
+  const logOpt = options && options.log;
+  if (
+    Array.isArray(logOpt) &&
+    logOpt.some((l) => l && typeof l === "object" && l.emit === "event")
+  ) {
+    state.skipped++;
+    warnOnce(
+      "events",
+      "a PrismaClient uses $on(...) event logging, which Prisma extensions do not support. That client is NOT hooked (the host app is unaffected).",
+    );
+    return base;
+  }
+  if (typeof base.$extends !== "function") {
+    state.skipped++;
+    warnOnce(
+      "old",
+      "this Prisma version has no $extends, so it cannot be hooked by this experiment (the host app is unaffected).",
+    );
+    return base;
+  }
+
+  undoPrisma.remember(base, state.dialect); // Undo runs through this unextended client, so its own writes are never captured
+  const extended = base.$extends({
+    name: "botversion-undo-experiment",
+    query: {
+      async $allOperations({
+        model,
+        operation,
+        args,
+        query,
+        __internalParams,
+      }) {
+        try {
+          observe(model, operation, args);
+        } catch (_) {
+          /* observation problems must never affect the host's operation */
+        }
+        // Tagged writes run inside our own transaction together with their snapshot.
+        const nested = !!(
+          args &&
+          typeof args === "object" &&
+          args.data &&
+          hasNestedWrites(args.data, 0)
+        );
+        const handled = await guard.runUnhooked(() =>
+          capturePrisma.capture({
+            base,
+            model,
+            operation,
+            args,
+            nested,
+            dialect: state.dialect,
+            internal: __internalParams,
+          }),
+        );
+        if (handled) return handled.result;
+        // Everything else runs as before; the pg hook must not capture it a second time.
+        return guard.runUnhooked(() => query(args));
+      },
+    },
+  });
+  state.clients++;
+  if (state.clients === 1) return extended;
+}
+
+// Returns a subclass of Prisma's generated client class that hooks every new instance.
+function wrapClass(Cls) {
+  if (typeof Cls !== "function" || Cls[CLASS_MARK]) return Cls;
+
+  class HookedPrismaClient extends Cls {
+    constructor(...args) {
+      super(...args);
+      let client = this;
+      try {
+        client = extendClient(this, args[0]) || this;
+      } catch (e) {
+        warnOnce(
+          "extend-failed",
+          "could not hook a PrismaClient: " +
+            (e && e.message) +
+            " (the host app is unaffected)",
+        );
+        client = this;
+      }
+      return client; // a constructor may hand back a different object; the host receives this one
+    }
+  }
+  try {
+    Object.defineProperty(HookedPrismaClient, "name", { value: Cls.name });
+  } catch (_) {
+    /* cosmetic only */
+  }
+  Object.defineProperty(HookedPrismaClient, CLASS_MARK, { value: true });
+  state.classes++;
+  return HookedPrismaClient;
+}
+
+// Called when Prisma's runtime file is loaded.
+// Its exports are locked (cannot be reassigned), so a Proxy is handed back instead.
+function handleRuntime(exp) {
+  if (!exp || typeof exp.getPrismaClient !== "function") return undefined; // not the file we want
+  if (proxies.has(exp)) return proxies.get(exp);
+
+  const originalGet = exp.getPrismaClient;
+  const wrappedGet = function getPrismaClient() {
+    return wrapClass(originalGet.apply(this, arguments));
+  };
+  const proxy = new Proxy(exp, {
+    get(target, prop) {
+      if (prop === "getPrismaClient") return wrappedGet;
+      return Reflect.get(target, prop, target);
+    },
+  });
+  proxies.set(exp, proxy);
+  return proxy;
+}
+
+// Prisma's runtime file can live in several places: inside @prisma/client, or copied into a
+// custom generator "output" folder. So files are recognised by WHAT THEY EXPORT (getPrismaClient),
+// not by where they are. This pattern only narrows which files get that quick check.
+const RUNTIME_FILE = /(^|[\\/])runtime[\\/][\w.-]+$/;
+
+function attach(hostRoot, provider) {
+  if (state.watching) return state;
+  state.watching = true;
+  // Capture is switched on only for databases that have snapshot SQL (Postgres, MySQL, SQLite, SQL Server).
+  const SUPPORTED = {
+    postgresql: "postgres",
+    postgres: "postgres",
+    mysql: "mysql",
+    sqlite: "sqlite",
+    sqlserver: "sqlserver",
+    mongodb: "mongodb",
+  };
+  state.dialect = SUPPORTED[provider] || null;
+
+  // If a Prisma runtime was loaded BEFORE us, clients built from it cannot be hooked.
+  try {
+    state.loadedEarly = Object.keys(require.cache).some((f) => {
+      if (!RUNTIME_FILE.test(f)) return false;
+      const m = require.cache[f];
+      return !!(
+        m &&
+        m.exports &&
+        typeof m.exports.getPrismaClient === "function"
+      );
+    });
+  } catch (_) {
+    /* ignore */
+  }
+
+  loader.onLoad((request) => RUNTIME_FILE.test(request), handleRuntime);
+  return state;
+}
+
+module.exports = { attach, state };

package/undo/lib/hooks/sqlite3.js

@@ -0,0 +1,310 @@
+// lib/hooks/sqlite3.js
+"use strict";
+// DATABASE HOOK: sqlite3 (the callback-style package called "sqlite3").
+// Covers the "sqlite" wrapper package, Knex, TypeORM and Sequelize running on sqlite3.
+//
+// sqlite3 builds a hidden Statement inside Database#run / all / get, so the hook works at two levels:
+//  - Database#run / all / get / each / exec: the SQL is the first argument.
+//  - Prepared statements (db.prepare): the SQL is remembered when the statement is created, then used on stmt.run / all / get / each.
+// While our capture runs the host's call, it is marked "unhooked", so the hidden Statement is not captured a second time.
+// Normal (untagged) requests are never touched.
+
+const path = require("path");
+const log = require("../log");
+const loader = require("../loader-watch");
+const tagger = require("../tagger");
+const guard = require("../capture-guard");
+const capture = require("../capture-sqlite");
+const undoSqlite = require("../undo-sqlite");
+const S = require("../sqlite-sql");
+
+const MARK = Symbol.for("botversion.undoExp.sqlite3Patched");
+const attachedCopies = [];
+
+function looksLikeSqlite3(exp) {
+  return !!(
+    exp &&
+    exp.Database &&
+    exp.Statement &&
+    exp.Database.prototype &&
+    exp.Statement.prototype &&
+    typeof exp.Database.prototype.run === "function" &&
+    typeof exp.Database.prototype.all === "function" &&
+    typeof exp.Database.prototype.prepare === "function" &&
+    typeof exp.Statement.prototype.run === "function"
+  );
+}
+
+function count() {
+  const st = tagger.getCurrent();
+  if (st && !guard.isUnhooked()) st.queries++;
+}
+
+function patchExports(exp, where) {
+  if (!looksLikeSqlite3(exp)) return false;
+  const Db = exp.Database.prototype;
+  const St = exp.Statement.prototype;
+  if (Db.run[MARK]) return false; // already patched
+
+  const orig = {};
+  for (const n of ["run", "all", "get", "each", "exec", "prepare"])
+    orig[n] = Db[n];
+  const sorig = {};
+  for (const n of ["run", "all", "get", "each", "bind"]) sorig[n] = St[n];
+
+  const recs = new WeakMap(); // prepared statement -> { sql, db, pre }
+  const txState = new WeakMap(); // database -> is the host inside a transaction?
+  const opsCache = new WeakMap();
+
+  // Remembers whether the host's own statements opened a transaction on this connection.
+  const trackTx = (db, text) => {
+    if (typeof text !== "string") return;
+    const m = /^\s*([A-Za-z]+)/.exec(text);
+    const w = m ? m[1].toUpperCase() : "";
+    if (w === "BEGIN" || w === "START" || w === "SAVEPOINT")
+      txState.set(db, true);
+    else if (
+      w === "COMMIT" ||
+      w === "END" ||
+      (w === "ROLLBACK" && !/^\s*ROLLBACK(\s+TRANSACTION)?\s+TO\b/i.test(text))
+    )
+      txState.set(db, false);
+  };
+
+  // How capture and Undo talk to this database without being seen by the hook again.
+  const opsFor = (db) => {
+    let o = opsCache.get(db);
+    if (!o) {
+      o = {
+        kind: "node",
+        query(sql, params) {
+          return new Promise((resolve, reject) => {
+            const p = S.cleanParams(params);
+            try {
+              if (/^\s*(SELECT|PRAGMA|WITH)\b/i.test(sql))
+                guard.runUnhooked(() =>
+                  orig.all.call(db, sql, p, (err, rows) =>
+                    err ? reject(err) : resolve({ rows: rows || [] }),
+                  ),
+                );
+              else
+                guard.runUnhooked(() =>
+                  orig.run.call(db, sql, p, function (err) {
+                    if (err) reject(err);
+                    else
+                      resolve({
+                        rows: [],
+                        changes: this.changes,
+                        lastInsertRowid: this.lastID,
+                      });
+                  }),
+                );
+            } catch (e) {
+              reject(e);
+            }
+          });
+        },
+        script(sql) {
+          return new Promise((resolve, reject) => {
+            try {
+              guard.runUnhooked(() =>
+                orig.exec.call(db, sql, (err) =>
+                  err ? reject(err) : resolve(),
+                ),
+              );
+            } catch (e) {
+              reject(e);
+            }
+          });
+        },
+      };
+      opsCache.set(db, o);
+    }
+    undoSqlite.remember(db, o); // Undo reuses the host's own database object
+    return o;
+  };
+
+  // ---- Database level ----
+  for (const name of ["run", "all", "get"]) {
+    const original = orig[name];
+    if (typeof original !== "function") continue;
+    const wrapped = function () {
+      const args = Array.prototype.slice.call(arguments);
+      try {
+        trackTx(this, args[0]);
+        count();
+      } catch (_) {
+        /* observation problems must never affect the host */
+      }
+      try {
+        if (typeof args[0] === "string") {
+          const self = this;
+          const handled = capture.captureNode({
+            target: self,
+            db: self,
+            method: name,
+            sql: args[0],
+            offset: 1,
+            args,
+            original,
+            ops: opsFor(self),
+            preBound: null,
+            getTx: () => txState.get(self) === true,
+          });
+          if (handled) return handled.value;
+        }
+      } catch (_) {
+        /* capture problems must never affect the host's call */
+      }
+      return original.apply(this, arguments);
+    };
+    Object.defineProperty(wrapped, MARK, { value: true });
+    Db[name] = wrapped;
+  }
+
+  for (const name of ["each", "exec"]) {
+    const original = orig[name];
+    if (typeof original !== "function") continue;
+    Db[name] = function () {
+      const args = Array.prototype.slice.call(arguments);
+      try {
+        trackTx(this, args[0]);
+        count();
+        if (typeof args[0] === "string") {
+          const handled = capture.refuseWriteNode({
+            target: this,
+            method: name,
+            sql: args[0],
+            offset: 1,
+            args,
+          });
+          if (handled) return handled.value;
+        }
+      } catch (_) {
+        /* never break the host */
+      }
+      return original.apply(this, arguments);
+    };
+  }
+
+  if (typeof orig.prepare === "function") {
+    Db.prepare = function () {
+      const stmt = orig.prepare.apply(this, arguments);
+      try {
+        const sql = arguments[0];
+        if (typeof sql === "string" && stmt && typeof stmt === "object") {
+          const rest = Array.prototype.slice
+            .call(arguments, 1)
+            .filter((a) => typeof a !== "function");
+          recs.set(stmt, { sql, db: this, pre: rest.length ? rest : null });
+        }
+      } catch (_) {
+        /* never break the host */
+      }
+      return stmt;
+    };
+  }
+
+  // ---- prepared Statement level ----
+  for (const name of ["run", "all", "get"]) {
+    const original = sorig[name];
+    if (typeof original !== "function") continue;
+    St[name] = function () {
+      const rec = recs.get(this);
+      if (!rec) return original.apply(this, arguments); // a hidden Statement built by Database#run etc.: already handled there
+      const args = Array.prototype.slice.call(arguments);
+      try {
+        trackTx(rec.db, rec.sql);
+        count();
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        const handled = capture.captureNode({
+          target: this,
+          db: rec.db,
+          method: name,
+          sql: rec.sql,
+          offset: 0,
+          args,
+          original,
+          ops: opsFor(rec.db),
+          preBound: rec.pre,
+          getTx: () => txState.get(rec.db) === true,
+        });
+        if (handled) return handled.value;
+      } catch (_) {
+        /* capture problems must never affect the host's call */
+      }
+      return original.apply(this, arguments);
+    };
+  }
+
+  if (typeof sorig.each === "function") {
+    St.each = function () {
+      const rec = recs.get(this);
+      if (rec) {
+        const args = Array.prototype.slice.call(arguments);
+        try {
+          count();
+          const handled = capture.refuseWriteNode({
+            target: this,
+            method: "each",
+            sql: rec.sql,
+            offset: 0,
+            args,
+          });
+          if (handled) return handled.value;
+        } catch (_) {
+          /* never break the host */
+        }
+      }
+      return sorig.each.apply(this, arguments);
+    };
+  }
+
+  if (typeof sorig.bind === "function") {
+    St.bind = function () {
+      try {
+        const rec = recs.get(this);
+        if (rec) {
+          const given = Array.prototype.slice
+            .call(arguments)
+            .filter((a) => typeof a !== "function");
+          rec.pre = given.length ? given : null;
+        }
+      } catch (_) {
+        /* never break the host */
+      }
+      return sorig.bind.apply(this, arguments);
+    };
+  }
+
+  attachedCopies.push(where || "unknown location");
+  return true;
+}
+
+// hostRoot = folder of the host project (found by the scanner).
+function attach(hostRoot) {
+  // 1. The host's own copy, if it can be found right now.
+  try {
+    const resolved = require.resolve("sqlite3", {
+      paths: [hostRoot, process.cwd()],
+    });
+    patchExports(require(resolved), path.dirname(resolved));
+  } catch (_) {
+    // Not installed or not loadable: fine, other databases may be in use.
+  }
+  // 2. Any other copy that loads later.
+  loader.onLoad(
+    (request) =>
+      request === "sqlite3" ||
+      /[\\/]sqlite3[\\/]lib[\\/]sqlite3\.js$/.test(request),
+    (exp, request, parent) => {
+      patchExports(exp, loader.whereOf(request, parent));
+    },
+  );
+  return attachedCopies.slice();
+}
+
+module.exports = { attach, attachedCopies };

package/undo/lib/loader-watch.js

@@ -0,0 +1,64 @@
+// lib/loader-watch.js
+"use strict";
+// MODULE LOADER WATCHER (shared by all database hooks)
+// Lets a hook say "when the app loads a module that looks like X, give me a chance
+// to patch it (or hand back a replacement)". One single patch of Node's loader is
+// shared by every hook, so adding a new database hook never adds another patch.
+
+const Module = require("module");
+const path = require("path");
+const log = require("./log");
+
+const handlers = [];
+const seenLoads = new Set(); // TEMP DEBUG: so each matched module is logged once
+let installed = false;
+
+function install() {
+  if (installed) return;
+  installed = true;
+  try {
+    const originalLoad = Module._load;
+    Module._load = function (request, parent) {
+      let exp = originalLoad.apply(this, arguments);
+      try {
+        if (typeof request === "string") {
+          for (const h of handlers) {
+            if (h.matches(request)) {
+              // TEMP DEBUG: which module requests the database hooks matched, and who asked for them
+              if (!seenLoads.has(request)) {
+                seenLoads.add(request);
+                log.debug(
+                  "loader matched:",
+                  request,
+                  "from=" + (parent && parent.filename ? parent.filename : "?"),
+                );
+              }
+              const replacement = h.handle(exp, request, parent);
+              if (replacement !== undefined) exp = replacement; // a hook may hand back a wrapped version
+            }
+          }
+        }
+      } catch (_) {
+        /* a hook problem must never break module loading */
+      }
+      return exp;
+    };
+  } catch (e) {}
+}
+
+// matches(requestString) -> bool ; handle(exports, requestString, parentModule) -> optional replacement exports
+function onLoad(matches, handle) {
+  handlers.push({ matches, handle });
+  install();
+}
+
+// Folder the requested module really lives in (for the report). Never throws.
+function whereOf(request, parent) {
+  try {
+    return path.dirname(Module._resolveFilename(request, parent));
+  } catch (_) {
+    return request;
+  }
+}
+
+module.exports = { onLoad, whereOf };