prisma-sql 1.37.0 → 1.38.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.37.0",
+      version: "1.38.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",
@@ -97,6 +97,17 @@ var require_package = __commonJS({
         "sonar-cli": "sonar-scanner   -Dsonar.projectKey=prisma-sql   -Dsonar.sources=./src   -Dsonar.host.url=http://localhost:9000   -Dsonar.login=sqp_9fe07460d0aa83f711d0edf4f317f05019d0613b",
         sonar: "yarn sonar-cli && npx tsx scripts/sonar.ts"
       },
+      workspaces: {
+        packages: [
+          "demo"
+        ],
+        nohoist: [
+          "**/prisma",
+          "**/prisma/**",
+          "**/@prisma/**",
+          "**/prisma-*"
+        ]
+      },
       keywords: [
         "prisma",
         "sql",
@@ -304,7 +315,7 @@ function getArrayType(prismaType, dialect) {
     case "DateTime":
       return "timestamptz[]";
     default:
-      return "text[]";
+      return `"${baseType}"[]`;
   }
 }
 function jsonAgg(content, dialect) {
@@ -1949,7 +1960,7 @@ function buildLogical(operator, value, ctx, builder) {
 }
 function buildScalarField(fieldName, value, ctx) {
   const field = assertFieldExists(fieldName, ctx.model, ctx.path);
-  const expr = col(ctx.alias, fieldName);
+  const expr = col(ctx.alias, fieldName, ctx.model);
   if (value === null) {
     return freezeResult(`${expr} ${SQL_TEMPLATES.IS_NULL}`, EMPTY_JOINS);
   }
@@ -3437,8 +3448,8 @@ function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
   const replacement = `${outerAlias}.`;
   return orderBy.split(needle).join(replacement);
 }
-function buildDistinctColumns(distinct, fromAlias) {
-  return distinct.map((f) => col(fromAlias, f)).join(SQL_SEPARATORS.FIELD_LIST);
+function buildDistinctColumns(distinct, fromAlias, model) {
+  return distinct.map((f) => col(fromAlias, f, model)).join(SQL_SEPARATORS.FIELD_LIST);
 }
 function buildOutputColumns(scalarNames, includeNames, hasCount) {
   const outputCols = [...scalarNames, ...includeNames];
@@ -3452,13 +3463,13 @@ function buildOutputColumns(scalarNames, includeNames, hasCount) {
   return formatted;
 }
 function buildWindowOrder(args) {
-  const { baseOrder, idField, fromAlias } = args;
+  const { baseOrder, idField, fromAlias, model } = args;
   const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase());
   const hasIdInOrder = orderFields.some(
     (f) => f.startsWith(`${fromAlias}.id `) || f.startsWith(`${fromAlias}."id" `)
   );
   if (hasIdInOrder) return baseOrder;
-  const idTiebreaker = idField ? `, ${col(fromAlias, "id")} ASC` : "";
+  const idTiebreaker = idField ? `, ${col(fromAlias, "id", model)} ASC` : "";
   return `${baseOrder}${idTiebreaker}`;
 }
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
@@ -3475,14 +3486,17 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     includeNames,
     hasCount
   );
-  const distinctCols = buildDistinctColumns([...distinct], from.alias);
-  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
-  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
+  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f, model)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
+  const idField = model.fields.find(
+    (f) => f.name === "id" && !f.isRelation
+  );
   const baseOrder = isNonEmptyString(orderBy) ? orderBy : fallbackOrder;
   const windowOrder = buildWindowOrder({
     baseOrder,
     idField,
-    fromAlias: from.alias
+    fromAlias: from.alias,
+    model
   });
   const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, `"__tp_distinct"`) : replaceOrderByAlias(fallbackOrder, from.alias, `"__tp_distinct"`);
   const joins = buildJoinsSql(whereJoins, countJoins);
@@ -3593,9 +3607,9 @@ function withCountJoins(spec, countJoins, whereJoins) {
     whereJoins: [...whereJoins || [], ...countJoins || []]
   });
 }
-function buildPostgresDistinctOnClause(fromAlias, distinct) {
+function buildPostgresDistinctOnClause(fromAlias, distinct, model) {
   if (!isNonEmptyArray(distinct)) return null;
-  const distinctCols = buildDistinctColumns([...distinct], fromAlias);
+  const distinctCols = buildDistinctColumns([...distinct], fromAlias, model);
   return `${SQL_TEMPLATES.DISTINCT_ON} (${distinctCols})`;
 }
 function pushJoinGroups(parts, ...groups) {
@@ -3625,7 +3639,8 @@ function constructFinalSql(spec) {
     method,
     cursorClause,
     params,
-    dialect
+    dialect,
+    model
   } = spec;
   const useWindowDistinct = hasWindowDistinct(spec);
   assertDistinctAllowed(method, useWindowDistinct);
@@ -3639,7 +3654,7 @@ function constructFinalSql(spec) {
     return finalizeSql(sql2, params);
   }
   const parts = [SQL_TEMPLATES.SELECT];
-  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct) : null;
+  const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct, model) : null;
   if (distinctOn) parts.push(distinctOn);
   const baseSelect = (select != null ? select : "").trim();
   const fullSelectList = buildSelectList(baseSelect, includeCols);
@@ -3899,17 +3914,17 @@ function getModelFieldMap(model) {
 function isTruthySelection(v) {
   return v === true;
 }
-function aggExprForField(aggKey, field, alias) {
+function aggExprForField(aggKey, field, alias, model) {
   if (aggKey === "_count") {
-    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field)})`;
+    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field, model)})`;
   }
   if (field === "_all") {
     throw new Error(`'${aggKey}' does not support '_all'`);
   }
-  if (aggKey === "_sum") return `SUM(${col(alias, field)})`;
-  if (aggKey === "_avg") return `AVG(${col(alias, field)})`;
-  if (aggKey === "_min") return `MIN(${col(alias, field)})`;
-  return `MAX(${col(alias, field)})`;
+  if (aggKey === "_sum") return `SUM(${col(alias, field, model)})`;
+  if (aggKey === "_avg") return `AVG(${col(alias, field, model)})`;
+  if (aggKey === "_min") return `MIN(${col(alias, field, model)})`;
+  return `MAX(${col(alias, field, model)})`;
 }
 function buildComparisonOp(op) {
   const sqlOp = COMPARISON_OPS[op];
@@ -4090,7 +4105,7 @@ function buildHavingForAggregateFirstShape(aggKey, target, alias, params, dialec
   for (const [field, filter] of Object.entries(target)) {
     assertHavingAggTarget(aggKey, field, model);
     if (!isPlainObject(filter) || Object.keys(filter).length === 0) continue;
-    const expr = aggExprForField(aggKey, field, alias);
+    const expr = aggExprForField(aggKey, field, alias, model);
     out.push(...buildHavingOpsForExpr(expr, filter, params, dialect));
   }
   return out;
@@ -4107,7 +4122,7 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
     assertAggregateFieldType(aggKey, field.type, field.name, model.name);
     const entries = Object.entries(aggFilter);
     if (entries.length === 0) continue;
-    const expr = aggExprForField(aggKey, fieldName, alias);
+    const expr = aggExprForField(aggKey, fieldName, alias, model);
     for (const [op, val] of entries) {
       if (op === "mode") continue;
       const built = buildSimpleComparison(expr, op, val, params, dialect);
@@ -4146,10 +4161,10 @@ function assertCountableScalarField(fieldMap, model, fieldName) {
     );
   }
 }
-function pushCountField(fields, alias, fieldName) {
+function pushCountField(fields, alias, fieldName, model) {
   const outAlias = `_count.${fieldName}`;
   fields.push(
-    `COUNT(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `COUNT(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addCountFields(fields, countArg, alias, model, fieldMap) {
@@ -4167,7 +4182,7 @@ function addCountFields(fields, countArg, alias, model, fieldMap) {
   );
   for (const [f] of selected) {
     assertCountableScalarField(fieldMap, model, f);
-    pushCountField(fields, alias, f);
+    pushCountField(fields, alias, f, model);
   }
 }
 function getAggregateSelectionObject(args, agg) {
@@ -4188,10 +4203,10 @@ function assertAggregatableScalarField(fieldMap, model, agg, fieldName) {
   }
   return field;
 }
-function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName) {
+function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
   const outAlias = `${agg}.${fieldName}`;
   fields.push(
-    `${aggFn}(${col(alias, fieldName)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    `${aggFn}(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
   );
 }
 function addAggregateFields(fields, args, alias, model, fieldMap) {
@@ -4209,7 +4224,7 @@ function addAggregateFields(fields, args, alias, model, fieldMap) {
         fieldName
       );
       assertAggregateFieldType(agg, field.type, fieldName, model.name);
-      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName);
+      pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model);
     }
   }
 }
@@ -4272,7 +4287,7 @@ function assertGroupByBy(args, model) {
   return byFields;
 }
 function buildGroupBySelectParts(args, alias, model, byFields) {
-  const groupCols = byFields.map((f) => col(alias, f));
+  const groupCols = byFields.map((f) => col(alias, f, model));
   const groupFields = groupCols.join(SQL_SEPARATORS.FIELD_LIST);
   const aggFields = buildAggregateFields(args, alias, model);
   const selectFields = isNonEmptyArray(aggFields) ? groupCols.concat(aggFields).join(SQL_SEPARATORS.FIELD_LIST) : groupCols.join(SQL_SEPARATORS.FIELD_LIST);
@@ -4565,6 +4580,29 @@ function generateSQL2(directive) {
 }
 
 // src/code-emitter.ts
+function extractEnumMappings(datamodel) {
+  const mappings = {};
+  const fieldTypes = {};
+  for (const enumDef of datamodel.enums) {
+    const enumMapping = {};
+    for (const value of enumDef.values) {
+      enumMapping[value.name] = value.dbName || value.name;
+    }
+    if (Object.keys(enumMapping).length > 0) {
+      mappings[enumDef.name] = enumMapping;
+    }
+  }
+  for (const model of datamodel.models) {
+    fieldTypes[model.name] = {};
+    for (const field of model.fields) {
+      const baseType = field.type.replace(/\[\]|\?/g, "");
+      if (mappings[baseType]) {
+        fieldTypes[model.name][field.name] = baseType;
+      }
+    }
+  }
+  return { mappings, fieldTypes };
+}
 function generateClient(options) {
   return __async(this, null, function* () {
     const { datamodel, outputDir, config } = options;
@@ -4606,7 +4644,7 @@ function generateClient(options) {
     }
     const absoluteOutputDir = path.resolve(process.cwd(), outputDir);
     yield promises.mkdir(absoluteOutputDir, { recursive: true });
-    const code = generateCode(models, queries, config.dialect);
+    const code = generateCode(models, queries, config.dialect, datamodel);
     const outputPath = path.join(absoluteOutputDir, "index.ts");
     yield promises.writeFile(outputPath, code);
     const totalQueries = Array.from(queries.values()).reduce(
@@ -4634,15 +4672,20 @@ function createQueryKey(processedQuery) {
     return value;
   });
 }
-function generateCode(models, queries, dialect) {
+function generateCode(models, queries, dialect, datamodel) {
   const cleanModels = models.map((model) => __spreadProps(__spreadValues({}, model), {
     fields: model.fields.filter((f) => f !== void 0 && f !== null)
   }));
+  const { mappings, fieldTypes } = extractEnumMappings(datamodel);
   return `// Generated by @prisma-sql/generator - DO NOT EDIT
 import { buildSQL, transformQueryResults, type PrismaMethod, type Model } from 'prisma-sql'
 
 export const MODELS: Model[] = ${JSON.stringify(cleanModels, null, 2)}
 
+const ENUM_MAPPINGS: Record<string, Record<string, string>> = ${JSON.stringify(mappings, null, 2)}
+
+const ENUM_FIELDS: Record<string, Record<string, string>> = ${JSON.stringify(fieldTypes, null, 2)}
+
 const QUERIES: Record<string, Record<string, Record<string, {
   sql: string
   params: unknown[]
@@ -4656,6 +4699,79 @@ function isDynamicParam(key: string): boolean {
   return key === 'skip' || key === 'take' || key === 'cursor'
 }
 
+function transformEnumInValue(value: unknown, enumType: string | undefined): unknown {
+  if (!enumType || value === null || value === undefined) {
+    return value
+  }
+
+  const mapping = ENUM_MAPPINGS[enumType]
+  if (!mapping) {
+    return value
+  }
+
+  // Handle array of enum values
+  if (Array.isArray(value)) {
+    return value.map(v => {
+      if (typeof v === 'string' && mapping[v] !== undefined) {
+        return mapping[v]
+      }
+      return v
+    })
+  }
+
+  // Handle single enum value
+  if (typeof value === 'string' && mapping[value] !== undefined) {
+    return mapping[value]
+  }
+
+  return value
+}
+
+function transformEnumValues(modelName: string, obj: any, currentPath: string[] = []): any {
+  if (obj === null || obj === undefined) {
+    return obj
+  }
+  
+  if (Array.isArray(obj)) {
+    return obj.map(item => transformEnumValues(modelName, item, currentPath))
+  }
+  
+  if (typeof obj === 'object') {
+    const transformed: any = {}
+    const modelFields = ENUM_FIELDS[modelName] || {}
+    
+    for (const [key, value] of Object.entries(obj)) {
+      const newPath = [...currentPath, key]
+      
+      // Check if current key is an enum field at root level
+      const enumType = modelFields[key]
+      
+      if (enumType) {
+        // This is an enum field - check if value is direct or has operators
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          // Has operators like { equals: "ACTIVE" }, { in: ["ACTIVE"] }, etc.
+          const transformedOperators: any = {}
+          for (const [op, opValue] of Object.entries(value)) {
+            transformedOperators[op] = transformEnumInValue(opValue, enumType)
+          }
+          transformed[key] = transformedOperators
+        } else {
+          // Direct value like { status: "ACTIVE" }
+          transformed[key] = transformEnumInValue(value, enumType)
+        }
+      } else if (typeof value === 'object' && value !== null) {
+        // Recursively transform nested objects (relations, logical operators, etc)
+        transformed[key] = transformEnumValues(modelName, value, newPath)
+      } else {
+        transformed[key] = value
+      }
+    }
+    return transformed
+  }
+  
+  return obj
+}
+
 function normalizeQuery(args: any): string {
   if (!args) return '{}'
   
@@ -4771,7 +4887,10 @@ export function speedExtension(config: {
       const modelName = this?.name || this?.$name
       const startTime = Date.now()
 
-      const queryKey = normalizeQuery(args)
+      // Transform enum values before processing
+      const transformedArgs = transformEnumValues(modelName, args || {})
+
+      const queryKey = normalizeQuery(transformedArgs)
       const prebakedQuery = QUERIES[modelName]?.[method]?.[queryKey]
 
       let sql: string
@@ -4780,7 +4899,7 @@ export function speedExtension(config: {
 
       if (prebakedQuery) {
         sql = prebakedQuery.sql
-        params = [...prebakedQuery.params, ...extractDynamicParams(args, prebakedQuery.dynamicKeys)]
+        params = [...prebakedQuery.params, ...extractDynamicParams(transformedArgs, prebakedQuery.dynamicKeys)]
         prebaked = true
       } else {
         const model = MODELS.find((m) => m.name === modelName)
@@ -4789,7 +4908,7 @@ export function speedExtension(config: {
           return this.$parent[modelName][method](args)
         }
 
-        const result = buildSQL(model, MODELS, method, args || {}, DIALECT)
+        const result = buildSQL(model, MODELS, method, transformedArgs, DIALECT)
         sql = result.sql
         params = result.params
       }