@rebasepro/server-postgresql 0.0.1-canary.dbf160a → 0.0.1-canary.e17585f

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

@@ -0,0 +1,6 @@
+import { DatabaseAdapter } from "@rebasepro/types";
+import type { PostgresDriverConfig } from "@rebasepro/server-core";
+/**
+ * Creates a Postgres database adapter for Rebase.
+ */
+export declare function createPostgresAdapter(pgConfig: PostgresDriverConfig): DatabaseAdapter;

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/PostgresBootstrapper.d.ts

@@ -2,11 +2,6 @@
  * PostgresBootstrapper
  *
  * Implements the `BackendBootstrapper` interface for PostgreSQL.
- * Encapsulates all Postgres-specific initialization logic that was previously
- * hardcoded inside `initializeRebaseBackend()`.
- *
- * Third-party drivers (MongoDB, MySQL, etc.) can implement their own
- * bootstrapper following this pattern and pass it to the coordinator.
  */
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { BackendBootstrapper } from "@rebasepro/types";

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

@@ -11,3 +11,4 @@ export * from "./websocket";
 export * from "./collections/PostgresCollectionRegistry";
 export * from "./services/BranchService";
 export * from "./PostgresBootstrapper";
+export * from "./PostgresAdapter";

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

@@ -1,11 +1,3 @@
-/**
- * Introspection logic — pure functions and the pipeline that transforms
- * raw PostgreSQL metadata into Rebase collection definition files.
- *
- * This module contains NO side-effects: no fs writes, no pg.Client creation,
- * no process.exit.  It is imported by introspect-db.ts (the CLI entry-point)
- * and consumed directly by tests.
- */
 export interface TableRow {
     table_name: string;
 }
@@ -57,6 +49,49 @@ 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;
@@ -66,7 +101,7 @@ export interface GeneratedFile {
  * 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[]>): string;
+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.
  */

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/server-postgresql/src/services/realtimeService.d.ts

@@ -152,6 +152,18 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
      * Returns ["posts", "posts/70"] for the example above
      */
     private getParentPaths;
+    /**
+     * Gracefully tear down all realtime resources.
+     *
+     * This MUST be called during process shutdown, **before** `pool.end()`.
+     * It ensures:
+     *  1. All debounced refetch timers are cancelled (prevents queries after pool closes).
+     *  2. All subscription state and callbacks are cleared.
+     *  3. The dedicated LISTEN client (outside the pool) is disconnected.
+     *  4. All WebSocket clients are removed (but not forcefully closed — the
+     *     HTTP server close will handle that).
+     */
+    destroy(): Promise<void>;
     /**
      * Enable cross-instance realtime broadcasting via Postgres LISTEN/NOTIFY.
      * Creates a dedicated pg.Client (outside the Drizzle pool) that stays

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

@@ -1,5 +1,6 @@
 import { RealtimeService } from "./services/realtimeService";
 import { PostgresBackendDriver } from "./PostgresBackendDriver";
+import { AuthAdapter } from "@rebasepro/types";
 import { Server } from "http";
 import { AuthConfig } from "@rebasepro/server-core";
-export declare function createPostgresWebSocket(server: Server, realtimeService: RealtimeService, driver: PostgresBackendDriver, authConfig?: AuthConfig): void;
+export declare function createPostgresWebSocket(server: Server, realtimeService: RealtimeService, driver: PostgresBackendDriver, authConfig?: AuthConfig, authAdapter?: AuthAdapter): void;

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.