@rebasepro/server-postgresql 0.3.0 → 0.4.0

package/src/schema/generate-drizzle-schema-logic.ts

@@ -70,6 +70,8 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
                 columnDefinition = `${enumName}("${colName}")`;
             } else if ("isId" in stringProp && stringProp.isId === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
+            } else if (stringProp.columnType === "uuid") {
+                columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "text") {
                 columnDefinition = `text("${colName}")`;
             } else if (stringProp.columnType === "char") {
@@ -145,11 +147,39 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: EntityCo
             }
             break;
         }
-        case "map":
+        case "map": {
+            const mapProp = prop as MapProperty;
+            if (mapProp.columnType === "json") {
+                columnDefinition = `json("${colName}")`;
+            } else {
+                columnDefinition = `jsonb("${colName}")`;
+            }
+            break;
+        }
         case "array": {
-            const arrayOrMapProp = prop as ArrayProperty | MapProperty;
-            if (arrayOrMapProp.columnType === "json") {
+            const arrayProp = prop as ArrayProperty;
+            let colType = arrayProp.columnType;
+            if (!colType && arrayProp.of && !Array.isArray(arrayProp.of)) {
+                const ofProp = arrayProp.of as Property;
+                if (ofProp.type === "string") {
+                    colType = "text[]";
+                } else if (ofProp.type === "number") {
+                    colType = ofProp.validation?.integer ? "integer[]" : "numeric[]";
+                } else if (ofProp.type === "boolean") {
+                    colType = "boolean[]";
+                }
+            }
+
+            if (colType === "json") {
                 columnDefinition = `json("${colName}")`;
+            } else if (colType === "text[]") {
+                columnDefinition = `text("${colName}").array()`;
+            } else if (colType === "integer[]") {
+                columnDefinition = `integer("${colName}").array()`;
+            } else if (colType === "boolean[]") {
+                columnDefinition = `boolean("${colName}").array()`;
+            } else if (colType === "numeric[]") {
+                columnDefinition = `numeric("${colName}").array()`;
             } else {
                 columnDefinition = `jsonb("${colName}")`;
             }

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

@@ -5,7 +5,7 @@ import { pathToFileURL } from "url";
 import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { EntityCollection } from "@rebasepro/types";
-import { defaultUsersCollection } from "@rebasepro/common";
+
 
 // --- Helper Functions ---
 
@@ -90,11 +90,7 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
             collections = [];
         }
 
-        // Always inject defaults first; developer collections override via generic dedup
-        // Map keyed by slug — last-write-wins, so developer collections overwrite defaults
-        collections = Array.from(
-            new Map([defaultUsersCollection, ...collections].map(c => [c.slug, c])).values()
-        );
+
 
         // Sort collections by slug alphabetically to ensure deterministic schema generation
         collections.sort((a, b) => a.slug.localeCompare(b.slug));

package/src/schema/introspect-db-logic.ts

@@ -589,9 +589,16 @@ export function generateCollectionFile(
         // Array/Map heuristics (Fallback if not inferred)
         if (finalPropType === "array" && !inferenceExtra.includes("of: {")) {
             let innerType = "string";
+            let colType = "";
             if (col.udt_name.startsWith("_")) {
                 const baseType = col.udt_name.substring(1);
                 innerType = mapPgType(baseType);
+                if (innerType === "string") colType = "text[]";
+                else if (innerType === "number") colType = col.udt_name === "_numeric" ? "numeric[]" : "integer[]";
+                else if (innerType === "boolean") colType = "boolean[]";
+            }
+            if (colType) {
+                extra += `\n            columnType: "${colType}",`;
             }
             extra += `\n            of: { name: "${humanize(col.column_name)} Item", type: "${innerType}" },`;
         } else if (finalPropType === "map" && !inferenceExtra.includes("keyValue: true") && !inferenceExtra.includes("properties: {")) {

package/src/services/EntityFetchService.ts

@@ -1,6 +1,6 @@
 import { and, asc, count, desc, eq, getTableName, gt, lt, or, SQL, TableRelationalConfig, TablesRelationalConfig } from "drizzle-orm";
 import { AnyPgColumn, PgTable } from "drizzle-orm/pg-core";
-import { Entity, EntityCollection, FilterValues, Relation } from "@rebasepro/types";
+import { Entity, EntityCollection, FilterValues, Relation, LogicalCondition } from "@rebasepro/types";
 import type { VectorSearchParams } from "@rebasepro/types";
 import { resolveCollectionRelations, findRelation, createRelationRef, createRelationRefWithData } from "@rebasepro/common";
 import { DrizzleConditionBuilder } from "../utils/drizzle-conditions";
@@ -465,6 +465,7 @@ export class EntityFetchService {
             offset?: number;
             startAfter?: Record<string, unknown>;
             searchString?: string;
+            logical?: LogicalCondition;
         },
         collectionPath: string,
         withConfig?: Record<string, unknown>
@@ -494,6 +495,11 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (options.logical) {
+            const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+            if (logicalCondition) allConditions.push(logicalCondition);
+        }
+
         // Cursor-based pagination (startAfter)
         if (options.startAfter) {
             const cursorConditions = this.buildCursorConditions(table, idField, idInfo, options, collectionPath);
@@ -700,6 +706,7 @@ export class EntityFetchService {
             searchString?: string;
             databaseId?: string;
             vectorSearch?: VectorSearchParams;
+            logical?: LogicalCondition;
         } = {}
     ): Promise<Entity<M>[]> {
         const collection = getCollectionByPath(collectionPath, this.registry);
@@ -774,6 +781,11 @@ export class EntityFetchService {
             if (filterConditions.length > 0) allConditions.push(...filterConditions);
         }
 
+        if (options.logical) {
+            const logicalCondition = DrizzleConditionBuilder.buildLogicalConditions(options.logical, table, collectionPath);
+            if (logicalCondition) allConditions.push(logicalCondition);
+        }
+
         // Vector distance threshold filter
         if (vectorMeta?.filter) {
             allConditions.push(vectorMeta.filter);

package/src/services/EntityPersistService.ts

@@ -53,6 +53,15 @@ export class EntityPersistService {
             .where(eq(idField, parsedId));
     }
 
+    /**
+     * Delete all entities from a collection
+     */
+    async deleteAll(collectionPath: string, _databaseId?: string): Promise<void> {
+        const collection = getCollectionByPath(collectionPath, this.registry);
+        const table = getTableForCollection(collection, this.registry);
+        await this.db.delete(table);
+    }
+
     /**
      * Save an entity (create or update)
      */

package/src/services/entityService.ts

@@ -169,6 +169,13 @@ export class EntityService implements EntityRepository {
         return this.persistService.deleteEntity(collectionPath, entityId, databaseId);
     }
 
+    /**
+     * Delete all entities from a collection
+     */
+    async deleteAll(collectionPath: string, databaseId?: string): Promise<void> {
+        return this.persistService.deleteAll(collectionPath, databaseId);
+    }
+
 
     /**
      * Execute raw SQL

package/src/utils/drizzle-conditions.ts

@@ -1,6 +1,6 @@
 import { and, eq, or, sql, SQL, ilike, inArray } from "drizzle-orm";
 import { AnyPgColumn, PgTable, PgVarchar, PgText, PgChar } from "drizzle-orm/pg-core";
-import { FilterValues, WhereFilterOp, Relation, JoinStep } from "@rebasepro/types";
+import { FilterValues, WhereFilterOp, Relation, JoinStep, LogicalCondition, FilterCondition } from "@rebasepro/types";
 import { getColumnName, resolveCollectionRelations } from "@rebasepro/common";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { ConditionBuilderStatic } from "../interfaces";
@@ -37,7 +37,6 @@ export class DrizzleConditionBuilder {
         for (const [field, filterParam] of Object.entries(filter)) {
             if (!filterParam) continue;
 
-            const [op, value] = filterParam as [WhereFilterOp, any];
             let fieldColumn = table[field as keyof typeof table] as AnyPgColumn;
 
             if (!fieldColumn) {
@@ -53,15 +52,51 @@ export class DrizzleConditionBuilder {
                 continue;
             }
 
-            const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
-            if (condition) {
-                conditions.push(condition);
+            const paramsList = Array.isArray(filterParam) && filterParam.length > 0 && Array.isArray(filterParam[0])
+                ? (filterParam as [WhereFilterOp, any][])
+                : [filterParam as [WhereFilterOp, any]];
+
+            for (const [op, value] of paramsList) {
+                const condition = this.buildSingleFilterCondition(fieldColumn, op, value);
+                if (condition) {
+                    conditions.push(condition);
+                }
             }
         }
 
         return conditions;
     }
 
+    /**
+     * Build logical conditions recursively from LogicalCondition or FilterCondition
+     */
+    static buildLogicalConditions(
+        cond: LogicalCondition | FilterCondition,
+        table: PgTable<any>,
+        collectionPath: string
+    ): SQL | null {
+        if ("type" in cond) {
+            const subSQLs = cond.conditions
+                .map(c => this.buildLogicalConditions(c, table, collectionPath))
+                .filter((sql): sql is SQL => sql !== null);
+            if (subSQLs.length === 0) return null;
+            return (cond.type === "or" ? or(...subSQLs) : and(...subSQLs)) ?? null;
+        } else {
+            let fieldColumn = table[cond.column as keyof typeof table] as AnyPgColumn;
+            if (!fieldColumn) {
+                const relationKey = `${cond.column}_id`;
+                if (relationKey in table) {
+                    fieldColumn = table[relationKey as keyof typeof table] as AnyPgColumn;
+                }
+            }
+            if (!fieldColumn) {
+                console.warn(`Filtering by field '${cond.column}', but it does not exist in table for collection '${collectionPath}'`);
+                return null;
+            }
+            return this.buildSingleFilterCondition(fieldColumn, cond.operator as WhereFilterOp, cond.value);
+        }
+    }
+
     /**
      * Build a single filter condition for a specific operator and value
      */

package/src/websocket.ts

@@ -547,15 +547,13 @@ colors: true }));
                     }
                         break;
 
-                    // Route subscription messages to RealtimeService
+                    // Route subscription messages, broadcast channels, and presence to RealtimeService
                     case "subscribe_collection":
                     case "subscribe_entity":
                     case "unsubscribe":
-                    // Broadcast channels
                     case "join_channel":
                     case "leave_channel":
                     case "broadcast":
-                    // Presence
                     case "presence_track":
                     case "presence_untrack":
                     case "presence_state": {

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";
 
@@ -344,18 +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 },
-                        { id: "editor",
-                            name: "Editor",
-                            is_admin: false,
-                            default_permissions: { edit: true },
-                            collection_permissions: null }
-                    ]
+                    rows: [{ roles: ["admin", "editor"] }]
                 });
 
                 const roles = await userService.getUserRoles("user-123");
@@ -363,7 +352,7 @@ describe("Auth Services", () => {
                 expect(roles).toHaveLength(2);
                 expect(roles[0]).toEqual({
                     id: "admin",
-                    name: "Admin",
+                    name: "admin",
                     isAdmin: true,
                     defaultPermissions: null,
                     collectionPermissions: null
@@ -374,13 +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 }
-                    ]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const roleIds = await userService.getUserRoleIds("user-123");
@@ -393,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);
             });
         });
 
@@ -408,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();
             });
@@ -419,11 +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 }]
+                    rows: [{ roles: ["admin"] }]
                 });
 
                 const result = await userService.getUserWithRoles("user-123");
@@ -431,7 +407,7 @@ describe("Auth Services", () => {
                 expect(result).toEqual({
                     user: mockUserData({}),
                     roles: [{ id: "admin",
-                        name: "Admin",
+                        name: "admin",
                         isAdmin: true,
                         defaultPermissions: null,
                         collectionPermissions: null }]
@@ -472,125 +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 }]
-                });
-
-                const result = await roleService.getRoleById("admin");
-
-                expect(result).toEqual({
-                    id: "admin",
-                    name: "Admin",
-                    isAdmin: true,
-                    defaultPermissions: null,
-                    collectionPermissions: 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 },
-                        { id: "editor",
-name: "Editor",
-is_admin: false,
-default_permissions: null,
-collection_permissions: 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 }]
-                });
-
-                const role = await roleService.createRole({
-                    id: "custom",
-                    name: "Custom Role",
-                    defaultPermissions: 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 }] })
-                    .mockResolvedValueOnce({ rows: [] })
-                    .mockResolvedValueOnce({ rows: [{ id: "admin",
-name: "Super Admin",
-is_admin: true,
-default_permissions: null,
-collection_permissions: 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", () => {