prisma-sql 1.29.0 → 1.32.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.29.0",
+      version: "1.32.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",
@@ -119,7 +119,7 @@ var require_package = __commonJS({
       author: "multipliedtwice <multipliedtwice@gmail.com>",
       license: "MIT",
       dependencies: {
-        "@dee-wan/schema-parser": "1.3.0",
+        "@dee-wan/schema-parser": "1.4.0",
         "@prisma/generator-helper": "^7.2.0",
         "@prisma/internals": "^7.2.0"
       },
@@ -943,14 +943,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)) {
@@ -1053,7 +1093,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(
@@ -1072,8 +1112,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 ")})`;
@@ -1678,7 +1718,7 @@ function buildRelation(fieldName, value, ctx, whereBuilder) {
     ctx.dialect
   );
   const relAlias = ctx.aliasGen.next(fieldName);
-  const join3 = joinCondition(field, ctx.alias, relAlias);
+  const join3 = joinCondition(field, ctx.model, relModel, ctx.alias, relAlias);
   const args = {
     fieldName,
     value,
@@ -2423,12 +2463,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}`);
@@ -2463,7 +2503,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");
@@ -2485,8 +2525,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)`;
@@ -2501,10 +2542,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;
@@ -2537,7 +2578,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);
@@ -2564,20 +2605,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)})`);
@@ -2585,15 +2635,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"
@@ -2678,7 +2728,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`);
@@ -2696,7 +2746,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) {
@@ -2712,7 +2764,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;
 }
@@ -2725,12 +2779,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;
@@ -2756,9 +2810,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);
 }
@@ -3045,8 +3102,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}`;
@@ -3133,7 +3190,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,
@@ -3158,7 +3221,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,
@@ -4521,9 +4589,9 @@ function generateClient(options) {
           if (!modelQueries.has(method)) {
             modelQueries.set(method, /* @__PURE__ */ new Map());
           }
-          const methodQueries = modelQueries.get(method);
+          const methodQueriesMap = modelQueries.get(method);
           const queryKey = createQueryKey(directive.query.processed);
-          methodQueries.set(queryKey, {
+          methodQueriesMap.set(queryKey, {
             sql: sqlDirective.sql,
             params: sqlDirective.staticParams,
             dynamicKeys: sqlDirective.dynamicKeys,
@@ -4546,7 +4614,9 @@ function generateClient(options) {
       ),
       0
     );
-    console.log(`\u2713 Generated ${queries.size} models, ${totalQueries} queries`);
+    console.log(
+      `\u2713 Generated ${queries.size} models, ${totalQueries} prebaked queries`
+    );
     console.log(`\u2713 Output: ${outputPath}`);
   });
 }
@@ -4569,7 +4639,10 @@ function generateCode(models, queries, dialect) {
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
 import { buildSQL, transformQueryResults, type PrismaMethod } from 'prisma-sql'
 
-const MODELS = ${JSON.stringify(cleanModels, null, 2)}
+// Export models for advanced use cases (createToSQL, etc)
+export const MODELS = ${JSON.stringify(cleanModels, null, 2)} as const
+
+export type Models = typeof MODELS
 
 const QUERIES: Record<string, Record<string, Record<string, {
   sql: string
@@ -4581,17 +4654,14 @@ const QUERIES: Record<string, Record<string, Record<string, {
 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 '{}'
   
-  // 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
     
@@ -4601,7 +4671,6 @@ function normalizeQuery(args: any): string {
     
     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 {
@@ -4613,13 +4682,11 @@ function normalizeQuery(args: any): string {
   
   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
       }
@@ -4630,7 +4697,6 @@ function normalizeQuery(args: any): string {
   
   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> = {}
@@ -4648,9 +4714,7 @@ function extractDynamicParams(args: any, dynamicKeys: string[]): unknown[] {
   
   for (const key of dynamicKeys) {
     const parts = key.split(':')
-
     const lookupKey = parts.length === 2 ? parts[1] : key
-    
     const value = args[lookupKey]
     
     if (value === undefined) {
@@ -4677,7 +4741,7 @@ async function executeQuery(client: any, sql: string, params: unknown[]): Promis
   return stmt.all(...params)
 }
 
-export function createExtension(config: {
+export function speedExtension(config: {
   postgres?: any
   sqlite?: any
   debug?: boolean
@@ -4690,10 +4754,11 @@ export function createExtension(config: {
     prebaked: boolean
   }) => void
 }) {
+  // models is NOT a parameter - uses internal MODELS
   const { postgres, sqlite, debug, onQuery } = config
 
   if (!postgres && !sqlite) {
-    throw new Error('Extension requires postgres or sqlite client')
+    throw new Error('speedExtension requires postgres or sqlite client')
   }
 
   const client = postgres || sqlite
@@ -4720,6 +4785,7 @@ export function createExtension(config: {
         params = [...prebakedQuery.params, ...extractDynamicParams(args, prebakedQuery.dynamicKeys)]
         prebaked = true
       } else {
+        // Use internal MODELS directly
         const model = MODELS.find((m: any) => m.name === modelName)
         
         if (!model) {