@rebasepro/server-postgresql 0.5.0 → 0.6.0

package/test/drizzle-conditions.test.ts

@@ -1,9 +1,10 @@
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
 import { eq } from "drizzle-orm";
-import { integer, pgTable, primaryKey, serial, varchar } from "drizzle-orm/pg-core";
+import { integer, pgTable, primaryKey, serial, varchar, text } from "drizzle-orm/pg-core";
 import { EntityCollection, Relation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "../src/utils/drizzle-conditions";
+import { getColumnMeta } from "../src/services/entity-helpers";
 
 // Mock tables for testing
 const mockAuthorsTable = pgTable("authors", {
@@ -900,37 +901,89 @@ describe("DrizzleConditionBuilder - Filter Operators", () => {
         id: serial("id").primaryKey(),
         name: varchar("name").notNull(),
         email: varchar("email").notNull(),
-        age: integer("age")
+        age: integer("age"),
+        tags: text("tags").array()
     });
 
     describe("buildSingleFilterCondition - array-contains", () => {
-        it("should generate a non-null condition for a single value", () => {
+        const { PgDialect } = require("drizzle-orm/pg-core");
+        const pgDialect = new PgDialect();
+
+        it("should generate a native array condition for native array columns", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.tags,
+                "array-contains",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."tags" @> ARRAY[$1]');
+            expect(query.params).toEqual(["featured"]);
+        });
+
+        it("should generate a JSONB condition for non-native array columns", () => {
             const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
                 mockUsersTable.name,
                 "array-contains",
                 "featured"
             );
             expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."name" @> $1');
+            expect(query.params).toEqual(['["featured"]']);
         });
     });
 
     describe("buildSingleFilterCondition - array-contains-any", () => {
-        it("should generate a non-null condition for an array of values", () => {
+        const { PgDialect } = require("drizzle-orm/pg-core");
+        const pgDialect = new PgDialect();
+
+        it("should generate a native array overlap condition for native array columns", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.tags,
+                "array-contains-any",
+                ["featured", "popular", "trending"]
+            );
+            expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."tags" && ARRAY[$1, $2, $3]');
+            expect(query.params).toEqual(["featured", "popular", "trending"]);
+        });
+
+        it("should generate a JSONB overlap (?|) condition for non-native array columns", () => {
             const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
                 mockUsersTable.name,
                 "array-contains-any",
                 ["featured", "popular", "trending"]
             );
             expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."name" ?| array[$1, $2, $3]');
+            expect(query.params).toEqual(["featured", "popular", "trending"]);
+        });
+
+        it("should fallback to native array-contains for native array columns with single value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.tags,
+                "array-contains-any",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."tags" @> ARRAY[$1]');
+            expect(query.params).toEqual(["featured"]);
         });
 
-        it("should fallback to array-contains for a single (non-array) value", () => {
+        it("should fallback to JSONB array-contains for non-native array columns with single value", () => {
             const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
                 mockUsersTable.name,
                 "array-contains-any",
                 "featured"
             );
             expect(condition).not.toBeNull();
+            const query = pgDialect.sqlToQuery(condition!);
+            expect(query.sql).toBe('"users"."name" @> $1');
+            expect(query.params).toEqual(['["featured"]']);
         });
     });
 
@@ -1017,7 +1070,7 @@ describe("DrizzleConditionBuilder - Filter Operators", () => {
                 42
             );
             expect(condition).toBeNull();
-            expect(warnSpy).toHaveBeenCalledWith("Unsupported filter operation: unknown-op");
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Unsupported filter operation: unknown-op"));
             warnSpy.mockRestore();
         });
     });

package/test/generate-drizzle-schema.test.ts

@@ -471,7 +471,7 @@ roles: ["admin"] }
             }];
 
             const result = await generateSchema(collections);
-            expect(result).toContain("string_to_array(auth.roles(), ',') @> ARRAY['admin']");
+            expect(result).toContain("string_to_array(auth.roles(), ',') && ARRAY['admin']");
         });
 
         it("should safely handle complex sub-string roles overlapping like 'view' and 'viewer'", async () => {
@@ -489,7 +489,7 @@ roles: ["view"] } // Should not match 'viewer'
             const result = await generateSchema(collections);
             // Before array change: auth.roles() ~ 'view' would match 'viewer'
             // Now: array intersection prevents this
-            expect(result).toContain("string_to_array(auth.roles(), ',') @> ARRAY['view']");
+            expect(result).toContain("string_to_array(auth.roles(), ',') && ARRAY['view']");
         });
 
         it("should securely handle multiple allowed roles", async () => {
@@ -505,7 +505,7 @@ roles: ["admin", "editor", "super-admin"] }
             }];
 
             const result = await generateSchema(collections);
-            expect(result).toContain("string_to_array(auth.roles(), ',') @> ARRAY['admin','editor','super-admin']");
+            expect(result).toContain("string_to_array(auth.roles(), ',') && ARRAY['admin','editor','super-admin']");
         });
 
         it("should combine roles with access: public", async () => {
@@ -523,7 +523,7 @@ access: "public" }
 
             const result = await generateSchema(collections);
             // Should be (true) AND (role check)
-            expect(result).toContain("(true) AND (string_to_array(auth.roles(), ',') @> ARRAY['admin','manager'])");
+            expect(result).toContain("(true) AND (string_to_array(auth.roles(), ',') && ARRAY['admin','manager'])");
         });
 
         it("should combine roles with ownerField", async () => {
@@ -545,7 +545,7 @@ ownerField: "user_id" }
             const result = await generateSchema(collections);
             // Should combine owner check AND role check
             expect(result).toContain("auth.uid()");
-            expect(result).toContain("string_to_array(auth.roles(), ',') @> ARRAY['editor']");
+            expect(result).toContain("string_to_array(auth.roles(), ',') && ARRAY['editor']");
             expect(result).toContain("AND");
         });
 
@@ -690,7 +690,8 @@ using: "{is_locked} = false" }
                 name: "Secure Data",
                 properties: { title: { type: "string" } },
                 securityRules: [
-                    { operation: "select", access: "public" }
+                    { operation: "select",
+access: "public" }
                 ]
             }];
 
@@ -731,7 +732,7 @@ roles: ["admin"] }
             ]
         }];
         const result = await generateSchema(collections);
-        expect(result).toContain("string_to_array(auth.roles(), ',') @> ARRAY['admin']");
+        expect(result).toContain("string_to_array(auth.roles(), ',') && ARRAY['admin']");
     });
     it("should generate multiple policies from operations array", async () => {
         const collections: EntityCollection[] = [{
@@ -845,7 +846,7 @@ using: "true" }
         }];
         const result = await generateSchema(collections);
         // Should be (true) AND (role check) — same effect as access: "public" + roles
-        expect(result).toContain("(true) AND (string_to_array(auth.roles(), ',') @> ARRAY['admin'])");
+        expect(result).toContain("(true) AND (string_to_array(auth.roles(), ',') && ARRAY['admin'])");
     });
     it("should use pgRoles instead of default 'public' when specified", async () => {
         const collections: EntityCollection[] = [{
@@ -956,7 +957,7 @@ roles: ["admin", "user"] }
         expect(matchUnsorted![1]).toEqual(matchSorted![1]);
 
         // The actual generated sql bodies should also be identical due to sorting
-        expect(resultUnsorted).toContain("string_to_array(auth.roles(), ',') @> ARRAY['admin','manager','user']");
+        expect(resultUnsorted).toContain("string_to_array(auth.roles(), ',') && ARRAY['admin','manager','user']");
         expect(resultUnsorted).toContain('to: ["app_role", "service_role"]');
     });
 });
@@ -1056,14 +1057,14 @@ describe("generateDrizzleSchema columnName support", () => {
                 employee_number_140a: {
                     type: "string",
                     name: "Employee Number 140a",
-                    columnName: "employee_number_140a",
+                    columnName: "employee_number_140a"
                 },
                 contract_number_140a: {
                     type: "string",
                     name: "Contract Number 140a",
-                    columnName: "contract_number_140a",
-                },
-            },
+                    columnName: "contract_number_140a"
+                }
+            }
         }];
 
         const result = await generateSchema(collections);
@@ -1086,10 +1087,10 @@ describe("generateDrizzleSchema columnName support", () => {
             properties: {
                 productName: {
                     type: "string",
-                    name: "Product Name",
+                    name: "Product Name"
                     // No columnName — should derive from key
-                },
-            },
+                }
+            }
         }];
 
         const result = await generateSchema(collections);
@@ -1109,14 +1110,14 @@ describe("generateDrizzleSchema columnName support", () => {
                 fee_number_140a: {
                     type: "string",
                     name: "Fee Number",
-                    columnName: "fee_number_140a",
+                    columnName: "fee_number_140a"
                 },
                 // Manually added: no columnName
                 displayName: {
                     type: "string",
-                    name: "Display Name",
-                },
-            },
+                    name: "Display Name"
+                }
+            }
         }];
 
         const result = await generateSchema(collections);
@@ -1137,24 +1138,24 @@ describe("generateDrizzleSchema columnName support", () => {
                 count_v2: {
                     type: "number",
                     name: "Count V2",
-                    columnName: "count_v2",
+                    columnName: "count_v2"
                 },
                 is_active_v2: {
                     type: "boolean",
                     name: "Is Active V2",
-                    columnName: "is_active_v2",
+                    columnName: "is_active_v2"
                 },
                 created_at_v2: {
                     type: "date",
                     name: "Created At V2",
-                    columnName: "created_at_v2",
+                    columnName: "created_at_v2"
                 },
                 metadata_v2: {
                     type: "map",
                     name: "Metadata V2",
-                    columnName: "metadata_v2",
-                },
-            },
+                    columnName: "metadata_v2"
+                }
+            }
         }];
 
         const result = await generateSchema(collections);
@@ -1173,20 +1174,44 @@ describe("generateDrizzleSchema columnName support", () => {
             table: "company_billing_config",
             name: "Company Billing Config",
             properties: {
-                employee_number_140a: { type: "string", name: "Employee Number", columnName: "employee_number_140a" },
-                contract_number_140a: { type: "string", name: "Contract Number", columnName: "contract_number_140a" },
-                amount: { type: "number", name: "Amount" },
-                id: { type: "number", name: "ID", isId: "increment" },
-                service_provider_140a: { type: "string", name: "Service Provider", columnName: "service_provider_140a" },
-                internal_area_code_140a: { type: "string", name: "Internal Area Code", columnName: "internal_area_code_140a" },
-                fee_number_140a: { type: "string", name: "Fee Number", columnName: "fee_number_140a" },
-                receiver_market_participant_140a: { type: "string", name: "Receiver Market Participant", columnName: "receiver_market_participant_140a" },
-                employee_value_number_140a: { type: "string", name: "Employee Value Number", columnName: "employee_value_number_140a" },
-                sender_market_participant_140a: { type: "string", name: "Sender Market Participant", columnName: "sender_market_participant_140a" },
-                processing_indicator_140a: { type: "string", name: "Processing Indicator", columnName: "processing_indicator_140a" },
-                insurance_id_140a: { type: "string", name: "Insurance ID", columnName: "insurance_id_140a" },
-                company_id: { type: "number", name: "Company ID" },
-            },
+                employee_number_140a: { type: "string",
+name: "Employee Number",
+columnName: "employee_number_140a" },
+                contract_number_140a: { type: "string",
+name: "Contract Number",
+columnName: "contract_number_140a" },
+                amount: { type: "number",
+name: "Amount" },
+                id: { type: "number",
+name: "ID",
+isId: "increment" },
+                service_provider_140a: { type: "string",
+name: "Service Provider",
+columnName: "service_provider_140a" },
+                internal_area_code_140a: { type: "string",
+name: "Internal Area Code",
+columnName: "internal_area_code_140a" },
+                fee_number_140a: { type: "string",
+name: "Fee Number",
+columnName: "fee_number_140a" },
+                receiver_market_participant_140a: { type: "string",
+name: "Receiver Market Participant",
+columnName: "receiver_market_participant_140a" },
+                employee_value_number_140a: { type: "string",
+name: "Employee Value Number",
+columnName: "employee_value_number_140a" },
+                sender_market_participant_140a: { type: "string",
+name: "Sender Market Participant",
+columnName: "sender_market_participant_140a" },
+                processing_indicator_140a: { type: "string",
+name: "Processing Indicator",
+columnName: "processing_indicator_140a" },
+                insurance_id_140a: { type: "string",
+name: "Insurance ID",
+columnName: "insurance_id_140a" },
+                company_id: { type: "number",
+name: "Company ID" }
+            }
         }];
 
         const result = await generateSchema(collections);