@rebasepro/server-postgresql 0.1.2 → 0.2.3

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

@@ -0,0 +1,94 @@
+/**
+ * @module DatabaseAdapter
+ *
+ * Pluggable database abstraction for Rebase.
+ *
+ *
+ * A `DatabaseAdapter` focuses purely on data persistence and related concerns (realtime, history).
+ * It does NOT handle authentication — auth is managed separately by an `AuthAdapter`.
+ *
+ * @example
+ * ```ts
+ * import { createPostgresAdapter } from "@rebasepro/server-postgresql";
+ *
+ * initializeRebaseBackend({
+ *   database: createPostgresAdapter({ connection: db, schema }),
+ *   auth: { jwtSecret: "..." },
+ * });
+ * ```
+ *
+ * @group Backend
+ */
+import type { DataDriver } from "../controllers/data_driver";
+import type { EntityCollection } from "./collections";
+import type { CollectionRegistryInterface, DatabaseAdmin, InitializedDriver, RealtimeProvider, BootstrappedAuth } from "./backend";
+/**
+ * A `DatabaseAdapter` provides data persistence for Rebase.
+ *
+ * @group Backend
+ */
+export interface DatabaseAdapter {
+    /**
+     * Which database engine this adapter handles.
+     *
+     * @example "postgres", "mysql", "mongodb", "sqlite"
+     */
+    readonly type: string;
+    /**
+     * Create the DataDriver for CRUD operations.
+     *
+     * This is the only **required** method.
+     *
+     * @param config - Coordinator-provided config containing registered
+     *                 collections and the collection registry.
+     */
+    initializeDriver(config: DatabaseAdapterInitConfig): Promise<InitializedDriver>;
+    /**
+     * Create a realtime provider for this database.
+     *
+     * Return `undefined` if the database does not support realtime
+     * change notifications.
+     */
+    initializeRealtime?(driverResult: InitializedDriver): Promise<RealtimeProvider | undefined>;
+    /**
+     * Initialize auth tables / services if this driver supports them.
+     */
+    initializeAuth?(config: unknown, driverResult: InitializedDriver): Promise<BootstrappedAuth | undefined>;
+    /**
+     * Initialize entity history tracking.
+     *
+     * Return `undefined` if the database does not support history.
+     */
+    initializeHistory?(config: unknown, driverResult: InitializedDriver): Promise<{
+        historyService: unknown;
+    } | undefined>;
+    /**
+     * Initialize WebSocket server for realtime operations.
+     */
+    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: DataDriver, config?: unknown): Promise<void> | void;
+    /**
+     * Return admin capabilities for this database (SQL editor, schema browser, branching).
+     */
+    getAdmin?(driverResult: InitializedDriver): DatabaseAdmin | undefined;
+    /**
+     * Mount any database-specific HTTP routes (e.g., custom admin endpoints).
+     *
+     * Called after all adapters are initialized.
+     */
+    mountRoutes?(app: unknown, basePath: string, driverResult: InitializedDriver): void;
+    /**
+     * Graceful shutdown: close connections, release resources.
+     */
+    destroy?(): Promise<void>;
+}
+/**
+ * Configuration passed by the coordinator to `DatabaseAdapter.initializeDriver()`.
+ *
+ * @group Backend
+ */
+export interface DatabaseAdapterInitConfig {
+    /** Registered collection definitions. */
+    collections: EntityCollection[];
+    /** The shared collection registry to register into. */
+    collectionRegistry: CollectionRegistryInterface;
+}

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

@@ -40,6 +40,12 @@ export interface EntityAction<M extends Record<string, unknown> = Record<string,
      * @param props
      */
     isEnabled?(props: EntityActionClickProps<M, USER>): boolean;
+    /**
+     * When true, this action is rendered inline on each row in the list view.
+     * By default, entity actions only appear in the table view and entity form.
+     * Use this for actions that should be easily accessible regardless of view mode.
+     */
+    showActionsInListView?: boolean;
     /**
      * Show this action collapsed in the menu of the collection view.
      * Defaults to true
@@ -72,7 +78,7 @@ export type EntityActionClickProps<M extends Record<string, unknown>, USER exten
     /**
      * If the action is rendered in the form, is it open in a side panel or full screen?
      */
-    openEntityMode: "side_panel" | "full_screen" | "split";
+    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
     /**
      * Optional selection controller, present if the action is being called from a collection view
      */

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

@@ -39,7 +39,7 @@ export type EntityCallbacks<M extends Record<string, unknown> = Record<string, u
      *
      * @param props
      */
-    beforeDelete?(props: EntityBeforeDeleteProps<M, USER>): void;
+    beforeDelete?(props: EntityBeforeDeleteProps<M, USER>): Promise<boolean | void> | boolean | void;
     /**
      * Callback used after the entity is deleted.
      *

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

@@ -35,12 +35,17 @@ export interface FormContext<M extends Record<string, unknown> = Record<string,
     status: "new" | "existing" | "copy";
     entity?: Entity<M>;
     savingError?: Error;
-    openEntityMode: "side_panel" | "full_screen" | "split";
+    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
     /**
      * The underlying formex controller that powers the form.
      */
     formex: FormexController<M>;
     disabled: boolean;
+    /**
+     * Whether the form context is in read-only detail view mode.
+     * Custom entity views can use this to adjust their rendering.
+     */
+    readOnly?: boolean;
 }
 export type EntityCustomView<M extends Record<string, unknown> = Record<string, unknown>> = {
     key: string;
@@ -58,3 +63,33 @@ export interface EntityCustomViewParams<M extends Record<string, unknown> = Reco
     parentCollectionSlugs?: string[];
     parentEntityIds?: string[];
 }
+/**
+ * Configuration for customizing the read-only detail view of an entity.
+ * Only used when `defaultEntityAction` is set to `"view"` on the collection.
+ * @group Models
+ */
+export type EntityDetailViewConfig<M extends Record<string, unknown> = Record<string, unknown>> = {
+    /**
+     * Custom component rendered above the property display in the detail view.
+     */
+    Header?: ComponentRef<EntityDetailViewParams<M>>;
+    /**
+     * Custom component rendered below the property display in the detail view.
+     */
+    Footer?: ComponentRef<EntityDetailViewParams<M>>;
+    /**
+     * Completely replace the default detail view with a custom component.
+     * When set, Header and Footer are ignored.
+     */
+    Builder?: ComponentRef<EntityDetailViewParams<M>>;
+};
+/**
+ * Props passed to detail view customization components (Header, Footer, Builder).
+ * @group Models
+ */
+export interface EntityDetailViewParams<M extends Record<string, unknown> = Record<string, unknown>> {
+    collection: EntityCollection<M>;
+    entity: Entity<M>;
+    path: string;
+    onEditClick: () => void;
+}

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

@@ -24,3 +24,5 @@ export * from "./data_source";
 export * from "./cron";
 export * from "./backend_hooks";
 export * from "./component_ref";
+export * from "./auth_adapter";
+export * from "./database_adapter";

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

@@ -250,7 +250,7 @@ export interface PluginFormActionProps<USER extends User = User, EC extends Enti
     disabled: boolean;
     formContext?: FormContext;
     context: RebaseContext<USER>;
-    openEntityMode: "side_panel" | "full_screen" | "split";
+    openEntityMode: "side_panel" | "full_screen" | "split" | "dialog";
 }
 /**
  * Parameters passed to the field builder wrap function.

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

@@ -1,5 +1,5 @@
 import type { ComponentRef } from "./component_ref";
-import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity } from "./entities";
+import type { EntityReference, EntityRelation, EntityValues, GeoPoint, Entity, Vector } from "./entities";
 import type { Relation, JoinStep, OnAction } from "./relations";
 import type { EntityCollection, FilterValues } from "./collections";
 import type { ColorKey, ColorScheme } from "./chips";
@@ -31,8 +31,8 @@ export type PropertyCallbacks<T = unknown, M extends Record<string, unknown> = R
 /**
  * @group Entity properties
  */
-export type DataType = "string" | "number" | "boolean" | "date" | "geopoint" | "reference" | "relation" | "array" | "map";
-export type Property = StringProperty | NumberProperty | BooleanProperty | DateProperty | GeopointProperty | ReferenceProperty | RelationProperty | ArrayProperty | MapProperty;
+export type DataType = "string" | "number" | "boolean" | "date" | "geopoint" | "reference" | "relation" | "array" | "map" | "vector" | "binary";
+export type Property = StringProperty | NumberProperty | BooleanProperty | DateProperty | GeopointProperty | ReferenceProperty | RelationProperty | ArrayProperty | MapProperty | VectorProperty | BinaryProperty;
 export type Properties = {
     [key: string]: Property;
 };
@@ -48,7 +48,7 @@ export type FirebaseProperties = {
  * A helper type to infer the underlying data type from a Property definition.
  * This is the core of the type inference system.
  */
-export type InferPropertyType<P extends Property> = P extends StringProperty ? string : P extends NumberProperty ? number : P extends BooleanProperty ? boolean : P extends DateProperty ? Date : P extends GeopointProperty ? GeoPoint : P extends ReferenceProperty ? EntityReference : P extends RelationProperty ? EntityRelation | EntityRelation[] : P extends ArrayProperty ? (P["of"] extends Property ? InferPropertyType<P["of"]>[] : unknown[]) : P extends MapProperty ? (P["properties"] extends Properties ? InferEntityType<P["properties"]> : Record<string, unknown>) : never;
+export type InferPropertyType<P extends Property> = P extends StringProperty ? string : P extends NumberProperty ? number : P extends BooleanProperty ? boolean : P extends DateProperty ? Date : P extends GeopointProperty ? GeoPoint : P extends ReferenceProperty ? EntityReference : P extends RelationProperty ? EntityRelation | EntityRelation[] : P extends ArrayProperty ? (P["of"] extends Property ? InferPropertyType<P["of"]>[] : unknown[]) : P extends MapProperty ? (P["properties"] extends Properties ? InferEntityType<P["properties"]> : Record<string, unknown>) : P extends VectorProperty ? Vector : P extends BinaryProperty ? string : never;
 /**
  * Helper type that determines whether a property is required.
  * Uses direct structural matching against `{ validation: { required: true } }`
@@ -309,6 +309,25 @@ export interface BooleanProperty extends BaseProperty {
      */
     validation?: PropertyValidationSchema;
 }
+/**
+ * @group Entity properties
+ */
+export interface VectorUIConfig extends BaseUIConfig {
+    clearable?: boolean;
+}
+export interface VectorProperty extends BaseProperty {
+    ui?: VectorUIConfig;
+    type: "vector";
+    dimensions: number;
+    validation?: PropertyValidationSchema;
+}
+/**
+ * @group Entity properties
+ */
+export interface BinaryProperty extends BaseProperty {
+    type: "binary";
+    validation?: PropertyValidationSchema;
+}
 /**
  * @group Entity properties
  */
@@ -421,7 +440,7 @@ export interface RelationProperty extends BaseProperty {
      * When set, the framework treats this property as a self-contained relation
      * definition and no separate `relations[]` entry is needed.
      */
-    target?: () => EntityCollection;
+    target?: string | (() => EntityCollection | string);
     /**
      * Whether this property references one or many records.
      * Defaults to `"one"`.

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

@@ -1,5 +1,5 @@
 import React from "react";
-import { ArrayProperty, MapProperty, StringProperty, NumberProperty, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty } from "./properties";
+import { ArrayProperty, MapProperty, StringProperty, NumberProperty, BooleanProperty, DateProperty, GeopointProperty, ReferenceProperty, RelationProperty, VectorProperty, BinaryProperty } from "./properties";
 import { BaseProperty } from "./properties";
 type CMSBasePropertyNoName = Omit<BaseProperty, "name">;
 export type ConfigProperty = (Omit<StringProperty, "name"> & {
@@ -28,6 +28,10 @@ export type ConfigProperty = (Omit<StringProperty, "name"> & {
 } & CMSBasePropertyNoName) | (Omit<MapProperty, "name" | "properties"> & {
     name?: string;
     properties?: Record<string, ConfigProperty>;
+} & CMSBasePropertyNoName) | (Omit<VectorProperty, "name"> & {
+    name?: string;
+} & CMSBasePropertyNoName) | (Omit<BinaryProperty, "name"> & {
+    name?: string;
 } & CMSBasePropertyNoName);
 /**
  * This is the configuration object for a property.
@@ -66,5 +70,5 @@ export type PropertyConfig = {
      */
     description?: string;
 };
-export type PropertyConfigId = "text_field" | "multiline" | "markdown" | "url" | "email" | "user_select" | "select" | "multi_select" | "number_input" | "number_select" | "multi_number_select" | "file_upload" | "multi_file_upload" | "group" | "key_value" | "reference" | "reference_as_string" | "multi_references" | "relation" | "switch" | "date_time" | "repeat" | "custom_array" | "block";
+export type PropertyConfigId = "text_field" | "multiline" | "markdown" | "url" | "email" | "user_select" | "select" | "multi_select" | "number_input" | "number_select" | "multi_number_select" | "file_upload" | "multi_file_upload" | "group" | "key_value" | "reference" | "reference_as_string" | "multi_references" | "relation" | "switch" | "date_time" | "repeat" | "custom_array" | "block" | "vector_input";
 export {};

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

@@ -17,7 +17,7 @@ export interface Relation {
     /**
      * The final collection you want to retrieve records from.
      */
-    target: () => EntityCollection;
+    target: (() => EntityCollection) | any;
     /**
      * The nature of the relationship, determining if one or many records are returned.
      */

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

@@ -30,6 +30,8 @@ export interface RebaseTranslations {
     copy: string;
     delete: string;
     delete_not_allowed: string;
+    edit_entity?: string;
+    back_to_detail?: string;
     delete_confirmation_title: string;
     delete_confirmation_body: string;
     delete_multiple_confirmation_body: string;
@@ -392,6 +394,12 @@ export interface RebaseTranslations {
     submit: string;
     no_filterable_properties: string;
     apply_filters: string;
+    /** Label shown on the filter presets dropdown trigger */
+    filter_presets?: string;
+    /** Tooltip shown when hovering over a preset entry */
+    filter_preset_apply?: string;
+    /** Shown when a preset is active, with {{label}} interpolation */
+    filter_preset_active?: string;
     list: string;
     table_view_mode: string;
     cards: string;

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

@@ -42,5 +42,10 @@ export type User = {
      * The date and time when the user was created.
      */
     createdAt?: Date | string | null;
+    /**
+     * Additional metadata/custom claims associated with the user.
+     * Accessible by the frontend, but only writable by the backend.
+     */
+    readonly metadata?: Record<string, any>;
     getIdToken?: (forceRefresh?: boolean) => Promise<string>;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.3",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -43,6 +43,7 @@
       "node"
     ],
     "moduleNameMapper": {
+      "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
       "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
       "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
@@ -51,7 +52,7 @@
   "exports": {
     ".": {
       "types": "./dist/server-postgresql/src/index.d.ts",
-      "development": "./src/index.ts",
+      "development": "./dist/index.es.js",
       "import": "./dist/index.es.js",
       "require": "./dist/index.umd.js"
     },
@@ -61,23 +62,29 @@
     "arg": "^5.0.2",
     "chalk": "^4.1.2",
     "chokidar": "5.0.0",
-    "drizzle-orm": "^0.44.4",
-    "execa": "^4.1.0",
-    "pg": "^8.11.3",
-    "@rebasepro/server-core": "0.1.2",
-    "@rebasepro/types": "0.1.2",
-    "@rebasepro/common": "0.1.2",
-    "@rebasepro/utils": "0.1.2"
+    "dotenv": "^16.6.1",
+    "drizzle-orm": "^0.44.7",
+    "execa": "^9.6.1",
+    "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"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/node": "^20.10.5",
-    "@types/pg": "^8.6.5",
-    "drizzle-kit": "^0.31.4",
+    "@types/node": "^20.19.41",
+    "@types/pg": "^8.20.0",
+    "@types/ws": "^8.18.1",
+    "@vitejs/plugin-react": "^4.7.0",
+    "drizzle-kit": "^0.31.10",
     "jest": "^29.7.0",
-    "ts-jest": "^29.4.5",
-    "typescript": "^5.0.0",
-    "vite": "^5.0.0"
+    "ts-jest": "^29.4.10",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.21"
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "publishConfig": {

package/src/PostgresAdapter.ts

@@ -0,0 +1,59 @@
+import { DatabaseAdapter, InitializedDriver, RealtimeProvider, DataDriver, DatabaseAdmin, BootstrappedAuth } from "@rebasepro/types";
+import { createPostgresBootstrapper } from "./PostgresBootstrapper";
+// @ts-ignore
+import type { PostgresDriverConfig } from "@rebasepro/server-core";
+
+/**
+ * Creates a Postgres database adapter for Rebase.
+ */
+export function createPostgresAdapter(pgConfig: PostgresDriverConfig): DatabaseAdapter {
+    const bootstrapper = createPostgresBootstrapper(pgConfig);
+    
+    return {
+        type: bootstrapper.type,
+        
+        async initializeDriver(config) {
+            return bootstrapper.initializeDriver(config);
+        },
+        
+        async initializeRealtime(driverResult) {
+            if (bootstrapper.initializeRealtime) {
+                return bootstrapper.initializeRealtime({}, driverResult);
+            }
+            return undefined;
+        },
+        
+        async initializeAuth(config, driverResult) {
+            if (bootstrapper.initializeAuth) {
+                return bootstrapper.initializeAuth(config, driverResult);
+            }
+            return undefined;
+        },
+        
+        async initializeHistory(config, driverResult) {
+            if (bootstrapper.initializeHistory) {
+                return bootstrapper.initializeHistory(config, driverResult);
+            }
+            return undefined;
+        },
+        
+        initializeWebsockets(server, realtimeService, driver, config) {
+            if (bootstrapper.initializeWebsockets) {
+                return bootstrapper.initializeWebsockets(server, realtimeService, driver, config);
+            }
+        },
+        
+        getAdmin(driverResult) {
+            if (bootstrapper.getAdmin) {
+                return bootstrapper.getAdmin(driverResult);
+            }
+            return undefined;
+        },
+        
+        mountRoutes(app, basePath, driverResult) {
+            if (bootstrapper.mountRoutes) {
+                bootstrapper.mountRoutes(app, basePath, driverResult);
+            }
+        }
+    };
+}

package/src/PostgresBackendDriver.ts

@@ -27,7 +27,8 @@ import {
     TablePolicyInfo,
     SQLAdmin,
     SchemaAdmin,
-    DatabaseAdmin
+    DatabaseAdmin,
+    RestFetchService
 } from "@rebasepro/types";
 import { buildRebaseData } from "@rebasepro/common";
 // @ts-ignore
@@ -116,7 +117,7 @@ export class PostgresBackendDriver implements DataDriver {
         if (!collection && !path) return { collection: undefined,
 callbacks: undefined,
 propertyCallbacks: undefined };
-        const registryCollection = this.registry.getCollectionByPath(path);
+        const registryCollection = this.registry?.getCollectionByPath(path);
         const resolvedCollection = registryCollection
             ? { ...collection,
 ...registryCollection } as EntityCollection<M>
@@ -165,7 +166,8 @@ propertyCallbacks: undefined };
                 user: this.user,
                 driver: this,
                 data: this.data,
-                client: this.client
+                client: this.client,
+                storageSource: this.client?.storage
             } as unknown as RebaseCallContext; // Backend context
             return Promise.all(entities.map(async (entity) => {
                 let fetched = entity;
@@ -275,7 +277,8 @@ propertyCallbacks: undefined };
                 user: this.user,
                 driver: this,
                 data: this.data,
-                client: this.client
+                client: this.client,
+                storageSource: this.client?.storage
             } as unknown as RebaseCallContext; // Backend context
             if (callbacks?.afterRead) {
                 entity = await callbacks.afterRead({
@@ -358,7 +361,8 @@ propertyCallbacks: undefined };
             user: this.user,
             driver: this,
             data: this.data,
-            client: this.client
+            client: this.client,
+            storageSource: this.client?.storage
         } as unknown as RebaseCallContext;
 
         // Fetch previous values for callbacks AND history recording
@@ -533,27 +537,38 @@ propertyCallbacks: undefined };
             user: this.user,
             driver: this,
             data: this.data,
-            client: this.client
+            client: this.client,
+            storageSource: this.client?.storage
         } as unknown as RebaseCallContext;
 
         if (callbacks?.beforeDelete || propertyCallbacks?.beforeDelete) {
+            let preventDefault = false;
             if (callbacks?.beforeDelete) {
-                await callbacks.beforeDelete({
+                const result = await callbacks.beforeDelete({
                     collection: resolvedCollection as EntityCollection<M>,
                     path: entity.path,
                     entityId: entity.id,
                     entity,
                     context: contextForCallback
                 });
+                if (result === false) {
+                    preventDefault = true;
+                }
             }
             if (propertyCallbacks?.beforeDelete) {
-                await propertyCallbacks.beforeDelete({
+                const result = await propertyCallbacks.beforeDelete({
                     collection: resolvedCollection as EntityCollection<M>,
                     path: entity.path,
                     entityId: entity.id,
                     entity,
                     context: contextForCallback
                 });
+                if (result === false) {
+                    preventDefault = true;
+                }
+            }
+            if (preventDefault) {
+                return;
             }
         }
 
@@ -664,7 +679,23 @@ searchString }
         const targetDb = this.getTargetDb(options?.database);
 
         try {
-            if (options?.role) {
+            // Determine if we actually need to switch roles.
+            // Skip SET LOCAL ROLE when the requested role matches the current session role,
+            // as it's a no-op that can fail on managed Postgres setups where the connection
+            // user doesn't have permission to SET ROLE.
+            let needsRoleSwitch = false;
+            if (options?.role && process.env.DISABLE_DB_ROLE_SWITCHING !== "true") {
+                try {
+                    const currentRoleResult = await targetDb.execute(drizzleSql.raw("SELECT current_user AS role"));
+                    const currentRole = (currentRoleResult.rows?.[0] as Record<string, unknown>)?.role as string | undefined;
+                    needsRoleSwitch = !!currentRole && currentRole !== options.role;
+                } catch {
+                    // If we can't determine the current role, attempt the switch anyway
+                    needsRoleSwitch = true;
+                }
+            }
+
+            if (needsRoleSwitch && options?.role) {
                 const safeRole = options.role.replace(/"/g, '""');
                 return await targetDb.transaction(async (tx) => {
                     await tx.execute(drizzleSql.raw(`SET LOCAL ROLE "${safeRole}"`));
@@ -711,7 +742,9 @@ searchString }
     }
 
     async fetchAvailableRoles(): Promise<string[]> {
-        const result = await this.executeSql("SELECT rolname FROM pg_roles;");
+        const result = await this.executeSql(
+            "SELECT rolname FROM pg_roles WHERE pg_has_role(current_user, rolname, 'member') ORDER BY rolname;"
+        );
         return result.map((r: Record<string, unknown>) => r.rolname as string);
     }
 
@@ -823,6 +856,7 @@ searchString }
                 }
             }
         }
+        // SAFETY: Raw SQL result rows are typed as QueryResultRow[]; the query shape matches TableColumnInfo
         const typedColumns = columns as unknown as TableColumnInfo[];
 
         // 2. Fetch Foreign Keys
@@ -841,7 +875,8 @@ searchString }
                   AND ccu.table_schema = tc.table_schema
             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = ${safeName};
         `);
-        const foreignKeys = fkResult.rows as unknown as TableForeignKeyInfo[];
+        // SAFETY: Raw SQL result rows match TableForeignKeyInfo shape from the SELECT aliases
+        const foreignKeys = fkResult.rows as TableForeignKeyInfo[];
 
         // 3. Fetch Junction Tables (Many-to-Many)
         // A simple junction table is one that has foreign keys to our table and other tables
@@ -861,7 +896,8 @@ searchString }
               AND ccu1.table_name = ${safeName}
               AND ccu2.table_name != ${safeName};
         `);
-        const junctions = junctionsResult.rows as unknown as TableJunctionInfo[];
+        // SAFETY: Raw SQL result rows match TableJunctionInfo shape from the SELECT aliases
+        const junctions = junctionsResult.rows as TableJunctionInfo[];
 
         // 4. Fetch RLS Policies
         const policiesResult = await this.db.execute(drizzleSql`
@@ -874,7 +910,8 @@ searchString }
             FROM pg_policy
             WHERE polrelid = (SELECT oid FROM pg_class WHERE relname = ${safeName} AND relnamespace = 'public'::regnamespace);
         `);
-        const policies = policiesResult.rows as unknown as TablePolicyInfo[];
+        // SAFETY: Raw SQL result rows match TablePolicyInfo shape from the SELECT aliases
+        const policies = policiesResult.rows as TablePolicyInfo[];
 
         return {
             columns: typedColumns,
@@ -921,6 +958,22 @@ export class AuthenticatedPostgresBackendDriver implements DataDriver {
      */
     admin: DatabaseAdmin;
 
+    get restFetchService(): RestFetchService | undefined {
+        if (!this.delegate.restFetchService) return undefined;
+        return {
+            fetchCollectionForRest: async (collectionPath, options, include) => {
+                return this.withTransaction(async (delegate) => {
+                    return delegate.restFetchService.fetchCollectionForRest(collectionPath, options, include);
+                });
+            },
+            fetchEntityForRest: async (collectionPath, entityId, include, databaseId) => {
+                return this.withTransaction(async (delegate) => {
+                    return delegate.restFetchService.fetchEntityForRest(collectionPath, entityId, include, databaseId);
+                });
+            }
+        };
+    }
+
     private async withTransaction<T>(
         operation: (delegate: PostgresBackendDriver) => Promise<T>
     ): Promise<T> {