prisma-sql 1.53.0 → 1.55.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.53.0",
+      version: "1.55.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",
@@ -813,6 +813,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;
 }
@@ -834,33 +837,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++;
@@ -869,15 +872,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");
@@ -951,7 +954,7 @@ function quote2(id) {
     );
   }
   if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
+    return quoteRawIdent(id);
   }
   return id;
 }
@@ -2590,28 +2593,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) {
@@ -2621,14 +2620,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);
@@ -2680,24 +2678,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) {
@@ -2709,16 +2702,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(
@@ -2770,13 +2766,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 {
@@ -2800,11 +2800,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()
   );
 }
 
@@ -2986,7 +2986,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(
@@ -3040,8 +3040,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}`
@@ -3100,8 +3101,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)
@@ -3111,9 +3113,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,
@@ -3174,7 +3174,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);
@@ -3186,9 +3188,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,
@@ -3241,7 +3241,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) {
@@ -3339,12 +3339,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)) {
@@ -3400,7 +3395,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(
@@ -3408,10 +3403,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}`
@@ -3439,8 +3435,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);
@@ -3516,12 +3513,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,
@@ -4951,12 +4943,81 @@ 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 BatchCountQuery, type TransactionQuery, type TransactionOptions } from 'prisma-sql'
+
+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) {
@@ -5003,9 +5064,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('.')
@@ -5017,9 +5075,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))
 }
@@ -5040,6 +5095,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'
 }
@@ -5206,6 +5263,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
@@ -5233,6 +5297,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()
@@ -5286,11 +5358,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: {
@@ -5318,6 +5509,18 @@ 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[]>
+}
+
+export type { BatchCountQuery, TransactionQuery, TransactionOptions }
 `;
 }
 function formatQueries(queries) {