prisma-sql 1.12.0 → 1.14.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.12.0",
+      version: "1.14.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",
@@ -4388,15 +4388,20 @@ function generateClient(options) {
     const queries = /* @__PURE__ */ new Map();
     for (const [modelName, result] of directiveResults) {
       if (result.directives.length === 0) continue;
-      const modelQueries = /* @__PURE__ */ new Map();
+      if (!queries.has(modelName)) {
+        queries.set(modelName, /* @__PURE__ */ new Map());
+      }
+      const modelQueries = queries.get(modelName);
       for (const directive of result.directives) {
         try {
+          const method = directive.header;
           const sqlDirective = generateSQL2(directive);
-          const queryKey = JSON.stringify(
-            directive.query.original,
-            Object.keys(directive.query.original).sort()
-          );
-          modelQueries.set(queryKey, {
+          if (!modelQueries.has(method)) {
+            modelQueries.set(method, /* @__PURE__ */ new Map());
+          }
+          const methodQueries = modelQueries.get(method);
+          const queryKey = createQueryKey(directive.query.processed);
+          methodQueries.set(queryKey, {
             sql: sqlDirective.sql,
             params: sqlDirective.staticParams,
             dynamicKeys: sqlDirective.dynamicKeys,
@@ -4406,9 +4411,6 @@ function generateClient(options) {
           if (!config.skipInvalid) throw error;
         }
       }
-      if (modelQueries.size > 0) {
-        queries.set(modelName, modelQueries);
-      }
     }
     const absoluteOutputDir = resolve(process.cwd(), outputDir);
     yield mkdir(absoluteOutputDir, { recursive: true });
@@ -4416,13 +4418,28 @@ function generateClient(options) {
     const outputPath = join(absoluteOutputDir, "index.ts");
     yield writeFile(outputPath, code);
     const totalQueries = Array.from(queries.values()).reduce(
-      (sum, m) => sum + m.size,
+      (sum, methodMap) => sum + Array.from(methodMap.values()).reduce(
+        (s, queryMap) => s + queryMap.size,
+        0
+      ),
       0
     );
     console.log(`\u2713 Generated ${queries.size} models, ${totalQueries} queries`);
     console.log(`\u2713 Output: ${outputPath}`);
   });
 }
+function createQueryKey(processedQuery) {
+  return JSON.stringify(processedQuery, (key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const sorted = {};
+      for (const k of Object.keys(value).sort()) {
+        sorted[k] = value[k];
+      }
+      return sorted;
+    }
+    return value;
+  });
+}
 function generateCode(models, queries, dialect) {
   const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
     fields: model.fields.filter((f) => f !== void 0 && f !== null)
@@ -4432,28 +4449,87 @@ import { buildSQL, transformQueryResults, type PrismaMethod } from 'prisma-sql'
 
 const MODELS = ${JSON.stringify(cleanModels, null, 2)}
 
-const QUERIES: Record<string, Record<string, {
+const QUERIES: Record<string, Record<string, Record<string, {
   sql: string
   params: unknown[]
   dynamicKeys: string[]
   paramMappings: any[]
-}>> = ${formatQueries(queries)}
+}>>> = ${formatQueries(queries)}
 
 const DIALECT = ${JSON.stringify(dialect)}
 
+function isDynamicParam(key: string): boolean {
+  // Common dynamic parameters that should be replaced with markers
+  return key === 'skip' || key === 'take' || key === 'cursor'
+}
+
 function normalizeQuery(args: any): string {
   if (!args) return '{}'
-  return JSON.stringify(args, Object.keys(args).sort())
+  
+  // Clone and normalize the args
+  const normalized = JSON.parse(JSON.stringify(args))
+  
+  // Replace dynamic params with markers to match prebaked keys
+  function replaceDynamicParams(obj: any): any {
+    if (!obj || typeof obj !== 'object') return obj
+    
+    if (Array.isArray(obj)) {
+      return obj.map(replaceDynamicParams)
+    }
+    
+    const result: any = {}
+    for (const [key, value] of Object.entries(obj)) {
+      // Replace top-level dynamic params with markers
+      if (isDynamicParam(key)) {
+        result[key] = \`__DYNAMIC_\${key}__\`
+      } else {
+        result[key] = replaceDynamicParams(value)
+      }
+    }
+    return result
+  }
+  
+  const withMarkers = replaceDynamicParams(normalized)
+  
+  // Remove empty objects to match prebaked keys
+  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)) {
+      // Skip empty objects (but keep empty arrays)
+      if (value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
+        continue
+      }
+      result[key] = removeEmptyObjects(value)
+    }
+    return result
+  }
+  
+  const cleaned = removeEmptyObjects(withMarkers)
+  
+  // Sort keys recursively for deterministic matching
+  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]
+      }
+      return sorted
+    }
+    return value
+  })
 }
 
 function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
   const params: unknown[] = []
   
   for (const key of dynamicKeys) {
-    const parts = key.split('.')
+    const parts = key.split(':')
+    const path = parts[0].split('.')
     let value: any = args
     
-    for (const part of parts) {
+    for (const part of path) {
       if (value === null || value === undefined) break
       value = value[part]
     }
@@ -4514,7 +4590,7 @@ export function createExtension(config: {
       const startTime = Date.now()
 
       const queryKey = normalizeQuery(args)
-      const prebakedQuery = QUERIES[modelName]?.[queryKey]
+      const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
 
       let sql: string
       let params: unknown[]
@@ -4595,23 +4671,29 @@ function formatQueries(queries) {
   if (queries.size === 0) {
     return "{}";
   }
-  const entries = [];
-  for (const [modelName, modelQueries] of queries) {
-    const queryEntries = [];
-    for (const [queryKey, query] of modelQueries) {
-      queryEntries.push(`  ${JSON.stringify(queryKey)}: {
-    sql: ${JSON.stringify(query.sql)},
-    params: ${JSON.stringify(query.params)},
-    dynamicKeys: ${JSON.stringify(query.dynamicKeys)},
-    paramMappings: ${JSON.stringify(query.paramMappings)},
-  }`);
-    }
-    entries.push(`  ${JSON.stringify(modelName)}: {
+  const modelEntries = [];
+  for (const [modelName, methodMap] of queries) {
+    const methodEntries = [];
+    for (const [method, queryMap] of methodMap) {
+      const queryEntries = [];
+      for (const [queryKey, query] of queryMap) {
+        queryEntries.push(`    ${JSON.stringify(queryKey)}: {
+      sql: ${JSON.stringify(query.sql)},
+      params: ${JSON.stringify(query.params)},
+      dynamicKeys: ${JSON.stringify(query.dynamicKeys)},
+      paramMappings: ${JSON.stringify(query.paramMappings)},
+    }`);
+      }
+      methodEntries.push(`    ${JSON.stringify(method)}: {
 ${queryEntries.join(",\n")}
+    }`);
+    }
+    modelEntries.push(`  ${JSON.stringify(modelName)}: {
+${methodEntries.join(",\n")}
   }`);
   }
   return `{
-${entries.join(",\n")}
+${modelEntries.join(",\n")}
 }`;
 }
 var { version } = require_package();