@rebasepro/server-postgres 0.0.1-canary.4829d6e

package/dist/backup/backup-service.d.ts

@@ -0,0 +1,85 @@
+import type { StorageController } from "@rebasepro/server";
+import { BackupDestination, VersionCompatibility } from "./pg-tools";
+import { BackupObject, RetentionOptions } from "./retention";
+export declare class BackupToolError extends Error {
+    readonly hint?: string | undefined;
+    constructor(message: string, hint?: string | undefined);
+}
+/** Locate `pg_dump` / `pg_restore`, honouring an env override. */
+export declare function resolvePgBinary(tool: "pg_dump" | "pg_restore", env?: Record<string, string | undefined>): string | null;
+/** Run `<bin> --version` and extract the major version. */
+export declare function detectToolMajor(bin: string): Promise<number | null>;
+/** Query the server for its major version via `server_version_num`. */
+export declare function getServerVersionMajor(connectionString: string): Promise<number | null>;
+export interface PreflightResult extends VersionCompatibility {
+    bin: string;
+    toolMajor: number | null;
+    serverMajor: number | null;
+}
+/**
+ * Verify the requested client tool exists and its major version is
+ * compatible with the live server. Throws {@link BackupToolError} — with a
+ * doctor-style hint — when the binary is missing.
+ */
+export declare function preflight(tool: "pg_dump" | "pg_restore", connectionString: string, env?: Record<string, string | undefined>): Promise<PreflightResult>;
+export interface BackupResult {
+    /** Absolute path of the produced dump file on local disk. */
+    localFile: string;
+    fileName: string;
+    sizeBytes: number;
+}
+/**
+ * Produce a custom-format dump on local disk. When `outDir` is omitted the
+ * file is written to the OS temp directory (used by the upload path, which
+ * cleans it up afterwards).
+ */
+export declare function createDump(opts: {
+    connectionString: string;
+    dbName: string;
+    outDir?: string;
+    fileName?: string;
+    excludeSchemas?: string[];
+    noOwner?: boolean;
+    inheritStdio?: boolean;
+    env?: Record<string, string | undefined>;
+}): Promise<BackupResult>;
+/**
+ * Restore a custom-format dump into the database named by
+ * `connectionString`. Destructive when `clean` is set (drops objects
+ * first). Never called automatically — the CLI gates it behind explicit
+ * confirmation.
+ */
+export declare function restoreDump(opts: {
+    connectionString: string;
+    inputFile: string;
+    clean?: boolean;
+    noOwner?: boolean;
+    inheritStdio?: boolean;
+    env?: Record<string, string | undefined>;
+}): Promise<void>;
+/**
+ * Create a database (if absent) by connecting to the maintenance
+ * `postgres` database. Used by `restore --create-db`.
+ */
+export declare function ensureDatabaseExists(adminConnectionString: string, dbName: string): Promise<boolean>;
+/**
+ * Upload a local dump to object storage under the destination's prefix.
+ * Backups may contain secrets/PII, so the object is written with a
+ * private/octet-stream content type; bucket-level ACLs must stay private.
+ */
+export declare function uploadBackup(storage: StorageController, localFile: string, dest: Extract<BackupDestination, {
+    kind: "s3" | "gcs";
+}>): Promise<{
+    key: string;
+    storageUrl: string;
+}>;
+/**
+ * List existing backups at a destination. For local destinations reads the
+ * directory; for object storage lists the prefix via the controller.
+ */
+export declare function listBackups(dest: BackupDestination, storage?: StorageController): Promise<BackupObject[]>;
+/**
+ * Apply a retention policy to a destination, deleting the backups selected
+ * by {@link selectBackupsToPrune}. Returns the keys that were removed.
+ */
+export declare function pruneBackups(dest: BackupDestination, options: RetentionOptions, storage?: StorageController): Promise<string[]>;

package/dist/backup/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Backup / restore for self-hosted rebase.
+ *
+ * - `pg-tools`      — pure argument/version/path helpers (unit-tested)
+ * - `retention`     — pure retention-pruning policy (unit-tested)
+ * - `backup-service`— pg_dump/pg_restore + storage orchestration
+ * - `backup-cron`   — scheduled backups for the server cron system
+ */
+export * from "./pg-tools";
+export * from "./retention";
+export * from "./backup-service";
+export * from "./backup-cron";

package/dist/backup/pg-tools.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Pure helpers for the backup/restore commands.
+ *
+ * Everything in this file is side-effect free so it can be unit-tested
+ * without a live Postgres server, matching the constraint that CI must
+ * not require a database.
+ */
+/**
+ * A parsed backup destination. `--out` (and the scheduled-backup config)
+ * accepts either a local filesystem path or an object-storage URL.
+ */
+export type BackupDestination = {
+    kind: "local";
+    path: string;
+} | {
+    kind: "s3";
+    bucket: string;
+    prefix: string;
+} | {
+    kind: "gcs";
+    bucket: string;
+    prefix: string;
+};
+/**
+ * Extract the database name from a Postgres connection string.
+ * Returns `null` when the URL has no database path (e.g. bare host).
+ */
+export declare function parseDbNameFromUrl(connectionString: string): string | null;
+/**
+ * Swap the database name in a connection string, preserving credentials,
+ * host, port and query params. Used by `--target-db` / `--create-db` so a
+ * restore can target a fresh database instead of clobbering the live one.
+ */
+export declare function withDatabaseName(connectionString: string, dbName: string): string;
+/**
+ * Parse the major version out of `pg_dump --version` / `pg_restore --version`
+ * output, e.g. `"pg_dump (PostgreSQL) 16.2"` → `16`. Handles the pre-10
+ * `9.6.x` scheme (returns `9`) and beta strings like `"17beta1"`.
+ */
+export declare function parsePgToolMajor(versionOutput: string): number | null;
+/**
+ * Convert `SELECT current_setting('server_version_num')` (e.g. `160002`)
+ * into a major version (`16`). Also accepts pre-10 encodings like `90603`
+ * → `9`.
+ */
+export declare function serverVersionNumToMajor(versionNum: number | string): number | null;
+export interface VersionCompatibility {
+    compatible: boolean;
+    reason?: string;
+}
+/**
+ * pg_dump / pg_restore must be **at least** as new as the server they talk
+ * to. A newer client against an older server is supported; an older client
+ * against a newer server is not and produces corrupt or rejected output.
+ */
+export declare function checkToolServerCompatibility(toolMajor: number | null, serverMajor: number | null): VersionCompatibility;
+/**
+ * Build a deterministic, sortable backup file name:
+ *   `rebase-<db>-<YYYYMMDD>T<HHMMSS>Z.dump`
+ *
+ * The UTC timestamp is embedded so retention pruning can recover the
+ * creation time from the object key alone, without extra metadata.
+ */
+export declare function buildBackupFilename(dbName: string, date?: Date): string;
+/**
+ * Recover the creation timestamp encoded in a backup file name by
+ * {@link buildBackupFilename}. Returns `null` for names that don't match,
+ * so foreign objects in a shared prefix are never pruned.
+ */
+export declare function parseBackupTimestamp(fileName: string): Date | null;
+/**
+ * Parse a destination string into a structured {@link BackupDestination}.
+ * `s3://bucket/prefix` and `gs://bucket/prefix` map to object storage;
+ * anything else is treated as a local path.
+ */
+export declare function parseBackupDestination(out: string): BackupDestination;
+/**
+ * Join a storage prefix and a file name without producing a leading or
+ * doubled slash.
+ */
+export declare function joinStorageKey(prefix: string, fileName: string): string;
+/**
+ * Assemble the `pg_dump` argument vector. Uses the custom format (`-Fc`),
+ * which is compressed and restorable selectively via `pg_restore`.
+ */
+export declare function buildPgDumpArgs(opts: {
+    connectionString: string;
+    outFile: string;
+    /** Extra schemas/tables to exclude, e.g. Atlas revision tables. */
+    excludeSchemas?: string[];
+    /** Number of parallel jobs (directory format only; ignored for -Fc). */
+    noOwner?: boolean;
+}): string[];
+/**
+ * Assemble the `pg_restore` argument vector for a custom-format dump.
+ */
+export declare function buildPgRestoreArgs(opts: {
+    connectionString: string;
+    inputFile: string;
+    /** Drop objects before recreating them (destructive but idempotent). */
+    clean?: boolean;
+    /** Continue past individual errors instead of aborting. */
+    exitOnError?: boolean;
+    noOwner?: boolean;
+}): string[];
+/**
+ * Resolve the Postgres connection string the backup commands should use,
+ * mirroring the precedence the branch command already relies on.
+ */
+export declare function resolveConnectionString(env: Record<string, string | undefined>): string | null;

package/dist/backup/retention.d.ts

@@ -0,0 +1,35 @@
+export interface BackupObject {
+    /** Storage key / file name. */
+    key: string;
+    /**
+     * Creation time. Optional — when absent it is recovered from the
+     * timestamp encoded in the key by `buildBackupFilename`.
+     */
+    createdAt?: Date;
+}
+export interface RetentionOptions {
+    /** Delete backups older than this many days. `0`/negative disables age pruning. */
+    retentionDays?: number;
+    /**
+     * Always keep at least this many of the most recent backups, even if
+     * they are older than `retentionDays`. Guards against wiping every
+     * backup after a long outage. Default: 0 (no minimum).
+     */
+    keepMinimum?: number;
+    /** Reference "now" — injectable for deterministic tests. */
+    now?: Date;
+}
+/**
+ * Decide which backups to delete under the given retention policy.
+ *
+ * Rules, applied in order:
+ *  1. Objects whose key isn't a recognised rebase backup (no parseable
+ *     timestamp and no `createdAt`) are never selected — foreign files in a
+ *     shared bucket are left untouched.
+ *  2. The `keepMinimum` newest backups are always retained.
+ *  3. Of the remainder, any older than `retentionDays` are selected for
+ *     deletion.
+ *
+ * Returns the keys to delete, oldest first.
+ */
+export declare function selectBackupsToPrune(backups: BackupObject[], options: RetentionOptions): string[];

package/dist/chunk-DSJWtz9O.js

@@ -0,0 +1,40 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+const require = __createRequire(import.meta.url);
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/dist/cli-errors.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Detect whether an error (or AggregateError wrapping multiple attempts)
+ * represents an ECONNREFUSED — i.e. the database is simply not running.
+ *
+ * Handles:
+ * - Direct `{ code: "ECONNREFUSED" }` errors from Node `net`
+ * - `AggregateError` from dual-stack IPv4+IPv6 connection attempts
+ * - Drizzle's `cause`-wrapped pg errors
+ */
+export declare function isEconnrefused(err: unknown): boolean;
+/**
+ * Detect PostgreSQL authentication failures.
+ * PG error codes: 28P01 (invalid_password), 28000 (invalid_authorization_specification)
+ */
+export declare function isAuthFailure(err: unknown): boolean;
+/**
+ * Detect the "SSL is not enabled on the server" failure — the client attempted
+ * an SSL handshake against a Postgres server that doesn't support it (common
+ * with a plain local dev database). The fix is `?sslmode=disable` on the URL.
+ */
+export declare function isSslNotEnabled(err: unknown): boolean;
+/**
+ * Detect PostgreSQL "cannot drop ... because other objects depend on it"
+ * (error code 2BP01, dependent_objects_still_exist). This is the failure that
+ * strands a declarative `db push` half-applied when a collection is removed but
+ * an enum type it defined is still referenced by another object.
+ */
+export declare function isDependencyDropError(err: unknown): boolean;
+/**
+ * Pre-flight check: verify that the database is reachable before running
+ * a heavy subprocess (Atlas, migrations, etc.).
+ *
+ * Exits with code 1 and a friendly banner on known failure modes.
+ * On unknown errors, logs a warning and allows the caller to proceed.
+ */
+export declare function checkDatabaseConnectivity(databaseUrl: string): Promise<void>;
+/**
+ * Post-hoc error diagnosis for direct database operations (e.g. applyPolicies).
+ * Returns a formatted diagnostic string if the error matches a known pattern,
+ * or null if unrecognized.
+ */
+export declare function diagnoseDbError(err: unknown, databaseUrl?: string): string | null;

package/dist/cli-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { CollectionConfig } from "@rebasepro/types";
+export declare function resolveLocalBin(binName: string): string | null;
+export declare function getTableIncludesFromCollections(collections: CollectionConfig[]): Promise<string[]>;
+export declare function getTableIncludes(collectionsPath: string): Promise<string[]>;
+export declare function getDevDatabaseUrl(databaseUrl: string): string;
+export declare function ensureDevDatabaseExists(databaseUrl: string, devDatabaseUrl: string): Promise<void>;
+export declare function getTableExcludes(databaseUrl: string, collectionsPath: string): Promise<string[]>;

package/dist/cli.d.ts

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

package/dist/collections/PostgresCollectionRegistry.d.ts

@@ -0,0 +1,47 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { type CollectionConfig } 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;
+    /**
+     * Returns all registered table names.
+     */
+    getTableNames(): string[];
+    /**
+     * Finds collections assigned to a specific data source that do not have a registered table.
+     */
+    getCollectionsWithoutTables(dataSourceKey?: string): CollectionConfig[];
+    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/connection.d.ts

@@ -0,0 +1,65 @@
+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;
+};
+/**
+ * Create a direct (non-pooled) connection for operations that require
+ * session-level features incompatible with PgBouncer transaction mode,
+ * such as LISTEN/NOTIFY, prepared statements, or advisory locks.
+ *
+ * Uses a smaller pool since this is only for specific use cases.
+ */
+export declare function createDirectDatabaseConnection(connectionString: string, schema?: Record<string, unknown>, poolConfig?: PostgresPoolConfig): {
+    db: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+        $client: Pool;
+    };
+    pool: Pool;
+    connectionString: string;
+};
+/**
+ * Create a read-only connection for routing read queries to replicas.
+ * Uses a moderate pool size since reads are distributed across replicas.
+ */
+export declare function createReadReplicaConnection(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/data-transformer.d.ts

@@ -0,0 +1,55 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { CollectionConfig, 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;
+        currentId?: 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>>(row: M, properties: Properties, collection?: CollectionConfig, 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: CollectionConfig, db?: NodePgDatabase<Record<string, unknown>>, registry?: PostgresCollectionRegistry): Promise<M>;
+export declare function parsePropertyFromServer(value: unknown, property: Property, collection: CollectionConfig, 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: CollectionConfig): M;

package/dist/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<Record<string, never>>;
+    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/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;
+    id: 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 row. Oldest pruned first. Default 200. */
+    maxEntries: number;
+    /** Entries older than this many days are pruned. Default 90. */
+    ttlDays: number;
+}
+/**
+ * Service for recording and querying row change history.
+ * Stores history entries 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 row 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 row.
+     */
+    recordHistory(params: RecordHistoryParams): Promise<void>;
+    /**
+     * Fetch history entries for an row, ordered by most recent first.
+     */
+    fetchHistory(tableName: string, id: 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 row: enforce maxEntries and TTL.
+     */
+    pruneEntity(tableName: string, id: string): Promise<number>;
+    /**
+     * Global prune: enforce TTL across ALL rows 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/history/ensure-history-table.d.ts

@@ -0,0 +1,7 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+/**
+ * Auto-create the row 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/index.d.ts

@@ -0,0 +1,15 @@
+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 "./backup";
+export * from "./PostgresBootstrapper";
+export * from "./PostgresAdapter";