prisma-sql 1.54.0 → 1.56.0

package/dist/index.js

@@ -704,6 +704,9 @@ function assertNoControlChars(label, s) {
     );
   }
 }
+function quoteRawIdent(id) {
+  return `"${id.replace(/"/g, '""')}"`;
+}
 function isIdentCharCode(c) {
   return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95;
 }
@@ -725,33 +728,33 @@ function parseQuotedPart(input, start) {
       }
       if (!sawAny) {
         throw new Error(
-          `tableName/tableRef has empty quoted identifier part: ${JSON.stringify(input)}`
+          `qualified name has empty quoted identifier part: ${JSON.stringify(input)}`
         );
       }
       return i + 1;
     }
     if (c === 10 || c === 13 || c === 0) {
       throw new Error(
-        `tableName/tableRef contains invalid characters: ${JSON.stringify(input)}`
+        `qualified name contains invalid characters: ${JSON.stringify(input)}`
       );
     }
     sawAny = true;
     i++;
   }
   throw new Error(
-    `tableName/tableRef has unterminated quoted identifier: ${JSON.stringify(input)}`
+    `qualified name has unterminated quoted identifier: ${JSON.stringify(input)}`
   );
 }
 function parseUnquotedPart(input, start) {
   const n = input.length;
   let i = start;
   if (i >= n) {
-    throw new Error(`tableName/tableRef is invalid: ${JSON.stringify(input)}`);
+    throw new Error(`qualified name is invalid: ${JSON.stringify(input)}`);
   }
   const c0 = input.charCodeAt(i);
   if (!isIdentStartCharCode(c0)) {
     throw new Error(
-      `tableName/tableRef must use identifiers (or quoted identifiers). Got: ${JSON.stringify(input)}`
+      `qualified name must use identifiers (or quoted identifiers). Got: ${JSON.stringify(input)}`
     );
   }
   i++;
@@ -760,15 +763,15 @@ function parseUnquotedPart(input, start) {
     if (c === 46) break;
     if (!isIdentCharCode(c)) {
       throw new Error(
-        `tableName/tableRef contains invalid identifier characters: ${JSON.stringify(input)}`
+        `qualified name contains invalid identifier characters: ${JSON.stringify(input)}`
       );
     }
     i++;
   }
   return i;
 }
-function assertSafeQualifiedName(tableRef) {
-  const raw = String(tableRef);
+function assertSafeQualifiedName(input) {
+  const raw = String(input);
   const trimmed = raw.trim();
   if (trimmed.length === 0) {
     throw new Error("tableName/tableRef is required and cannot be empty");
@@ -842,7 +845,7 @@ function quote2(id) {
     );
   }
   if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
+    return quoteRawIdent(id);
   }
   return id;
 }
@@ -2481,28 +2484,24 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
 function toSafeSqlIdentifier(input) {
   const raw = String(input);
   const n = raw.length;
+  if (n === 0) return "_t";
   let out = "";
   for (let i = 0; i < n; i++) {
     const c = raw.charCodeAt(i);
     const isAZ = c >= 65 && c <= 90 || c >= 97 && c <= 122;
     const is09 = c >= 48 && c <= 57;
     const isUnderscore = c === 95;
-    if (isAZ || is09 || isUnderscore) {
-      out += raw[i];
-    } else {
-      out += "_";
-    }
+    out += isAZ || is09 || isUnderscore ? raw[i] : "_";
   }
-  if (out.length === 0) out = "_t";
   const c0 = out.charCodeAt(0);
   const startsOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
-  if (!startsOk) out = `_${out}`;
-  const lowered = out.toLowerCase();
+  const lowered = (startsOk ? out : `_${out}`).toLowerCase();
   return ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
 }
 function createAliasGenerator(maxAliases = 1e4) {
   let counter = 0;
   const usedAliases = /* @__PURE__ */ new Set();
+  const maxLen = 63;
   return {
     next(baseName) {
       if (usedAliases.size >= maxAliases) {
@@ -2512,14 +2511,13 @@ function createAliasGenerator(maxAliases = 1e4) {
       }
       const base = toSafeSqlIdentifier(baseName);
       const suffix = `_${counter}`;
-      const maxLen = 63;
       const baseMax = Math.max(1, maxLen - suffix.length);
       const trimmedBase = base.length > baseMax ? base.slice(0, baseMax) : base;
       const alias = `${trimmedBase}${suffix}`;
       counter += 1;
       if (usedAliases.has(alias)) {
         throw new Error(
-          `CRITICAL: Duplicate alias '${alias}' at counter=${counter}. This indicates a bug in alias generation logic.`
+          `CRITICAL: Duplicate alias '${alias}' at counter=${counter}.`
         );
       }
       usedAliases.add(alias);
@@ -2571,24 +2569,19 @@ function normalizeDynamicNameOrThrow(dynamicName, index) {
   }
   return dn;
 }
-function assertUniqueDynamicName(dn, seen) {
-  if (seen.has(dn)) {
-    throw new Error(`CRITICAL: Duplicate dynamic param name in mappings: ${dn}`);
-  }
-  seen.add(dn);
-}
-function validateMappingEntry(m, expectedIndex, seenDynamic) {
-  assertSequentialIndex(m.index, expectedIndex);
-  assertExactlyOneOfDynamicOrValue(m);
-  if (typeof m.dynamicName === "string") {
-    const dn = normalizeDynamicNameOrThrow(m.dynamicName, m.index);
-    assertUniqueDynamicName(dn, seenDynamic);
-  }
-}
 function validateMappings(mappings) {
   const seenDynamic = /* @__PURE__ */ new Set();
   for (let i = 0; i < mappings.length; i++) {
-    validateMappingEntry(mappings[i], i + 1, seenDynamic);
+    const m = mappings[i];
+    assertSequentialIndex(m.index, i + 1);
+    assertExactlyOneOfDynamicOrValue(m);
+    if (typeof m.dynamicName === "string") {
+      const dn = normalizeDynamicNameOrThrow(m.dynamicName, m.index);
+      if (seenDynamic.has(dn)) {
+        throw new Error(`CRITICAL: Duplicate dynamic param name: ${dn}`);
+      }
+      seenDynamic.add(dn);
+    }
   }
 }
 function validateState(params, mappings, index) {
@@ -2600,16 +2593,19 @@ function validateState(params, mappings, index) {
 }
 function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
   let index = startIndex;
-  const params = initialParams.length > 0 ? [...initialParams] : [];
-  const mappings = initialMappings.length > 0 ? [...initialMappings] : [];
+  const params = initialParams.length > 0 ? initialParams.slice() : [];
+  const mappings = initialMappings.length > 0 ? initialMappings.slice() : [];
   const dynamicNameToIndex = /* @__PURE__ */ new Map();
-  for (const m of mappings) {
+  for (let i = 0; i < mappings.length; i++) {
+    const m = mappings[i];
     if (typeof m.dynamicName === "string") {
       dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
     }
   }
   let dirty = true;
   let cachedSnapshot = null;
+  let frozenParams = null;
+  let frozenMappings = null;
   function assertCanAdd() {
     if (index > MAX_PARAM_INDEX) {
       throw new Error(
@@ -2661,13 +2657,17 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
   }
   function snapshot() {
     if (!dirty && cachedSnapshot) return cachedSnapshot;
+    if (!frozenParams) frozenParams = Object.freeze(params.slice());
+    if (!frozenMappings) frozenMappings = Object.freeze(mappings.slice());
     const snap = {
       index,
-      params,
-      mappings
+      params: frozenParams,
+      mappings: frozenMappings
     };
     cachedSnapshot = snap;
     dirty = false;
+    frozenParams = null;
+    frozenMappings = null;
     return snap;
   }
   return {
@@ -2691,11 +2691,11 @@ function createParamStore(startIndex = 1) {
   return createStoreInternal(startIndex);
 }
 function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
-  validateState([...existingParams], [...existingMappings], nextIndex);
+  validateState(existingParams, existingMappings, nextIndex);
   return createStoreInternal(
     nextIndex,
-    [...existingParams],
-    [...existingMappings]
+    existingParams.slice(),
+    existingMappings.slice()
   );
 }
 
@@ -2877,7 +2877,7 @@ function getRelationTableReference(relModel, dialect) {
     dialect
   );
 }
-function resolveRelationOrThrow(model, schemas, schemaByName, relName) {
+function resolveRelationOrThrow(model, schemaByName, relName) {
   const field = model.fields.find((f) => f.name === relName);
   if (!isNotNullish(field)) {
     throw new Error(
@@ -2931,8 +2931,9 @@ function validateOrderByForModel(model, orderBy) {
       throw new Error("orderBy array entries must have exactly one field");
     }
     const fieldName = String(entries[0][0]).trim();
-    if (fieldName.length === 0)
+    if (fieldName.length === 0) {
       throw new Error("orderBy field name cannot be empty");
+    }
     if (!scalarSet.has(fieldName)) {
       throw new Error(
         `orderBy references unknown or non-scalar field '${fieldName}' on model ${model.name}`
@@ -2991,8 +2992,9 @@ function extractRelationPaginationConfig(relArgs) {
 function maybeReverseNegativeTake(takeVal, hasOrderBy, orderByInput) {
   if (typeof takeVal !== "number") return { takeVal, orderByInput };
   if (takeVal >= 0) return { takeVal, orderByInput };
-  if (!hasOrderBy)
+  if (!hasOrderBy) {
     throw new Error("Negative take requires orderBy for deterministic results");
+  }
   return {
     takeVal: Math.abs(takeVal),
     orderByInput: reverseOrderByInput(orderByInput)
@@ -3002,9 +3004,7 @@ function finalizeOrderByForInclude(args) {
   if (args.hasOrderBy && isNotNullish(args.orderByInput)) {
     validateOrderByForModel(args.relModel, args.orderByInput);
   }
-  if (!args.hasPagination) {
-    return args.orderByInput;
-  }
+  if (!args.hasPagination) return args.orderByInput;
   return ensureDeterministicOrderByInput({
     orderBy: args.hasOrderBy ? args.orderByInput : void 0,
     model: args.relModel,
@@ -3065,7 +3065,9 @@ function buildOrderBySql(finalOrderByInput, relAlias, dialect, relModel) {
   return isNotNullish(finalOrderByInput) ? buildOrderBy(finalOrderByInput, relAlias, dialect, relModel) : "";
 }
 function buildBaseSql(args) {
-  return `${SQL_TEMPLATES.SELECT} ${args.selectExpr} ${SQL_TEMPLATES.FROM} ${args.relTable} ${args.relAlias} ${args.joins} ${SQL_TEMPLATES.WHERE} ${args.joinPredicate}${args.whereClause}`;
+  const joins = args.joins ? ` ${args.joins}` : "";
+  const where = `${SQL_TEMPLATES.WHERE} ${args.joinPredicate}${args.whereClause}`;
+  return `${SQL_TEMPLATES.SELECT} ${args.selectExpr} ${SQL_TEMPLATES.FROM} ${args.relTable} ${args.relAlias}${joins} ` + where;
 }
 function buildOneToOneIncludeSql(args) {
   const objExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
@@ -3077,9 +3079,7 @@ function buildOneToOneIncludeSql(args) {
     joinPredicate: args.joinPredicate,
     whereClause: args.whereClause
   });
-  if (args.orderBySql) {
-    sql += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
-  }
+  if (args.orderBySql) sql += ` ${SQL_TEMPLATES.ORDER_BY} ${args.orderBySql}`;
   if (isNotNullish(args.takeVal)) {
     return appendLimitOffset(
       sql,
@@ -3132,7 +3132,7 @@ function buildListIncludeSpec(args) {
     `include.${args.relName}`
   );
   const selectExpr = jsonAgg("row", args.ctx.dialect);
-  const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${rowAlias}`;
+  const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${SQL_TEMPLATES.AS} ${rowAlias}`;
   return Object.freeze({ name: args.relName, sql, isOneToOne: false });
 }
 function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
@@ -3230,12 +3230,7 @@ function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias
         `Query complexity limit exceeded: ${stats.totalSubqueries} subqueries generated. Maximum allowed: ${MAX_TOTAL_SUBQUERIES}. This indicates exponential include nesting. Stats: depth=${stats.maxDepth}, includes=${stats.totalIncludes}. Path: ${visitPath.join(" -> ")}. Simplify your include structure or split into multiple queries.`
       );
     }
-    const resolved = resolveRelationOrThrow(
-      model,
-      schemas,
-      schemaByName,
-      relName
-    );
+    const resolved = resolveRelationOrThrow(model, schemaByName, relName);
     const relationPath = `${model.name}.${relName}`;
     const currentPath = [...visitPath, relationPath];
     if (visitPath.includes(relationPath)) {
@@ -3291,7 +3286,7 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     stats
   );
 }
-function resolveCountRelationOrThrow(relName, model, schemas, schemaByName) {
+function resolveCountRelationOrThrow(relName, model, schemaByName) {
   const relationSet = getRelationFieldSet(model);
   if (!relationSet.has(relName)) {
     throw new Error(
@@ -3299,10 +3294,11 @@ function resolveCountRelationOrThrow(relName, model, schemas, schemaByName) {
     );
   }
   const field = model.fields.find((f) => f.name === relName);
-  if (!field)
+  if (!field) {
     throw new Error(
       `_count.${relName} references unknown relation on model ${model.name}`
     );
+  }
   if (!isValidRelationField(field)) {
     throw new Error(
       `_count.${relName} has invalid relation metadata on model ${model.name}`
@@ -3330,8 +3326,9 @@ function defaultReferencesForCount(fkCount) {
 }
 function resolveCountKeyPairs(field) {
   const fkFields = normalizeKeyList(field.foreignKey);
-  if (fkFields.length === 0)
+  if (fkFields.length === 0) {
     throw new Error("Relation count requires foreignKey");
+  }
   const refsRaw = field.references;
   const refs = normalizeKeyList(refsRaw);
   const refFields = refs.length > 0 ? refs : defaultReferencesForCount(fkFields.length);
@@ -3407,12 +3404,7 @@ function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params
   for (const m of schemas) schemaByName.set(m.name, m);
   for (const [relName, shouldCount] of Object.entries(countSelect)) {
     if (!shouldCount) continue;
-    const resolved = resolveCountRelationOrThrow(
-      relName,
-      model,
-      schemas,
-      schemaByName
-    );
+    const resolved = resolveCountRelationOrThrow(relName, model, schemaByName);
     const built = buildCountJoinAndPair({
       relName,
       field: resolved.field,
@@ -5140,6 +5132,618 @@ function buildSQLWithCache(model, models, method, args, dialect) {
   queryCache.size;
   return result;
 }
+
+// src/batch.ts
+function assertNoControlChars2(label, s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c <= 31 || c === 127) {
+      throw new Error(`${label} contains control characters`);
+    }
+  }
+}
+function assertSafeIdentifier(label, s) {
+  const raw = String(s);
+  if (raw.trim() !== raw) {
+    throw new Error(`${label} must not contain leading/trailing whitespace`);
+  }
+  if (raw.length === 0) throw new Error(`${label} cannot be empty`);
+  assertNoControlChars2(label, raw);
+  if (/[ \t\r\n]/.test(raw)) {
+    throw new Error(`${label} must not contain whitespace`);
+  }
+  if (raw.includes(";")) {
+    throw new Error(`${label} must not contain semicolons`);
+  }
+  if (raw.includes("--") || raw.includes("/*") || raw.includes("*/")) {
+    throw new Error(`${label} must not contain SQL comment tokens`);
+  }
+}
+function quoteIdent(id) {
+  const raw = String(id);
+  assertSafeIdentifier("Identifier", raw);
+  return `"${raw.replace(/"/g, '""')}"`;
+}
+function makeBatchAlias(i) {
+  return `k${i}`;
+}
+function replacePgPlaceholders(sql, replace) {
+  const s = String(sql);
+  const n = s.length;
+  let i = 0;
+  let mode = "normal";
+  let dollarTag = null;
+  let out = "";
+  const startsWith = (pos, lit) => s.slice(pos, pos + lit.length) === lit;
+  const readDollarTag = (pos) => {
+    if (s.charCodeAt(pos) !== 36) return null;
+    let j = pos + 1;
+    while (j < n) {
+      const c = s.charCodeAt(j);
+      if (c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95) {
+        j++;
+        continue;
+      }
+      break;
+    }
+    if (j < n && s.charCodeAt(j) === 36 && j > pos) {
+      return s.slice(pos, j + 1);
+    }
+    if (pos + 1 < n && s.charCodeAt(pos + 1) === 36) {
+      return "$$";
+    }
+    return null;
+  };
+  while (i < n) {
+    const ch = s.charCodeAt(i);
+    if (mode === "normal") {
+      if (ch === 39) {
+        out += s[i];
+        mode = "single";
+        i++;
+        continue;
+      }
+      if (ch === 34) {
+        out += s[i];
+        mode = "double";
+        i++;
+        continue;
+      }
+      if (ch === 45 && i + 1 < n && s.charCodeAt(i + 1) === 45) {
+        out += "--";
+        mode = "lineComment";
+        i += 2;
+        continue;
+      }
+      if (ch === 47 && i + 1 < n && s.charCodeAt(i + 1) === 42) {
+        out += "/*";
+        mode = "blockComment";
+        i += 2;
+        continue;
+      }
+      if (ch === 36) {
+        const tag = readDollarTag(i);
+        if (tag) {
+          out += tag;
+          mode = "dollar";
+          dollarTag = tag;
+          i += tag.length;
+          continue;
+        }
+        let j = i + 1;
+        if (j < n) {
+          const c1 = s.charCodeAt(j);
+          if (c1 >= 48 && c1 <= 57) {
+            while (j < n) {
+              const cj = s.charCodeAt(j);
+              if (cj >= 48 && cj <= 57) {
+                j++;
+                continue;
+              }
+              break;
+            }
+            const numStr = s.slice(i + 1, j);
+            const oldIndex = Number(numStr);
+            if (!Number.isInteger(oldIndex) || oldIndex < 1) {
+              throw new Error(`Invalid param placeholder: $${numStr}`);
+            }
+            out += replace(oldIndex);
+            i = j;
+            continue;
+          }
+        }
+      }
+      out += s[i];
+      i++;
+      continue;
+    }
+    if (mode === "single") {
+      out += s[i];
+      if (ch === 39) {
+        if (i + 1 < n && s.charCodeAt(i + 1) === 39) {
+          out += s[i + 1];
+          i += 2;
+          continue;
+        }
+        mode = "normal";
+        i++;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (mode === "double") {
+      out += s[i];
+      if (ch === 34) {
+        if (i + 1 < n && s.charCodeAt(i + 1) === 34) {
+          out += s[i + 1];
+          i += 2;
+          continue;
+        }
+        mode = "normal";
+        i++;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (mode === "lineComment") {
+      out += s[i];
+      if (ch === 10) {
+        mode = "normal";
+      }
+      i++;
+      continue;
+    }
+    if (mode === "blockComment") {
+      if (ch === 42 && i + 1 < n && s.charCodeAt(i + 1) === 47) {
+        out += "*/";
+        i += 2;
+        mode = "normal";
+        continue;
+      }
+      out += s[i];
+      i++;
+      continue;
+    }
+    if (mode === "dollar") {
+      if (dollarTag && startsWith(i, dollarTag)) {
+        out += dollarTag;
+        i += dollarTag.length;
+        mode = "normal";
+        dollarTag = null;
+        continue;
+      }
+      out += s[i];
+      i++;
+      continue;
+    }
+    out += s[i];
+    i++;
+  }
+  return out;
+}
+function reindexParams(sql, params, offset) {
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new Error(`Invalid param offset: ${offset}`);
+  }
+  const newParams = [];
+  const paramMap = /* @__PURE__ */ new Map();
+  const reindexed = replacePgPlaceholders(sql, (oldIndex) => {
+    const existing = paramMap.get(oldIndex);
+    if (existing !== void 0) return `$${existing}`;
+    const pos = oldIndex - 1;
+    if (pos >= params.length) {
+      throw new Error(
+        `Param placeholder $${oldIndex} exceeds params length (${params.length})`
+      );
+    }
+    const newIndex = offset + newParams.length + 1;
+    paramMap.set(oldIndex, newIndex);
+    newParams.push(params[pos]);
+    return `$${newIndex}`;
+  });
+  return { sql: reindexed, params: newParams };
+}
+function wrapQueryForMethod(method, cteName, resultAlias) {
+  const outKey = quoteIdent(resultAlias);
+  switch (method) {
+    case "findMany":
+    case "groupBy":
+      return `(SELECT COALESCE(json_agg(row_to_json(t)), '[]'::json) FROM ${cteName} t) AS ${outKey}`;
+    case "findFirst":
+    case "findUnique":
+      return `(SELECT row_to_json(t) FROM ${cteName} t LIMIT 1) AS ${outKey}`;
+    case "count":
+      return `(SELECT * FROM ${cteName}) AS ${outKey}`;
+    case "aggregate":
+      return `(SELECT row_to_json(t) FROM ${cteName} t) AS ${outKey}`;
+    default:
+      throw new Error(`Unsupported batch method: ${method}`);
+  }
+}
+function isAllCountQueries(queries, keys) {
+  var _a;
+  for (let i = 0; i < keys.length; i++) {
+    if (((_a = queries[keys[i]]) == null ? void 0 : _a.method) !== "count") return false;
+  }
+  return true;
+}
+function looksTooComplexForFilter(sql) {
+  const s = sql.toLowerCase();
+  if (s.includes(" group by ")) return true;
+  if (s.includes(" having ")) return true;
+  if (s.includes(" union ")) return true;
+  if (s.includes(" intersect ")) return true;
+  if (s.includes(" except ")) return true;
+  if (s.includes(" window ")) return true;
+  if (s.includes(" distinct ")) return true;
+  return false;
+}
+function containsPgPlaceholder(sql) {
+  return /\$[1-9][0-9]*/.test(sql);
+}
+function parseSimpleCountSql(sql) {
+  const trimmed = sql.trim().replace(/;$/, "").trim();
+  const lower = trimmed.toLowerCase();
+  if (!lower.startsWith("select")) return null;
+  if (!lower.includes("count(*)")) return null;
+  if (looksTooComplexForFilter(trimmed)) return null;
+  const match = trimmed.match(
+    /^select\s+count\(\*\)(?:\s*::\s*[a-zA-Z0-9_\."]+)?\s+as\s+("[^"]+"|[a-zA-Z_][a-zA-Z0-9_\.]*)\s+from\s+([\s\S]+?)(?:\s+where\s+([\s\S]+))?$/i
+  );
+  if (!match) return null;
+  const fromSql = match[2].trim();
+  const whereSql = match[3] ? match[3].trim() : null;
+  if (!fromSql) return null;
+  return { fromSql, whereSql };
+}
+function buildMergedCountBatchSql(queries, keys, aliasesByKey, modelMap, models, dialect) {
+  const modelGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const q = queries[key];
+    const alias = aliasesByKey.get(key);
+    if (!alias) return null;
+    if (!modelGroups.has(q.model)) modelGroups.set(q.model, []);
+    modelGroups.get(q.model).push({ key, alias, args: q.args || {} });
+  }
+  const subqueries = [];
+  let aliasIndex = 0;
+  for (const [modelName, items] of modelGroups) {
+    const model = modelMap.get(modelName);
+    if (!model) return null;
+    let sharedFrom = null;
+    const expressions = [];
+    const localParams = [];
+    const localKeys = [];
+    const localAliases = [];
+    for (let i = 0; i < items.length; i++) {
+      const { key, alias: alias2, args } = items[i];
+      const built = buildSQLWithCache(model, models, "count", args, dialect);
+      const parsed = parseSimpleCountSql(built.sql);
+      if (!parsed) return null;
+      if (containsPgPlaceholder(parsed.fromSql)) {
+        return null;
+      }
+      if (!parsed.whereSql) {
+        if (built.params.length > 0) return null;
+        if (sharedFrom === null) sharedFrom = parsed.fromSql;
+        if (sharedFrom !== parsed.fromSql) return null;
+        expressions.push(`count(*) AS ${quoteIdent(alias2)}`);
+        localKeys.push(key);
+        localAliases.push(alias2);
+        continue;
+      }
+      if (sharedFrom === null) sharedFrom = parsed.fromSql;
+      if (sharedFrom !== parsed.fromSql) return null;
+      const re = reindexParams(
+        parsed.whereSql,
+        built.params,
+        localParams.length
+      );
+      for (let p = 0; p < re.params.length; p++) localParams.push(re.params[p]);
+      expressions.push(
+        `count(*) FILTER (WHERE ${re.sql}) AS ${quoteIdent(alias2)}`
+      );
+      localKeys.push(key);
+      localAliases.push(alias2);
+    }
+    if (!sharedFrom) return null;
+    const alias = `m_${aliasIndex++}`;
+    const subSql = `(SELECT ${expressions.join(", ")} FROM ${sharedFrom}) ${alias}`;
+    subqueries.push({
+      alias,
+      sql: subSql,
+      params: localParams,
+      keys: localKeys,
+      aliases: localAliases
+    });
+  }
+  if (subqueries.length === 0) return null;
+  let offset = 0;
+  const rewrittenSubs = [];
+  const finalParams = [];
+  for (let i = 0; i < subqueries.length; i++) {
+    const sq = subqueries[i];
+    const re = reindexParams(sq.sql, sq.params, offset);
+    offset += re.params.length;
+    rewrittenSubs.push(re.sql);
+    for (let p = 0; p < re.params.length; p++) finalParams.push(re.params[p]);
+  }
+  const selectParts = [];
+  for (let i = 0; i < subqueries.length; i++) {
+    const sq = subqueries[i];
+    for (let k = 0; k < sq.aliases.length; k++) {
+      const outAlias = sq.aliases[k];
+      selectParts.push(
+        `${sq.alias}.${quoteIdent(outAlias)} AS ${quoteIdent(outAlias)}`
+      );
+    }
+  }
+  const fromSql = rewrittenSubs.join(" CROSS JOIN ");
+  const sql = `SELECT ${selectParts.join(", ")} FROM ${fromSql}`;
+  const aliases = keys.map((k) => aliasesByKey.get(k));
+  return { sql, params: finalParams, keys, aliases };
+}
+function buildBatchSql(queries, modelMap, models, dialect) {
+  const keys = Object.keys(queries);
+  if (keys.length === 0) {
+    throw new Error("buildBatchSql requires at least one query");
+  }
+  if (dialect !== "postgres") {
+    throw new Error("Batch queries are only supported for postgres dialect");
+  }
+  const aliases = new Array(keys.length);
+  const aliasesByKey = /* @__PURE__ */ new Map();
+  for (let i = 0; i < keys.length; i++) {
+    const a = makeBatchAlias(i);
+    aliases[i] = a;
+    aliasesByKey.set(keys[i], a);
+  }
+  if (isAllCountQueries(queries, keys)) {
+    const merged = buildMergedCountBatchSql(
+      queries,
+      keys,
+      aliasesByKey,
+      modelMap,
+      models,
+      dialect
+    );
+    if (merged) return merged;
+  }
+  const ctes = new Array(keys.length);
+  const selects = new Array(keys.length);
+  const allParams = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const query = queries[key];
+    const model = modelMap.get(query.model);
+    if (!model) {
+      throw new Error(
+        `Model '${query.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+      );
+    }
+    const { sql: querySql, params: queryParams } = buildSQLWithCache(
+      model,
+      models,
+      query.method,
+      query.args || {},
+      dialect
+    );
+    const { sql: reindexedSql, params: reindexedParams } = reindexParams(
+      querySql,
+      queryParams,
+      allParams.length
+    );
+    for (let p = 0; p < reindexedParams.length; p++) {
+      allParams.push(reindexedParams[p]);
+    }
+    const cteName = `batch_${i}`;
+    ctes[i] = `${cteName} AS (${reindexedSql})`;
+    selects[i] = wrapQueryForMethod(query.method, cteName, aliases[i]);
+  }
+  const sql = `WITH ${ctes.join(", ")} SELECT ${selects.join(", ")}`;
+  return { sql, params: allParams, keys, aliases };
+}
+function buildBatchCountSql(queries, modelMap, models, dialect) {
+  if (queries.length === 0) {
+    throw new Error("buildBatchCountSql requires at least one query");
+  }
+  if (dialect !== "postgres") {
+    throw new Error(
+      "Batch count queries are only supported for postgres dialect"
+    );
+  }
+  const ctes = new Array(queries.length);
+  const selects = new Array(queries.length);
+  const allParams = [];
+  for (let i = 0; i < queries.length; i++) {
+    const query = queries[i];
+    const model = modelMap.get(query.model);
+    if (!model) {
+      throw new Error(
+        `Model '${query.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+      );
+    }
+    const { sql: querySql, params: queryParams } = buildSQLWithCache(
+      model,
+      models,
+      "count",
+      query.args || {},
+      dialect
+    );
+    const { sql: reindexedSql, params: reindexedParams } = reindexParams(
+      querySql,
+      queryParams,
+      allParams.length
+    );
+    for (let p = 0; p < reindexedParams.length; p++) {
+      allParams.push(reindexedParams[p]);
+    }
+    const cteName = `count_${i}`;
+    const resultKey = `count_${i}`;
+    ctes[i] = `${cteName} AS (${reindexedSql})`;
+    selects[i] = `(SELECT * FROM ${cteName}) AS ${quoteIdent(resultKey)}`;
+  }
+  const sql = `WITH ${ctes.join(", ")} SELECT ${selects.join(", ")}`;
+  return { sql, params: allParams };
+}
+function looksLikeJsonString(s) {
+  const t = s.trim();
+  if (t.length === 0) return false;
+  const c0 = t.charCodeAt(0);
+  const cN = t.charCodeAt(t.length - 1);
+  if (c0 === 123 && cN === 125) return true;
+  if (c0 === 91 && cN === 93) return true;
+  if (t === "null" || t === "true" || t === "false") return true;
+  return false;
+}
+function parseJsonValue(value) {
+  if (typeof value !== "string") return value;
+  if (!looksLikeJsonString(value)) return value;
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return value;
+  }
+}
+function parseCountValue(value) {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : 0;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const countKey = Object.prototype.hasOwnProperty.call(obj, "count") ? "count" : Object.prototype.hasOwnProperty.call(obj, "_count") ? "_count" : Object.keys(obj).find((k) => k.endsWith("_count"));
+    if (countKey !== void 0) {
+      const v = obj[countKey];
+      if (typeof v === "number") return v;
+      if (typeof v === "string") {
+        const n = Number.parseInt(v, 10);
+        return Number.isFinite(n) ? n : 0;
+      }
+    }
+  }
+  return 0;
+}
+function parseBatchCountResults(row, count) {
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    const key = `count_${i}`;
+    const value = row[key];
+    results.push(parseCountValue(value));
+  }
+  return results;
+}
+function parseBatchResults(row, keys, queries, aliases) {
+  const results = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const columnKey = aliases && aliases[i] ? aliases[i] : key;
+    const rawValue = row[columnKey];
+    const query = queries[key];
+    switch (query.method) {
+      case "findMany": {
+        const parsed = parseJsonValue(rawValue);
+        results[key] = Array.isArray(parsed) ? parsed : [];
+        break;
+      }
+      case "findFirst":
+      case "findUnique": {
+        const parsed = parseJsonValue(rawValue);
+        results[key] = parsed != null ? parsed : null;
+        break;
+      }
+      case "count": {
+        results[key] = parseCountValue(rawValue);
+        break;
+      }
+      case "aggregate": {
+        const parsed = parseJsonValue(rawValue);
+        const obj = parsed != null ? parsed : {};
+        results[key] = transformQueryResults("aggregate", [obj]);
+        break;
+      }
+      case "groupBy": {
+        const parsed = parseJsonValue(rawValue);
+        const arr = Array.isArray(parsed) ? parsed : [];
+        results[key] = transformQueryResults("groupBy", arr);
+        break;
+      }
+      default:
+        results[key] = rawValue;
+    }
+  }
+  return results;
+}
+
+// src/transaction.ts
+function isolationLevelToPostgresKeyword(level) {
+  switch (level) {
+    case "ReadCommitted":
+      return "read committed";
+    case "RepeatableRead":
+      return "repeatable read";
+    case "Serializable":
+      return "serializable";
+    default:
+      return void 0;
+  }
+}
+function createTransactionExecutor(deps) {
+  const { modelMap, allModels, dialect, executeRaw, postgresClient } = deps;
+  return {
+    execute(queries, options) {
+      return __async(this, null, function* () {
+        if (queries.length === 0) return [];
+        if (dialect !== "postgres") {
+          throw new Error("$transaction is only supported for postgres dialect");
+        }
+        if (!postgresClient) {
+          throw new Error("postgresClient is required for transactions");
+        }
+        const transactionCallback = (sql) => __async(null, null, function* () {
+          const results = [];
+          const isolationLevel = isolationLevelToPostgresKeyword(
+            options == null ? void 0 : options.isolationLevel
+          );
+          if (isolationLevel) {
+            yield sql.unsafe(
+              `SET TRANSACTION ISOLATION LEVEL ${isolationLevel.toUpperCase()}`
+            );
+          }
+          if (options == null ? void 0 : options.timeout) {
+            yield sql.unsafe(
+              `SET LOCAL statement_timeout = ${Math.floor(options.timeout)}`
+            );
+          }
+          for (const q of queries) {
+            const model = modelMap.get(q.model);
+            if (!model) {
+              throw new Error(
+                `Model '${q.model}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+              );
+            }
+            const { sql: sqlStr, params } = buildSQLWithCache(
+              model,
+              allModels,
+              q.method,
+              q.args || {},
+              dialect
+            );
+            const rawResults = yield sql.unsafe(sqlStr, params);
+            results.push(transformQueryResults(q.method, rawResults));
+          }
+          return results;
+        });
+        return yield postgresClient.begin(transactionCallback);
+      });
+    }
+  };
+}
 var ACCELERATED_METHODS = /* @__PURE__ */ new Set([
   "findMany",
   "findFirst",
@@ -5156,10 +5760,15 @@ function executePostgres(client, sql, params) {
     return yield client.unsafe(sql, params);
   });
 }
-function executeSqlite(db, sql, params) {
+function shouldSqliteUseGet(method) {
+  return method === "count" || method === "findFirst" || method === "findUnique" || method === "aggregate";
+}
+function executeSqlite(db, method, sql, params) {
   const stmt = db.prepare(sql);
-  if (sql.toUpperCase().includes("COUNT(*) AS")) {
-    return [stmt.get(...params)];
+  if (shouldSqliteUseGet(method)) {
+    const row = stmt.get(...params);
+    if (row === void 0) return [];
+    return [row];
   }
   return stmt.all(...params);
 }
@@ -5179,7 +5788,7 @@ function executeWithTiming(input) {
       console.log("SQL:", sql);
       console.log("Params:", params);
     }
-    const results = yield input.executeQuery(sql, params);
+    const results = yield input.executeQuery(input.method, sql, params);
     const duration = Date.now() - startTime;
     (_a = input.onQuery) == null ? void 0 : _a.call(input, {
       model: input.modelName,
@@ -5206,11 +5815,11 @@ function fallbackToPrisma(ctx, modelName, method, args) {
   return ctx.$parent[modelName][method](args);
 }
 function createExecuteQuery(client, dialect) {
-  return (sql, params) => __async(null, null, function* () {
+  return (method, sql, params) => __async(null, null, function* () {
     if (dialect === "postgres") {
       return yield executePostgres(client, sql, params);
     }
-    return executeSqlite(client, sql, params);
+    return executeSqlite(client, method, sql, params);
   });
 }
 function logAcceleratedError(debug, dialect, modelName, method, error) {
@@ -5256,6 +5865,58 @@ function handleMethodCall(ctx, method, args, deps) {
     }
   });
 }
+var DeferredQuery = class {
+  constructor(model, method, args) {
+    this.model = model;
+    this.method = method;
+    this.args = args;
+  }
+  then(onfulfilled, onrejected) {
+    throw new Error(
+      "Cannot await a batch query. Batch queries must not be awaited inside the $batch callback."
+    );
+  }
+};
+function createBatchProxy(modelMap, allowedModels) {
+  return new Proxy(
+    {},
+    {
+      get(_target, modelName) {
+        if (typeof modelName === "symbol") return void 0;
+        const model = modelMap.get(modelName);
+        if (!model) {
+          throw new Error(
+            `Model '${modelName}' not found. Available: ${[...modelMap.keys()].join(", ")}`
+          );
+        }
+        if (allowedModels && !allowedModels.includes(modelName)) {
+          throw new Error(
+            `Model '${modelName}' not allowed. Allowed: ${allowedModels.join(", ")}`
+          );
+        }
+        return new Proxy(
+          {},
+          {
+            get(_target2, method) {
+              if (!ACCELERATED_METHODS.has(method)) {
+                throw new Error(
+                  `Method '${method}' not supported in batch. Supported: ${[...ACCELERATED_METHODS].join(", ")}`
+                );
+              }
+              return (args) => {
+                return new DeferredQuery(
+                  modelName,
+                  method,
+                  args
+                );
+              };
+            }
+          }
+        );
+      }
+    }
+  );
+}
 function speedExtension(config) {
   const {
     postgres,
@@ -5280,9 +5941,7 @@ function speedExtension(config) {
   } else if (dmmf) {
     models = convertDMMFToModels(dmmf.datamodel);
   } else {
-    throw new Error(
-      'speedExtension requires either models or dmmf parameter.\n\n\u26A0\uFE0F  RECOMMENDED APPROACH:\n   Use the generated extension for zero runtime overhead:\n\n   import { speedExtension } from "./generated/sql"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql })\n   )\n\n   1. Add generator to schema.prisma:\n      generator sql {\n        provider = "prisma-sql-generator"\n      }\n\n   2. Run: npx prisma generate\n\n   3. Import from generated file\n\n\u274C RUNTIME-ONLY MODE:\n   If you cannot use the generator, provide models or dmmf:\n\n   import { speedExtension } from "prisma-sql"\n   import { MODELS } from "./generated/sql"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql, models: MODELS })\n   )\n\n   Or with DMMF (auto-converts on startup):\n\n   import { Prisma } from "@prisma/client"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql, dmmf: Prisma.dmmf })\n   )'
-    );
+    throw new Error("speedExtension requires either models or dmmf parameter.");
   }
   if (!Array.isArray(models) || models.length === 0) {
     throw new Error("speedExtension: models array is empty or invalid");
@@ -5313,10 +5972,86 @@ function speedExtension(config) {
     for (const method of ACCELERATED_METHODS) {
       methodHandlers[method] = createMethodHandler(method);
     }
+    const executeRaw = (sql, params) => __async(null, null, function* () {
+      if (dialect === "postgres") {
+        return yield client.unsafe(sql, params);
+      }
+      throw new Error("Raw execution for sqlite not supported in transactions");
+    });
+    const txExecutor = createTransactionExecutor({
+      modelMap,
+      allModels: models,
+      dialect,
+      executeRaw,
+      postgresClient: postgres
+    });
+    function batch(callback) {
+      return __async(this, null, function* () {
+        const batchProxy = createBatchProxy(modelMap, allowedModels);
+        const queries = yield callback(batchProxy);
+        const batchQueries = {};
+        for (const [key, deferred] of Object.entries(queries)) {
+          if (!(deferred instanceof DeferredQuery)) {
+            throw new Error(
+              `Batch query '${key}' must be a deferred query. Did you await it?`
+            );
+          }
+          batchQueries[key] = {
+            model: deferred.model,
+            method: deferred.method,
+            args: deferred.args || {}
+          };
+        }
+        const startTime = Date.now();
+        const { sql, params, keys, aliases } = buildBatchSql(
+          batchQueries,
+          modelMap,
+          models,
+          dialect
+        );
+        if (debug) {
+          console.log(`[${dialect}] $batch (${keys.length} queries)`);
+          console.log("SQL:", sql);
+          console.log("Params:", params);
+        }
+        const rows = yield executeQuery("findMany", sql, params);
+        const row = rows[0];
+        const results = parseBatchResults(row, keys, batchQueries, aliases);
+        const duration = Date.now() - startTime;
+        onQuery == null ? void 0 : onQuery({
+          model: "_batch",
+          method: "batch",
+          sql,
+          params,
+          duration
+        });
+        return results;
+      });
+    }
+    function transaction(queries, options) {
+      return __async(this, null, function* () {
+        const startTime = Date.now();
+        if (debug) {
+          console.log(`[${dialect}] $transaction (${queries.length} queries)`);
+        }
+        const results = yield txExecutor.execute(queries, options);
+        const duration = Date.now() - startTime;
+        onQuery == null ? void 0 : onQuery({
+          model: "_transaction",
+          method: "transaction",
+          sql: `TRANSACTION(${queries.length})`,
+          params: [],
+          duration
+        });
+        return results;
+      });
+    }
     return prisma.$extends({
       name: "prisma-sql-speed",
       client: {
-        $original: prisma
+        $original: prisma,
+        $batch: batch,
+        $transaction: transaction
       },
       model: {
         $allModels: methodHandlers
@@ -5324,6 +6059,10 @@ function speedExtension(config) {
     });
   };
 }
+function extendPrisma(prisma, config) {
+  const extension = speedExtension(config);
+  return extension(prisma);
+}
 function createToSQLFunction(models, dialect) {
   if (!models || !Array.isArray(models) || models.length === 0) {
     throw new Error("createToSQL requires non-empty models array");
@@ -5358,13 +6097,18 @@ function createPrismaSQL(config) {
     throw new Error("createPrismaSQL: models array is empty or invalid");
   }
   const toSQL = createToSQLFunction(models, dialect);
+  const modelMap = new Map(models.map((m) => [m.name, m]));
   function query(_0, _1) {
     return __async(this, arguments, function* (model, method, args = {}) {
       const { sql, params } = toSQL(model, method, args);
       return execute(client, sql, params);
     });
   }
-  return { toSQL, query, client };
+  function batchSql(queries) {
+    const { sql, params } = buildBatchSql(queries, modelMap, models, dialect);
+    return { sql, params };
+  }
+  return { toSQL, query, batchSql, client };
 }
 function generateSQL2(directive) {
   return generateSQL(directive);
@@ -5406,6 +6150,6 @@ function generateSQLByModel(directives) {
   return byModel;
 }
 
-export { buildSQL, createPrismaSQL, createToSQL, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel, getGlobalDialect, setGlobalDialect, speedExtension, transformQueryResults };
+export { buildBatchCountSql, buildBatchSql, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, extendPrisma, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel, getGlobalDialect, parseBatchCountResults, parseBatchResults, setGlobalDialect, speedExtension, transformQueryResults };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map