prisma-sql 1.53.0 → 1.54.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.53.0",
+      version: "1.54.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",
@@ -4953,12 +4953,98 @@ function generateCode(models, queries, dialect, datamodel) {
   }));
   const { mappings, fieldTypes } = extractEnumMappings(datamodel);
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
-import { buildSQL, transformQueryResults, type PrismaMethod, type Model } from 'prisma-sql'
+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
+}
+
+class DeferredQuery {
+  constructor(
+    public readonly model: string,
+    public readonly method: PrismaMethod,
+    public readonly args: any,
+  ) {}
+
+  then(onfulfilled?: any, onrejected?: any): any {
+    throw new Error(
+      'Cannot await a batch query. Batch queries must not be awaited inside the $batch callback.',
+    )
+  }
+}
+
+interface BatchProxy {
+  [modelName: string]: {
+    findMany: (args?: any) => DeferredQuery
+    findFirst: (args?: any) => DeferredQuery
+    findUnique: (args?: any) => DeferredQuery
+    count: (args?: any) => DeferredQuery
+    aggregate: (args?: any) => DeferredQuery
+    groupBy: (args?: any) => DeferredQuery
+  }
+}
+
+const ACCELERATED_METHODS = new Set<PrismaMethod>([
+  'findMany',
+  'findFirst',
+  'findUnique',
+  'count',
+  'aggregate',
+  'groupBy',
+])
+
+function createBatchProxy(): BatchProxy {
+  return new Proxy(
+    {},
+    {
+      get(_target, modelName: string): any {
+        if (typeof modelName === 'symbol') return undefined
+
+        const model = MODEL_MAP.get(modelName)
+        if (!model) {
+          throw new Error(
+            \`Model '\${modelName}' not found. Available: \${[...MODEL_MAP.keys()].join(', ')}\`,
+          )
+        }
+
+        return new Proxy(
+          {},
+          {
+            get(_target, method: string): (args?: any) => DeferredQuery {
+              if (!ACCELERATED_METHODS.has(method as PrismaMethod)) {
+                throw new Error(
+                  \`Method '\${method}' not supported in batch. Supported: \${[...ACCELERATED_METHODS].join(', ')}\`,
+                )
+              }
+
+              return (args?: any): DeferredQuery => {
+                return new DeferredQuery(
+                  modelName,
+                  method as PrismaMethod,
+                  args,
+                )
+              }
+            },
+          },
+        )
+      },
+    },
+  ) as BatchProxy
+}
 
-/**
- * Normalize values for SQL params.
- * Synced from src/utils/normalize-value.ts
- */
 function normalizeValue(value: unknown, seen = new WeakSet<object>(), depth = 0): unknown {
   const MAX_DEPTH = 20
   if (depth > MAX_DEPTH) {
@@ -5005,9 +5091,6 @@ function normalizeValue(value: unknown, seen = new WeakSet<object>(), depth = 0)
   return value
 }
 
-/**
- * Get nested value from object using dot notation path
- */
 function getByPath(obj: any, path: string): unknown {
   if (!obj || !path) return undefined
   const keys = path.split('.')
@@ -5019,9 +5102,6 @@ function getByPath(obj: any, path: string): unknown {
   return result
 }
 
-/**
- * Normalize all params in array
- */
 function normalizeParams(params: unknown[]): unknown[] {
   return params.map(p => normalizeValue(p))
 }
@@ -5042,6 +5122,8 @@ const QUERIES: Record<string, Record<string, Record<string, {
 
 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'
 }
@@ -5208,6 +5290,13 @@ async function executeQuery(client: any, sql: string, params: unknown[]): Promis
   return stmt.all(...normalizedParams)
 }
 
+async function executeRaw(client: any, sql: string, params?: unknown[]): Promise<unknown[]> {
+  if (DIALECT === 'postgres') {
+    return await client.unsafe(sql, (params || []) as any[])
+  }
+  throw new Error('Raw execution for sqlite not supported in transactions')
+}
+
 export function speedExtension(config: {
   postgres?: any
   sqlite?: any
@@ -5235,6 +5324,14 @@ export function speedExtension(config: {
   }
 
   return (prisma: any) => {
+    const txExecutor = createTransactionExecutor({
+      modelMap: MODEL_MAP,
+      allModels: MODELS,
+      dialect: DIALECT,
+      executeRaw: (sql: string, params?: unknown[]) => executeRaw(client, sql, params),
+      postgresClient: postgres,
+    })
+
     const handleMethod = async function(this: any, method: PrismaMethod, args: any) {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
@@ -5288,11 +5385,130 @@ export function speedExtension(config: {
       return transformQueryResults(method, results)
     }
 
+    async function batch<T extends Record<string, DeferredQuery>>(
+      callback: (batch: BatchProxy) => T | Promise<T>,
+    ): Promise<{ [K in keyof T]: any }> {
+      const batchProxy = createBatchProxy()
+      const queries = await callback(batchProxy)
+
+      const batchQueries: Record<string, BatchQuery> = {}
+
+      for (const [key, deferred] of Object.entries(queries)) {
+        if (!(deferred instanceof DeferredQuery)) {
+          throw new Error(
+            \`Batch query '\${key}' must be a deferred query. Did you await it?\`,
+          )
+        }
+
+        batchQueries[key] = {
+          model: deferred.model,
+          method: deferred.method,
+          args: deferred.args || {},
+        }
+      }
+
+      const startTime = Date.now()
+      const { sql, params, keys } = buildBatchSql(
+        batchQueries,
+        MODEL_MAP,
+        MODELS,
+        DIALECT,
+      )
+
+      if (debug) {
+        console.log(\`[\${DIALECT}] $batch (\${keys.length} queries)\`)
+        console.log('SQL:', sql)
+        console.log('Params:', params)
+      }
+
+      const normalizedParams = normalizeParams(params)
+      const rows = await client.unsafe(sql, normalizedParams as any[])
+      const row = rows[0] as Record<string, unknown>
+      const results = parseBatchResults(row, keys, batchQueries)
+      const duration = Date.now() - startTime
+
+      onQuery?.({
+        model: '_batch',
+        method: 'batch',
+        sql,
+        params: normalizedParams,
+        duration,
+        prebaked: false,
+      })
+
+      return results as { [K in keyof T]: any }
+    }
+
+    async function batchCount(queries: BatchCountQuery[]): Promise<number[]> {
+      if (queries.length === 0) return []
+
+      const startTime = Date.now()
+      const { sql, params } = buildBatchCountSql(
+        queries,
+        MODEL_MAP,
+        MODELS,
+        DIALECT,
+      )
+
+      if (debug) {
+        console.log(\`[\${DIALECT}] $batchCount (\${queries.length} queries)\`)
+        console.log('SQL:', sql)
+        console.log('Params:', params)
+      }
+
+      const normalizedParams = normalizeParams(params)
+      const rows = await client.unsafe(sql, normalizedParams as any[])
+      const row = rows[0] as Record<string, unknown>
+      const results = parseBatchCountResults(row, queries.length)
+      const duration = Date.now() - startTime
+
+      onQuery?.({
+        model: '_batch',
+        method: 'count',
+        sql,
+        params: normalizedParams,
+        duration,
+        prebaked: false,
+      })
+
+      return results
+    }
+
+    async function transaction(
+      queries: TransactionQuery[],
+      options?: TransactionOptions,
+    ): Promise<unknown[]> {
+      const startTime = Date.now()
+
+      if (debug) {
+        console.log(\`[\${DIALECT}] $transaction (\${queries.length} queries)\`)
+      }
+
+      const results = await txExecutor.execute(queries, options)
+      const duration = Date.now() - startTime
+
+      onQuery?.({
+        model: '_transaction',
+        method: 'count',
+        sql: \`TRANSACTION(\${queries.length})\`,
+        params: [],
+        duration,
+        prebaked: false,
+      })
+
+      return results
+    }
+
     return prisma.$extends({
       name: 'prisma-sql-generated',
       
       client: {
         $original: prisma,
+        $batch: batch as <T extends Record<string, DeferredQuery>>(
+          callback: (batch: BatchProxy) => T | Promise<T>,
+        ) => Promise<{ [K in keyof T]: any }>,
+        $batchCount: batchCount as (...args: any[]) => Promise<number[]>,
+        $transaction: transaction as (...args: any[]) => Promise<unknown[]>,
       },
 
       model: {
@@ -5320,6 +5536,16 @@ export function speedExtension(config: {
     })
   }
 }
+
+type SpeedExtensionReturn = ReturnType<ReturnType<typeof speedExtension>>
+
+export type SpeedClient<T> = T & {
+  $batch<T extends Record<string, DeferredQuery>>(
+    callback: (batch: BatchProxy) => T | Promise<T>,
+  ): Promise<{ [K in keyof T]: any }>
+  $batchCount(queries: BatchCountQuery[]): Promise<number[]>
+  $transaction(queries: TransactionQuery[], options?: TransactionOptions): Promise<unknown[]>
+}
 `;
 }
 function formatQueries(queries) {