feat(orm): support nested enum in where and/or

Author: DoctorFTB

packages/orm/src/client/executor/name-mapper.ts

@@ -25,7 +25,6 @@ import {
     ValueListNode,
     ValueNode,
     ValuesNode,
-    WhereNode,
 } from 'kysely';
 import type { EnumDef, EnumField, FieldDef, ModelDef, SchemaDef } from '../../schema';
 import {
@@ -185,40 +184,42 @@ export class QueryNameMapper extends OperationNodeTransformer {
         return ColumnNode.create(mappedName);
     }
 
-    protected override transformWhere(node: WhereNode): WhereNode {
+    protected override transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode {
         if (
-            BinaryOperationNode.is(node.where) &&
-            ReferenceNode.is(node.where.leftOperand) &&
-            ColumnNode.is(node.where.leftOperand.column) &&
-            node.where.leftOperand.table &&
-            TableNode.is(node.where.leftOperand.table) &&
-            // where: { enumColumn: Enum.VALUE }
-            (ValueNode.is(node.where.rightOperand) ||
-                // where: { enumColumn: { in: [Enum.VALUE] } }
-                PrimitiveValueListNode.is(node.where.rightOperand))
+            ReferenceNode.is(node.leftOperand) &&
+            ColumnNode.is(node.leftOperand.column) &&
+            node.leftOperand.table &&
+            TableNode.is(node.leftOperand.table) &&
+            //  { enumColumn: Enum.VALUE }
+            (ValueNode.is(node.rightOperand) ||
+                //  { enumColumn: { in: [Enum.VALUE] } }
+                PrimitiveValueListNode.is(node.rightOperand))
         ) {
-            const tableName = node.where.leftOperand.table.table.identifier.name;
-            const columnNode = node.where.leftOperand.column;
-            const valueNode = node.where.rightOperand;
+            const tableName = node.leftOperand.table.table.identifier.name;
+            const columnNode = node.leftOperand.column;
+            const valueNode = node.rightOperand;
 
             let resultValue: OperationNode = valueNode;
 
             if (ValueNode.is(valueNode)) {
                 resultValue = this.processEnumMappingForValue(tableName, columnNode, valueNode) as OperationNode;
             } else if (PrimitiveValueListNode.is(valueNode)) {
                 resultValue = PrimitiveValueListNode.create(
-                    this.processEnumMappingForValues(tableName, valueNode.values.map(() => columnNode), valueNode.values),
+                    this.processEnumMappingForValues(
+                        tableName,
+                        valueNode.values.map(() => columnNode),
+                        valueNode.values,
+                    ),
                 );
             }
 
-            return super.transformWhere(
-                WhereNode.create(
-                    BinaryOperationNode.create(node.where.leftOperand, node.where.operator, resultValue)
-                )
-            );
+            return super.transformBinaryOperation({
+                ...node,
+                rightOperand: resultValue,
+            });
         }
 
-        return super.transformWhere(node);
+        return super.transformBinaryOperation(node);
     }
 
     protected override transformUpdateQuery(node: UpdateQueryNode) {

tests/e2e/orm/client-api/name-mapping.test.ts

@@ -211,6 +211,22 @@ describe('Name mapping tests', () => {
             }),
         ).resolves.toEqual([expect.objectContaining({ email: 'u1@test.com', role: 'USER' })]);
 
+        await expect(
+            db.user.findMany({
+                where: {
+                    AND: [
+                        { role: { in: ['USER'] } },
+                        { role: { in: ['USER'] } },
+                        { OR: [{ role: { in: ['USER'] } }] },
+                    ],
+                },
+                select: {
+                    email: true,
+                    role: true,
+                },
+            }),
+        ).resolves.toEqual([expect.objectContaining({ email: 'u1@test.com', role: 'USER' })]);
+
         // select all
         await expect(
             db.user.findFirst({