@rebasepro/server-postgresql 0.0.1-canary.09e5ec5

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

@@ -0,0 +1,100 @@
+import { EntityService } from "./services/entityService";
+import { BranchService } from "./services/BranchService";
+import { RealtimeService } from "./services/realtimeService";
+import { DatabasePoolManager } from "./databasePoolManager";
+import { DrizzleClient } from "./interfaces";
+import { User } 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";
+export declare class PostgresBackendDriver implements DataDriver {
+    db: DrizzleClient;
+    readonly registry: PostgresCollectionRegistry;
+    poolManager?: DatabasePoolManager | undefined;
+    key: string;
+    initialised: boolean;
+    entityService: EntityService;
+    realtimeService: RealtimeService;
+    historyService?: HistoryService;
+    branchService?: BranchService;
+    user?: User;
+    data: RebaseData;
+    /**
+     * When true, realtime notifications are deferred until after the
+     * wrapping transaction commits.  Set by `withAuth` → `withTransaction`.
+     */
+    _deferNotifications: boolean;
+    _pendingNotifications: Array<{
+        path: string;
+        entityId: string;
+        entity: Entity | null;
+        databaseId?: string;
+    }>;
+    constructor(db: DrizzleClient, realtimeService: RealtimeService, registry: PostgresCollectionRegistry, user?: User, poolManager?: DatabasePoolManager | undefined, historyService?: HistoryService);
+    /**
+     * Typed admin capabilities (SQLAdmin + SchemaAdmin + BranchAdmin).
+     * Implemented as a getter so method references are resolved at call-time,
+     * allowing test spies applied after construction to take effect.
+     */
+    get admin(): DatabaseAdmin;
+    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;
+    fetchEntity<M extends Record<string, unknown>>({ path, entityId, databaseId, collection }: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>({ path, entityId, collection, onUpdate, onError }: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>({ path, entityId, values, collection, status }: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>({ entity, collection }: DeleteEntityProps<M>): Promise<void>;
+    checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
+    countEntities<M extends Record<string, unknown>>({ path, collection, filter, searchString }: FetchCollectionProps<M>): Promise<number>;
+    private getTargetDb;
+    executeSql(sqlText: string, options?: {
+        database?: string;
+        role?: string;
+    }): Promise<Record<string, unknown>[]>;
+    fetchAvailableDatabases(): Promise<string[]>;
+    fetchAvailableRoles(): Promise<string[]>;
+    fetchCurrentDatabase(): Promise<string | undefined>;
+    /**
+     * Fetch public tables that are not yet mapped to a collection.
+     * Excludes internal tables (_rebase_*, _auth_*, auth tables, etc.)
+     * and junction/connection tables used for many-to-many relations.
+     */
+    fetchUnmappedTables(mappedPaths?: string[]): Promise<string[]>;
+    /**
+     * Fetch metadata for a given table from information_schema (columns, policies, constraints).
+     */
+    fetchTableMetadata(tableName: string): Promise<TableMetadata>;
+    private generateSubscriptionId;
+    /**
+     * Create a new delegate instance with authenticated context.
+     * Starts a transaction and sets the current_user_id and current_user_roles
+     * configuration parameters for PostgreSQL Row Level Security.
+     */
+    withAuth(user: User): Promise<DataDriver>;
+}
+export declare class AuthenticatedPostgresBackendDriver implements DataDriver {
+    delegate: PostgresBackendDriver;
+    key: string;
+    initialised: boolean;
+    user: User;
+    data: RebaseData;
+    constructor(delegate: PostgresBackendDriver, user: User);
+    /**
+     * Typed admin capabilities — delegates to the base driver.
+     */
+    admin: DatabaseAdmin;
+    private withTransaction;
+    fetchCollection<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<Entity<M>[]>;
+    /**
+     * Injects the authenticated user's context into the most recently
+     * registered realtime subscription so RLS-aware polling can apply.
+     */
+    private injectAuthContext;
+    listenCollection<M extends Record<string, unknown>>(props: ListenCollectionProps<M>): () => void;
+    fetchEntity<M extends Record<string, unknown>>(props: FetchEntityProps<M>): Promise<Entity<M> | undefined>;
+    listenEntity<M extends Record<string, unknown>>(props: ListenEntityProps<M>): () => void;
+    saveEntity<M extends Record<string, unknown>>(props: SaveEntityProps<M>): Promise<Entity<M>>;
+    deleteEntity<M extends Record<string, unknown>>(props: DeleteEntityProps<M>): Promise<void>;
+    checkUniqueField(path: string, name: string, value: unknown, entityId?: string, collection?: EntityCollection): Promise<boolean>;
+    countEntities<M extends Record<string, unknown>>(props: FetchCollectionProps<M>): Promise<number>;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * 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";
+import { PostgresBackendDriver } from "./PostgresBackendDriver";
+import { RealtimeService } from "./services/realtimeService";
+import { DatabasePoolManager } from "./databasePoolManager";
+import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
+import type { PostgresDriverConfig } from "@rebasepro/server-core";
+/**
+ * Opaque internals bag that PostgresBootstrapper stores during `initializeDriver()`
+ * and re-uses in subsequent lifecycle hooks.
+ */
+export interface PostgresDriverInternals {
+    db: NodePgDatabase<any>;
+    registry: PostgresCollectionRegistry;
+    realtimeService: RealtimeService;
+    driver: PostgresBackendDriver;
+    poolManager?: DatabasePoolManager;
+}
+/**
+ * Default PostgreSQL bootstrapper.
+ *
+ * Use it to register Postgres with `initializeRebaseBackend()`:
+ * ```typescript
+ * initializeRebaseBackend({
+ *   ...config,
+ *   bootstrappers: [postgresBootstrapper()]
+ * });
+ * ```
+ */
+export declare function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): BackendBootstrapper;

package/dist/server-postgresql/src/auth/ensure-tables.d.ts

@@ -0,0 +1,6 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+/**
+ * Auto-create auth tables if they don't exist
+ * This runs on startup to ensure the database is ready for auth
+ */
+export declare function ensureAuthTablesExist(db: NodePgDatabase): Promise<void>;

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

@@ -0,0 +1,192 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { User, NewUser } from "../schema/auth-schema";
+import { UserRepository, RoleRepository, TokenRepository, AuthRepository, UserData, CreateUserData, RoleData, CreateRoleData, RefreshTokenInfo, PasswordResetTokenInfo, UserIdentityData, ListUsersOptions, PaginatedUsersResult, RoleData as Role } from "@rebasepro/server-core";
+export type { Role };
+/**
+ * PostgreSQL implementation of UserRepository.
+ * Handles all user-related database operations using Drizzle ORM.
+ */
+export declare class UserService implements UserRepository {
+    private db;
+    constructor(db: NodePgDatabase);
+    createUser(data: NewUser): Promise<User>;
+    getUserById(id: string): Promise<User | null>;
+    getUserByEmail(email: string): Promise<User | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<User | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
+    updateUser(id: string, data: Partial<Omit<NewUser, "id">>): Promise<User | null>;
+    deleteUser(id: string): Promise<void>;
+    listUsers(): Promise<User[]>;
+    listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult>;
+    /**
+     * Update user's password hash
+     */
+    updatePassword(id: string, passwordHash: string): Promise<void>;
+    /**
+     * Set email verification status
+     */
+    setEmailVerified(id: string, verified: boolean): Promise<void>;
+    /**
+     * Set email verification token
+     */
+    setVerificationToken(id: string, token: string | null): Promise<void>;
+    /**
+     * Find user by email verification token
+     */
+    getUserByVerificationToken(token: string): Promise<User | null>;
+    /**
+     * Get roles for a user from database
+     */
+    getUserRoles(userId: string): Promise<Role[]>;
+    /**
+     * Get role IDs for a user
+     */
+    getUserRoleIds(userId: string): Promise<string[]>;
+    /**
+     * Set roles for a user
+     */
+    setUserRoles(userId: string, roleIds: string[]): Promise<void>;
+    /**
+     * Assign a specific role to new user
+     */
+    assignDefaultRole(userId: string, roleId: string): Promise<void>;
+    /**
+     * Get user with their roles
+     */
+    getUserWithRoles(userId: string): Promise<{
+        user: User;
+        roles: Role[];
+    } | null>;
+}
+/**
+ * PostgreSQL implementation of RoleRepository.
+ * Handles all role-related database operations using Drizzle ORM.
+ */
+export declare class RoleService implements RoleRepository {
+    private db;
+    constructor(db: NodePgDatabase);
+    getRoleById(id: string): Promise<Role | null>;
+    listRoles(): Promise<Role[]>;
+    createRole(data: Omit<Role, "isAdmin" | "collectionPermissions"> & {
+        isAdmin?: boolean;
+        collectionPermissions?: Role["collectionPermissions"];
+    }): Promise<Role>;
+    updateRole(id: string, data: Partial<Omit<Role, "id">>): Promise<Role | null>;
+    deleteRole(id: string): Promise<void>;
+}
+export declare class RefreshTokenService {
+    private db;
+    constructor(db: NodePgDatabase);
+    createToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
+    findByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
+    deleteByHash(tokenHash: string): Promise<void>;
+    deleteAllForUser(userId: string): Promise<void>;
+    listForUser(userId: string): Promise<RefreshTokenInfo[]>;
+    deleteById(id: string, userId: string): Promise<void>;
+}
+/**
+ * Password reset token service
+ */
+export declare class PasswordResetTokenService {
+    private db;
+    constructor(db: NodePgDatabase);
+    /**
+     * Create a password reset token
+     */
+    createToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
+    /**
+     * Find a valid (not expired, not used) token by hash
+     */
+    findValidByHash(tokenHash: string): Promise<{
+        userId: string;
+        expiresAt: Date;
+    } | null>;
+    /**
+     * Mark token as used
+     */
+    markAsUsed(tokenHash: string): Promise<void>;
+    /**
+     * Delete all tokens for a user
+     */
+    deleteAllForUser(userId: string): Promise<void>;
+    /**
+     * Clean up expired tokens
+     */
+    deleteExpired(): Promise<void>;
+}
+/**
+ * PostgreSQL implementation of TokenRepository.
+ * Combines refresh token and password reset token operations.
+ */
+export declare class PostgresTokenRepository implements TokenRepository {
+    private db;
+    private refreshTokenService;
+    private passwordResetTokenService;
+    constructor(db: NodePgDatabase);
+    createRefreshToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
+    findRefreshTokenByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
+    deleteRefreshToken(tokenHash: string): Promise<void>;
+    deleteAllRefreshTokensForUser(userId: string): Promise<void>;
+    listRefreshTokensForUser(userId: string): Promise<RefreshTokenInfo[]>;
+    deleteRefreshTokenById(id: string, userId: string): Promise<void>;
+    createPasswordResetToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
+    findValidPasswordResetToken(tokenHash: string): Promise<PasswordResetTokenInfo | null>;
+    markPasswordResetTokenUsed(tokenHash: string): Promise<void>;
+    deleteAllPasswordResetTokensForUser(userId: string): Promise<void>;
+    deleteExpiredTokens(): Promise<void>;
+}
+/**
+ * PostgreSQL implementation of AuthRepository.
+ * Combines user, role, and token repository operations.
+ * This provides a convenient single-class interface for all auth operations.
+ */
+export declare class PostgresAuthRepository implements AuthRepository {
+    private db;
+    private userService;
+    private roleService;
+    private tokenRepository;
+    constructor(db: NodePgDatabase);
+    createUser(data: CreateUserData): Promise<UserData>;
+    getUserById(id: string): Promise<UserData | null>;
+    getUserByEmail(email: string): Promise<UserData | null>;
+    getUserByIdentity(provider: string, providerId: string): Promise<UserData | null>;
+    getUserIdentities(userId: string): Promise<UserIdentityData[]>;
+    linkUserIdentity(userId: string, provider: string, providerId: string, profileData?: Record<string, unknown>): Promise<void>;
+    updateUser(id: string, data: Partial<Omit<CreateUserData, "id">>): Promise<UserData | null>;
+    deleteUser(id: string): Promise<void>;
+    listUsers(): Promise<UserData[]>;
+    listUsersPaginated(options?: ListUsersOptions): Promise<PaginatedUsersResult>;
+    updatePassword(id: string, passwordHash: string): Promise<void>;
+    setEmailVerified(id: string, verified: boolean): Promise<void>;
+    setVerificationToken(id: string, token: string | null): Promise<void>;
+    getUserByVerificationToken(token: string): Promise<UserData | null>;
+    getUserRoles(userId: string): Promise<RoleData[]>;
+    getUserRoleIds(userId: string): Promise<string[]>;
+    setUserRoles(userId: string, roleIds: string[]): Promise<void>;
+    assignDefaultRole(userId: string, roleId: string): Promise<void>;
+    getUserWithRoles(userId: string): Promise<{
+        user: UserData;
+        roles: RoleData[];
+    } | null>;
+    getRoleById(id: string): Promise<RoleData | null>;
+    listRoles(): Promise<RoleData[]>;
+    createRole(data: CreateRoleData): Promise<RoleData>;
+    updateRole(id: string, data: Partial<Omit<RoleData, "id">>): Promise<RoleData | null>;
+    deleteRole(id: string): Promise<void>;
+    createRefreshToken(userId: string, tokenHash: string, expiresAt: Date, userAgent?: string, ipAddress?: string): Promise<void>;
+    findRefreshTokenByHash(tokenHash: string): Promise<RefreshTokenInfo | null>;
+    deleteRefreshToken(tokenHash: string): Promise<void>;
+    deleteAllRefreshTokensForUser(userId: string): Promise<void>;
+    listRefreshTokensForUser(userId: string): Promise<RefreshTokenInfo[]>;
+    deleteRefreshTokenById(id: string, userId: string): Promise<void>;
+    createPasswordResetToken(userId: string, tokenHash: string, expiresAt: Date): Promise<void>;
+    findValidPasswordResetToken(tokenHash: string): Promise<PasswordResetTokenInfo | null>;
+    markPasswordResetTokenUsed(tokenHash: string): Promise<void>;
+    deleteAllPasswordResetTokensForUser(userId: string): Promise<void>;
+    deleteExpiredTokens(): Promise<void>;
+}
+/** PostgreSQL user repository implementation */
+export type PostgresUserRepository = UserService;
+/** PostgreSQL role repository implementation */
+export type PostgresRoleRepository = RoleService;

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

@@ -0,0 +1 @@
+export declare function runPluginCommand(args: string[]): Promise<void>;

package/dist/server-postgresql/src/collections/PostgresCollectionRegistry.d.ts

@@ -0,0 +1,43 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { type EntityCollection } from "@rebasepro/types";
+import { PgEnum, PgTable } from "drizzle-orm/pg-core";
+import { Relations } from "drizzle-orm";
+import { CollectionRegistryInterface } from "../interfaces";
+/**
+ * PostgreSQL-specific collection registry.
+ * Extends the base CollectionRegistry with support for Drizzle ORM tables, enums, and relations.
+ *
+ * Satisfies CollectionRegistryInterface through inheritance from CollectionRegistry.
+ */
+export declare class PostgresCollectionRegistry extends CollectionRegistry implements CollectionRegistryInterface {
+    private tables;
+    private enums;
+    private relations;
+    registerTable(table: PgTable, tableName: string): void;
+    getTable(tableName: string): PgTable | undefined;
+    /**
+     * Checks if a specific collection has a registered table
+     */
+    hasTableForCollection(tableName: string): boolean;
+    /**
+     * Finds collections assigned to a specific driver that do not have a registered table.
+     */
+    getCollectionsWithoutTables(driverId?: string): EntityCollection[];
+    registerEnums(enums: Record<string, PgEnum<[string, ...string[]]>>): void;
+    registerRelations(relations: Record<string, Relations>): void;
+    getEnum(name: string): PgEnum<[string, ...string[]]> | undefined;
+    getRelation(name: string): Relations | undefined;
+    getAllEnums(): Record<string, PgEnum<[string, ...string[]]>>;
+    getAllRelations(): Record<string, Relations>;
+    /**
+     * Get the merged schema object (tables + relations) for use with Drizzle's
+     * relational query API (`db.query`).
+     */
+    getMergedSchema(): Record<string, unknown>;
+    /**
+     * Get the available Drizzle relation keys for a given collection path.
+     * Maps from the collection's relation property names to the Drizzle relation names
+     * defined in the schema.
+     */
+    getRelationKeysForCollection(collectionPath: string): string[];
+}

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

@@ -0,0 +1,40 @@
+import { Pool } from "pg";
+/**
+ * Configuration for the Postgres connection pool.
+ *
+ * Sensible defaults are provided for production Cloud Run / single-instance
+ * deployments. Override via environment variables or explicit config.
+ */
+export interface PostgresPoolConfig {
+    /** Maximum number of connections in the pool (default: 20) */
+    max?: number;
+    /** Close idle connections after this many ms (default: 30 000) */
+    idleTimeoutMillis?: number;
+    /** Abort connection attempts after this many ms (default: 10 000) */
+    connectionTimeoutMillis?: number;
+    /** Per-query timeout in ms (default: 30 000) */
+    queryTimeout?: number;
+    /** Per-statement timeout in ms (default: 30 000) */
+    statementTimeout?: number;
+    /** Enable TCP keep-alive (default: true) */
+    keepAlive?: boolean;
+}
+/**
+ * Create a Drizzle-backed Postgres connection with a production-grade
+ * connection pool.
+ *
+ * @param connectionString  Postgres connection URL
+ * @param schema            Optional Drizzle schema for the relational API
+ * @param poolConfig        Optional pool tuning (merged over defaults)
+ *
+ * @returns `{ db, pool, connectionString }` — the `pool` is exposed so
+ *          callers can register shutdown hooks (`pool.end()`) or monitor
+ *          pool metrics.
+ */
+export declare function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+        $client: Pool;
+    };
+    pool: Pool;
+    connectionString: string;
+};

package/dist/server-postgresql/src/data-transformer.d.ts

@@ -0,0 +1,58 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { EntityCollection, Properties, Property, Relation } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
+/**
+ * Data transformation utilities for converting between frontend and database formats.
+ */
+/**
+ * Typed result from `serializeDataToServer`.
+ * Replaces the hidden `__inverseRelationUpdates` / `__joinPathRelationUpdates`
+ * dunder-property mutation pattern with explicit, typed state management.
+ */
+export interface SerializedEntityData {
+    /** Scalar column values ready for INSERT/UPDATE. */
+    scalarData: Record<string, unknown>;
+    /** Inverse relation updates that must be applied to target tables. */
+    inverseRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newValue: unknown;
+        currentEntityId?: string | number;
+    }>;
+    /** JoinPath relation updates that require multi-hop writes. */
+    joinPathRelationUpdates: Array<{
+        relationKey: string;
+        relation: Relation;
+        newTargetId: string | number | null;
+    }>;
+}
+/**
+ * Helper function to sanitize and convert dates to ISO strings
+ */
+export declare function sanitizeAndConvertDates(obj: unknown): unknown;
+/**
+ * Transform relations for database storage (relation objects to IDs)
+ */
+export declare function serializeDataToServer<M extends Record<string, unknown>>(entity: M, properties: Properties, collection?: EntityCollection, registry?: PostgresCollectionRegistry): SerializedEntityData;
+/**
+ * Serialize a single property value for database storage
+ */
+export declare function serializePropertyToServer(value: unknown, property: Property): unknown;
+/**
+ * Transform IDs back to relation objects for frontend
+ */
+export declare function parseDataFromServer<M extends Record<string, unknown>>(data: M, collection: EntityCollection, db?: NodePgDatabase<Record<string, unknown>>, registry?: PostgresCollectionRegistry): Promise<M>;
+/**
+ * Parse a single property value from database format to frontend format
+ */
+export declare function parsePropertyFromServer(value: unknown, property: Property, collection: EntityCollection, propertyKey?: string): unknown;
+/**
+ * Lightweight value normalization for db.query results.
+ * Only handles type coercion (dates, numbers, NaN) and property filtering.
+ * Does NOT query the database for relations — those are already resolved
+ * by Drizzle's relational query API.
+ *
+ * Use this instead of `parseDataFromServer` when processing results from
+ * `db.query.findFirst/findMany` which return pre-hydrated relation data.
+ */
+export declare function normalizeDbValues<M extends Record<string, unknown>>(data: M, collection: EntityCollection): M;

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

@@ -0,0 +1,20 @@
+import { Pool } from "pg";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+export declare class DatabasePoolManager {
+    private pools;
+    private drizzleInstances;
+    readonly defaultDatabaseName: string;
+    private readonly rootConnectionString;
+    constructor(adminConnectionString: string);
+    getDrizzle(databaseName: string): NodePgDatabase<any>;
+    getPool(databaseName: string): Pool;
+    /**
+     * Disconnect and remove the pool for a specific database.
+     * Required before `CREATE DATABASE ... TEMPLATE` or `DROP DATABASE`,
+     * which need exclusive access to the target database.
+     */
+    disconnectDatabase(databaseName: string): Promise<void>;
+    /** Check if a pool exists for a given database name. */
+    hasPool(databaseName: string): boolean;
+    shutdown(): Promise<void>;
+}

package/dist/server-postgresql/src/history/HistoryService.d.ts

@@ -0,0 +1,71 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+export interface HistoryEntry {
+    id: string;
+    table_name: string;
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    updated_at: string;
+}
+export interface RecordHistoryParams {
+    tableName: string;
+    entityId: string;
+    action: "create" | "update" | "delete";
+    values?: Record<string, unknown> | null;
+    previousValues?: Record<string, unknown> | null;
+    updatedBy?: string | null;
+}
+export interface FetchHistoryOptions {
+    limit?: number;
+    offset?: number;
+}
+export interface HistoryRetentionConfig {
+    /** Max entries per entity. Oldest pruned first. Default 200. */
+    maxEntries: number;
+    /** Entries older than this many days are pruned. Default 90. */
+    ttlDays: number;
+}
+/**
+ * Service for recording and querying entity change history.
+ * Stores snapshots in the `rebase.entity_history` table.
+ */
+export declare class HistoryService {
+    private db;
+    retention: HistoryRetentionConfig;
+    constructor(db: NodePgDatabase, retention?: Partial<HistoryRetentionConfig>);
+    /**
+     * Record a history entry for an entity change.
+     * This is intentionally fire-and-forget safe — errors are logged but never
+     * bubble up to block the main save/delete operation.
+     *
+     * After inserting, kicks off a non-blocking pruning pass for this entity.
+     */
+    recordHistory(params: RecordHistoryParams): Promise<void>;
+    /**
+     * Fetch history entries for an entity, ordered by most recent first.
+     */
+    fetchHistory(tableName: string, entityId: string, options?: FetchHistoryOptions): Promise<{
+        data: HistoryEntry[];
+        total: number;
+    }>;
+    /**
+     * Fetch a single history entry by ID.
+     */
+    fetchHistoryEntry(historyId: string): Promise<HistoryEntry | null>;
+    /**
+     * Prune history for a single entity: enforce maxEntries and TTL.
+     */
+    pruneEntity(tableName: string, entityId: string): Promise<number>;
+    /**
+     * Global prune: enforce TTL across ALL entities in a single sweep.
+     * Intended to be called periodically (e.g. once per hour or daily).
+     */
+    pruneExpired(): Promise<number>;
+}
+/**
+ * Shallow comparison to find top-level keys that changed between two objects.
+ */
+export declare function findChangedFields(oldValues: Record<string, unknown>, newValues: Record<string, unknown>): string[] | null;

package/dist/server-postgresql/src/history/ensure-history-table.d.ts

@@ -0,0 +1,7 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+/**
+ * Auto-create the entity history table if it doesn't exist.
+ * This runs on startup when history is enabled, following the same
+ * pattern as `ensureAuthTablesExist`.
+ */
+export declare function ensureHistoryTableExists(db: NodePgDatabase): Promise<void>;

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

@@ -0,0 +1,13 @@
+export * from "./connection";
+export * from "./interfaces";
+export * from "./PostgresBackendDriver";
+export * from "./databasePoolManager";
+export * from "./schema/auth-schema";
+export * from "./schema/generate-drizzle-schema-logic";
+export * from "./schema/generate-drizzle-schema";
+export * from "./utils/drizzle-conditions";
+export * from "./services/realtimeService";
+export * from "./websocket";
+export * from "./collections/PostgresCollectionRegistry";
+export * from "./services/BranchService";
+export * from "./PostgresBootstrapper";

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

@@ -0,0 +1,18 @@
+/**
+ * Database Abstraction Interfaces
+ *
+ * These interfaces define the contracts that any database backend must implement
+ * to be used with Rebase. This allows for pluggable database backends like
+ * PostgreSQL, MongoDB, MySQL, etc.
+ */
+import { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, EntityRepository, CollectionSubscriptionConfig, EntitySubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory } from "@rebasepro/types";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTransaction } from "drizzle-orm/pg-core";
+/**
+ * Type representing either a direct database connection or a transaction.
+ * Used to allow services to operate within a transaction context.
+ * Note: `any` is intentional here — it represents a Drizzle client with
+ * a dynamic schema, enabling `db.query[tableName]` access without casts.
+ */
+export type DrizzleClient = NodePgDatabase<any> | PgTransaction<any, any, any>;
+export type { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, EntityRepository, CollectionSubscriptionConfig, EntitySubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory };