prisma-sql 1.77.0 → 1.79.0

package/dist/generator.cjs

@@ -70,7 +70,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.77.0",
+      version: "1.79.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",
@@ -6287,6 +6287,31 @@ function normalizeArgsForDialect(dialect, args) {
   if (dialect !== "postgres") return args;
   return applyPostgresDistinctOrderBy(args);
 }
+function normalizeCompoundCursor(cursor, model) {
+  const keys = Object.keys(cursor);
+  if (keys.length !== 1) return cursor;
+  const key = keys[0];
+  const value = cursor[key];
+  const scalarSet = getScalarFieldSet(model);
+  if (scalarSet.has(key)) return cursor;
+  if (!isPlainObject(value)) return cursor;
+  const nested = value;
+  const nestedKeys = Object.keys(nested);
+  if (nestedKeys.length === 0) return cursor;
+  for (const nk of nestedKeys) {
+    if (!scalarSet.has(nk)) return cursor;
+  }
+  return nested;
+}
+function normalizeArgsCompoundCursor(args, model) {
+  if (!isNotNullish(args.cursor) || !isPlainObject(args.cursor)) return args;
+  const flat = normalizeCompoundCursor(
+    args.cursor,
+    model
+  );
+  if (flat === args.cursor) return args;
+  return __spreadProps(__spreadValues({}, args), { cursor: flat });
+}
 function buildCursorClauseIfAny(input) {
   const { cursor, orderBy, tableName, alias, params, skip, dialect, model } = input;
   if (!isNotNullish(cursor)) return {};
@@ -6384,7 +6409,8 @@ function buildSelectSql(input) {
   assertSafeTableRef(from.tableName);
   const dialectToUse = resolveDialect(dialect);
   const argsForSql = normalizeArgsForNegativeTake(method, args);
-  const normalizedArgs = normalizeArgsForDialect(dialectToUse, argsForSql);
+  const argsWithDialect = normalizeArgsForDialect(dialectToUse, argsForSql);
+  const normalizedArgs = normalizeArgsCompoundCursor(argsWithDialect, model);
   validateDistinct(model, normalizedArgs.distinct);
   validateOrderBy(model, normalizedArgs.orderBy);
   validateCursor(model, normalizedArgs.cursor, normalizedArgs.distinct);
@@ -7835,6 +7861,23 @@ function resolveParamsFromMappings(args: any, paramMappings: any[]): unknown[] {
     params.push(normalizeValue(value))
   }
   return params
+}
+
+function normalizeCompoundCursor(cursor: any, model: any): any {
+  if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor) || cursor instanceof Date) return cursor
+  const keys = Object.keys(cursor)
+  if (keys.length !== 1) return cursor
+  const key = keys[0]
+  const value = cursor[key]
+  if (!value || typeof value !== 'object' || Array.isArray(value) || value instanceof Date) return cursor
+  const scalarSet = new Set(model.fields.filter((f: any) => !f.isRelation).map((f: any) => f.name))
+  if (scalarSet.has(key)) return cursor
+  const nestedKeys = Object.keys(value)
+  if (nestedKeys.length === 0) return cursor
+  for (const nk of nestedKeys) {
+    if (!scalarSet.has(nk)) return cursor
+  }
+  return value
 }`;
 }
 function generateDataConstants(cleanModels, mappings, fieldTypes, queries, dialect) {
@@ -8139,7 +8182,7 @@ function generateExtension(runtimeImportPath) {
       $parent?: any
     }
 
-    async function handleMethod(
+  async function handleMethod(
       this: ModelContext,
       method: PrismaMethod,
       args: unknown
@@ -8151,6 +8194,7 @@ function generateExtension(runtimeImportPath) {
       }
 
       const startTime = Date.now()
+      let sql: string | undefined
 
       try {
         if (args !== undefined && args !== null && typeof args !== 'object') {
@@ -8159,7 +8203,7 @@ function generateExtension(runtimeImportPath) {
           )
         }
 
-        const transformedArgs = transformEnumValuesByModel(modelName, args || {})
+        let transformedArgs = transformEnumValuesByModel(modelName, args || {})
 
         const model = MODEL_MAP.get(modelName)
         if (!model) {
@@ -8169,6 +8213,13 @@ function generateExtension(runtimeImportPath) {
           return this.$parent[modelName][method](args)
         }
 
+        if (transformedArgs.cursor) {
+          const flatCursor = normalizeCompoundCursor(transformedArgs.cursor, model)
+          if (flatCursor !== transformedArgs.cursor) {
+            transformedArgs = { ...transformedArgs, cursor: flatCursor }
+          }
+        }
+
         const plan = planQueryStrategy({
           model,
           method,
@@ -8179,7 +8230,6 @@ function generateExtension(runtimeImportPath) {
 
         const queryKey = normalizeQuery(plan.filteredArgs)
         const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
-        let sql: string
         let params: unknown[]
         let prebaked = false
         let requiresReduction = false
@@ -8332,12 +8382,19 @@ function generateExtension(runtimeImportPath) {
         throw new Error('Streaming requires postgres.js client')
       }
 
-      const transformedArgs = transformEnumValuesByModel(modelName, args || {})
+      let transformedArgs = transformEnumValuesByModel(modelName, args || {})
       const model = MODEL_MAP.get(modelName)
       if (!model) {
         throw new Error(\`Model '\${modelName}' not found\`)
       }
 
+      if (transformedArgs.cursor) {
+        const flatCursor = normalizeCompoundCursor(transformedArgs.cursor, model)
+        if (flatCursor !== transformedArgs.cursor) {
+          transformedArgs = { ...transformedArgs, cursor: flatCursor }
+        }
+      }
+
       const plan = planQueryStrategy({
         model,
         method: 'findMany',