prisma-sql 1.40.0 → 1.42.0

package/dist/index.cjs

@@ -2438,12 +2438,6 @@ function validateState(params, mappings, index) {
   validateMappings(mappings);
   assertNextIndexMatches(mappings.length, index);
 }
-function normalizeValue2(value) {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  return value;
-}
 function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
   let index = startIndex;
   const params = [...initialParams];
@@ -2486,7 +2480,7 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
   }
   function addStatic(value) {
     const position = index;
-    const normalizedValue = normalizeValue2(value);
+    const normalizedValue = normalizeValue(value);
     params.push(normalizedValue);
     mappings.push({ index: position, value: normalizedValue });
     index++;
@@ -3708,7 +3702,12 @@ function buildSelectSpec(input) {
     model,
     alias
   );
-  const orderByClause = buildOrderByClause(normalizedArgs, alias, dialect);
+  const orderByClause = buildOrderByClause(
+    normalizedArgs,
+    alias,
+    dialect,
+    model
+  );
   const { take, skip, cursor } = getPaginationParams(method, normalizedArgs);
   const params = createParamStoreFrom(
     whereResult.params,
@@ -4771,48 +4770,27 @@ function toSqliteParams(sql, params) {
   return { sql: parts.join(""), params: reorderedParams };
 }
 function canonicalizeQuery(modelName, method, args) {
-  function normalize(obj, path = []) {
-    if (obj === null || typeof obj !== "object") return obj;
-    if (Array.isArray(obj)) return obj.map((v, i) => normalize(v, [...path, String(i)]));
-    const sorted = {};
-    const keys = Object.keys(obj).sort();
-    for (const key of keys) {
-      const fullPath = [...path, key].join(".");
-      const value = obj[key];
-      if (schemaParser.isDynamicParameter(value)) {
-        sorted[key] = `__DYN:${fullPath}__`;
-      } else {
-        sorted[key] = normalize(value, [...path, key]);
+  function normalize(obj) {
+    if (obj === null || obj === void 0) return obj;
+    if (obj instanceof Date) {
+      return "__DATE_PARAM__";
+    }
+    if (Array.isArray(obj)) {
+      return obj.map(normalize);
+    }
+    if (typeof obj === "object") {
+      const sorted = {};
+      for (const key of Object.keys(obj).sort()) {
+        const value = obj[key];
+        sorted[key] = schemaParser.isDynamicParameter(value) ? "__DYN__" : normalize(value);
       }
+      return sorted;
     }
-    return sorted;
+    return obj;
   }
   const canonical = normalize(args);
   return `${modelName}:${method}:${JSON.stringify(canonical)}`;
 }
-function extractValueFromPath(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current === void 0 || current === null) return void 0;
-    current = current[part];
-  }
-  return current;
-}
-function rebuildParams(mappings, args) {
-  const params = new Array(mappings.length);
-  for (let i = 0; i < mappings.length; i++) {
-    const mapping = mappings[i];
-    if (mapping.dynamicName !== void 0) {
-      const parts = mapping.dynamicName.split(":");
-      const path = parts.length === 2 ? parts[1] : mapping.dynamicName;
-      params[i] = extractValueFromPath(args, path);
-    } else {
-      params[i] = mapping.value;
-    }
-  }
-  return params;
-}
 function buildSQLFull(model, models, method, args, dialect) {
   const tableName = buildTableReference(
     SQL_TEMPLATES.PUBLIC_SCHEMA,
@@ -4835,13 +4813,32 @@ function buildSQLFull(model, models, method, args, dialect) {
   let result;
   switch (method) {
     case "aggregate":
-      result = buildAggregateSql(withMethod, whereResult, tableName, alias, model);
+      result = buildAggregateSql(
+        withMethod,
+        whereResult,
+        tableName,
+        alias,
+        model
+      );
       break;
     case "groupBy":
-      result = buildGroupBySql(withMethod, whereResult, tableName, alias, model, dialect);
+      result = buildGroupBySql(
+        withMethod,
+        whereResult,
+        tableName,
+        alias,
+        model,
+        dialect
+      );
       break;
     case "count":
-      result = buildCountSql(whereResult, tableName, alias, args.skip, dialect);
+      result = buildCountSql(
+        whereResult,
+        tableName,
+        alias,
+        args.skip,
+        dialect
+      );
       break;
     default:
       result = buildSelectSql({
@@ -4854,24 +4851,18 @@ function buildSQLFull(model, models, method, args, dialect) {
         dialect
       });
   }
-  const finalResult = dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
-  return __spreadProps(__spreadValues({}, finalResult), {
-    paramMappings: result.paramMappings
-  });
+  return dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
 }
 function buildSQLWithCache(model, models, method, args, dialect) {
   const cacheKey = canonicalizeQuery(model.name, method, args);
-  const cached = queryCache.get(cacheKey);
-  if (cached) {
-    const params = rebuildParams(cached.paramMappings, args);
-    return { sql: cached.sql, params };
+  const cachedSql = queryCache.get(cacheKey);
+  if (cachedSql) {
+    const result2 = buildSQLFull(model, models, method, args, dialect);
+    return { sql: cachedSql, params: result2.params };
   }
   const result = buildSQLFull(model, models, method, args, dialect);
-  queryCache.set(cacheKey, {
-    sql: result.sql,
-    paramMappings: result.paramMappings
-  });
-  return { sql: result.sql, params: result.params };
+  queryCache.set(cacheKey, result.sql);
+  return result;
 }
 var ACCELERATED_METHODS = /* @__PURE__ */ new Set([
   "findMany",