prisma-sql 1.54.0 → 1.55.0

package/dist/generator.js

@@ -54,7 +54,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.54.0",
+      version: "1.55.0",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -813,6 +813,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;
 }
@@ -834,33 +837,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++;
@@ -869,15 +872,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");
@@ -951,7 +954,7 @@ function quote2(id) {
     );
   }
   if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
+    return quoteRawIdent(id);
   }
   return id;
 }
@@ -2590,28 +2593,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) {
@@ -2621,14 +2620,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);
@@ -2680,24 +2678,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) {
@@ -2709,16 +2702,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(
@@ -2770,13 +2766,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 {
@@ -2800,11 +2800,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()
   );
 }
 
@@ -2986,7 +2986,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(
@@ -3040,8 +3040,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}`
@@ -3100,8 +3101,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)
@@ -3111,9 +3113,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,
@@ -3174,7 +3174,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);
@@ -3186,9 +3188,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,
@@ -3241,7 +3241,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) {
@@ -3339,12 +3339,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)) {
@@ -3400,7 +3395,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(
@@ -3408,10 +3403,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}`
@@ -3439,8 +3435,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);
@@ -3516,12 +3513,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,
@@ -4951,24 +4943,7 @@ function generateCode(models, queries, dialect, datamodel) {
   }));
   const { mappings, fieldTypes } = extractEnumMappings(datamodel);
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
-import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, type PrismaMethod, type Model, type BatchQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'
-
-export interface BatchCountQuery {
-  model: string
-  method: 'count'
-  args?: { where?: Record<string, unknown> }
-}
-
-export interface TransactionQuery {
-  model: string
-  method: PrismaMethod
-  args?: Record<string, unknown>
-}
-
-export interface TransactionOptions {
-  isolationLevel?: 'ReadCommitted' | 'RepeatableRead' | 'Serializable'
-  timeout?: number
-}
+import { buildSQL, buildBatchSql, parseBatchResults, buildBatchCountSql, parseBatchCountResults, createTransactionExecutor, transformQueryResults, type PrismaMethod, type Model, type BatchQuery, type BatchCountQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'
 
 class DeferredQuery {
   constructor(
@@ -5544,6 +5519,8 @@ export type SpeedClient<T> = T & {
   $batchCount(queries: BatchCountQuery[]): Promise<number[]>
   $transaction(queries: TransactionQuery[], options?: TransactionOptions): Promise<unknown[]>
 }
+
+export type { BatchCountQuery, TransactionQuery, TransactionOptions }
 `;
 }
 function formatQueries(queries) {