botversion-sdk 2.2.3 → 2.3.0

package/undo/lib/hooks/mssql.js

@@ -0,0 +1,209 @@
+// lib/hooks/mssql.js
+"use strict";
+// DATABASE HOOK: SQL Server driver (`tedious`).
+// Covers the `mssql` package, Knex, Sequelize and TypeORM running on SQL Server, because they all call tedious.
+//
+// Logs writes of AI-tagged requests, and for tagged UPDATE / INSERT / DELETE saves a snapshot first (see capture-mssql.js).
+// Stored procedures, prepared statements and bulk loads cannot be saved, so a tagged one is blocked until the user confirms.
+// 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-mssql");
+const undoMssql = require("../undo-mssql");
+const {
+  classifyMssql,
+  wouldBeNonCapturableMssql,
+} = require("../sql-classify-mssql");
+
+const MARK = Symbol.for("botversion.undoExp.tediousPatched");
+const attachedCopies = [];
+
+function looksLikeTedious(exp) {
+  return !!(
+    exp &&
+    exp.Request &&
+    exp.TYPES &&
+    exp.Connection &&
+    exp.Connection.prototype &&
+    typeof exp.Connection.prototype.execSql === "function" &&
+    typeof exp.Connection.prototype.execSqlBatch === "function" &&
+    typeof exp.Connection.prototype.callProcedure === "function"
+  );
+}
+
+// Capture only works while the connection is idle. If tedious reports another state, the host's call is passed
+// through untouched so the host sees tedious's own answer. If the state cannot be read, capture goes ahead.
+function isIdle(conn) {
+  const n = conn && conn.state && conn.state.name;
+  return typeof n !== "string" || n === "LoggedIn";
+}
+
+// Called for every query on a patched tedious. Must never throw and never alter anything.
+function observe(method, request) {
+  if (guard.isUnhooked()) return;
+  const store = tagger.getCurrent();
+  if (!store) return; // normal (untagged) request: do nothing at all
+
+  store.queries++;
+
+  if (method === "callProcedure") {
+    store.writes++;
+    return;
+  }
+
+  const text =
+    request && typeof request.sqlTextOrProcedure === "string"
+      ? request.sqlTextOrProcedure
+      : null;
+  if (text === null) {
+    return;
+  }
+
+  const paramCount = Array.isArray(request.parameters)
+    ? request.parameters.length
+    : 0;
+  const result = classifyMssql(text);
+
+  if (result.parseFailed) {
+    return;
+  }
+  for (const w of result.writes) {
+    store.writes++;
+    const tables = w.tables.filter(Boolean).join(", ") || "?";
+    const notes = w.notes.length ? "  notes=" + w.notes.join(",") : "";
+  }
+}
+
+function patchExports(exp, where) {
+  if (!looksLikeTedious(exp)) return false;
+  const proto = exp.Connection.prototype;
+  if (proto.execSql[MARK]) return false; // already patched
+
+  const origSql = proto.execSql;
+  const origBatch = proto.execSqlBatch;
+  const origProc = proto.callProcedure;
+  const origExecute = proto.execute; // prepared statements (may not exist in very old versions)
+  const origBulk = proto.execBulkLoad; // bulk loads (may not exist in very old versions)
+
+  // The loaded copy of tedious plus its ORIGINAL execSql / execSqlBatch, so our own reads are never seen by the hook.
+  const copy = { exp, fns: { sql: origSql, batch: origBatch } };
+
+  const seen = new WeakSet(); // connections already handed to Undo
+  const remember = (conn) => {
+    if (!conn || typeof conn !== "object" || seen.has(conn)) return;
+    seen.add(conn);
+    undoMssql.remember(conn, copy); // Undo reuses an idle connection of the host's own
+  };
+
+  // execSql / execSqlBatch: tagged UPDATE/INSERT/DELETE are captured, other writes that cannot be saved are blocked.
+  const wrapQuery = (method, original) => {
+    const wrapped = function (request) {
+      try {
+        observe(method, request);
+      } catch (_) {
+        /* observation problems must never affect the host's query */
+      }
+      try {
+        remember(this);
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        // capture runs the host's request itself (or blocks it) and returns true
+        if (isIdle(this) && capture.maybeCapture(this, request, original, copy))
+          return;
+      } catch (_) {
+        /* capture problems must never affect the host's query */
+      }
+      return original.apply(this, arguments);
+    };
+    Object.defineProperty(wrapped, MARK, { value: true });
+    proto[method] = wrapped;
+  };
+  wrapQuery("execSql", origSql);
+  wrapQuery("execSqlBatch", origBatch);
+
+  // Stored procedures and prepared statements: their writes cannot be saved, so a tagged one is blocked until confirmed.
+  const wrapRefuse = (method, original, kind) => {
+    if (typeof original !== "function") return;
+    proto[method] = function (request) {
+      try {
+        observe(method, request);
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        remember(this);
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        if (isIdle(this) && capture.maybeRefuse(this, request, original, kind))
+          return;
+      } catch (_) {
+        /* never break the host */
+      }
+      return original.apply(this, arguments);
+    };
+  };
+  wrapRefuse("callProcedure", origProc, "procedure");
+  wrapRefuse("execute", origExecute, "prepared");
+
+  // Bulk loads: always a write that cannot be saved.
+  if (typeof origBulk === "function") {
+    proto.execBulkLoad = function (bulk) {
+      try {
+        const st = tagger.getCurrent();
+        if (st && !guard.isUnhooked()) {
+          st.queries++;
+          st.writes++;
+        }
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        remember(this);
+      } catch (_) {
+        /* never break the host */
+      }
+      try {
+        if (capture.refuseBulk(bulk)) return;
+      } catch (_) {
+        /* never break the host */
+      }
+      return origBulk.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 of tedious, if it can be found right now.
+  try {
+    const resolved = require.resolve("tedious", {
+      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 of tedious that loads later (for example one nested inside the mssql package).
+  loader.onLoad(
+    (request) =>
+      request === "tedious" ||
+      /[\\/]tedious[\\/]lib[\\/]tedious\.js$/.test(request),
+    (exp, request, parent) => {
+      patchExports(exp, loader.whereOf(request, parent));
+    },
+  );
+  return attachedCopies.slice();
+}
+
+module.exports = { attach, attachedCopies };

package/undo/lib/hooks/mysql2.js

@@ -0,0 +1,148 @@
+// lib/hooks/mysql2.js
+"use strict";
+// DATABASE HOOK: MySQL / MariaDB driver (`mysql2`).
+// Covers Sequelize, TypeORM, Knex, Drizzle and MikroORM running on MySQL, because they call mysql2.
+// mysql2's promise API sits on top of the same core connection, so patching the core covers both.
+//
+// Logs writes of AI-tagged requests, and for tagged UPDATE / INSERT / DELETE saves a snapshot first (see capture-mysql.js).
+// 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-mysql");
+const undoMysql = require("../undo-mysql");
+const {
+  classifyMysql,
+  wouldBeNonCapturableMysql,
+} = require("../sql-classify-mysql");
+
+const MARK = Symbol.for("botversion.undoExp.mysql2Patched");
+const attachedCopies = [];
+
+function looksLikeMysql2(exp) {
+  return !!(
+    exp &&
+    typeof exp.createConnection === "function" &&
+    typeof exp.createPool === "function" &&
+    exp.Connection &&
+    exp.Connection.prototype &&
+    typeof exp.Connection.prototype.query === "function" &&
+    typeof exp.Connection.prototype.execute === "function"
+  );
+}
+
+// mysql2 gets either a string, an options object { sql, values }, or its own internal query object (also has .sql).
+function readCall(args) {
+  const first = args[0];
+  if (typeof first === "string")
+    return {
+      text: first,
+      values: Array.isArray(args[1]) ? args[1] : undefined,
+    };
+  if (first && typeof first.sql === "string")
+    return {
+      text: first.sql,
+      values: Array.isArray(first.values)
+        ? first.values
+        : Array.isArray(args[1])
+          ? args[1]
+          : undefined,
+    };
+  return { text: null };
+}
+
+// Called for every query on a patched mysql2. Must never throw and never alter anything.
+function observe(method, args) {
+  if (guard.isUnhooked()) return;
+  const store = tagger.getCurrent();
+  if (!store) return; // normal (untagged) request: do nothing at all
+
+  store.queries++;
+  const { text, values } = readCall(args);
+  if (text === null) {
+    return;
+  }
+
+  const paramCount = Array.isArray(values) ? values.length : 0;
+  const result = classifyMysql(text);
+
+  if (result.parseFailed) {
+    return;
+  }
+  for (const w of result.writes) {
+    store.writes++;
+    const tables = w.tables.filter(Boolean).join(", ") || "?";
+    const notes = w.notes.length ? "  notes=" + w.notes.join(",") : "";
+  }
+}
+
+function wrapMethod(proto, method, queryOriginal) {
+  const original = proto[method];
+  if (typeof original !== "function" || original[MARK]) return false;
+  const wrapped = function () {
+    try {
+      observe(method, arguments);
+    } catch (_) {
+      /* observation problems must never affect the host's query */
+    }
+    try {
+      // Remember the host's pool (pool connections point back to it) so Undo can reuse it, with no connection string needed.
+      if (this && this._pool) undoMysql.remember(this._pool);
+    } catch (_) {
+      /* never break the host */
+    }
+    try {
+      // Tagged UPDATE/INSERT/DELETE: capture saves the snapshot, then runs the host's statement itself.
+      const handled = capture.maybeCapture(
+        this,
+        arguments,
+        original,
+        queryOriginal,
+      );
+      if (handled) return handled.value;
+    } catch (_) {
+      /* capture problems must never affect the host's query */
+    }
+    return original.apply(this, arguments);
+  };
+  Object.defineProperty(wrapped, MARK, { value: true });
+  proto[method] = wrapped;
+  return true;
+}
+
+function patchExports(exp, where) {
+  if (!looksLikeMysql2(exp)) return false;
+  const proto = exp.Connection.prototype;
+  const queryOriginal = proto.query; // mysql2's real query, used by capture for its own reads and saves
+  const a = wrapMethod(proto, "query", queryOriginal);
+  const b = wrapMethod(proto, "execute", queryOriginal);
+  if (!a && !b) return false;
+  attachedCopies.push(where || "unknown location");
+  return true;
+}
+
+function attach(hostRoot) {
+  // 1. The host's own copy of mysql2, if it can be found right now.
+  try {
+    const resolved = require.resolve("mysql2", {
+      paths: [hostRoot, process.cwd()],
+    });
+    patchExports(require(resolved), path.dirname(resolved));
+  } catch (_) {
+    // Not installed: fine, other databases may be in use.
+  }
+  // 2. Any other copy of mysql2 that loads later (nested copies).
+  loader.onLoad(
+    (request) =>
+      request === "mysql2" || /[\\/]mysql2[\\/]index\.js$/.test(request),
+    (exp, request, parent) => {
+      patchExports(exp, loader.whereOf(request, parent));
+    },
+  );
+  return attachedCopies.slice();
+}
+
+module.exports = { attach, attachedCopies };

package/undo/lib/hooks/pg.js

@@ -0,0 +1,156 @@
+// lib/hooks/pg.js
+"use strict";
+// DATABASE HOOK: Postgres driver (`pg`).
+// Covers Sequelize, TypeORM, Knex, Drizzle, MikroORM and Prisma-with-driver-adapter
+// running on Postgres, because they all end up calling pg's Client.prototype.query.
+//
+// How it avoids the "duplicate driver copy" problem (plan section 15):
+//  1. It patches the SHARED prototype of the host's own copy of pg, so connections
+//     created earlier are covered too.
+//  2. It also watches Node's module loader, so any OTHER copy of pg loaded later
+//     (nested node_modules, ESM import path) gets patched the moment it loads.
+//
+// EXPERIMENT: this hook only LOGS writes of AI-tagged requests. It never changes
+// the query, its parameters or its result.
+
+const path = require("path");
+const log = require("../log");
+const loader = require("../loader-watch");
+const tagger = require("../tagger");
+const { classify, wouldBeNonCapturable } = require("../sql-classify");
+const capture = require("../capture-sql");
+const guard = require("../capture-guard");
+const undoPg = require("../undo-pg");
+
+const MARK = Symbol.for("botversion.undoExp.pgPatched");
+const attachedCopies = []; // where we attached, for the startup report
+
+// Looks like the real `pg` package? (works even when it was loaded by file path)
+function looksLikePg(exp) {
+  return !!(
+    exp &&
+    exp.Client &&
+    exp.Pool &&
+    exp.Client.prototype &&
+    typeof exp.Client.prototype.query === "function" &&
+    typeof exp.Client.prototype.escapeIdentifier === "function"
+  );
+}
+
+// Called for every query on a patched pg. Must never throw and never alter anything.
+function observe(args) {
+  if (guard.isUnhooked()) return; // the Prisma hook is handling this write
+  const store = tagger.getCurrent();
+  if (!store) return; // normal (untagged) request: do nothing at all
+
+  store.queries++;
+
+  const first = args[0];
+  let text = null;
+  let values;
+  if (typeof first === "string") {
+    text = first;
+    values = args[1];
+  } else if (first && typeof first.text === "string") {
+    text = first.text;
+    values = first.values !== undefined ? first.values : args[1];
+  }
+
+  if (text === null) {
+    // e.g. cursors / custom query objects: we cannot read these.
+    return;
+  }
+
+  const paramCount = Array.isArray(values) ? values.length : 0;
+  const result = classify(text);
+
+  if (result.parseFailed) {
+    return;
+  }
+
+  for (const w of result.writes) {
+    store.writes++;
+    const tables = w.tables.filter(Boolean).join(", ") || "?";
+    const notes = w.notes.length ? "  notes=" + w.notes.join(",") : "";
+    const nonCapturable = wouldBeNonCapturable(w);
+  }
+}
+
+function patchExports(exp, where) {
+  if (!looksLikePg(exp)) return false;
+  const proto = exp.Client.prototype;
+  if (proto.query[MARK]) return false; // already patched
+
+  const original = proto.query;
+  const wrapped = function query() {
+    try {
+      observe(arguments);
+    } catch (_) {
+      /* observation problems must never affect the host's query */
+    }
+    try {
+      // Tagged UPDATE/INSERT: capture saves the snapshot, then runs the host's query itself.
+      const handled = capture.maybeCapture(this, arguments, original);
+      if (handled) return handled.value;
+    } catch (_) {
+      /* capture problems must never affect the host's query */
+    }
+    return original.apply(this, arguments);
+  };
+  Object.defineProperty(wrapped, MARK, { value: true });
+  proto.query = wrapped;
+
+  // Remember the host's connection pool so Undo can reuse it (no connection string needed).
+  try {
+    const poolProto = exp.Pool && exp.Pool.prototype;
+    if (
+      poolProto &&
+      typeof poolProto.connect === "function" &&
+      !poolProto.connect[MARK]
+    ) {
+      const origConnect = poolProto.connect;
+      const wrappedConnect = function connect() {
+        try {
+          undoPg.remember(this);
+        } catch (_) {
+          /* never break the host */
+        }
+        return origConnect.apply(this, arguments);
+      };
+      Object.defineProperty(wrappedConnect, MARK, { value: true });
+      poolProto.connect = wrappedConnect;
+    }
+  } catch (_) {
+    /* never break the host */
+  }
+
+  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 of pg, if it can be found right now.
+  try {
+    const resolved = require.resolve("pg", {
+      paths: [hostRoot, process.cwd()],
+    });
+    const exp = require(resolved);
+    patchExports(exp, path.dirname(resolved));
+  } catch (_) {
+    // Not installed or not loadable: fine, other databases may be in use.
+  }
+
+  // 2. Catch any other copy of pg that loads later (nested copies, ESM import path).
+  loader.onLoad(
+    (request) =>
+      request === "pg" || /[\\/]pg[\\/]lib[\\/]index\.js$/.test(request),
+    (exp, request, parent) => {
+      patchExports(exp, loader.whereOf(request, parent));
+    },
+  );
+
+  return attachedCopies.slice();
+}
+
+module.exports = { attach, attachedCopies };