fullshield 0.1.1 → 0.2.6

package/dist/runtime/koa.js

@@ -0,0 +1,573 @@
+// src/runtime/dlp/index.ts
+var DLP_FLAG = "FULLSHIELD_EXPERIMENTAL_DLP";
+var DLP_MAX_BYTES = 64 * 1024;
+var DLP_GENERIC = { error: "internal error" };
+var SECRET_RES = [
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\bsk_(?:live|test)_[A-Za-z0-9]{16,}\b/g,
+  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/g,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+  /\bAIza[0-9A-Za-z_-]{35}\b/g,
+  /\bsk-ant-[A-Za-z0-9_-]{16,}\b|\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /-----BEGIN (?:[A-Z]+ )*PRIVATE KEY-----/g,
+  /\b(?:postgres(?:ql)?|mysql|mariadb|mongodb(?:\+srv)?|redis|amqp):\/\/[^\s'"@/:]+:[^\s'"@]+@/g
+];
+var STACK_RE = /(?:Error|Exception|TypeError|ReferenceError|SyntaxError|RangeError)[^\n]{0,240}(?:\n|\r\n|\\n)[ \t]*at[ \t]+\S+[^\n]{0,320}(?:\n|\r\n|\\n)[ \t]*at[ \t]+/g;
+var INTERNAL_IP_RE = /\b(?:10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3}|172\.(?:1[6-9]|2\d|3[01])\.\d{1,3}\.\d{1,3}|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|169\.254\.\d{1,3}\.\d{1,3})\b/g;
+var HOST_TLDS = [".internal", ".corp", ".lan", ".local"];
+var BULK_EMAILS = 5;
+var PII_LEARN = 2;
+var REDACT = "[REDACTED]";
+var EMPTY_HITS = [];
+function isDlpEnabled() {
+  return process.env[DLP_FLAG] === "1";
+}
+function allMatches(re, text) {
+  re.lastIndex = 0;
+  return [...text.matchAll(re)];
+}
+function maskSample(value) {
+  if (value.length <= 4) return "****";
+  return `${value.slice(0, 4)}****`.slice(0, 40);
+}
+function luhnOk(digits) {
+  if (digits.length < 13 || digits.length > 19) return false;
+  const first = digits.charCodeAt(0) - 48;
+  if (first < 3 || first > 6) return false;
+  if (digits.split("").every((c) => c === digits[0])) return false;
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let n = digits.charCodeAt(i) - 48;
+    if (alt) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+}
+var SECRET_MARKERS = [
+  "AKIA",
+  "sk_",
+  "ghp_",
+  "gho_",
+  "ghu_",
+  "ghs_",
+  "ghr_",
+  "xox",
+  "AIza",
+  "sk-",
+  "BEGIN ",
+  "postgres",
+  "mysql",
+  "mariadb",
+  "mongodb",
+  "redis",
+  "amqp"
+];
+function hasAny(text, markers) {
+  for (const m of markers) {
+    if (text.includes(m)) return true;
+  }
+  return false;
+}
+function collectSpans(text) {
+  const spans = [];
+  if (hasAny(text, SECRET_MARKERS)) {
+    for (const re of SECRET_RES) {
+      for (const m of allMatches(re, text)) {
+        if (m[0] === void 0 || m.index === void 0) continue;
+        if (re.source.includes("postgres") && /\$\{|^<[^>]+>$|^\{[^}]+\}$/.test(m[0])) continue;
+        spans.push({ start: m.index, end: m.index + m[0].length, ruleId: "DLP-SECRET-001", text: m[0] });
+      }
+    }
+  }
+  if (text.includes(" at ") || text.includes("Error") || text.includes("Exception")) {
+    for (const m of allMatches(STACK_RE, text)) {
+      if (m[0] === void 0 || m.index === void 0) continue;
+      spans.push({ start: m.index, end: m.index + m[0].length, ruleId: "DLP-STACK-001", text: m[0] });
+    }
+  }
+  if (/\d/.test(text)) {
+    for (const m of allMatches(INTERNAL_IP_RE, text)) {
+      if (m[0] === void 0 || m.index === void 0) continue;
+      spans.push({ start: m.index, end: m.index + m[0].length, ruleId: "DLP-INTERNAL-001", text: m[0] });
+    }
+    spans.push(...findCards(text));
+  }
+  if (text.includes("localhost") || text.includes("LOCALHOST")) {
+    spans.push(...findLocalhost(text));
+  }
+  if (text.includes(".internal") || text.includes(".corp") || text.includes(".lan") || text.includes(".local") || text.includes(".INTERNAL") || text.includes(".CORP") || text.includes(".LAN") || text.includes(".LOCAL")) {
+    spans.push(...findInternalHosts(text));
+  }
+  return spans;
+}
+function isWord(c) {
+  return c !== void 0 && /[A-Za-z0-9-]/.test(c);
+}
+function findIgnoreCase(hay, needle, from) {
+  const n = needle.length;
+  outer: for (let i = from; i <= hay.length - n; i += 1) {
+    for (let j = 0; j < n; j += 1) {
+      const a = hay.charCodeAt(i + j);
+      const b = needle.charCodeAt(j);
+      if (a !== b && a !== b - 32 && a !== b + 32) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+function findLocalhost(text) {
+  const spans = [];
+  let from = 0;
+  while (from < text.length) {
+    const idx = findIgnoreCase(text, "localhost", from);
+    if (idx < 0) break;
+    if (!isWord(text[idx - 1]) && !isWord(text[idx + 9])) {
+      spans.push({ start: idx, end: idx + 9, ruleId: "DLP-INTERNAL-001", text: text.slice(idx, idx + 9) });
+    }
+    from = idx + 9;
+  }
+  return spans;
+}
+function findInternalHosts(text) {
+  const spans = [];
+  for (const tld of HOST_TLDS) {
+    let from = 0;
+    while (from < text.length) {
+      const idx = findIgnoreCase(text, tld, from);
+      if (idx < 0) break;
+      let start = idx - 1;
+      while (start >= 0 && /[A-Za-z0-9.-]/.test(text[start] ?? "")) start -= 1;
+      start += 1;
+      const label = text.slice(start, idx).toLowerCase();
+      const end = idx + tld.length;
+      if (label.length > 0 && /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/.test(label) && !isWord(text[end])) {
+        spans.push({ start, end, ruleId: "DLP-INTERNAL-001", text: text.slice(start, end) });
+      }
+      from = idx + tld.length;
+    }
+  }
+  return spans;
+}
+function findCards(text) {
+  const spans = [];
+  let i = 0;
+  while (i < text.length) {
+    const code = text.charCodeAt(i);
+    if (code < 48 || code > 57) {
+      i += 1;
+      continue;
+    }
+    let j = i;
+    let digits = "";
+    while (j < text.length) {
+      const c = text.charCodeAt(j);
+      if (c >= 48 && c <= 57) {
+        digits += text[j] ?? "";
+        j += 1;
+      } else if (c === 32 || c === 9 || c === 45) {
+        j += 1;
+      } else {
+        break;
+      }
+    }
+    if (luhnOk(digits)) {
+      spans.push({ start: i, end: j, ruleId: "DLP-CARD-001", text: text.slice(i, j) });
+    }
+    i = j > i ? j : i + 1;
+  }
+  return spans;
+}
+function findEmails(text) {
+  const spans = [];
+  let from = 0;
+  while (from < text.length) {
+    const at = text.indexOf("@", from);
+    if (at < 0) break;
+    let start = at - 1;
+    while (start >= 0 && /[A-Za-z0-9._%+-]/.test(text[start] ?? "")) start -= 1;
+    start += 1;
+    let end = at + 1;
+    while (end < text.length && /[A-Za-z0-9.-]/.test(text[end] ?? "")) end += 1;
+    const local = text.slice(start, at);
+    const domain = text.slice(at + 1, end);
+    const dot = domain.lastIndexOf(".");
+    const tld = dot > 0 ? domain.slice(dot + 1) : "";
+    if (local.length >= 1 && local.length <= 64 && domain.length >= 3 && domain.length <= 255 && /^[A-Za-z]{2,24}$/.test(tld)) {
+      spans.push({ start, end, ruleId: "DLP-PII-001", text: text.slice(start, end) });
+    }
+    from = at + 1;
+  }
+  return spans;
+}
+function countEmails(text) {
+  if (!text.includes("@")) return { count: 0, spans: [] };
+  const spans = findEmails(text);
+  return { count: spans.length, spans };
+}
+function redact(text, spans) {
+  const ordered = [...spans].sort((a, b) => b.start - a.start);
+  let out = text;
+  const taken = [];
+  for (const s of ordered) {
+    if (taken.some(([a, b]) => s.start < b && s.end > a)) continue;
+    taken.push([s.start, s.end]);
+    out = `${out.slice(0, s.start)}${REDACT}${out.slice(s.end)}`;
+  }
+  return out;
+}
+function uniqueHits(spans) {
+  const seen = /* @__PURE__ */ new Set();
+  const hits = [];
+  for (const s of spans) {
+    if (seen.has(s.ruleId)) continue;
+    seen.add(s.ruleId);
+    hits.push({ ruleId: s.ruleId, sample: maskSample(s.text) });
+  }
+  return hits;
+}
+function toText(body) {
+  if (body === null || body === void 0) return void 0;
+  if (typeof body === "string") return { text: body, kind: "string" };
+  if (typeof body === "number" || typeof body === "boolean") return { text: String(body), kind: "string" };
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) return void 0;
+  try {
+    return { text: JSON.stringify(body), kind: "json" };
+  } catch {
+    return void 0;
+  }
+}
+function createDlpInspector(options = {}) {
+  if (!isDlpEnabled() || options.dlp === void 0) return void 0;
+  const mode = options.dlp.mode;
+  const maxBytes = options.dlp.maxBytes ?? DLP_MAX_BYTES;
+  const routes = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  const inspect = (body, ctx) => {
+    const ct = ctx.contentType ?? "";
+    if (ct.length > 0 && !/json|text|javascript|xml/i.test(ct)) {
+      return { action: "allow", body, hits: [], skippedOverCap: false };
+    }
+    const serialized = toText(body);
+    if (serialized === void 0) {
+      return { action: "allow", body, hits: [], skippedOverCap: false };
+    }
+    if (serialized.text.length > maxBytes) {
+      skipped += 1;
+      return { action: "skip", body, hits: [], skippedOverCap: true };
+    }
+    const spans = collectSpans(serialized.text);
+    const emails = countEmails(serialized.text);
+    let pii = routes.get(ctx.path);
+    if (pii === void 0) {
+      pii = { samples: 0, seenLow: false, seenHigh: false };
+      routes.set(ctx.path, pii);
+    }
+    if (pii.samples < PII_LEARN) {
+      pii.samples += 1;
+      if (emails.count <= 1) pii.seenLow = true;
+      if (emails.count >= BULK_EMAILS) pii.seenHigh = true;
+    } else if (pii.seenLow && !pii.seenHigh && emails.count >= BULK_EMAILS) {
+      spans.push(...emails.spans);
+    }
+    const hits = uniqueHits(spans);
+    if (hits.length === 0) {
+      return { action: "allow", body, hits: EMPTY_HITS, skippedOverCap: false };
+    }
+    const ip = ctx.ip ?? "unknown";
+    for (const hit of hits) {
+      const event = { ruleId: hit.ruleId, path: ctx.path, ip, sample: hit.sample };
+      options.onEvent?.(event);
+    }
+    if (mode === "monitor") {
+      return { action: "allow", body, hits, skippedOverCap: false };
+    }
+    if (mode === "block") {
+      return { action: "block", body: { ...DLP_GENERIC }, hits, skippedOverCap: false };
+    }
+    const maskedText = redact(serialized.text, spans);
+    let masked = maskedText;
+    if (serialized.kind === "json") {
+      try {
+        masked = JSON.parse(maskedText);
+      } catch {
+        masked = maskedText;
+      }
+    }
+    return { action: "mask", body: masked, hits, skippedOverCap: false };
+  };
+  const api = inspect;
+  Object.defineProperty(api, "inspect", { value: inspect });
+  Object.defineProperty(api, "skippedOverCap", { get: () => skipped });
+  return api;
+}
+function applyDlpWrite(dlp, body, ctx) {
+  const result = dlp.inspect(body, ctx);
+  return { body: result.body, block: result.action === "block" };
+}
+
+// src/runtime/signatures.ts
+var SQLI = /('\s*or\s+'?1'?\s*='?1)|union\s+select|;\s*drop\s+table|;\s*delete\s+from/i;
+var XSS = /<\s*script\b|javascript:\s*|onerror\s*=/i;
+var PATH = /(\.\.\/|\.\.\\|%2e%2e%2f|%2e%2e\\)/i;
+function flattenValues(value, out = [], depth = 0) {
+  if (depth > 8 || out.length > 200) return out;
+  if (typeof value === "string") {
+    out.push(value);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) flattenValues(item, out, depth + 1);
+    return out;
+  }
+  if (value !== null && typeof value === "object") {
+    for (const item of Object.values(value)) {
+      flattenValues(item, out, depth + 1);
+    }
+  }
+  return out;
+}
+function detectAttack(text) {
+  if (PATH.test(text)) return "path";
+  if (XSS.test(text)) return "xss";
+  if (SQLI.test(text)) return "sqli";
+  return void 0;
+}
+function inspectValues(values) {
+  for (const value of values) {
+    const hit = detectAttack(value);
+    if (hit !== void 0) return hit;
+  }
+  return void 0;
+}
+
+// src/runtime/lru.ts
+var LruMap = class {
+  constructor(max) {
+    this.max = max;
+    if (max < 1) throw new Error("LruMap max must be >= 1");
+  }
+  max;
+  map = /* @__PURE__ */ new Map();
+  get size() {
+    return this.map.size;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    if (!this.map.has(key)) return void 0;
+    const value = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    while (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest === void 0) break;
+      this.map.delete(oldest);
+    }
+    return this;
+  }
+};
+
+// src/runtime/rateLimit.ts
+var DEFAULT_MAX_KEYS = 1e4;
+function createRateLimiter(options) {
+  const maxKeys = options.maxKeys ?? DEFAULT_MAX_KEYS;
+  const hits = new LruMap(maxKeys);
+  return {
+    allow(key, now = Date.now()) {
+      const windowStart = now - options.windowMs;
+      const prev = hits.get(key);
+      if (prev === void 0) {
+        hits.set(key, [now]);
+        return true;
+      }
+      let keep = 0;
+      for (let i = 0; i < prev.length; i += 1) {
+        const t = prev[i];
+        if (t !== void 0 && t > windowStart) {
+          prev[keep] = t;
+          keep += 1;
+        }
+      }
+      prev.length = keep;
+      if (prev.length >= options.max) {
+        hits.set(key, prev);
+        return false;
+      }
+      prev.push(now);
+      hits.set(key, prev);
+      return true;
+    },
+    get size() {
+      return hits.size;
+    },
+    get maxKeys() {
+      return maxKeys;
+    }
+  };
+}
+
+// src/runtime/inspect.ts
+var RULE = {
+  sqli: "RUNTIME-SQLI-001",
+  xss: "RUNTIME-XSS-001",
+  path: "RUNTIME-PATH-001"
+};
+function bodyStats(value, depth = 0) {
+  if (value === null || value === void 0) return { bytes: 0, depth, keys: 0 };
+  if (typeof value === "string") return { bytes: value.length, depth, keys: 0 };
+  if (typeof value === "number" || typeof value === "boolean") {
+    return { bytes: String(value).length, depth, keys: 0 };
+  }
+  if (typeof value !== "object") return { bytes: 0, depth, keys: 0 };
+  const entries = Object.entries(value);
+  let bytes = 2;
+  let keys = entries.length;
+  let maxDepth = depth;
+  for (const [k, v] of entries) {
+    bytes += k.length;
+    const inner = bodyStats(v, depth + 1);
+    bytes += inner.bytes;
+    keys += inner.keys;
+    if (inner.depth > maxDepth) maxDepth = inner.depth;
+  }
+  return { bytes, depth: maxDepth, keys };
+}
+var DEFAULT_MAX_ROUTES = 1e3;
+var DEFAULT_MAX_PARAM_NAMES = 200;
+function keysOf(value) {
+  if (value === null || value === void 0 || typeof value !== "object") return [];
+  return Object.keys(value);
+}
+function createInspector(options = {}) {
+  const mode = options.mode ?? "monitor";
+  const authRoutes = new Set(options.authRoutes ?? ["/login"]);
+  const limiter = createRateLimiter(options.rateLimit ?? { windowMs: 6e4, max: 20 });
+  const maxBodyBytes = options.maxBodyBytes ?? 1e6;
+  const maxBodyDepth = options.maxBodyDepth ?? 8;
+  const maxBodyKeys = options.maxBodyKeys ?? 200;
+  const anomaly = options.anomaly;
+  const maxRoutes = anomaly?.maxRoutes ?? DEFAULT_MAX_ROUTES;
+  const maxParamNames = anomaly?.maxParamNames ?? DEFAULT_MAX_PARAM_NAMES;
+  const routes = new LruMap(maxRoutes);
+  let windowStart;
+  const inspect = ((req) => {
+    const path = req.path ?? req.url?.split("?")[0] ?? "/";
+    const ip = req.ip ?? "unknown";
+    const emit = (ruleId, sample, shouldBlock) => {
+      const event = { ruleId, path, ip, sample: sample.slice(0, 40) };
+      options.onEvent?.(event);
+      if (shouldBlock) options.onBlock?.(event);
+      return { block: shouldBlock, event };
+    };
+    if (authRoutes.has(path) && !limiter.allow(`${ip}:${path}`)) {
+      return emit("RUNTIME-RATELIMIT-001", path, mode === "block");
+    }
+    const stats = bodyStats(req.body);
+    if (stats.bytes > maxBodyBytes || stats.depth > maxBodyDepth || stats.keys > maxBodyKeys) {
+      return emit("RUNTIME-BODY-001", "oversized-body", mode === "block");
+    }
+    const values = [
+      ...flattenValues(req.query),
+      ...flattenValues(req.body),
+      ...flattenValues(req.params)
+    ];
+    const kind = inspectValues(values);
+    if (kind !== void 0) {
+      return emit(RULE[kind], kind, mode === "block");
+    }
+    if (anomaly !== void 0) {
+      const now = anomaly.now ?? Date.now;
+      const t = now();
+      if (windowStart === void 0) windowStart = t;
+      const learning = t - windowStart < anomaly.learnMinutes * 6e4;
+      let baseline = routes.get(path);
+      if (baseline === void 0) {
+        baseline = {
+          count: 0,
+          bodySum: 0,
+          paramNames: new LruMap(maxParamNames),
+          status401: 0,
+          status404: 0,
+          recent404: 0
+        };
+        routes.set(path, baseline);
+      }
+      const names = [...keysOf(req.query), ...keysOf(req.body), ...keysOf(req.params)];
+      const status = req.statusCode;
+      if (learning) {
+        baseline.count += 1;
+        baseline.bodySum += stats.bytes;
+        for (const n of names) baseline.paramNames.set(n, true);
+        if (status === 401) baseline.status401 += 1;
+        if (status === 404) baseline.status404 += 1;
+      } else {
+        const newParam = names.some((n) => !baseline.paramNames.has(n));
+        const spike401 = status === 401 && baseline.status401 === 0 && baseline.count > 0;
+        if (status === 404) baseline.recent404 += 1;
+        else baseline.recent404 = 0;
+        const burst404 = baseline.recent404 >= 3 && baseline.status404 === 0 && baseline.count > 0;
+        if (newParam || spike401 || burst404) {
+          const event = {
+            ruleId: "RUNTIME-ANOMALY-001",
+            path,
+            ip,
+            sample: newParam ? "new-param" : spike401 ? "401-spike" : "404-burst"
+          };
+          anomaly.onAnomaly?.(event);
+          options.onEvent?.(event);
+          return { block: false, event };
+        }
+      }
+    }
+    return { block: false };
+  });
+  Object.defineProperty(inspect, "limiterSize", { get: () => limiter.size });
+  Object.defineProperty(inspect, "routeCount", { get: () => routes.size });
+  inspect.paramCount = (path) => routes.get(path)?.paramNames.size ?? 0;
+  return inspect;
+}
+
+// src/runtime/koa.ts
+function shieldGuard(options = {}) {
+  const inspect = createInspector(options);
+  const dlp = createDlpInspector(options);
+  return async function fullshieldKoa(ctx, next) {
+    const result = inspect({
+      method: ctx.method,
+      url: ctx.url,
+      path: ctx.path ?? ctx.url?.split("?")[0],
+      ip: ctx.ip,
+      query: ctx.query,
+      body: ctx.request?.body,
+      params: ctx.params,
+      headers: ctx.headers
+    });
+    if (result.block) {
+      ctx.status = 403;
+      ctx.body = { error: "blocked", ruleId: result.event?.ruleId };
+      return;
+    }
+    await next();
+    if (dlp === void 0) return;
+    const out = applyDlpWrite(dlp, ctx.body, { path: ctx.path ?? ctx.url?.split("?")[0] ?? "/", ip: ctx.ip });
+    if (out.block) {
+      ctx.status = 500;
+      ctx.body = { error: "internal error" };
+      return;
+    }
+    ctx.body = out.body;
+  };
+}
+
+export { shieldGuard };

package/dist/runtime/rasp.js

@@ -526,9 +526,25 @@ function sinkTexts(sink) {
   if (typeof sink === "number" || typeof sink === "boolean") return [String(sink)];
   return [];
 }
+function whereJsChangesStructure(sink, ctx) {
+  let code = "";
+  if (typeof sink === "string") code = sink;
+  else if (sink !== null && typeof sink === "object" && !Array.isArray(sink) && "$where" in sink) {
+    const where = sink.$where;
+    if (typeof where === "string") code = where;
+  }
+  if (!code) return false;
+  for (const input of ctx.strings) {
+    if (input && sqlInputChangesStructure(code, input)) return true;
+  }
+  return false;
+}
 function detectStructureChange(kind, sink, ctx, base) {
   if (kind === "proto") return protoPolluted(ctx);
-  if (kind === "nosql") return nosqlUserOperators(sink, ctx);
+  if (kind === "nosql") {
+    if (nosqlUserOperators(sink, ctx)) return true;
+    return whereJsChangesStructure(sink, ctx);
+  }
   for (const text of sinkTexts(sink)) {
     for (const input of ctx.strings) {
       if (!input) continue;
@@ -826,11 +842,38 @@ function patchMethod(obj, key, wrapper) {
     record[key] = orig;
   });
 }
+function sqlTextFrom(sql) {
+  if (typeof sql === "string") return sql;
+  if (Array.isArray(sql)) {
+    return sql.filter((part) => typeof part === "string").join(" ");
+  }
+  if (sql !== null && typeof sql === "object") {
+    const rec = sql;
+    if (typeof rec.text === "string") return rec.text;
+    if (typeof rec.sql === "string") return rec.sql;
+    if (Array.isArray(rec.strings)) {
+      return rec.strings.filter((part) => typeof part === "string").join(" ");
+    }
+  }
+  return "";
+}
 function wrapSqlMethod(obj, key) {
   patchMethod(obj, key, (orig) => {
     return function(sql, ...rest) {
-      const text = typeof sql === "string" ? sql : sql && typeof sql === "object" && "text" in sql && typeof sql.text === "string" ? sql.text : "";
-      return applySink("sql", text, void 0, () => orig.call(this, sql, ...rest));
+      return applySink(
+        "sql",
+        sqlTextFrom(sql),
+        void 0,
+        () => orig.call(this, sql, ...rest)
+      );
+    };
+  });
+}
+function wrapNosqlWhere(obj, key) {
+  patchMethod(obj, key, (orig) => {
+    return function(expr, ...rest) {
+      const sink = typeof expr === "string" ? { $where: expr } : expr ?? {};
+      return applySink("nosql", sink, void 0, () => orig.call(this, expr, ...rest));
     };
   });
 }
@@ -1121,6 +1164,57 @@ function wrapKnownPackage(request, exported) {
     wrappedPackages.add(obj);
     return exported;
   }
+  if (name === "@prisma/client" || name === "prisma" || name.endsWith("/@prisma/client")) {
+    const client = exported.PrismaClient?.prototype;
+    if (client) {
+      wrapSqlMethod(client, "$queryRawUnsafe");
+      wrapSqlMethod(client, "$executeRawUnsafe");
+      wrapSqlMethod(client, "$queryRaw");
+      wrapSqlMethod(client, "$executeRaw");
+    }
+    const Prisma = exported.Prisma;
+    if (Prisma) wrapSqlMethod(Prisma, "raw");
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "sequelize" || name.endsWith("/sequelize")) {
+    const rec = exported;
+    const proto = rec.Sequelize?.prototype ?? rec.prototype;
+    if (proto) wrapSqlMethod(proto, "query");
+    if (typeof rec.literal === "function") wrapSqlMethod(rec, "literal");
+    if (rec.Sequelize && typeof rec.Sequelize.literal === "function") wrapSqlMethod(rec.Sequelize, "literal");
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "knex" || name.endsWith("/knex")) {
+    if (typeof exported.raw === "function") wrapSqlMethod(obj, "raw");
+    const client = exported.Client?.prototype;
+    if (client) {
+      wrapSqlMethod(client, "raw");
+      wrapSqlMethod(client, "whereRaw");
+      wrapSqlMethod(client, "orderByRaw");
+      wrapSqlMethod(client, "query");
+    }
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "typeorm" || name.endsWith("/typeorm")) {
+    const rec = exported;
+    for (const cls of ["DataSource", "EntityManager", "QueryRunner", "Connection"]) {
+      const proto = rec[cls]?.prototype;
+      if (proto) wrapSqlMethod(proto, "query");
+    }
+    const qb = rec.SelectQueryBuilder?.prototype ?? rec.QueryBuilder?.prototype;
+    if (qb) wrapSqlMethod(qb, "where");
+    wrappedPackages.add(obj);
+    return exported;
+  }
+  if (name === "drizzle-orm" || name.endsWith("/drizzle-orm")) {
+    const sql = exported.sql;
+    if (sql) wrapSqlMethod(sql, "raw");
+    wrappedPackages.add(obj);
+    return exported;
+  }
   if (name === "mongodb" || name.includes("mongodb")) {
     const col = exported.Collection?.prototype;
     if (col) {
@@ -1141,7 +1235,10 @@ function wrapKnownPackage(request, exported) {
           return applySink("nosql", query ?? {}, void 0, () => orig.call(this, query, ...rest));
         };
       });
+      wrapNosqlWhere(q, "$where");
     }
+    const model = exported.Model?.prototype;
+    if (model) wrapNosqlWhere(model, "$where");
     wrappedPackages.add(obj);
     return exported;
   }