prisma-sql 1.53.0 → 1.55.0

package/dist/index.cjs

@@ -705,6 +705,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;
 }
@@ -726,33 +729,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++;
@@ -761,15 +764,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");
@@ -843,7 +846,7 @@ function quote2(id) {
     );
   }
   if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
+    return quoteRawIdent(id);
   }
   return id;
 }
@@ -2482,28 +2485,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) {
@@ -2513,14 +2512,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);
@@ -2572,24 +2570,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) {
@@ -2601,16 +2594,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(
@@ -2662,13 +2658,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 {
@@ -2692,11 +2692,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()
   );
 }
 
@@ -2878,7 +2878,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(
@@ -2932,8 +2932,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}`
@@ -2992,8 +2993,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)
@@ -3003,9 +3005,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,
@@ -3066,7 +3066,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);
@@ -3078,9 +3080,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,
@@ -3133,7 +3133,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) {
@@ -3231,12 +3231,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)) {
@@ -3292,7 +3287,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(
@@ -3300,10 +3295,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}`
@@ -3331,8 +3327,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);
@@ -3408,12 +3405,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,
@@ -5141,6 +5133,304 @@ 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 quoteIdent(id) {
+  const raw = String(id);
+  if (raw.length === 0) throw new Error("Identifier cannot be empty");
+  assertNoControlChars2("Identifier", raw);
+  return `"${raw.replace(/"/g, '""')}"`;
+}
+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 = sql.replace(/\$(\d+)/g, (_match, num) => {
+    const oldIndex = Number(num);
+    if (!Number.isInteger(oldIndex) || oldIndex < 1) {
+      throw new Error(`Invalid param placeholder: $${num}`);
+    }
+    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, resultKey) {
+  const outKey = quoteIdent(resultKey);
+  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 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 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, key);
+  }
+  const sql = `WITH ${ctes.join(", ")} SELECT ${selects.join(", ")}`;
+  return { sql, params: allParams, keys };
+}
+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) {
+  const results = {};
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const rawValue = row[key];
+    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",
@@ -5257,6 +5547,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,
@@ -5281,9 +5623,7 @@ function speedExtension(config) {
   } else if (dmmf) {
     models = schemaParser.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");
@@ -5314,10 +5654,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 } = 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(sql, params);
+        const row = rows[0];
+        const results = parseBatchResults(row, keys, batchQueries);
+        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: "count",
+          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
@@ -5325,6 +5741,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");
@@ -5359,13 +5779,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);
@@ -5411,13 +5836,19 @@ Object.defineProperty(exports, "convertDMMFToModels", {
   enumerable: true,
   get: function () { return schemaParser.convertDMMFToModels; }
 });
+exports.buildBatchCountSql = buildBatchCountSql;
+exports.buildBatchSql = buildBatchSql;
 exports.buildSQL = buildSQL;
 exports.createPrismaSQL = createPrismaSQL;
 exports.createToSQL = createToSQL;
+exports.createTransactionExecutor = createTransactionExecutor;
+exports.extendPrisma = extendPrisma;
 exports.generateAllSQL = generateAllSQL;
 exports.generateSQL = generateSQL2;
 exports.generateSQLByModel = generateSQLByModel;
 exports.getGlobalDialect = getGlobalDialect;
+exports.parseBatchCountResults = parseBatchCountResults;
+exports.parseBatchResults = parseBatchResults;
 exports.setGlobalDialect = setGlobalDialect;
 exports.speedExtension = speedExtension;
 exports.transformQueryResults = transformQueryResults;