prisma-sql 1.30.0 → 1.32.0

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { ParamMap, DirectiveProps, Model as Model$1 } from '@dee-wan/schema-parser';
 export { convertDMMFToModels } from '@dee-wan/schema-parser';
+import { DMMF } from '@prisma/generator-helper';
 
 type SqlDialect = 'postgres' | 'sqlite';
 declare function setGlobalDialect(dialect: SqlDialect): void;
@@ -64,7 +65,8 @@ interface SqlResult {
 interface SpeedExtensionConfig {
     postgres?: any;
     sqlite?: any;
-    models: Model$1[];
+    models?: Model$1[];
+    dmmf?: DMMF.Document;
     debug?: boolean;
     allowedModels?: string[];
     onQuery?: (info: QueryInfo) => void;
@@ -77,14 +79,73 @@ interface QueryInfo {
     duration: number;
 }
 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;
-declare function createToSQL(models: Model$1[], dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
+/**
+ * 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 createToSQL(modelsOrDmmf: Model$1[] | DMMF.Document, dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
 interface PrismaSQLConfig<TClient> {
     client: TClient;
-    models: Model$1[];
+    models?: Model$1[];
+    dmmf?: DMMF.Document;
     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>): {
     toSQL: (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
     query: <T = unknown[]>(model: string, method: PrismaMethod, args?: Record<string, unknown>) => Promise<T>;

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { ParamMap, DirectiveProps, Model as Model$1 } from '@dee-wan/schema-parser';
 export { convertDMMFToModels } from '@dee-wan/schema-parser';
+import { DMMF } from '@prisma/generator-helper';
 
 type SqlDialect = 'postgres' | 'sqlite';
 declare function setGlobalDialect(dialect: SqlDialect): void;
@@ -64,7 +65,8 @@ interface SqlResult {
 interface SpeedExtensionConfig {
     postgres?: any;
     sqlite?: any;
-    models: Model$1[];
+    models?: Model$1[];
+    dmmf?: DMMF.Document;
     debug?: boolean;
     allowedModels?: string[];
     onQuery?: (info: QueryInfo) => void;
@@ -77,14 +79,73 @@ interface QueryInfo {
     duration: number;
 }
 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;
-declare function createToSQL(models: Model$1[], dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
+/**
+ * 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 createToSQL(modelsOrDmmf: Model$1[] | DMMF.Document, dialect: SqlDialect): (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
 interface PrismaSQLConfig<TClient> {
     client: TClient;
-    models: Model$1[];
+    models?: Model$1[];
+    dmmf?: DMMF.Document;
     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>): {
     toSQL: (model: string, method: PrismaMethod, args?: Record<string, unknown>) => SqlResult;
     query: <T = unknown[]>(model: string, method: PrismaMethod, args?: Record<string, unknown>) => Promise<T>;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { isDynamicParameter, convertDMMFToModels, extractDynamicName } from '@dee-wan/schema-parser';
+import { convertDMMFToModels, isDynamicParameter, extractDynamicName } from '@dee-wan/schema-parser';
 export { convertDMMFToModels } from '@dee-wan/schema-parser';
 
 var __defProp = Object.defineProperty;
@@ -836,14 +836,54 @@ function quote(id) {
   }
   return id;
 }
-function col(alias, field) {
+function pickDbFieldName(field) {
+  const candidates = [
+    field == null ? void 0 : field.dbName,
+    field == null ? void 0 : field.columnName,
+    field == null ? void 0 : field.databaseName,
+    field == null ? void 0 : field.mappedName
+  ];
+  for (const c of candidates) {
+    if (typeof c === "string") {
+      const s = c.trim();
+      if (s.length > 0) return s;
+    }
+  }
+  return void 0;
+}
+function resolveColumnName(model, fieldName) {
+  var _a;
+  if (!model) return fieldName;
+  const f = model.fields.find((x) => (x == null ? void 0 : x.name) === fieldName);
+  if (!f) return fieldName;
+  return (_a = pickDbFieldName(f)) != null ? _a : fieldName;
+}
+function quoteColumn(model, fieldName) {
+  return quote(resolveColumnName(model, fieldName));
+}
+function col(alias, field, model) {
   if (isEmptyString(alias)) {
     throw new Error("col: alias is required and cannot be empty");
   }
   if (isEmptyString(field)) {
     throw new Error("col: field is required and cannot be empty");
   }
-  return `${alias}.${quote(field)}`;
+  const columnName = resolveColumnName(model, field);
+  return `${alias}.${quote(columnName)}`;
+}
+function colWithAlias(alias, field, model) {
+  if (isEmptyString(alias)) {
+    throw new Error("colWithAlias: alias is required and cannot be empty");
+  }
+  if (isEmptyString(field)) {
+    throw new Error("colWithAlias: field is required and cannot be empty");
+  }
+  const columnName = resolveColumnName(model, field);
+  const columnRef = `${alias}.${quote(columnName)}`;
+  if (columnName !== field) {
+    return `${columnRef} AS ${quote(field)}`;
+  }
+  return columnRef;
 }
 function sqlStringLiteral(value) {
   if (containsControlChars(value)) {
@@ -946,7 +986,7 @@ function getReferenceFieldNames(field, foreignKeyCount) {
   if (refs.length !== foreignKeyCount) return [];
   return refs;
 }
-function joinCondition(field, parentAlias, childAlias) {
+function joinCondition(field, parentModel, childModel, parentAlias, childAlias) {
   const fkFields = normalizeKeyList(field.foreignKey);
   if (fkFields.length === 0) {
     throw createError(
@@ -965,8 +1005,8 @@ function joinCondition(field, parentAlias, childAlias) {
   for (let i = 0; i < fkFields.length; i++) {
     const fk = fkFields[i];
     const ref = refFields[i];
-    const left = field.isForeignKeyLocal ? `${childAlias}.${quote(ref)}` : `${childAlias}.${quote(fk)}`;
-    const right = field.isForeignKeyLocal ? `${parentAlias}.${quote(fk)}` : `${parentAlias}.${quote(ref)}`;
+    const left = field.isForeignKeyLocal ? `${childAlias}.${quoteColumn(childModel, ref)}` : `${childAlias}.${quoteColumn(childModel, fk)}`;
+    const right = field.isForeignKeyLocal ? `${parentAlias}.${quoteColumn(parentModel, fk)}` : `${parentAlias}.${quoteColumn(parentModel, ref)}`;
     parts.push(`${left} = ${right}`);
   }
   return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
@@ -1571,7 +1611,7 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
     ctx.dialect
   );
   const relAlias = ctx.aliasGen.next(fieldName);
-  const join = joinCondition(field, ctx.alias, relAlias);
+  const join = joinCondition(field, ctx.model, relModel, ctx.alias, relAlias);
   const args = {
     fieldName,
     value,
@@ -2316,12 +2356,12 @@ function readSkipTake(relArgs) {
   const takeVal = hasTake ? normalizeIntegerOrDynamic("take", obj.take) : void 0;
   return { hasSkip, hasTake, skipVal, takeVal };
 }
-function buildOrderByFragment(entries, alias, dialect) {
+function buildOrderByFragment(entries, alias, dialect, model) {
   if (entries.length === 0) return "";
   const out = [];
   for (const e of entries) {
     const dir = e.direction.toUpperCase();
-    const c = col(alias, e.field);
+    const c = col(alias, e.field, model);
     if (dialect === "postgres") {
       const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
       out.push(`${c} ${dir}${nulls}`);
@@ -2356,7 +2396,7 @@ function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
   }
   return out;
 }
-function buildCursorFilterParts(cursor, cursorAlias, params) {
+function buildCursorFilterParts(cursor, cursorAlias, params, model) {
   const entries = Object.entries(cursor);
   if (entries.length === 0) {
     throw new Error("cursor must have at least one field");
@@ -2378,8 +2418,9 @@ function buildCursorFilterParts(cursor, cursorAlias, params) {
     placeholdersByField
   };
 }
-function cursorValueExpr(tableName, cursorAlias, cursorWhereSql, field) {
-  return `(SELECT ${cursorAlias}.${quote(field)} ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
+function cursorValueExpr(tableName, cursorAlias, cursorWhereSql, field, model) {
+  const colName = quote(field);
+  return `(SELECT ${cursorAlias}.${colName} ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
 }
 function buildCursorRowExistsExpr(tableName, cursorAlias, cursorWhereSql) {
   return `EXISTS (${SQL_TEMPLATES.SELECT} 1 ${SQL_TEMPLATES.FROM} ${tableName} ${cursorAlias} ${SQL_TEMPLATES.WHERE} ${cursorWhereSql} ${SQL_TEMPLATES.LIMIT} 1)`;
@@ -2394,10 +2435,10 @@ function buildCursorInequalityExpr(columnExpr, direction, nulls, valueExpr) {
   }
   return `(CASE WHEN ${valueExpr} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${valueExpr}) OR (${columnExpr} IS NULL)) END)`;
 }
-function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params) {
+function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params, model) {
   const parts = [];
   for (const [field, value] of Object.entries(cursor)) {
-    const c = col(outerAlias, field);
+    const c = col(outerAlias, field, model);
     if (value === null) {
       parts.push(`${c} IS NULL`);
       continue;
@@ -2430,7 +2471,7 @@ function buildOrderEntries(orderBy) {
   }
   return entries;
 }
-function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect) {
+function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
   var _a;
   const d = dialect != null ? dialect : getGlobalDialect();
   const cursorEntries = Object.entries(cursor);
@@ -2457,20 +2498,29 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
     cursor,
     alias,
     placeholdersByField,
-    params
+    params,
+    model
   );
   const orClauses = [];
   for (let level = 0; level < orderEntries.length; level++) {
     const andParts = [];
     for (let i = 0; i < level; i++) {
       const e2 = orderEntries[i];
-      const c2 = col(alias, e2.field);
-      const v2 = cursorValueExpr(tableName, cursorAlias, cursorWhereSql, e2.field);
+      const c2 = col(alias, e2.field, model);
+      const v2 = cursorValueExpr(
+        tableName,
+        cursorAlias,
+        cursorWhereSql,
+        e2.field);
       andParts.push(buildCursorEqualityExpr(c2, v2));
     }
     const e = orderEntries[level];
-    const c = col(alias, e.field);
-    const v = cursorValueExpr(tableName, cursorAlias, cursorWhereSql, e.field);
+    const c = col(alias, e.field, model);
+    const v = cursorValueExpr(
+      tableName,
+      cursorAlias,
+      cursorWhereSql,
+      e.field);
     const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
     andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, v));
     orClauses.push(`(${andParts.join(SQL_SEPARATORS.CONDITION_AND)})`);
@@ -2478,15 +2528,15 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
   const exclusive = orClauses.join(SQL_SEPARATORS.CONDITION_OR);
   return `(${existsExpr} ${SQL_SEPARATORS.CONDITION_AND} ((${exclusive})${SQL_SEPARATORS.CONDITION_OR}(${outerCursorMatch})))`;
 }
-function buildOrderBy(orderBy, alias, dialect) {
+function buildOrderBy(orderBy, alias, dialect, model) {
   const entries = buildOrderEntries(orderBy);
   if (entries.length === 0) return "";
   const d = dialect != null ? dialect : getGlobalDialect();
-  return buildOrderByFragment(entries, alias, d);
+  return buildOrderByFragment(entries, alias, d, model);
 }
-function buildOrderByClause(args, alias, dialect) {
+function buildOrderByClause(args, alias, dialect, model) {
   if (!isNotNullish(args.orderBy)) return "";
-  const result = buildOrderBy(args.orderBy, alias, dialect);
+  const result = buildOrderBy(args.orderBy, alias, dialect, model);
   if (!isNonEmptyString(result)) {
     throw new Error(
       "buildOrderByClause: orderBy specified but produced empty result"
@@ -2571,7 +2621,7 @@ function buildDefaultScalarFields(model, alias) {
   for (const f of model.fields) {
     if (f.isRelation) continue;
     const excluded = excludedPrefixes.some((p) => f.name.startsWith(p));
-    if (!excluded) out.push(col(alias, f.name));
+    if (!excluded) out.push(colWithAlias(alias, f.name, model));
   }
   if (!isNonEmptyArray(out)) {
     throw new Error(`Model ${model.name} has no selectable fields`);
@@ -2589,7 +2639,9 @@ function buildSelectFields(args, model, alias) {
   const entries = toSelectEntries(args.select);
   validateSelectKeys(entries, scalarSet, relationSet);
   const { scalarSelected, hasRelationSelection, hasCount } = analyzeSelectEntries(entries, scalarSet, relationSet);
-  const fields = scalarSelected.map((field) => col(alias, field));
+  const fields = scalarSelected.map(
+    (field) => colWithAlias(alias, field, model)
+  );
   if (!isNonEmptyArray(fields)) {
     if (hasRelationSelection) return "";
     if (!hasCount) {
@@ -2605,7 +2657,9 @@ function buildAllScalarParts(model, alias) {
   }
   const parts = [];
   for (const field of scalarFields) {
-    parts.push(`${sqlStringLiteral(field.name)}, ${col(alias, field.name)}`);
+    parts.push(
+      `${sqlStringLiteral(field.name)}, ${col(alias, field.name, model)}`
+    );
   }
   return parts;
 }
@@ -2618,12 +2672,12 @@ function validateRelationSelectKeys(entries, scalarNames, relationNames) {
     throw new Error(`Select contains unknown fields: ${unknown.join(", ")}`);
   }
 }
-function buildSelectedScalarParts(entries, scalarNames, alias) {
+function buildSelectedScalarParts(entries, scalarNames, alias, model) {
   const parts = [];
   for (const [key, value] of entries) {
     if (!scalarNames.has(key)) continue;
     if (value === true) {
-      parts.push(`${sqlStringLiteral(key)}, ${col(alias, key)}`);
+      parts.push(`${sqlStringLiteral(key)}, ${col(alias, key, model)}`);
     }
   }
   return parts;
@@ -2649,9 +2703,12 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
     );
     const entries = toSelectEntries(sel);
     validateRelationSelectKeys(entries, scalarNames, relationNames);
-    return buildSelectedScalarParts(entries, scalarNames, relAlias).join(
-      SQL_SEPARATORS.FIELD_LIST
-    );
+    return buildSelectedScalarParts(
+      entries,
+      scalarNames,
+      relAlias,
+      relModel
+    ).join(SQL_SEPARATORS.FIELD_LIST);
   }
   return buildAllScalarParts(relModel, relAlias).join(SQL_SEPARATORS.FIELD_LIST);
 }
@@ -2938,8 +2995,8 @@ function limitOneSql(sql, params, skipVal, scope) {
   }
   return `${sql} ${SQL_TEMPLATES.LIMIT} 1`;
 }
-function buildOrderBySql(finalOrderByInput, relAlias, dialect) {
-  return isNotNullish(finalOrderByInput) ? buildOrderBy(finalOrderByInput, relAlias, dialect) : "";
+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}`;
@@ -3026,7 +3083,13 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const relTable = getRelationTableReference(relModel, ctx.dialect);
   const relAlias = ctx.aliasGen.next(relName);
   const isList = typeof field.type === "string" && field.type.endsWith("[]");
-  const joinPredicate = joinCondition(field, ctx.parentAlias, relAlias);
+  const joinPredicate = joinCondition(
+    field,
+    ctx.model,
+    relModel,
+    ctx.parentAlias,
+    relAlias
+  );
   const whereInput = readWhereInput(relArgs);
   const relSelect = buildSelectWithNestedIncludes(
     relArgs,
@@ -3051,7 +3114,12 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     adjusted.orderByInput,
     hasPagination
   );
-  const orderBySql = buildOrderBySql(finalOrderByInput, relAlias, ctx.dialect);
+  const orderBySql = buildOrderBySql(
+    finalOrderByInput,
+    relAlias,
+    ctx.dialect,
+    relModel
+  );
   if (!isList) {
     const sql = buildOneToOneIncludeSql({
       relName,
@@ -4638,7 +4706,8 @@ function speedExtension(config) {
   const {
     postgres,
     sqlite,
-    models,
+    models: providedModels,
+    dmmf,
     debug = false,
     allowedModels,
     onQuery
@@ -4651,11 +4720,19 @@ function speedExtension(config) {
       "speedExtension cannot use both postgres and sqlite clients"
     );
   }
-  if (!models || !Array.isArray(models) || models.length === 0) {
+  let models;
+  if (providedModels) {
+    models = providedModels;
+  } else if (dmmf) {
+    models = convertDMMFToModels(dmmf.datamodel);
+  } else {
     throw new Error(
-      "speedExtension requires models parameter. Convert DMMF first: speedExtension({ models: convertDMMFToModels(Prisma.dmmf.datamodel) })"
+      'speedExtension requires either models or dmmf parameter.\n\n\u26A0\uFE0F  RECOMMENDED APPROACH:\n   Use the generated extension for zero runtime overhead:\n\n   import { speedExtension } from "./generated/sql"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql })\n   )\n\n   1. Add generator to schema.prisma:\n      generator sql {\n        provider = "prisma-sql-generator"\n      }\n\n   2. Run: npx prisma generate\n\n   3. Import from generated file\n\n\u274C RUNTIME-ONLY MODE:\n   If you cannot use the generator, provide models or dmmf:\n\n   import { speedExtension } from "prisma-sql"\n   import { MODELS } from "./generated/sql"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql, models: MODELS })\n   )\n\n   Or with DMMF (auto-converts on startup):\n\n   import { Prisma } from "@prisma/client"\n   const prisma = new PrismaClient().$extends(\n     speedExtension({ postgres: sql, dmmf: Prisma.dmmf })\n   )'
     );
   }
+  if (!Array.isArray(models) || models.length === 0) {
+    throw new Error("speedExtension: models array is empty or invalid");
+  }
   const dialect = postgres ? "postgres" : "sqlite";
   const client = postgres || sqlite;
   setGlobalDialect(dialect);
@@ -4683,7 +4760,7 @@ function speedExtension(config) {
       methodHandlers[method] = createMethodHandler(method);
     }
     return prisma.$extends({
-      name: "speed-extension",
+      name: "prisma-sql-speed",
       client: {
         $original: prisma
       },
@@ -4709,13 +4786,22 @@ function createToSQLFunction(models, dialect) {
     return buildSQL(m, models, method, args, dialect);
   };
 }
-function createToSQL(models, dialect) {
+function createToSQL(modelsOrDmmf, dialect) {
+  const models = Array.isArray(modelsOrDmmf) ? modelsOrDmmf : convertDMMFToModels(modelsOrDmmf.datamodel);
   return createToSQLFunction(models, dialect);
 }
 function createPrismaSQL(config) {
-  const { client, models, dialect, execute } = config;
-  if (!models || !Array.isArray(models) || models.length === 0) {
-    throw new Error("createPrismaSQL requires non-empty models array");
+  const { client, models: providedModels, dmmf, dialect, execute } = config;
+  let models;
+  if (providedModels) {
+    models = providedModels;
+  } else if (dmmf) {
+    models = convertDMMFToModels(dmmf.datamodel);
+  } else {
+    throw new Error("createPrismaSQL requires either models or dmmf parameter");
+  }
+  if (!Array.isArray(models) || models.length === 0) {
+    throw new Error("createPrismaSQL: models array is empty or invalid");
   }
   const toSQL = createToSQLFunction(models, dialect);
   function query(_0, _1) {