fix: resolve field's model from scope instead of relying on table qualification

Author: ymc9

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

@@ -184,39 +184,51 @@ export class QueryNameMapper extends OperationNodeTransformer {
         return ColumnNode.create(mappedName);
     }
 
-    protected override transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode {
+    protected override transformBinaryOperation(node: BinaryOperationNode) {
+        // transform enum name mapping for enum values used inside binary operations
+        //   1. simple value: column = EnumValue
+        //   2. list value: column IN [EnumValue, EnumValue2]
+
+        // note: Kysely only allows column ref on the left side of a binary operation
+
         if (
             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))
+            (ValueNode.is(node.rightOperand) || PrimitiveValueListNode.is(node.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,
-                    ),
-                );
-            }
 
-            return super.transformBinaryOperation({
-                ...node,
-                rightOperand: resultValue,
-            });
+            // resolve field from scope in case it's not directly qualified with a table name
+            const resolvedScope = this.resolveFieldFromScopes(
+                columnNode.column.name,
+                node.leftOperand.table?.table.identifier.name,
+            );
+
+            if (resolvedScope?.model) {
+                const valueNode = node.rightOperand;
+                let resultValue: OperationNode = valueNode;
+
+                if (ValueNode.is(valueNode)) {
+                    resultValue = this.processEnumMappingForValue(
+                        resolvedScope.model,
+                        columnNode,
+                        valueNode,
+                    ) as OperationNode;
+                } else if (PrimitiveValueListNode.is(valueNode)) {
+                    resultValue = PrimitiveValueListNode.create(
+                        this.processEnumMappingForValues(
+                            resolvedScope.model,
+                            valueNode.values.map(() => columnNode),
+                            valueNode.values,
+                        ),
+                    );
+                }
+
+                return super.transformBinaryOperation({
+                    ...node,
+                    rightOperand: resultValue,
+                });
+            }
         }
 
         return super.transformBinaryOperation(node);

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

@@ -8,10 +8,10 @@ describe('Name mapping tests', () => {
     let db: ClientContract<SchemaType>;
 
     beforeEach(async () => {
-        db = (await createTestClient(schema, {
+        db = await createTestClient(schema, {
             usePrismaPush: true,
             schemaFile: path.join(__dirname, '../schemas/name-mapping/schema.zmodel'),
-        })) as any;
+        });
     });
 
     afterEach(async () => {
@@ -214,11 +214,7 @@ describe('Name mapping tests', () => {
         await expect(
             db.user.findMany({
                 where: {
-                    AND: [
-                        { role: { in: ['USER'] } },
-                        { role: { in: ['USER'] } },
-                        { OR: [{ role: { in: ['USER'] } }] },
-                    ],
+                    AND: [{ role: { in: ['USER'] } }, { role: { in: ['USER'] } }, { OR: [{ role: { in: ['USER'] } }] }],
                 },
                 select: {
                     email: true,
@@ -266,6 +262,38 @@ describe('Name mapping tests', () => {
             role: 'USER',
         });
 
+        // name mapping for enum value in where clause, with unqualified column name
+        await expect(
+            db.$qb.selectFrom('User').select(['User.email', 'User.role']).where('role', '=', 'USER').executeTakeFirst(),
+        ).resolves.toMatchObject({
+            email: 'u1@test.com',
+            role: 'USER',
+        });
+
+        // name mapping for enum value in simple where clause, with qualified column name
+        await expect(
+            db.$qb
+                .selectFrom('User as u')
+                .select(['u.email', 'u.role'])
+                .where('u.role', '=', 'USER')
+                .executeTakeFirst(),
+        ).resolves.toMatchObject({
+            email: 'u1@test.com',
+            role: 'USER',
+        });
+
+        // enum value in list
+        await expect(
+            db.$qb
+                .selectFrom('User')
+                .select(['User.email', 'User.role'])
+                .where('role', 'in', ['USER', 'ADMIN'])
+                .executeTakeFirst(),
+        ).resolves.toMatchObject({
+            email: 'u1@test.com',
+            role: 'USER',
+        });
+
         await expect(
             db.$qb
                 .selectFrom('User')