@rebasepro/server-postgresql 0.2.3 → 0.2.5

package/test/auth-services.test.ts

@@ -1,5 +1,5 @@
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { UserService, RoleService, RefreshTokenService, PasswordResetTokenService, Role } from "../src/auth/services";
+import { UserService, RefreshTokenService, PasswordResetTokenService, Role } from "../src/auth/services";
 import { users, refreshTokens, passwordResetTokens } from "../src/schema/auth-schema";
 import { UserData } from "@rebasepro/server-core";
 
@@ -37,6 +37,7 @@ function mockUserData(overrides: Partial<UserData>): UserData {
         createdAt: expect.any(Date),
         updatedAt: expect.any(Date),
         metadata: {},
+        isAnonymous: false,
         ...overrides
     };
 }
@@ -343,20 +344,7 @@ describe("Auth Services", () => {
         describe("getUserRoles", () => {
             it("should return roles for user", async () => {
                 mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-                            name: "Admin",
-                            is_admin: true,
-                            default_permissions: null,
-                            collection_permissions: null,
-                            config: null },
-                        { id: "editor",
-                            name: "Editor",
-                            is_admin: false,
-                            default_permissions: { edit: true },
-                            collection_permissions: null,
-                            config: null }
-                    ]
+                    rows: [{ roles: ["admin", "editor"] }]
                 });
 
                 const roles = await userService.getUserRoles("user-123");
@@ -364,11 +352,10 @@ describe("Auth Services", () => {
                 expect(roles).toHaveLength(2);
                 expect(roles[0]).toEqual({
                     id: "admin",
-                    name: "Admin",
+                    name: "admin",
                     isAdmin: true,
                     defaultPermissions: null,
-                    collectionPermissions: null,
-                    config: null
+                    collectionPermissions: null
                 });
             });
         });
@@ -376,14 +363,7 @@ describe("Auth Services", () => {
         describe("getUserRoleIds", () => {
             it("should return role IDs for user", async () => {
                 mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-                            name: "Admin",
-                            is_admin: true,
-                            default_permissions: null,
-                            collection_permissions: null,
-                            config: null }
-                    ]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const roleIds = await userService.getUserRoleIds("user-123");
@@ -396,10 +376,7 @@ describe("Auth Services", () => {
             it("should delete existing and insert new roles", async () => {
                 await userService.setUserRoles("user-123", ["admin", "editor"]);
 
-                // First call deletes existing roles
                 expect(mockExecute).toHaveBeenCalled();
-                // Subsequent calls insert new roles
-                expect(mockExecute.mock.calls.length).toBeGreaterThanOrEqual(1);
             });
         });
 
@@ -411,7 +388,7 @@ describe("Auth Services", () => {
             });
 
             it("should use editor as default role", async () => {
-                await userService.assignDefaultRole("user-123");
+                await userService.assignDefaultRole("user-123", "editor");
 
                 expect(mockExecute).toHaveBeenCalled();
             });
@@ -422,12 +399,7 @@ describe("Auth Services", () => {
                 const mockUser = { id: "user-123", email: "test@example.com" };
                 mockSelectWhere.mockResolvedValueOnce([mockUser]);
                 mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "admin",
-                        name: "Admin",
-                        is_admin: true,
-                        default_permissions: null,
-                        collection_permissions: null,
-                        config: null }]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const result = await userService.getUserWithRoles("user-123");
@@ -435,11 +407,10 @@ describe("Auth Services", () => {
                 expect(result).toEqual({
                     user: mockUserData({}),
                     roles: [{ id: "admin",
-                        name: "Admin",
+                        name: "admin",
                         isAdmin: true,
                         defaultPermissions: null,
-                        collectionPermissions: null,
-                        config: null }]
+                        collectionPermissions: null }]
                 });
             });
 
@@ -477,133 +448,6 @@ describe("Auth Services", () => {
         });
     });
 
-    describe("RoleService", () => {
-        let roleService: RoleService;
-
-        beforeEach(() => {
-            roleService = new RoleService(db);
-        });
-
-        describe("getRoleById", () => {
-            it("should return role when found", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null,
-config: null }]
-                });
-
-                const result = await roleService.getRoleById("admin");
-
-                expect(result).toEqual({
-                    id: "admin",
-                    name: "Admin",
-                    isAdmin: true,
-                    defaultPermissions: null,
-                    collectionPermissions: null,
-                    config: null
-                });
-            });
-
-            it("should return null when role not found", async () => {
-                mockExecute.mockResolvedValueOnce({ rows: [] });
-
-                const result = await roleService.getRoleById("nonexistent");
-
-                expect(result).toBeNull();
-            });
-        });
-
-        describe("listRoles", () => {
-            it("should return all roles", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [
-                        { id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null,
-config: null },
-                        { id: "editor",
-name: "Editor",
-is_admin: false,
-default_permissions: null,
-collection_permissions: null,
-config: null }
-                    ]
-                });
-
-                const roles = await roleService.listRoles();
-
-                expect(roles).toHaveLength(2);
-            });
-        });
-
-        describe("createRole", () => {
-            it("should create a role", async () => {
-                mockExecute.mockResolvedValueOnce({
-                    rows: [{ id: "custom",
-name: "Custom Role",
-is_admin: false,
-default_permissions: null,
-collection_permissions: null,
-config: null }]
-                });
-
-                const role = await roleService.createRole({
-                    id: "custom",
-                    name: "Custom Role",
-                    defaultPermissions: null,
-                    config: null
-                });
-
-                expect(role.id).toBe("custom");
-                expect(role.name).toBe("Custom Role");
-            });
-        });
-
-        describe("updateRole", () => {
-            it("should update a role", async () => {
-                mockExecute
-                    .mockResolvedValueOnce({ rows: [{ id: "admin",
-name: "Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null,
-config: null }] })
-                    .mockResolvedValueOnce({ rows: [] })
-                    .mockResolvedValueOnce({ rows: [{ id: "admin",
-name: "Super Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: null,
-config: null }] });
-
-                const result = await roleService.updateRole("admin", { name: "Super Admin" });
-
-                expect(result?.name).toBe("Super Admin");
-            });
-
-            it("should return null when role not found", async () => {
-                mockExecute.mockResolvedValueOnce({ rows: [] });
-
-                const result = await roleService.updateRole("nonexistent", { name: "Test" });
-
-                expect(result).toBeNull();
-            });
-        });
-
-        describe("deleteRole", () => {
-            it("should delete a role", async () => {
-                await roleService.deleteRole("custom");
-
-                expect(mockExecute).toHaveBeenCalled();
-            });
-        });
-    });
-
     describe("RefreshTokenService", () => {
         let refreshTokenService: RefreshTokenService;
 

package/test/doctor.test.ts

@@ -135,8 +135,12 @@ columnType: "time" } as DateProperty)).toBe("time without time zone");
         it("should map json types correctly", () => {
             expect(getExpectedColumnType({ type: "map" })).toBe("jsonb");
             expect(getExpectedColumnType({ type: "array" })).toBe("jsonb");
-            expect(getExpectedColumnType({ type: "array",
-columnType: "json" } as ArrayProperty)).toBe("json");
+            expect(getExpectedColumnType({ type: "array", columnType: "json" } as ArrayProperty)).toBe("json");
+            
+            // Native array element type mappings
+            expect(getExpectedColumnType({ type: "array", of: { type: "string" } } as ArrayProperty)).toBe("ARRAY");
+            expect(getExpectedColumnType({ type: "array", of: { type: "number", validation: { integer: true } } } as ArrayProperty)).toBe("ARRAY");
+            expect(getExpectedColumnType({ type: "array", of: { type: "boolean" } } as ArrayProperty)).toBe("ARRAY");
         });
 
         it("should map enum string to USER-DEFINED", () => {

package/test/drizzle-conditions.test.ts

@@ -893,3 +893,171 @@ describe("DrizzleConditionBuilder - Many-to-Many Relations", () => {
         });
     });
 });
+
+describe("DrizzleConditionBuilder - Filter Operators", () => {
+    // Mock table for filter tests
+    const mockUsersTable = pgTable("users", {
+        id: serial("id").primaryKey(),
+        name: varchar("name").notNull(),
+        email: varchar("email").notNull(),
+        age: integer("age")
+    });
+
+    describe("buildSingleFilterCondition - array-contains", () => {
+        it("should generate a non-null condition for a single value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - array-contains-any", () => {
+        it("should generate a non-null condition for an array of values", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains-any",
+                ["featured", "popular", "trending"]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should fallback to array-contains for a single (non-array) value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "array-contains-any",
+                "featured"
+            );
+            expect(condition).not.toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - not-in", () => {
+        it("should generate a non-null condition for an array of values", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                [1, 2, 3]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should return null for empty array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                []
+            );
+            expect(condition).toBeNull();
+        });
+
+        it("should return null for non-array value", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "not-in",
+                42
+            );
+            expect(condition).toBeNull();
+        });
+    });
+
+    describe("buildSingleFilterCondition - existing operators", () => {
+        it("should generate a condition for equality", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "==",
+                "alice"
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should generate IS NULL for equality with null", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "==",
+                null
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should generate IS NOT NULL for inequality with null", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.name,
+                "!=",
+                null
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should handle in operator with array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "in",
+                [18, 21, 25]
+            );
+            expect(condition).not.toBeNull();
+        });
+
+        it("should return null for in operator with empty array", () => {
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "in",
+                []
+            );
+            expect(condition).toBeNull();
+        });
+
+        it("should warn and return null for unsupported operators", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+            const condition = DrizzleConditionBuilder.buildSingleFilterCondition(
+                mockUsersTable.age,
+                "unknown-op" as any,
+                42
+            );
+            expect(condition).toBeNull();
+            expect(warnSpy).toHaveBeenCalledWith("Unsupported filter operation: unknown-op");
+            warnSpy.mockRestore();
+        });
+    });
+
+    describe("buildFilterConditions - integration with array operators", () => {
+        it("should build filter with array-contains operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { name: ["array-contains", "featured"] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should build filter with array-contains-any operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { name: ["array-contains-any", ["featured", "popular"]] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should build filter with not-in operator", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { age: ["not-in", [1, 2, 3]] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(1);
+        });
+
+        it("should skip not-in filter with empty array", () => {
+            const conditions = DrizzleConditionBuilder.buildFilterConditions(
+                { age: ["not-in", []] },
+                mockUsersTable,
+                "users"
+            );
+            expect(conditions).toHaveLength(0);
+        });
+    });
+});
+

package/vite.config.ts

@@ -33,7 +33,7 @@ const isExternal = (id: string) => {
     // Externalize only deps the consumer app explicitly installs
     if (CONSUMER_EXTERNALS.some(ext => id === ext || id.startsWith(ext + "/"))) return true;
     // Externalize Node built-ins
-    if (["fs", "path", "url", "util", "crypto", "http", "https", "net", "tls", "stream", "events", "os", "child_process", "buffer", "assert", "node:"].some(b => id === b || id.startsWith("node:") || id.startsWith(b + "/"))) return true;
+    if (["fs", "path", "url", "util", "crypto", "http", "https", "net", "tls", "stream", "events", "os", "child_process", "buffer", "assert", "dns", "zlib", "querystring", "node:"].some(b => id === b || id.startsWith("node:") || id.startsWith(b + "/"))) return true;
     // Inline everything else (jsonwebtoken, ws, zod, etc.)
     return false;
 };

package/dist/server-postgresql/src/schema/default-collections.d.ts

@@ -1,2 +0,0 @@
-import { PostgresCollection } from "@rebasepro/types";
-export declare const defaultUsersCollection: PostgresCollection;

package/dist/types/src/users/roles.d.ts

@@ -1,22 +0,0 @@
-export type Role = {
-    /**
-     * ID of the role
-     */
-    id: string;
-    /**
-     * Name of the role
-     */
-    name: string;
-    /**
-     * If this flag is true, the user can perform any action
-     */
-    isAdmin?: boolean;
-    /**
-     * Permissions related to editing the collections
-     */
-    config?: {
-        createCollections?: boolean;
-        editCollections?: boolean | "own";
-        deleteCollections?: boolean | "own";
-    };
-};

package/src/schema/default-collections.ts

@@ -1,69 +0,0 @@
-import { PostgresCollection } from "@rebasepro/types";
-
-export const defaultUsersCollection: PostgresCollection = {
-    name: "Users",
-    singularName: "User",
-    slug: "users",
-    table: "users",
-    schema: "rebase",
-    icon: "Users",
-    group: "Settings",
-    properties: {
-        id: {
-            name: "ID",
-            type: "string",
-            isId: "uuid"
-        },
-        email: {
-            name: "Email",
-            type: "string",
-            validation: { required: true, unique: true }
-        },
-        password_hash: {
-            name: "Password Hash",
-            type: "string",
-            ui: { hideFromCollection: true }
-        },
-        display_name: {
-            name: "Display Name",
-            type: "string"
-        },
-        photo_url: {
-            name: "Photo URL",
-            type: "string"
-        },
-        email_verified: {
-            name: "Email Verified",
-            type: "boolean",
-            defaultValue: false
-        },
-        email_verification_token: {
-            name: "Email Verification Token",
-            type: "string",
-            ui: { hideFromCollection: true }
-        },
-        email_verification_sent_at: {
-            name: "Email Verification Sent At",
-            type: "date",
-            ui: { hideFromCollection: true }
-        },
-        metadata: {
-            name: "Metadata",
-            type: "map",
-            defaultValue: {},
-            ui: { hideFromCollection: true }
-        },
-        created_at: {
-            name: "Created At",
-            type: "date",
-            autoValue: "on_create",
-            ui: { readOnly: true, hideFromCollection: true }
-        },
-        updated_at: {
-            name: "Updated At",
-            type: "date",
-            autoValue: "on_update",
-            ui: { readOnly: true, hideFromCollection: true }
-        }
-    }
-};