@rebasepro/server-postgresql 0.0.1-canary.eae7889 → 0.1.0

package/dist/server-postgresql/src/PostgresBackendDriver.d.ts

@@ -3,7 +3,7 @@ import { BranchService } from "./services/BranchService";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { DrizzleClient } from "./interfaces";
-import { User } from "@rebasepro/types";
+import { User, RebaseClient } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DataDriver, DeleteEntityProps, Entity, EntityCollection, FetchCollectionProps, FetchEntityProps, ListenCollectionProps, ListenEntityProps, SaveEntityProps, RebaseData, TableMetadata, DatabaseAdmin } from "@rebasepro/types";
 import { HistoryService } from "./history/HistoryService";
@@ -19,6 +19,7 @@ export declare class PostgresBackendDriver implements DataDriver {
     branchService?: BranchService;
     user?: User;
     data: RebaseData;
+    client?: RebaseClient;
     /**
      * When true, realtime notifications are deferred until after the
      * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
@@ -37,6 +38,12 @@ export declare class PostgresBackendDriver implements DataDriver {
      * allowing test spies applied after construction to take effect.
      */
     get admin(): DatabaseAdmin;
+    /**
+     * REST-optimised fetch service (include-aware eager-loading).
+     * Delegates to the underlying EntityFetchService which already
+     * implements the matching method signatures.
+     */
+    get restFetchService(): import("./services").EntityFetchService;
     private resolveCollectionCallbacks;
     fetchCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order }: FetchCollectionProps<M>): Promise<Entity<M>[]>;
     listenCollection<M extends Record<string, unknown>>({ path, collection, filter, limit, offset, startAfter, orderBy, searchString, order, onUpdate, onError }: ListenCollectionProps<M>): () => void;

package/dist/server-postgresql/src/schema/introspect-db-inference.d.ts

@@ -0,0 +1,5 @@
+export interface InferenceResult {
+    propType?: string;
+    extra?: string;
+}
+export declare function inferPropertyFromData(columnName: string, pgDataType: string, currentPropType: string, sampleValues: unknown[], isPk: boolean): InferenceResult;

package/dist/server-postgresql/src/schema/introspect-db-logic.d.ts

@@ -0,0 +1,117 @@
+export interface TableRow {
+    table_name: string;
+}
+export interface TableColumn {
+    table_name: string;
+    column_name: string;
+    data_type: string;
+    udt_name: string;
+    is_nullable: string;
+    column_default: string | null;
+}
+export interface EnumValue {
+    enum_name: string;
+    enum_value: string;
+    sort_order: number;
+}
+export interface PrimaryKeyRow {
+    table_name: string;
+    column_name: string;
+}
+export interface ForeignKeyRow {
+    table_name: string;
+    column_name: string;
+    foreign_table_name: string;
+    foreign_column_name: string;
+}
+export interface TableMeta {
+    name: string;
+    columns: TableColumn[];
+    pks: string[];
+    fks: ForeignKeyRow[];
+}
+export declare function singularize(word: string): string;
+/**
+ * Convert a snake_case name to a human-readable Title Case label.
+ * e.g. "created_at" -> "Created At", "customer_id" -> "Customer Id"
+ */
+export declare function humanize(snakeName: string): string;
+/**
+ * Convert a snake_case table name to a camelCase + "Collection" variable name.
+ * e.g. "company_token" -> "companyTokenCollection"
+ */
+export declare function toCollectionVarName(tableName: string): string;
+export declare function getIconForTable(tableName: string): string;
+/**
+ * Map a PostgreSQL data type to a Rebase property type.
+ */
+export declare function mapPgType(dataType: string): string;
+export declare function buildEnumMap(enumValues: EnumValue[]): Map<string, string[]>;
+export declare function buildTablesMap(tables: TableRow[], columns: TableColumn[], pks: PrimaryKeyRow[], fks: ForeignKeyRow[]): Map<string, TableMeta>;
+export declare function identifyJoinTables(tablesMap: Map<string, TableMeta>): Set<string>;
+/**
+ * Property metadata used to compute display priority.
+ * Keeps computePropertyPriority free of any TableMeta coupling.
+ */
+export interface PropertyOrderingContext {
+    /** The resolved Rebase property type (e.g. "string", "number", "date", "relation"). */
+    propType: string;
+    /** Whether this column is a primary key. */
+    isPk: boolean;
+    /** Whether this column is an enum (USER-DEFINED with matching values). */
+    isEnum: boolean;
+    /** Whether this is a storage/file-upload field (detected from column name). */
+    isStorage: boolean;
+    /** The PostgreSQL data_type (e.g. "text", "character varying", "jsonb"). */
+    pgDataType: string;
+    /** The original column index in PostgreSQL (for stable tiebreaking). */
+    originalIndex: number;
+}
+/**
+ * Compute a numeric priority score for a property.
+ * Lower scores appear first in the generated `propertiesOrder` array.
+ *
+ * The system uses 14 tiers (0–139), with the original column index
+ * added as a fractional tiebreaker (originalIndex / 10000) to
+ * guarantee stable ordering within the same tier.
+ *
+ * Pure function — no side effects.
+ */
+export declare function computePropertyPriority(columnName: string, ctx: PropertyOrderingContext): number;
+/**
+ * Sort a `propertiesOrder` array using the priority heuristic.
+ * Returns a new sorted array; does not mutate the input.
+ *
+ * @param entries - Array of { key, columnName, propType, ... } objects
+ *                  carrying the information needed to compute priority.
+ */
+export interface PropertyOrderEntry {
+    /** The property key in the generated collection (may differ from columnName for relations). */
+    key: string;
+    /** The ordering context for this property. */
+    ctx: PropertyOrderingContext;
+}
+export declare function sortPropertiesOrder(entries: PropertyOrderEntry[]): string[];
+export interface GeneratedFile {
+    tableName: string;
+    fileName: string;
+    content: string;
+}
+/**
+ * Generate the full TypeScript file content for a single collection.
+ * Pure function — no I/O.
+ */
+export declare function generateCollectionFile(tableName: string, meta: TableMeta, allFks: ForeignKeyRow[], joinTables: Set<string>, tablesMap: Map<string, TableMeta>, enumMap: Map<string, string[]>, sampleData?: Record<string, unknown>[]): string;
+/**
+ * Generate the content for an index.ts file that re-exports all collections.
+ */
+export declare function generateIndexContent(fileNames: string[]): string;
+/**
+ * Merge new exports into existing index.ts content.
+ * Returns the merged content string.
+ */
+export declare function mergeIndexContent(existingContent: string, newFileNames: string[]): string;
+/**
+ * Safely extract the host portion of a database URL for logging.
+ */
+export declare function safeHostFromUrl(url: string): string;

package/dist/server-postgresql/src/schema/introspect-db.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server-postgresql/src/services/EntityPersistService.d.ts

@@ -33,6 +33,15 @@ export declare class EntityPersistService {
      * Translate raw PostgreSQL / Drizzle errors into user-friendly messages.
      */
     private toUserFriendlyError;
+    /**
+     * Walk the error cause chain and return the deepest meaningful message.
+     */
+    private extractCauseMessage;
+    /**
+     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
+     * keeping only the error description.
+     */
+    private stripSqlFromMessage;
     /**
      * Extract the underlying PostgreSQL error from a Drizzle wrapper.
      * Drizzle wraps PG errors in a `cause` property.

package/dist/types/src/controllers/auth.d.ts

@@ -80,8 +80,14 @@ export type AuthController<USER extends User = User, ExtraData = unknown> = {
 export interface AuthControllerExtended<USER extends User = User, ExtraData = unknown> extends AuthController<USER, ExtraData> {
     /** Login with email and password */
     emailPasswordLogin?(email: string, password: string): Promise<void>;
-    /** Login with a Google ID token or trigger Google popup */
-    googleLogin?(idToken: string): Promise<void>;
+    /** Login with a Google token or authorization code */
+    googleLogin?: {
+        (token: string, tokenType?: "idToken" | "accessToken"): Promise<void>;
+        (payload: {
+            code: string;
+            redirectUri: string;
+        }): Promise<void>;
+    };
     /** Register a new user */
     register?(email: string, password: string, displayName?: string): Promise<void>;
     /** Skip login (for anonymous access if enabled) */

package/dist/types/src/controllers/client.d.ts

@@ -167,4 +167,17 @@ export interface RebaseClient<DB = unknown> {
     email?: EmailService;
     /** Admin API for user and role management */
     admin?: AdminAPI;
+    /**
+     * The base HTTP URL of the backend server.
+     * Exposed by the SDK client (`@rebasepro/client`) and used to auto-derive
+     * the `ApiConfigProvider` URL.
+     */
+    baseUrl?: string;
+    /**
+     * WebSocket client for realtime subscriptions and admin capabilities.
+     * Exposed by the SDK client (`@rebasepro/client`). The shape is intentionally
+     * left as `unknown` in the base interface — callers should narrow via feature
+     * detection (e.g. `typeof ws.executeSql === "function"`).
+     */
+    ws?: unknown;
 }

package/dist/types/src/controllers/collection_registry.d.ts

@@ -36,7 +36,8 @@ export type CollectionRegistryController<DB = Record<string, unknown>, EC extend
      * Retrieve all the related parent collection ids for a given path
      * @param path
      */
-    getParentCollectionIds: (path: string) => string[];
+    getParentCollectionSlugs: (path: string) => string[];
+    getParentEntityIds: (path: string) => string[];
     /**
      * Resolve paths from a list of ids
      * @param ids

package/dist/types/src/controllers/data_driver.d.ts

@@ -144,12 +144,19 @@ export interface DataDriver {
         path: string;
         databaseId?: string;
         collection: EntityCollection;
-        parentCollectionIds?: string[];
+        parentCollectionSlugs?: string[];
+        parentEntityIds?: string[];
     }) => Promise<boolean>;
     /**
      * Flag to indicate if the driver has requested the initialization of the text search index
      */
     needsInitTextSearch?: boolean;
+    /**
+     * Optional REST-optimised fetch service. When present, the REST API
+     * generator uses these methods instead of the generic `fetchEntity` /
+     * `fetchCollection` pipeline, enabling include-aware eager-loading.
+     */
+    restFetchService?: RestFetchService;
     /**
      * Return the admin capabilities of this driver.
      * @see SQLAdmin
@@ -158,3 +165,31 @@ export interface DataDriver {
      */
     admin?: import("../types/backend").DatabaseAdmin;
 }
+/**
+ * REST-optimised fetch service exposed by drivers that support
+ * eager-loading of relations via `include`.
+ *
+ * The methods return flattened rows (`{ id, ...columns }`) rather
+ * than the `Entity<M>` wrapper used by the generic DataDriver API.
+ *
+ * @group DataDriver
+ */
+export interface RestFetchService {
+    /**
+     * Fetch a collection of flattened entities with optional relation includes.
+     */
+    fetchCollectionForRest(collectionPath: string, options?: {
+        filter?: FilterValues<string>;
+        orderBy?: string;
+        order?: "desc" | "asc";
+        limit?: number;
+        offset?: number;
+        startAfter?: Record<string, unknown>;
+        searchString?: string;
+        databaseId?: string;
+    }, include?: string[]): Promise<Record<string, unknown>[]>;
+    /**
+     * Fetch a single flattened entity with optional relation includes.
+     */
+    fetchEntityForRest(collectionPath: string, entityId: string | number, include?: string[], databaseId?: string): Promise<Record<string, unknown> | null>;
+}

package/dist/types/src/controllers/navigation.d.ts

@@ -144,17 +144,18 @@ export interface AppView {
      * It will still be accessible if you reach the specified path
      */
     hideFromNavigation?: boolean;
+    /**
+     * Navigation group for this view.
+     * Views sharing the same group name will be visually grouped
+     * together in the drawer and home page. If not set, the view
+     * falls into the default "Views" group.
+     */
+    group?: string;
     /**
      * Component to be rendered. This can be any React component, and can use
      * any of the provided hooks
      */
     view: React.ReactNode;
-    /**
-     * Optional field used to group top level navigation entries under a
-     * navigation view.
-     * This prop is ignored for admin views.
-     */
-    group?: string;
     /**
      * If true, a wildcard route (slug/*) is automatically registered
      * alongside the base route, enabling nested navigation within this view.
@@ -193,6 +194,17 @@ export interface NavigationGroupMapping {
      * List of collection ids or view paths that belong to this group.
      */
     entries: string[];
+    /**
+     * Configure which groups start collapsed.
+     * Set to `true` to collapse in both drawer and home page,
+     * or use an object to control each independently.
+     *
+     * @defaultValue false (expanded)
+     */
+    collapsedByDefault?: boolean | {
+        drawer?: boolean;
+        home?: boolean;
+    };
 }
 export interface NavigationEntry {
     id: string;

package/dist/types/src/controllers/registry.d.ts

@@ -3,7 +3,7 @@ import type { EntityCollection } from "../types/collections";
 import type { EntityCollectionsBuilder } from "../types/builders";
 import type { EntityCustomView } from "../types/entity_views";
 import type { EntityAction } from "../types/entity_actions";
-import type { AppView } from "./navigation";
+import type { AppView, NavigationGroupMapping } from "./navigation";
 /**
  * Options to enable the built-in collection editor.
  * When provided to `<RebaseCMS>`, the editor is auto-wired as a native feature.
@@ -25,6 +25,14 @@ export interface RebaseCMSConfig<EC extends EntityCollection = any> {
     entityViews?: EntityCustomView<any>[];
     entityActions?: EntityAction[];
     plugins?: any[];
+    /**
+     * Centralized configuration for how collections and views are grouped
+     * in the navigation sidebar and home page.
+     * Each mapping defines a named group and the collection/view slugs
+     * that belong to it. The array order determines group display order.
+     * Entry order within each group determines card order.
+     */
+    navigationGroupMappings?: NavigationGroupMapping[];
     /**
      * Enable the built-in visual collection/schema editor.
      * Pass `true` for zero-config, or an options object for fine-grained control.

package/dist/types/src/controllers/side_entity_controller.d.ts

@@ -62,6 +62,13 @@ export interface EntitySidePanelProps<M extends Record<string, unknown> = Record
      * Allow the user to open the entity fullscreen
      */
     allowFullScreen?: boolean;
+    /**
+     * Pre-populate the form with these values when creating a new entity.
+     * Only applied when `entityId` is not set (i.e. the form is in "new" mode).
+     * Useful for actions that fetch data from an external source (e.g. a URL)
+     * and want to pre-fill the document before the user saves.
+     */
+    defaultValues?: Partial<M>;
 }
 /**
  * Controller to open the side dialog displaying entity forms

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

@@ -3,6 +3,7 @@ import type { AuthController } from "./controllers/auth";
 import type { StorageSource } from "./controllers/storage";
 import type { UserConfigurationPersistence } from "./controllers/local_config_persistence";
 import type { DatabaseAdmin } from "./types/backend";
+import type { RebaseClient } from "./controllers/client";
 import type { RebaseData } from "./controllers/data";
 import type { User } from "./users";
 import type { UserManagementDelegate } from "./types/user_management_delegate";
@@ -12,6 +13,22 @@ import type { UserManagementDelegate } from "./types/user_management_delegate";
  * @group Hooks and utilities
  */
 export type RebaseCallContext<USER extends User = User> = {
+    /**
+     * The Rebase client instance.
+     * Available in all entity callbacks (beforeSave, afterSave, afterRead,
+     * beforeDelete, afterDelete) and in CollectionActionsProps via context.
+     * Use it to call backend functions, access data, storage, etc.
+     *
+     * @example
+     * // In a beforeSave callback:
+     * const result = await context.client.functions.invoke('my-function', { ... });
+     *
+     * @example
+     * // In a CollectionAction component:
+     * const { client } = props.context;
+     * const result = await client.functions.invoke('extract-job', { url });
+     */
+    client: RebaseClient<any>;
     /**
      * Unified data access — `context.data.products.create(...)`.
      * Access any collection as a dynamic property.

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

@@ -0,0 +1,187 @@
+import type { AdminUser, AdminRole } from "../controllers/client";
+/**
+ * Context passed to every backend hook.
+ * Provides information about the request that triggered the hook.
+ * @group Backend Hooks
+ */
+export interface BackendHookContext {
+    /** The currently authenticated user making the request (if any) */
+    requestUser?: {
+        userId: string;
+        roles: string[];
+    };
+    /** The HTTP method of the request */
+    method: "GET" | "POST" | "PUT" | "DELETE";
+}
+/**
+ * Hooks for intercepting Admin User data at the API boundary.
+ *
+ * These hooks run on the server after the database operation completes
+ * but before the response is sent to the client.
+ *
+ * @group Backend Hooks
+ */
+export interface UserHooks {
+    /**
+     * Transform a user record after it's read from the database,
+     * before it's returned to the client.
+     *
+     * Return the modified user, or `null` to filter it out entirely
+     * (the user won't appear in listings or individual fetches).
+     */
+    afterRead?(user: AdminUser, context: BackendHookContext): AdminUser | null | Promise<AdminUser | null>;
+    /**
+     * Transform user data before it's written to the database.
+     * Runs on POST (create) and PUT (update).
+     *
+     * Return the (possibly modified) data to proceed with the save.
+     * Throw an error to abort the operation.
+     */
+    beforeSave?(data: {
+        email?: string;
+        displayName?: string;
+        roles?: string[];
+    }, context: BackendHookContext): {
+        email?: string;
+        displayName?: string;
+        roles?: string[];
+    } | Promise<{
+        email?: string;
+        displayName?: string;
+        roles?: string[];
+    }>;
+    /**
+     * Called after a user is successfully created or updated.
+     * Useful for side-effects like sending notifications.
+     */
+    afterSave?(user: AdminUser, context: BackendHookContext): void | Promise<void>;
+    /**
+     * Called before a user is deleted. Throw to prevent deletion.
+     */
+    beforeDelete?(userId: string, context: BackendHookContext): void | Promise<void>;
+    /**
+     * Called after a user is successfully deleted.
+     */
+    afterDelete?(userId: string, context: BackendHookContext): void | Promise<void>;
+}
+/**
+ * Hooks for intercepting Admin Role data at the API boundary.
+ * @group Backend Hooks
+ */
+export interface RoleHooks {
+    /**
+     * Transform a role record after it's read from the database,
+     * before it's returned to the client.
+     *
+     * Return the modified role, or `null` to filter it out entirely.
+     */
+    afterRead?(role: AdminRole, context: BackendHookContext): AdminRole | null | Promise<AdminRole | null>;
+}
+/**
+ * Hooks for intercepting collection entity data at the REST API boundary.
+ *
+ * These run **after** per-collection `EntityCallbacks` (which execute inside
+ * the DataDriver) and provide a single cross-cutting interception point for
+ * ALL collections flowing through the REST API.
+ *
+ * Every callback receives the collection `slug` so you can target specific
+ * collections or apply logic globally.
+ *
+ * @group Backend Hooks
+ */
+export interface DataHooks {
+    /**
+     * Transform an entity after it's read from the database,
+     * before it's returned to the client.
+     *
+     * Runs for both list (GET /:slug) and single (GET /:slug/:id) fetches.
+     * Return the modified entity, or `null` to filter it out.
+     *
+     * @param slug - The collection slug (e.g. "orders", "products")
+     * @param entity - The flattened entity object (id + values merged)
+     * @param context - Request context (authenticated user, HTTP method)
+     */
+    afterRead?(slug: string, entity: Record<string, unknown>, context: BackendHookContext): Record<string, unknown> | null | Promise<Record<string, unknown> | null>;
+    /**
+     * Transform entity values before they are written to the database.
+     * Runs on POST (create) and PUT (update).
+     *
+     * Return the (possibly modified) values. Throw to abort the save.
+     *
+     * @param slug - The collection slug
+     * @param values - The raw request body values
+     * @param entityId - The entity ID (only present on updates)
+     * @param context - Request context
+     */
+    beforeSave?(slug: string, values: Record<string, unknown>, entityId: string | undefined, context: BackendHookContext): Record<string, unknown> | Promise<Record<string, unknown>>;
+    /**
+     * Called after an entity is successfully saved (created or updated).
+     * Useful for side-effects like syncing to external systems.
+     *
+     * @param slug - The collection slug
+     * @param entity - The saved entity (flattened)
+     * @param context - Request context
+     */
+    afterSave?(slug: string, entity: Record<string, unknown>, context: BackendHookContext): void | Promise<void>;
+    /**
+     * Called before an entity is deleted. Throw to prevent deletion.
+     *
+     * @param slug - The collection slug
+     * @param entityId - The entity ID being deleted
+     * @param context - Request context
+     */
+    beforeDelete?(slug: string, entityId: string, context: BackendHookContext): void | Promise<void>;
+    /**
+     * Called after an entity is successfully deleted.
+     *
+     * @param slug - The collection slug
+     * @param entityId - The deleted entity ID
+     * @param context - Request context
+     */
+    afterDelete?(slug: string, entityId: string, context: BackendHookContext): void | Promise<void>;
+}
+/**
+ * Backend-level hooks for intercepting data at the API boundary.
+ *
+ * These hooks run server-side after database operations complete and before
+ * API responses are sent.
+ *
+ * - `users` / `roles` — intercept admin user and role management endpoints
+ * - `data` — intercept ALL collection entity data flowing through the REST API
+ *
+ * `data` hooks complement per-collection `EntityCallbacks`. Entity callbacks
+ * run inside the DataDriver (close to the DB); data hooks run at the HTTP
+ * boundary (close to the client). Use data hooks for cross-cutting concerns
+ * like audit logging, response enrichment, or field masking.
+ *
+ * @example
+ * ```typescript
+ * const hooks: BackendHooks = {
+ *     data: {
+ *         afterRead(slug, entity, ctx) {
+ *             // Mask PII for non-admin users across all collections
+ *             if (!ctx.requestUser?.roles.includes("admin") && entity.email) {
+ *                 return { ...entity, email: "***" };
+ *             }
+ *             return entity;
+ *         }
+ *     },
+ *     users: {
+ *         afterRead(user, ctx) {
+ *             if (user.email.endsWith("@system.internal")) return null;
+ *             return user;
+ *         }
+ *     }
+ * };
+ * ```
+ *
+ * @group Backend Hooks
+ */
+export interface BackendHooks {
+    /** Hooks for intercepting user management data */
+    users?: UserHooks;
+    /** Hooks for intercepting role management data */
+    roles?: RoleHooks;
+    /** Hooks for intercepting ALL collection entity data via the REST API */
+    data?: DataHooks;
+}