fix(orm): properly cast values for array filters for postgres (#662)

* fix(orm): properly cast values for array filters for postgres

fixes #651

* add missing Array conversion

* refactor

Author: ymc9

packages/orm/src/client/crud/dialects/base-dialect.ts

@@ -513,7 +513,7 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
                 }
 
                 case 'has': {
-                    clauses.push(this.buildArrayContains(receiver, this.eb.val(value)));
+                    clauses.push(this.buildArrayContains(receiver, this.eb.val(value), fieldType));
                     break;
                 }
 
@@ -1442,7 +1442,11 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
     /**
      * Builds an expression that checks if an array contains a single value.
      */
-    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>): AliasableExpression<SqlBool>;
+    abstract buildArrayContains(
+        field: Expression<unknown>,
+        value: Expression<unknown>,
+        elemType?: string,
+    ): AliasableExpression<SqlBool>;
 
     /**
      * Builds an expression that checks if an array contains all values from another array.

packages/orm/src/client/crud/dialects/mysql.ts

@@ -231,6 +231,7 @@ export class MySqlCrudDialect<Schema extends SchemaDef> extends LateralJoinDiale
     override buildArrayContains(
         _field: Expression<unknown>,
         _value: Expression<unknown>,
+        _elemType?: string,
     ): AliasableExpression<SqlBool> {
         throw createNotSupportedError('MySQL does not support native array operations');
     }

packages/orm/src/client/crud/dialects/postgresql.ts

@@ -284,9 +284,20 @@ export class PostgresCrudDialect<Schema extends SchemaDef> extends LateralJoinDi
         return this.eb.cast(arr, sql`${sql.raw(mappedType)}[]`);
     }
 
-    override buildArrayContains(field: Expression<unknown>, value: Expression<unknown>): AliasableExpression<SqlBool> {
-        // PostgreSQL @> operator expects array on both sides, so wrap single value in array
-        return this.eb(field, '@>', sql`ARRAY[${value}]`);
+    override buildArrayContains(
+        field: Expression<unknown>,
+        value: Expression<unknown>,
+        elemType?: string,
+    ): AliasableExpression<SqlBool> {
+        // PostgreSQL @> operator expects array on both sides, so wrap single value in a typed array
+        const arrayExpr = sql`ARRAY[${value}]`;
+        if (elemType) {
+            const mappedType = this.getSqlType(elemType);
+            const typedArray = this.eb.cast(arrayExpr, sql`${sql.raw(mappedType)}[]`);
+            return this.eb(field, '@>', typedArray);
+        } else {
+            return this.eb(field, '@>', arrayExpr);
+        }
     }
 
     override buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool> {

packages/orm/src/client/crud/dialects/sqlite.ts

@@ -456,6 +456,7 @@ export class SqliteCrudDialect<Schema extends SchemaDef> extends BaseCrudDialect
     override buildArrayContains(
         _field: Expression<unknown>,
         _value: Expression<unknown>,
+        _elemType?: string,
     ): AliasableExpression<SqlBool> {
         throw createNotSupportedError('SQLite does not support native array operations');
     }

packages/orm/src/client/helpers/schema-db-pusher.ts

@@ -440,6 +440,7 @@ export class SchemaDbPusher<Schema extends SchemaDef> {
 
     private get floatType() {
         return match<string, ColumnDataType | RawBuilder<unknown>>(this.schema.provider.type)
+            .with('postgresql', () => 'double precision')
             .with('mysql', () => sql.raw('double'))
             .otherwise(() => 'real');
     }

tests/regression/test/issue-651.test.ts

@@ -0,0 +1,105 @@
+import { createTestClient } from '@zenstackhq/testtools';
+import { describe, expect, it } from 'vitest';
+
+describe('Regression for issue 651', () => {
+    it('float array queries should work with all operators on PostgreSQL', async () => {
+        const db = await createTestClient(
+            `
+model User {
+    id Int @id @default(autoincrement())
+    email String @unique
+    floatArray Float[]
+}
+            `,
+            { provider: 'postgresql', usePrismaPush: true },
+        );
+
+        // Create test users with different float arrays
+        const user1 = await db.user.create({
+            data: {
+                email: 'user1@example.com',
+                floatArray: [1.1, 2.2, 3.3],
+            },
+        });
+
+        const user2 = await db.user.create({
+            data: {
+                email: 'user2@example.com',
+                floatArray: [1.1, 2.2, 3.3, 4.4, 5.5],
+            },
+        });
+
+        const user3 = await db.user.create({
+            data: {
+                email: 'user3@example.com',
+                floatArray: [],
+            },
+        });
+
+        // Test 'equals' operator
+        const equalsResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    equals: [1.1, 2.2, 3.3],
+                },
+            },
+        });
+        expect(equalsResult).toHaveLength(1);
+        expect(equalsResult[0].id).toBe(user1.id);
+
+        // Test 'has' operator - contains single value
+        const hasResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    has: 4.4,
+                },
+            },
+        });
+        expect(hasResult).toHaveLength(1);
+        expect(hasResult[0].id).toBe(user2.id);
+
+        // Test 'hasSome' operator - contains any of the values
+        const hasSomeResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    hasSome: [3.3, 6.6, 7.7],
+                },
+            },
+        });
+        expect(hasSomeResult).toHaveLength(2);
+        expect(hasSomeResult.map((u: any) => u.id).sort()).toEqual([user1.id, user2.id].sort());
+
+        // Test 'hasEvery' operator - contains all values
+        const hasEveryResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    hasEvery: [1.1, 2.2],
+                },
+            },
+        });
+        expect(hasEveryResult).toHaveLength(2);
+        expect(hasEveryResult.map((u: any) => u.id).sort()).toEqual([user1.id, user2.id].sort());
+
+        // Test 'isEmpty' operator
+        const isEmptyResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    isEmpty: true,
+                },
+            },
+        });
+        expect(isEmptyResult).toHaveLength(1);
+        expect(isEmptyResult[0].id).toBe(user3.id);
+
+        // Test 'isEmpty: false'
+        const notEmptyResult = await db.user.findMany({
+            where: {
+                floatArray: {
+                    isEmpty: false,
+                },
+            },
+        });
+        expect(notEmptyResult).toHaveLength(2);
+        expect(notEmptyResult.map((u: any) => u.id).sort()).toEqual([user1.id, user2.id].sort());
+    });
+});