botversion-sdk 2.2.3 → 2.3.0

package/undo/lib/scanner.js

@@ -0,0 +1,400 @@
+// lib/scanner.js
+"use strict";
+// ENVIRONMENT SCANNER
+// Detects, at runtime, which database libraries the host project has and how it
+// looks like it is built (bundled or not). It never touches the database and
+// never reads any data. (The full database-structure scan is Phase 1.)
+
+const fs = require("fs");
+const path = require("path");
+const log = require("./log");
+
+// name -> does THIS experiment have a hook for it?
+const DRIVERS = [
+  { name: "pg", label: "Postgres (pg)", hooked: true },
+  { name: "mysql2", label: "MySQL (mysql2)", hooked: true },
+  { name: "mysql", label: "MySQL (mysql)", hooked: false },
+  { name: "mongodb", label: "MongoDB (mongodb)", hooked: true },
+  { name: "mongoose", label: "MongoDB (mongoose)", hooked: true },
+  { name: "better-sqlite3", label: "SQLite (better-sqlite3)", hooked: true },
+  { name: "sqlite3", label: "SQLite (sqlite3)", hooked: true },
+  { name: "mssql", label: "SQL Server (mssql)", hooked: true },
+  { name: "tedious", label: "SQL Server (tedious)", hooked: true },
+  { name: "oracledb", label: "Oracle (oracledb)", hooked: false },
+  { name: "@neondatabase/serverless", label: "Neon serverless", hooked: false },
+  {
+    name: "@planetscale/database",
+    label: "PlanetScale serverless",
+    hooked: false,
+  },
+  { name: "@libsql/client", label: "Turso / libSQL", hooked: false },
+  {
+    name: "@supabase/supabase-js",
+    label: "Supabase web API (cannot be hooked)",
+    hooked: false,
+  },
+];
+
+const ORMS = [
+  "prisma",
+  "@prisma/client",
+  "sequelize",
+  "typeorm",
+  "knex",
+  "drizzle-orm",
+  "@mikro-orm/core",
+  "mongoose",
+];
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (_) {
+    return null;
+  }
+}
+
+// Walks up from a folder until it finds a package.json.
+function findProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 12; i++) {
+    if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+function findHostRoot() {
+  const candidates = [];
+  try {
+    if (require.main && require.main.filename)
+      candidates.push(path.dirname(require.main.filename));
+  } catch (_) {
+    /* ignore */
+  }
+  candidates.push(process.cwd());
+  for (const c of candidates) {
+    // A launcher inside node_modules (e.g. the "next" or "nest" command) is a tool, not the host project.
+    if (/[\\/]node_modules[\\/]/.test(c)) continue;
+    const root = findProjectRoot(c);
+    if (root && !/[\\/]node_modules[\\/]/.test(root)) return root;
+  }
+  return process.cwd();
+}
+
+// Finds an installed package from the HOST's point of view.
+// Looks directly for node_modules/<name>/package.json going up the folder tree.
+// (Not require.resolve: packages with a strict "exports" map refuse that lookup,
+// which would make them invisible to the scan.)
+function locate(name, hostRoot) {
+  const starts = [hostRoot, process.cwd()];
+  for (const start of starts) {
+    let dir = start;
+    for (let i = 0; i < 20; i++) {
+      const pkgFile = path.join(dir, "node_modules", name, "package.json");
+      if (fs.existsSync(pkgFile)) {
+        const json = readJson(pkgFile);
+        return { dir: path.dirname(pkgFile), version: json && json.version };
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+
+function majorOf(version) {
+  const n = parseInt(String(version || "").split(".")[0], 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+// Reads which database Prisma is configured for, from the schema file(s).
+// Only the provider NAME is read (e.g. "postgresql") - never the connection URL.
+// Handles single-file and multi-file schemas; returns null if no schema is found.
+function readPrismaDatasource(hostRoot) {
+  const pkg = readJson(path.join(hostRoot, "package.json")) || {};
+  const candidates = [];
+  if (pkg.prisma && typeof pkg.prisma.schema === "string")
+    candidates.push(path.resolve(hostRoot, pkg.prisma.schema));
+  candidates.push(
+    path.join(hostRoot, "prisma", "schema.prisma"),
+    path.join(hostRoot, "schema.prisma"),
+    path.join(hostRoot, "prisma", "schema"),
+    path.join(hostRoot, "src", "prisma", "schema.prisma"),
+  );
+
+  const files = [];
+  for (const c of candidates) {
+    try {
+      const st = fs.statSync(c);
+      if (st.isDirectory()) {
+        for (const f of fs.readdirSync(c))
+          if (f.endsWith(".prisma")) files.push(path.join(c, f));
+      } else {
+        files.push(c);
+      }
+    } catch (_) {
+      /* not there - try the next place */
+    }
+  }
+
+  for (const file of files) {
+    try {
+      const text = fs.readFileSync(file, "utf8").replace(/\/\/.*$/gm, ""); // drop comments
+      const block = /datasource\s+\w+\s*\{([^}]*)\}/.exec(text);
+      if (!block) continue;
+      const prov = /provider\s*=\s*"([^"]+)"/.exec(block[1]);
+      if (prov)
+        return { provider: prov[1], file: path.relative(hostRoot, file) };
+    } catch (_) {
+      /* unreadable file - try the next one */
+    }
+  }
+  return null;
+}
+
+const PROVIDER_LABELS = {
+  postgresql: "PostgreSQL",
+  postgres: "PostgreSQL",
+  cockroachdb: "CockroachDB (Postgres-compatible)",
+  mysql: "MySQL",
+  sqlite: "SQLite",
+  sqlserver: "SQL Server",
+  mongodb: "MongoDB",
+};
+
+// Which path does Prisma use? (plan VERIFY item). Heuristic only - the report says so.
+function detectPrisma(hostRoot) {
+  const client = locate("@prisma/client", hostRoot);
+  if (!client) return null;
+  const adapters = [];
+  for (const name of [
+    "@prisma/adapter-pg",
+    "@prisma/adapter-neon",
+    "@prisma/adapter-planetscale",
+    "@prisma/adapter-libsql",
+    "@prisma/adapter-mariadb",
+    "@prisma/adapter-better-sqlite3",
+    "@prisma/adapter-mssql",
+  ]) {
+    if (locate(name, hostRoot)) adapters.push(name);
+  }
+  const major = majorOf(client.version);
+  let path_;
+  if (adapters.length) {
+    path_ =
+      "driver adapter (" +
+      adapters.join(", ") +
+      ") - queries should pass through the normal driver";
+  } else if (major !== null && major >= 7) {
+    path_ =
+      "Prisma 7+ (driver adapters are expected) - no adapter package found, please check";
+  } else {
+    path_ =
+      "Prisma's own engine - NOT visible to the pg hook (the Prisma hook covers it at model level)";
+  }
+  const ds = readPrismaDatasource(hostRoot);
+  // TEMP DEBUG: where the schema was looked for and whether a database provider was read
+  log.debug(
+    "scanner prisma schema:",
+    "hostRoot=" + hostRoot,
+    ds
+      ? "provider=" + ds.provider + " file=" + ds.file
+      : "no schema file found in the usual places",
+  );
+  const database = ds
+    ? {
+        name: PROVIDER_LABELS[ds.provider] || ds.provider,
+        file: ds.file,
+        provider: ds.provider,
+      }
+    : null;
+  return { version: client.version, path: path_, adapters, database };
+}
+
+// Does this code look like it is running from a bundle instead of from node_modules?
+function detectBundling(ownDir) {
+  const signals = [];
+  try {
+    if (typeof __webpack_require__ !== "undefined")
+      signals.push("webpack bundle markers present");
+  } catch (_) {
+    /* ignore */
+  }
+  const inNodeModules = /[\\/]node_modules[\\/]/.test(ownDir);
+  if (!inNodeModules)
+    signals.push(
+      "this package is running from outside node_modules (" + ownDir + ")",
+    );
+  if (
+    /[\\/]\.next[\\/]/.test(ownDir) ||
+    /[\\/]dist[\\/]/.test(ownDir) ||
+    /[\\/]\.output[\\/]/.test(ownDir)
+  ) {
+    signals.push("running from a build output folder");
+  }
+  return { looksBundled: signals.length > 0, signals };
+}
+
+// Is a copy of pg loaded from somewhere that is NOT node_modules? (= bundled copy)
+function pgLoadedFromOutsideNodeModules() {
+  try {
+    return Object.keys(require.cache).filter(
+      (f) =>
+        /[\\/]pg[\\/]lib[\\/]client\.js$/.test(f) && !/node_modules/.test(f),
+    );
+  } catch (_) {
+    return [];
+  }
+}
+
+// Which SQL dialect should the snapshot table be written for? Prisma's schema file is the most reliable
+// source; otherwise the installed driver, but only if exactly one kind is installed (else unknown -> example).
+const PROVIDER_TO_DIALECT = {
+  postgresql: "postgres",
+  postgres: "postgres",
+  cockroachdb: "postgres",
+  mysql: "mysql",
+  sqlite: "sqlite",
+  sqlserver: "sqlserver",
+  mongodb: "mongodb",
+};
+const DRIVER_TO_DIALECT = {
+  pg: "postgres",
+  "@neondatabase/serverless": "postgres",
+  mysql2: "mysql",
+  mysql: "mysql",
+  "@planetscale/database": "mysql",
+  "better-sqlite3": "sqlite",
+  sqlite3: "sqlite",
+  "@libsql/client": "sqlite",
+  mssql: "sqlserver",
+  tedious: "sqlserver",
+  mongodb: "mongodb",
+  mongoose: "mongodb",
+};
+const DIALECT_LABELS = {
+  postgres: "Postgres",
+  mysql: "MySQL",
+  sqlite: "SQLite",
+  sqlserver: "SQL Server",
+  mongodb: "MongoDB",
+};
+
+function detectSnapshotDialect(prisma, drivers) {
+  if (
+    prisma &&
+    prisma.database &&
+    PROVIDER_TO_DIALECT[prisma.database.provider]
+  ) {
+    const dialect = PROVIDER_TO_DIALECT[prisma.database.provider];
+    return {
+      dialect,
+      label: DIALECT_LABELS[dialect],
+      source: "Prisma schema file " + prisma.database.file,
+    };
+  }
+  const found = new Map(); // dialect -> first driver name that implies it
+  for (const d of drivers) {
+    const dialect = DRIVER_TO_DIALECT[d.name];
+    if (dialect && !found.has(dialect)) found.set(dialect, d.name);
+  }
+  if (found.size === 1) {
+    const [dialect, driverName] = [...found.entries()][0];
+    return {
+      dialect,
+      label: DIALECT_LABELS[dialect],
+      source: "installed library " + driverName,
+    };
+  }
+  return null; // none found, or several kinds: do not guess
+}
+
+// FIX: reads the database type from a live Prisma client, so it does not depend on where the schema file is.
+// Returns the same words the snapshot code uses (postgres, mysql, sqlite, sqlserver, mongodb), or null if the client does not say.
+function dialectFromPrismaClient(client) {
+  try {
+    const provider =
+      (client && client._activeProvider) ||
+      (client && client._engineConfig && client._engineConfig.activeProvider) ||
+      null;
+    return (
+      (provider && PROVIDER_TO_DIALECT[String(provider).toLowerCase()]) || null
+    );
+  } catch (_) {
+    return null;
+  }
+}
+
+function scan() {
+  const hostRoot = findHostRoot();
+  const hostPkg = readJson(path.join(hostRoot, "package.json")) || {};
+  const declared = Object.assign(
+    {},
+    hostPkg.dependencies,
+    hostPkg.devDependencies,
+  );
+
+  const drivers = [];
+  for (const d of DRIVERS) {
+    const found = locate(d.name, hostRoot);
+    if (found) drivers.push({ ...d, version: found.version, dir: found.dir });
+  }
+
+  const orms = [];
+  for (const name of ORMS) {
+    if (declared[name] || locate(name, hostRoot)) {
+      const found = locate(name, hostRoot);
+      orms.push({ name, version: found && found.version });
+    }
+  }
+
+  const prisma = detectPrisma(hostRoot);
+  const snapshotTable = detectSnapshotDialect(prisma, drivers);
+  // TEMP DEBUG: what detection found (names and paths only)
+  log.debug(
+    "scanner result:",
+    "hostRoot=" + hostRoot,
+    "prismaFound=" + !!prisma,
+    "prismaDatabase=" +
+      (prisma && prisma.database
+        ? prisma.database.provider + " from " + prisma.database.file
+        : "NOT FOUND"),
+    "snapshotDialect=" +
+      (snapshotTable
+        ? snapshotTable.dialect + " via " + snapshotTable.source
+        : "NONE"),
+    "drivers=" + drivers.map((d) => d.name).join("|"),
+  );
+
+  return {
+    hostRoot,
+    hostName: hostPkg.name || "(unnamed project)",
+    nodeVersion: process.version,
+    framework: [
+      "next",
+      "nestjs",
+      "@nestjs/core",
+      "express",
+      "fastify",
+      "koa",
+      "hono",
+      "@remix-run/node",
+      "nuxt",
+      "@sveltejs/kit",
+    ]
+      .filter((n) => declared[n] || locate(n, hostRoot))
+      .map((n) => n),
+    drivers,
+    orms,
+    prisma,
+    snapshotTable,
+    bundling: detectBundling(__dirname),
+    pgOutsideNodeModules: pgLoadedFromOutsideNodeModules(),
+  };
+}
+
+module.exports = { scan, findHostRoot, dialectFromPrismaClient };

package/undo/lib/schema-reader.js

@@ -0,0 +1,129 @@
+// lib/schema-reader.js
+"use strict";
+// SCHEMA READER (Phase 1)
+// Reads tables, primary keys and foreign-key delete rules from Prisma's own data model.
+// Structure only: never row data, never a database connection, never the connection string.
+// Must run AFTER the database hooks are attached, so loading Prisma here cannot make the Prisma hook miss it.
+// Never throws: on any problem it returns { ok: false, reason }.
+
+const log = require("./log");
+
+function loadPrismaNamespace(hostRoot) {
+  const resolved = require.resolve("@prisma/client", {
+    paths: [hostRoot, process.cwd()],
+  });
+  return require(resolved).Prisma;
+}
+
+function readPrismaStructure(hostRoot) {
+  try {
+    const Prisma = loadPrismaNamespace(hostRoot);
+    const dm = Prisma && Prisma.dmmf && Prisma.dmmf.datamodel;
+    if (!dm || !Array.isArray(dm.models)) {
+      return {
+        ok: false,
+        reason: "this Prisma version does not expose its data model here",
+      };
+    }
+
+    const tableOf = new Map();
+    for (const m of dm.models) tableOf.set(m.name, m.dbName || m.name);
+
+    const tables = [];
+    const links = [];
+    for (const m of dm.models) {
+      const table = tableOf.get(m.name);
+
+      // Primary key: a compound key if declared, otherwise the field(s) marked as id.
+      let primaryKey = [];
+      if (
+        m.primaryKey &&
+        Array.isArray(m.primaryKey.fields) &&
+        m.primaryKey.fields.length
+      ) {
+        primaryKey = m.primaryKey.fields.slice();
+      } else {
+        primaryKey = m.fields.filter((f) => f.isId).map((f) => f.name);
+      }
+      tables.push({ table, primaryKey });
+
+      // Only the side that holds the foreign key states the delete rule.
+      for (const f of m.fields) {
+        if (
+          f.kind !== "object" ||
+          !Array.isArray(f.relationFromFields) ||
+          f.relationFromFields.length === 0
+        )
+          continue;
+        const written =
+          typeof f.relationOnDelete === "string" && f.relationOnDelete
+            ? f.relationOnDelete
+            : null;
+        // No rule written in the schema: Prisma's documented default (Restrict if required, SetNull if optional).
+        const rule = written || (f.isRequired ? "Restrict" : "SetNull");
+        links.push({
+          child: table,
+          parent: tableOf.get(f.type) || f.type,
+          rule,
+          explicit: !!written,
+        });
+      }
+    }
+    return { ok: true, source: "Prisma's data model", tables, links };
+  } catch (e) {
+    return { ok: false, reason: String((e && e.message) || e).slice(0, 120) };
+  }
+}
+
+// Delete links by MODEL name: parent model -> the models that hold a foreign key to it, with the delete rule.
+// Read at the moment of a delete (never at startup), so loading Prisma here cannot make the Prisma hook miss it.
+function readDeleteGraph(hostRoot) {
+  try {
+    const Prisma = loadPrismaNamespace(hostRoot);
+    const dm = Prisma && Prisma.dmmf && Prisma.dmmf.datamodel;
+    if (!dm || !Array.isArray(dm.models)) {
+      // TEMP DEBUG: why the delete links could not be read
+      log.debug(
+        "schema-reader delete graph: no data model",
+        "hasPrismaNamespace=" + !!Prisma,
+        "hasDmmf=" + !!(Prisma && Prisma.dmmf),
+      );
+      return null;
+    }
+    const graph = new Map();
+    for (const m of dm.models) {
+      for (const f of m.fields) {
+        if (
+          f.kind !== "object" ||
+          !Array.isArray(f.relationFromFields) ||
+          f.relationFromFields.length === 0
+        )
+          continue;
+        const written =
+          typeof f.relationOnDelete === "string" && f.relationOnDelete
+            ? f.relationOnDelete
+            : null;
+        const rule = written || (f.isRequired ? "Restrict" : "SetNull");
+        if (!graph.has(f.type)) graph.set(f.type, []);
+        graph.get(f.type).push({
+          child: m.name,
+          rule,
+          fromFields: f.relationFromFields.slice(),
+          toFields: (f.relationToFields || []).slice(),
+        });
+      }
+    }
+    return graph;
+  } catch (e) {
+    // TEMP DEBUG: why Prisma's data model could not be loaded
+    log.debug(
+      "schema-reader delete graph failed:",
+      "name=" + (e && e.name),
+      "code=" + ((e && e.code) || "none"),
+      "msg=" + String((e && e.message) || "").slice(0, 150),
+    );
+    return null;
+  }
+}
+
+module.exports = { readPrismaStructure, readDeleteGraph };