@rebasepro/server-postgresql 0.2.3 → 0.2.5

package/dist/types/src/types/properties.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentRef } from "./component_ref";
-import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity, Vector } from "./entities";
-import type { Relation, JoinStep, OnAction } from "./relations";
+import type { Entity, EntityReference, EntityRelation, EntityValues, GeoPoint, Vector } from "./entities";
+import type { JoinStep, OnAction, Relation } from "./relations";
 import type { EntityCollection, FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
 import type { AuthController } from "../controllers/auth";
@@ -104,8 +104,8 @@ export interface BaseUIConfig<CustomProps = unknown> {
     disabled?: boolean | PropertyDisabledConfig;
     widthPercentage?: number;
     customProps?: CustomProps;
-    Field?: ComponentRef<any>;
-    Preview?: ComponentRef<any>;
+    Field?: ComponentRef;
+    Preview?: ComponentRef;
 }
 export interface BaseProperty<CustomProps = unknown> {
     ui?: BaseUIConfig<CustomProps>;
@@ -185,7 +185,7 @@ export interface StringProperty extends BaseProperty {
      * Optional database column type. If not set, it defaults to `varchar` or `uuid` depending on `isId` configuration.
      * Use `text` for strings with unbound length, `char` for fixed-length strings, or `varchar` for variable-length strings with a limit.
      */
-    columnType?: "varchar" | "text" | "char";
+    columnType?: "varchar" | "text" | "char" | "uuid";
     /**
      * Rules for validating this property
      */
@@ -541,9 +541,11 @@ export interface ArrayProperty extends BaseProperty {
     ui?: ArrayUIConfig;
     type: "array";
     /**
-     * Optional database column type. Defaults to `jsonb`.
+     * Optional database column type. By default, maps to a native Postgres array
+     * (e.g. `text[]`, `integer[]`/`numeric[]`, `boolean[]`) if the element type
+     * is a primitive, otherwise defaults to `jsonb`.
      */
-    columnType?: "json" | "jsonb";
+    columnType?: "json" | "jsonb" | "text[]" | "integer[]" | "boolean[]" | "numeric[]";
     /**
      * The property of this array.
      * You can specify any property (except another Array property)

package/dist/types/src/types/translations.d.ts

@@ -105,6 +105,12 @@ export interface RebaseTranslations {
     navigation_drawer: string;
     collapse: string;
     expand: string;
+    /** Tooltip for the language switcher in the drawer footer */
+    change_language?: string;
+    /** Tooltip for the theme toggle in the drawer footer */
+    toggle_theme?: string;
+    /** Aria label for the user menu trigger in the drawer footer */
+    user_menu?: string;
     error: string;
     error_uploading_file: string;
     error_deleting: string;
@@ -426,18 +432,28 @@ export interface RebaseTranslations {
     deleted: string;
     select_reference: string;
     select_references: string;
-    account_settings: string;
-    profile: string;
-    sessions: string;
-    display_name: string;
-    photo_url: string;
-    save_profile: string;
-    saving: string;
-    no_active_sessions: string;
-    revoking: string;
-    revoke_all_sessions: string;
-    unknown_device: string;
-    current: string;
+    account_settings?: string;
+    profile?: string;
+    sessions?: string;
+    security?: string;
+    change_password?: string;
+    current_password?: string;
+    new_password?: string;
+    confirm_password?: string;
+    password_changed?: string;
+    passwords_dont_match?: string;
+    password_too_short?: string;
+    password_change_not_available?: string;
+    changing_password?: string;
+    display_name?: string;
+    photo_url?: string;
+    save_profile?: string;
+    saving?: string;
+    no_active_sessions?: string;
+    revoking?: string;
+    revoke_all_sessions?: string;
+    unknown_device?: string;
+    current?: string;
     role_id: string;
     role_name: string;
     add_reference: string;

package/dist/types/src/types/user_management_delegate.d.ts

@@ -1,4 +1,4 @@
-import { Role, User } from "../users";
+import type { User } from "../users";
 /**
  * Result of creating a new user via admin flow.
  * Contains the created user plus information about how credentials were delivered.
@@ -15,56 +15,46 @@ export interface UserCreationResult<USER extends User = User> {
     temporaryPassword?: string;
 }
 /**
- * Delegate to manage users, roles, and their permissions.
- * This interface allows the CMS to be completely agnostic of the underlying
- * authentication provider or backend.
+ * Delegate to manage auth-specific user operations.
+ *
+ * This interface allows the CMS to be agnostic of the underlying
+ * authentication provider or backend. User/role CRUD is now handled
+ * by the collection system; this delegate only exposes auth-specific
+ * operations (password hashing, invitations, bootstrap).
  *
  * @group Models
  */
 export interface UserManagementDelegate<USER extends User = User> {
     /**
-     * Are the users and roles currently being fetched?
+     * Are auth-related operations currently loading?
      */
     loading: boolean;
     /**
-     * List of users managed by the CMS.
+     * In-memory list of users (used for client-side filtering fallback).
      */
-    users: USER[];
+    users?: USER[];
     /**
-     * Optional error if users failed to load.
+     * Error from fetching the users list, if any.
      */
     usersError?: Error;
     /**
-     * Function to get a user by its uid. This is used to show
-     * user information when assigning ownership of an entity.
-     * @param uid
+     * Look up a single user by UID from the in-memory cache.
      */
-    getUser: (uid: string) => USER | null;
+    getUser?: (uid: string) => USER | null;
     /**
-     * Search users with server-side pagination.
-     * When provided, the CMS will use this for the users table
-     * instead of loading all users into memory.
+     * Server-side user search with pagination.
      */
-    searchUsers?: (options: {
+    searchUsers?: (params: {
         search?: string;
         limit?: number;
         offset?: number;
-        orderBy?: string;
-        orderDir?: "asc" | "desc";
-        roleId?: string;
     }) => Promise<{
         users: USER[];
         total: number;
     }>;
-    /**
-     * Save a user (create or update)
-     * @param user
-     */
-    saveUser?: (user: USER) => Promise<USER>;
     /**
      * Create a new user with invitation/password generation support.
      * Returns additional info about how the credentials were delivered.
-     * Falls back to saveUser if not provided.
      */
     createUser?: (user: USER) => Promise<UserCreationResult<USER>>;
     /**
@@ -73,46 +63,21 @@ export interface UserManagementDelegate<USER extends User = User> {
      * or a flag indicating an email invitation was sent.
      */
     resetPassword?: (user: USER) => Promise<UserCreationResult<USER>>;
-    /**
-     * Delete a user
-     * @param user
-     */
-    deleteUser?: (user: USER) => Promise<void>;
-    /**
-     * List of roles defined in the CMS.
-     */
-    roles?: Role[];
-    /**
-     * Optional error if roles failed to load.
-     */
-    rolesError?: Error;
-    /**
-     * Save a role (create or update)
-     * @param role
-     */
-    saveRole?: (role: Role) => Promise<void>;
-    /**
-     * Delete a role
-     * @param role
-     */
-    deleteRole?: (role: Role) => Promise<void>;
     /**
      * Is the currently logged in user an admin?
      */
     isAdmin?: boolean;
-    /**
-     * If true, the UI will allow the user to create the default roles (admin, editor, viewer).
-     */
-    allowDefaultRolesCreation?: boolean;
-    /**
-     * Should collection config permissions be included?
-     */
-    includeCollectionConfigPermissions?: boolean;
     /**
      * Optionally define roles for a given user. This is useful when the roles
      * are coming from a separate provider than the one issuing the tokens.
      */
-    defineRolesFor?: (user: USER) => Promise<Role[] | undefined> | Role[] | undefined;
+    defineRolesFor?: (user: USER) => Promise<string[] | undefined> | string[] | undefined;
+    /**
+     * Whether any admin users exist. Used by the bootstrap banner to decide
+     * whether to prompt.  Populated via a lightweight check (e.g. `limit=1`
+     * query) instead of loading all users.
+     */
+    hasAdminUsers?: boolean;
     /**
      * Optional function to bootstrap an admin user.
      * Often used when the database is empty.

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

@@ -1,2 +1 @@
 export * from "./user";
-export * from "./roles";

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

@@ -35,7 +35,6 @@ export type User = {
     readonly isAnonymous: boolean;
     /**
      * Role IDs assigned to this user (e.g. ["admin", "editor"]).
-     * These are plain string IDs — use the UserManagementDelegate to look up full Role objects.
      */
     roles?: string[];
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -68,11 +68,11 @@
     "hono": "^4.12.21",
     "pg": "^8.21.0",
     "ws": "^8.20.1",
-    "@rebasepro/common": "0.2.3",
-    "@rebasepro/server-core": "0.2.3",
-    "@rebasepro/types": "0.2.3",
-    "@rebasepro/utils": "0.2.3",
-    "@rebasepro/sdk-generator": "0.2.3"
+    "@rebasepro/common": "0.2.5",
+    "@rebasepro/utils": "0.2.5",
+    "@rebasepro/server-core": "0.2.5",
+    "@rebasepro/sdk-generator": "0.2.5",
+    "@rebasepro/types": "0.2.5"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/PostgresBackendDriver.ts

@@ -145,7 +145,8 @@ propertyCallbacks: undefined };
         startAfter,
         orderBy,
         searchString,
-        order
+        order,
+        vectorSearch
     }: FetchCollectionProps<M>): Promise<Entity<M>[]> {
 
         const entities = await this.entityService.fetchCollection<M>(path, {
@@ -156,7 +157,8 @@ propertyCallbacks: undefined };
             offset,
             startAfter: startAfter as Record<string, unknown> | undefined,
             databaseId: collection?.databaseId,
-            searchString
+            searchString,
+            vectorSearch
         });
 
         const { collection: resolvedCollection, callbacks, propertyCallbacks } = this.resolveCollectionCallbacks(collection, path);
@@ -629,6 +631,12 @@ propertyCallbacks: undefined };
 
     }
 
+    async deleteAll(path: string): Promise<void> {
+        await this.entityService.deleteAll(path);
+        // Notify real-time subscribers of bulk change
+        await this.realtimeService.notifyEntityUpdate(path, "*", null);
+    }
+
     async checkUniqueField(
         path: string,
         name: string,
@@ -1070,6 +1078,10 @@ roles: this.user?.roles ?? [] };
         return this.withTransaction((delegate) => delegate.deleteEntity(props));
     }
 
+    async deleteAll(path: string): Promise<void> {
+        return this.delegate.deleteAll(path);
+    }
+
     async checkUniqueField(
         path: string,
         name: string,

package/src/PostgresBootstrapper.ts

@@ -25,11 +25,12 @@ import {
     createAuthRoutes,
     createAdminRoutes,
     requireAuth,
-    requireAdmin
+    requireAdmin,
+    logger
 // @ts-ignore
 } from "@rebasepro/server-core";
 import { ensureAuthTablesExist } from "./auth/ensure-tables";
-import { RoleService, UserService, PostgresAuthRepository, AuthSchemaTables } from "./auth/services";
+import { UserService, PostgresAuthRepository, AuthSchemaTables } from "./auth/services";
 import { createAuthSchema } from "./schema/auth-schema";
 
 // @ts-ignore
@@ -50,6 +51,7 @@ import type { HonoEnv } from "@rebasepro/server-core";
  */
 export interface PostgresDriverInternals {
     db: NodePgDatabase<any>;
+    readDb?: NodePgDatabase<any>;
     registry: PostgresCollectionRegistry;
     realtimeService: RealtimeService;
     driver: PostgresBackendDriver;
@@ -83,7 +85,7 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             const registry = new PostgresCollectionRegistry();
             if (collections) {
                 registry.registerMultiple(collections);
-                console.log(`📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: [${registry.getCollections().map(c => c.slug).join(", ")}]`);
+                logger.info(`📋 [PostgresRegistry] Registered ${registry.getCollections().length} collections: [${registry.getCollections().map(c => c.slug).join(", ")}]`);
             }
 
             // Register tables
@@ -114,12 +116,26 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             try {
                 await schemaAwareDb.execute(sql`SELECT 1`);
             } catch (err) {
-                console.error("❌ Failed to connect to PostgreSQL:", err);
-                console.warn("⚠️ Continuing without initial database verification. Drizzle/PG will attempt to connect on subsequent queries.");
+                logger.error("❌ Failed to connect to PostgreSQL", { error: err });
+                logger.warn("⚠️ Continuing without initial database verification. Drizzle/PG will attempt to connect on subsequent queries.");
             }
 
             // Create services
             const realtimeService = new RealtimeService(schemaAwareDb, registry);
+
+            // Initialize read replica connection if configured
+            let readDb: import("drizzle-orm/node-postgres").NodePgDatabase<any> | undefined;
+            const readUrl = process.env.DATABASE_READ_URL;
+            if (readUrl && readUrl !== pgConfig.connectionString) {
+                try {
+                    const { createReadReplicaConnection } = await import("./connection");
+                    const readResources = createReadReplicaConnection(readUrl, mergedSchema);
+                    readDb = readResources.db;
+                    logger.info("📖 [PostgresBootstrapper] Read replica connection established");
+                } catch (err) {
+                    logger.warn("⚠️ Could not connect to read replica, falling back to primary for all queries", { error: err });
+                }
+            }
             const poolManager = pgConfig.adminConnectionString
                 ? new DatabasePoolManager(pgConfig.adminConnectionString)
                 : undefined;
@@ -131,21 +147,24 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
                 try {
                     await driver.branchService.ensureBranchMetadataTable();
                 } catch (err) {
-                    console.warn("⚠️ Could not initialize branch metadata table:", err);
+                    logger.warn("⚠️ Could not initialize branch metadata table", { error: err });
                 }
             }
 
             // Enable cross-instance realtime (opt-in)
-            if (pgConfig.connectionString) {
+            // Prefer DATABASE_DIRECT_URL to bypass PgBouncer for LISTEN/NOTIFY
+            const directUrl = process.env.DATABASE_DIRECT_URL || pgConfig.connectionString;
+            if (directUrl) {
                 try {
-                    await realtimeService.startListening(pgConfig.connectionString);
+                    await realtimeService.startListening(directUrl);
                 } catch (err) {
-                    console.warn("⚠️ Cross-instance realtime could not be started:", err);
+                    logger.warn("⚠️ Cross-instance realtime could not be started", { error: err });
                 }
             }
 
             const internals: PostgresDriverInternals = {
                 db: schemaAwareDb,
+                readDb,
                 registry,
                 realtimeService,
                 driver,
@@ -176,32 +195,23 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             }
 
             const customUsersTable = registry?.getTable("users");
-            const customRolesTable = registry?.getTable("roles");
 
             let usersSchemaName = "rebase";
-            let rolesSchemaName = "rebase";
 
             if (customUsersTable) {
                 usersSchemaName = getTableConfig(customUsersTable).schema || "public";
             }
-            if (customRolesTable) {
-                rolesSchemaName = getTableConfig(customRolesTable).schema || "public";
-            }
 
-            const authTables = createAuthSchema(rolesSchemaName, usersSchemaName) as unknown as AuthSchemaTables;
+            const authTables = createAuthSchema(usersSchemaName) as unknown as AuthSchemaTables;
             if (customUsersTable) {
                 authTables.users = customUsersTable as unknown as PgTable & Record<string, AnyPgColumn>;
             }
-            if (customRolesTable) {
-                authTables.roles = customRolesTable as unknown as PgTable & Record<string, AnyPgColumn>;
-            }
 
             const userService = new UserService(db, authTables);
-            const roleService = new RoleService(db, authTables);
             const authRepository = new PostgresAuthRepository(db, authTables);
 
             return { userService,
-roleService,
+roleService: userService,
 emailService,
 authRepository };
         },