prisma-sql 1.54.0 → 1.56.0

package/dist/generator.cjs

@@ -56,7 +56,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.54.0",
+      version: "1.56.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",
@@ -815,6 +815,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;
 }
@@ -836,33 +839,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++;
@@ -871,15 +874,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");
@@ -953,7 +956,7 @@ function quote2(id) {
     );
   }
   if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
+    return quoteRawIdent(id);
   }
   return id;
 }
@@ -2592,28 +2595,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) {
@@ -2623,14 +2622,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);
@@ -2682,24 +2680,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) {
@@ -2711,16 +2704,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(
@@ -2772,13 +2768,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 {
@@ -2802,11 +2802,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()
   );
 }
 
@@ -2988,7 +2988,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(
@@ -3042,8 +3042,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}`
@@ -3102,8 +3103,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)
@@ -3113,9 +3115,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,
@@ -3176,7 +3176,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);
@@ -3188,9 +3190,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,
@@ -3243,7 +3243,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) {
@@ -3341,12 +3341,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)) {
@@ -3402,7 +3397,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(
@@ -3410,10 +3405,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}`
@@ -3441,8 +3437,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);
@@ -3518,12 +3515,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,
@@ -4953,24 +4945,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(
@@ -5091,6 +5066,10 @@ function normalizeValue(value: unknown, seen = new WeakSet<object>(), depth = 0)
   return value
 }
 
+function normalizeParams(params: unknown[]): unknown[] {
+  return params.map(p => normalizeValue(p))
+}
+
 function getByPath(obj: any, path: string): unknown {
   if (!obj || !path) return undefined
   const keys = path.split('.')
@@ -5102,11 +5081,6 @@ function getByPath(obj: any, path: string): unknown {
   return result
 }
 
-function normalizeParams(params: unknown[]): unknown[] {
-  return params.map(p => normalizeValue(p))
-}
-
-
 export const MODELS: Model[] = ${JSON.stringify(cleanModels, null, 2)}
 
 const ENUM_MAPPINGS: Record<string, Record<string, string>> = ${JSON.stringify(mappings, null, 2)}
@@ -5124,8 +5098,11 @@ const DIALECT = ${JSON.stringify(dialect)}
 
 const MODEL_MAP = new Map(MODELS.map(m => [m.name, m]))
 
-function isDynamicParam(key: string): boolean {
-  return key === 'skip' || key === 'take' || key === 'cursor'
+function isDynamicKeyForQueryKey(path: string[], key: string): boolean {
+  if (key !== 'skip' && key !== 'take' && key !== 'cursor') return false
+  if (path.includes('where')) return false
+  if (path.includes('data')) return false
+  return true
 }
 
 function transformEnumInValue(value: unknown, enumType: string | undefined): unknown {
@@ -5154,28 +5131,43 @@ function transformEnumInValue(value: unknown, enumType: string | undefined): unk
   return value
 }
 
-function transformEnumValues(modelName: string, obj: any, currentPath: string[] = []): any {
+function getRelatedModelName(currentModelName: string, relationFieldName: string): string | null {
+  const m = MODEL_MAP.get(currentModelName)
+  if (!m) return null
+  const f: any = (m as any).fields?.find((x: any) => x?.name === relationFieldName)
+  if (!f || !f.isRelation) return null
+  return f.relatedModel || null
+}
+
+function transformEnumValuesByModel(modelName: string, obj: any, path: string[] = []): any {
   if (obj === null || obj === undefined) {
     return obj
   }
-  
+
   if (Array.isArray(obj)) {
-    return obj.map(item => transformEnumValues(modelName, item, currentPath))
+    return obj.map(item => transformEnumValuesByModel(modelName, item, path))
   }
-  
+
   if (obj instanceof Date) {
     return obj
   }
-  
+
   if (typeof obj === 'object') {
     const transformed: any = {}
     const modelFields = ENUM_FIELDS[modelName] || {}
-    
+
     for (const [key, value] of Object.entries(obj)) {
-      const newPath = [...currentPath, key]
-      
+      const nextPath = [...path, key]
+
+      const relModel = getRelatedModelName(modelName, key)
+
+      if (relModel && value && typeof value === 'object') {
+        transformed[key] = transformEnumValuesByModel(relModel, value, nextPath)
+        continue
+      }
+
       const enumType = modelFields[key]
-      
+
       if (enumType) {
         if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
           const transformedOperators: any = {}
@@ -5189,46 +5181,46 @@ function transformEnumValues(modelName: string, obj: any, currentPath: string[]
       } else if (value instanceof Date) {
         transformed[key] = value
       } else if (typeof value === 'object' && value !== null) {
-        transformed[key] = transformEnumValues(modelName, value, newPath)
+        transformed[key] = transformEnumValuesByModel(modelName, value, nextPath)
       } else {
         transformed[key] = value
       }
     }
+
     return transformed
   }
-  
+
   return obj
 }
 
-
 function normalizeQuery(args: any): string {
   if (!args) return '{}'
-  
+
   const normalized = JSON.parse(JSON.stringify(args))
-  
-  function replaceDynamicParams(obj: any): any {
+
+  function replaceDynamicParams(obj: any, path: string[] = []): any {
     if (!obj || typeof obj !== 'object') return obj
-    
+
     if (Array.isArray(obj)) {
-      return obj.map(replaceDynamicParams)
+      return obj.map((v) => replaceDynamicParams(v, path))
     }
-    
+
     const result: any = {}
     for (const [key, value] of Object.entries(obj)) {
-      if (isDynamicParam(key)) {
+      if (isDynamicKeyForQueryKey(path, key)) {
         result[key] = \`__DYNAMIC_\${key}__\`
       } else {
-        result[key] = replaceDynamicParams(value)
+        result[key] = replaceDynamicParams(value, [...path, key])
       }
     }
     return result
   }
-  
+
   const withMarkers = replaceDynamicParams(normalized)
-  
+
   function removeEmptyObjects(obj: any): any {
     if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return obj
-    
+
     const result: any = {}
     for (const [key, value] of Object.entries(obj)) {
       if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
@@ -5238,14 +5230,14 @@ function normalizeQuery(args: any): string {
     }
     return result
   }
-  
+
   const cleaned = removeEmptyObjects(withMarkers)
-  
+
   return JSON.stringify(cleaned, (key, value) => {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
       const sorted: Record<string, unknown> = {}
       for (const k of Object.keys(value).sort()) {
-        sorted[k] = value[k]
+        sorted[k] = (value as any)[k]
       }
       return sorted
     }
@@ -5273,7 +5265,6 @@ function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
   return params
 }
 
-
 async function executeQuery(client: any, sql: string, params: unknown[]): Promise<unknown[]> {
   const normalizedParams = normalizeParams(params)
 
@@ -5336,7 +5327,7 @@ export function speedExtension(config: {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
 
-      const transformedArgs = transformEnumValues(modelName, args || {})
+      const transformedArgs = transformEnumValuesByModel(modelName, args || {})
 
       const queryKey = normalizeQuery(transformedArgs)
       const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
@@ -5489,7 +5480,7 @@ export function speedExtension(config: {
 
       onQuery?.({
         model: '_transaction',
-        method: 'count',
+        method: 'transaction',
         sql: \`TRANSACTION(\${queries.length})\`,
         params: [],
         duration,
@@ -5501,7 +5492,7 @@ export function speedExtension(config: {
 
     return prisma.$extends({
       name: 'prisma-sql-generated',
-      
+
       client: {
         $original: prisma,
         $batch: batch as <T extends Record<string, DeferredQuery>>(
@@ -5546,6 +5537,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) {