prisma-sql 1.53.0 → 1.55.0

package/dist/index.d.mts

@@ -59,6 +59,49 @@ interface PrismaQueryArgs {
     method?: string;
 }
 
+interface BatchQuery {
+    model: string;
+    method: PrismaMethod;
+    args?: Record<string, unknown>;
+}
+interface BatchCountQuery {
+    model: string;
+    method: 'count';
+    args?: {
+        where?: Record<string, unknown>;
+    };
+}
+interface BatchResult {
+    sql: string;
+    params: unknown[];
+}
+declare function buildBatchSql(queries: Record<string, BatchQuery>, modelMap: Map<string, Model>, models: Model[], dialect: SqlDialect): BatchResult & {
+    keys: string[];
+};
+declare function buildBatchCountSql(queries: BatchCountQuery[], modelMap: Map<string, Model>, models: Model[], dialect: SqlDialect): BatchResult;
+declare function parseBatchCountResults(row: Record<string, unknown>, count: number): number[];
+declare function parseBatchResults(row: Record<string, unknown>, keys: string[], queries: Record<string, BatchQuery>): Record<string, unknown>;
+
+interface TransactionQuery {
+    model: string;
+    method: PrismaMethod;
+    args?: Record<string, unknown>;
+}
+interface TransactionOptions {
+    isolationLevel?: 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
+    timeout?: number;
+}
+interface TransactionExecutor {
+    execute(queries: TransactionQuery[], options?: TransactionOptions): Promise<unknown[]>;
+}
+declare function createTransactionExecutor(deps: {
+    modelMap: Map<string, Model>;
+    allModels: Model[];
+    dialect: SqlDialect;
+    executeRaw: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+    postgresClient?: any;
+}): TransactionExecutor;
+
 interface SqlResult {
     sql: string;
     params: unknown[];
@@ -79,48 +122,32 @@ interface QueryInfo {
     params: unknown[];
     duration: number;
 }
+interface DeferredQueryLike {
+    readonly model: string;
+    readonly method: PrismaMethod;
+    readonly args: any;
+}
+interface BatchProxy {
+    [modelName: string]: {
+        findMany: (args?: any) => DeferredQueryLike;
+        findFirst: (args?: any) => DeferredQueryLike;
+        findUnique: (args?: any) => DeferredQueryLike;
+        count: (args?: any) => DeferredQueryLike;
+        aggregate: (args?: any) => DeferredQueryLike;
+        groupBy: (args?: any) => DeferredQueryLike;
+    };
+}
+interface SpeedExtensionClient {
+    $original: any;
+    $batch: <T extends Record<string, DeferredQueryLike>>(callback: (batch: BatchProxy) => T | Promise<T>) => Promise<{
+        [K in keyof T]: any;
+    }>;
+    $transaction: (queries: TransactionQuery[], options?: TransactionOptions) => Promise<unknown[]>;
+}
+type ExtendedPrismaClient<T> = T & SpeedExtensionClient;
 declare function buildSQL(model: Model$1, models: Model$1[], method: PrismaMethod, args: Record<string, unknown>, dialect: SqlDialect): SqlResult;
-/**
- * Runtime-only Prisma extension for SQL acceleration.
- *
- * ⚠️ RECOMMENDED: Use generated extension instead for zero overhead!
- *
- * @example
- * // RECOMMENDED: Generated extension (no models/dmmf needed)
- * import { speedExtension } from './generated/sql'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql })
- * )
- *
- * @example
- * // Runtime with pre-converted models
- * import { speedExtension } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql, models: MODELS })
- * )
- *
- * @example
- * // Runtime with DMMF (auto-converts on startup)
- * import { speedExtension } from 'prisma-sql'
- * import { Prisma } from '@prisma/client'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql, dmmf: Prisma.dmmf })
- * )
- */
 declare function speedExtension(config: SpeedExtensionConfig): (prisma: any) => any;
-/**
- * Create a SQL generator function from models.
- *
- * @example
- * import { createToSQL } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- *
- * const toSQL = createToSQL(MODELS, 'postgres')
- * const { sql, params } = toSQL('User', 'findMany', {
- *   where: { status: 'ACTIVE' }
- * })
- */
+declare function extendPrisma<T>(prisma: T, config: SpeedExtensionConfig): ExtendedPrismaClient<T>;
 declare function createToSQL(modelsOrDmmf: Model$1[] | DMMF.Document, dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
 interface PrismaSQLConfig<TClient> {
     client: TClient;
@@ -129,31 +156,15 @@ interface PrismaSQLConfig<TClient> {
     dialect: SqlDialect;
     execute: (client: TClient, sql: string, params: unknown[]) => Promise<unknown[]>;
 }
-/**
- * Create a Prisma SQL client for environments where extensions aren't supported.
- *
- * @example
- * import { createPrismaSQL } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- *
- * const prismaSQL = createPrismaSQL({
- *   client: sql,
- *   models: MODELS,
- *   dialect: 'postgres',
- *   execute: (client, sql, params) => client.unsafe(sql, params)
- * })
- *
- * const users = await prismaSQL.query('User', 'findMany', {
- *   where: { status: 'ACTIVE' }
- * })
- */
-declare function createPrismaSQL<TClient>(config: PrismaSQLConfig<TClient>): {
+interface PrismaSQLResult<TClient> {
     toSQL: (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
     query: <T = unknown[]>(model: string, method: PrismaMethod, args?: Record<string, unknown>) => Promise<T>;
+    batchSql: (queries: Record<string, BatchQuery>) => SqlResult;
     client: TClient;
-};
+}
+declare function createPrismaSQL<TClient>(config: PrismaSQLConfig<TClient>): PrismaSQLResult<TClient>;
 declare function generateSQL(directive: DirectiveProps): SQLDirective;
 declare function generateAllSQL(directives: DirectiveProps[]): SQLDirective[];
 declare function generateSQLByModel(directives: DirectiveProps[]): Map<string, SQLDirective[]>;
 
-export { type Field, type Model, type PrismaMethod, type PrismaQueryArgs, type PrismaSQLConfig, type QueryInfo, type SQLDirective, type SpeedExtensionConfig, type SqlDialect, type SqlResult, buildSQL, createPrismaSQL, createToSQL, generateAllSQL, generateSQL, generateSQLByModel, getGlobalDialect, setGlobalDialect, speedExtension, transformQueryResults };
+export { type BatchCountQuery, type BatchProxy, type BatchQuery, type DeferredQueryLike, type ExtendedPrismaClient, type Field, type Model, type PrismaMethod, type PrismaQueryArgs, type PrismaSQLConfig, type PrismaSQLResult, type QueryInfo, type SQLDirective, type SpeedExtensionClient, type SpeedExtensionConfig, type SqlDialect, type SqlResult, type TransactionExecutor, type TransactionOptions, type TransactionQuery, buildBatchCountSql, buildBatchSql, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, extendPrisma, generateAllSQL, generateSQL, generateSQLByModel, getGlobalDialect, parseBatchCountResults, parseBatchResults, setGlobalDialect, speedExtension, transformQueryResults };

package/dist/index.d.ts

@@ -59,6 +59,49 @@ interface PrismaQueryArgs {
     method?: string;
 }
 
+interface BatchQuery {
+    model: string;
+    method: PrismaMethod;
+    args?: Record<string, unknown>;
+}
+interface BatchCountQuery {
+    model: string;
+    method: 'count';
+    args?: {
+        where?: Record<string, unknown>;
+    };
+}
+interface BatchResult {
+    sql: string;
+    params: unknown[];
+}
+declare function buildBatchSql(queries: Record<string, BatchQuery>, modelMap: Map<string, Model>, models: Model[], dialect: SqlDialect): BatchResult & {
+    keys: string[];
+};
+declare function buildBatchCountSql(queries: BatchCountQuery[], modelMap: Map<string, Model>, models: Model[], dialect: SqlDialect): BatchResult;
+declare function parseBatchCountResults(row: Record<string, unknown>, count: number): number[];
+declare function parseBatchResults(row: Record<string, unknown>, keys: string[], queries: Record<string, BatchQuery>): Record<string, unknown>;
+
+interface TransactionQuery {
+    model: string;
+    method: PrismaMethod;
+    args?: Record<string, unknown>;
+}
+interface TransactionOptions {
+    isolationLevel?: 'ReadCommitted' | 'RepeatableRead' | 'Serializable';
+    timeout?: number;
+}
+interface TransactionExecutor {
+    execute(queries: TransactionQuery[], options?: TransactionOptions): Promise<unknown[]>;
+}
+declare function createTransactionExecutor(deps: {
+    modelMap: Map<string, Model>;
+    allModels: Model[];
+    dialect: SqlDialect;
+    executeRaw: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+    postgresClient?: any;
+}): TransactionExecutor;
+
 interface SqlResult {
     sql: string;
     params: unknown[];
@@ -79,48 +122,32 @@ interface QueryInfo {
     params: unknown[];
     duration: number;
 }
+interface DeferredQueryLike {
+    readonly model: string;
+    readonly method: PrismaMethod;
+    readonly args: any;
+}
+interface BatchProxy {
+    [modelName: string]: {
+        findMany: (args?: any) => DeferredQueryLike;
+        findFirst: (args?: any) => DeferredQueryLike;
+        findUnique: (args?: any) => DeferredQueryLike;
+        count: (args?: any) => DeferredQueryLike;
+        aggregate: (args?: any) => DeferredQueryLike;
+        groupBy: (args?: any) => DeferredQueryLike;
+    };
+}
+interface SpeedExtensionClient {
+    $original: any;
+    $batch: <T extends Record<string, DeferredQueryLike>>(callback: (batch: BatchProxy) => T | Promise<T>) => Promise<{
+        [K in keyof T]: any;
+    }>;
+    $transaction: (queries: TransactionQuery[], options?: TransactionOptions) => Promise<unknown[]>;
+}
+type ExtendedPrismaClient<T> = T & SpeedExtensionClient;
 declare function buildSQL(model: Model$1, models: Model$1[], method: PrismaMethod, args: Record<string, unknown>, dialect: SqlDialect): SqlResult;
-/**
- * Runtime-only Prisma extension for SQL acceleration.
- *
- * ⚠️ RECOMMENDED: Use generated extension instead for zero overhead!
- *
- * @example
- * // RECOMMENDED: Generated extension (no models/dmmf needed)
- * import { speedExtension } from './generated/sql'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql })
- * )
- *
- * @example
- * // Runtime with pre-converted models
- * import { speedExtension } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql, models: MODELS })
- * )
- *
- * @example
- * // Runtime with DMMF (auto-converts on startup)
- * import { speedExtension } from 'prisma-sql'
- * import { Prisma } from '@prisma/client'
- * const prisma = new PrismaClient().$extends(
- *   speedExtension({ postgres: sql, dmmf: Prisma.dmmf })
- * )
- */
 declare function speedExtension(config: SpeedExtensionConfig): (prisma: any) => any;
-/**
- * Create a SQL generator function from models.
- *
- * @example
- * import { createToSQL } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- *
- * const toSQL = createToSQL(MODELS, 'postgres')
- * const { sql, params } = toSQL('User', 'findMany', {
- *   where: { status: 'ACTIVE' }
- * })
- */
+declare function extendPrisma<T>(prisma: T, config: SpeedExtensionConfig): ExtendedPrismaClient<T>;
 declare function createToSQL(modelsOrDmmf: Model$1[] | DMMF.Document, dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
 interface PrismaSQLConfig<TClient> {
     client: TClient;
@@ -129,31 +156,15 @@ interface PrismaSQLConfig<TClient> {
     dialect: SqlDialect;
     execute: (client: TClient, sql: string, params: unknown[]) => Promise<unknown[]>;
 }
-/**
- * Create a Prisma SQL client for environments where extensions aren't supported.
- *
- * @example
- * import { createPrismaSQL } from 'prisma-sql'
- * import { MODELS } from './generated/sql'
- *
- * const prismaSQL = createPrismaSQL({
- *   client: sql,
- *   models: MODELS,
- *   dialect: 'postgres',
- *   execute: (client, sql, params) => client.unsafe(sql, params)
- * })
- *
- * const users = await prismaSQL.query('User', 'findMany', {
- *   where: { status: 'ACTIVE' }
- * })
- */
-declare function createPrismaSQL<TClient>(config: PrismaSQLConfig<TClient>): {
+interface PrismaSQLResult<TClient> {
     toSQL: (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
     query: <T = unknown[]>(model: string, method: PrismaMethod, args?: Record<string, unknown>) => Promise<T>;
+    batchSql: (queries: Record<string, BatchQuery>) => SqlResult;
     client: TClient;
-};
+}
+declare function createPrismaSQL<TClient>(config: PrismaSQLConfig<TClient>): PrismaSQLResult<TClient>;
 declare function generateSQL(directive: DirectiveProps): SQLDirective;
 declare function generateAllSQL(directives: DirectiveProps[]): SQLDirective[];
 declare function generateSQLByModel(directives: DirectiveProps[]): Map<string, SQLDirective[]>;
 
-export { type Field, type Model, type PrismaMethod, type PrismaQueryArgs, type PrismaSQLConfig, type QueryInfo, type SQLDirective, type SpeedExtensionConfig, type SqlDialect, type SqlResult, buildSQL, createPrismaSQL, createToSQL, generateAllSQL, generateSQL, generateSQLByModel, getGlobalDialect, setGlobalDialect, speedExtension, transformQueryResults };
+export { type BatchCountQuery, type BatchProxy, type BatchQuery, type DeferredQueryLike, type ExtendedPrismaClient, type Field, type Model, type PrismaMethod, type PrismaQueryArgs, type PrismaSQLConfig, type PrismaSQLResult, type QueryInfo, type SQLDirective, type SpeedExtensionClient, type SpeedExtensionConfig, type SqlDialect, type SqlResult, type TransactionExecutor, type TransactionOptions, type TransactionQuery, buildBatchCountSql, buildBatchSql, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, extendPrisma, generateAllSQL, generateSQL, generateSQLByModel, getGlobalDialect, parseBatchCountResults, parseBatchResults, setGlobalDialect, speedExtension, transformQueryResults };