@rebasepro/server-postgres 0.17.3 → 0.18.1

package/src/databasePoolManager.ts

@@ -1,95 +0,0 @@
-import { Pool } from "pg";
-import { drizzle } from "drizzle-orm/node-postgres";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { logger } from "@rebasepro/server";
-import { guardPoolAgainstDirtyRelease, pinSearchPath, cappedPoolMax } from "./connection";
-
-export class DatabasePoolManager {
-    private pools: Map<string, Pool> = new Map();
-    private drizzleInstances: Map<string, NodePgDatabase> = new Map();
-    public readonly defaultDatabaseName: string;
-    private readonly rootConnectionString: string;
-
-    constructor(adminConnectionString: string) {
-        this.rootConnectionString = adminConnectionString;
-        try {
-            const url = new URL(adminConnectionString);
-            this.defaultDatabaseName = url.pathname.slice(1);
-        } catch (e) {
-            throw new Error(`Invalid adminConnectionString provided: ${e}`);
-        }
-    }
-
-    public getDrizzle(databaseName: string): NodePgDatabase<Record<string, never>> {
-        const existing = this.drizzleInstances.get(databaseName);
-        if (existing) {
-            return existing;
-        }
-
-        const pool = this.getPool(databaseName);
-        const db = drizzle(pool);
-        this.drizzleInstances.set(databaseName, db);
-        return db;
-    }
-
-    public getPool(databaseName: string): Pool {
-        if (this.pools.has(databaseName)) {
-            return this.pools.get(databaseName)!;
-        }
-
-        const url = new URL(this.rootConnectionString);
-        url.pathname = `/${databaseName}`;
-
-        const pool = new Pool({
-            // Same pin as the primary pool: these are branch/multi-database
-            // connections to the *same* server, so they inherit the same
-            // `"$user"` hazard. See `pinSearchPath`.
-            connectionString: pinSearchPath(url.toString()),
-            // Capped by REBASE_DB_POOL_MAX, which the managed development
-            // database sets to 1: PGlite multiplexes onto a single session and
-            // overlapping transactions deadlock there.
-            max: cappedPoolMax(10),
-            idleTimeoutMillis: 10000, // Reduced from 30000 for aggressive cleanup
-            allowExitOnIdle: true // Prevent idle clients from hanging the Node.js process
-        });
-
-        // Prevent idle client errors from crashing the Node.js process
-        pool.on("error", (err) => {
-            logger.error(`[DatabasePoolManager] Unexpected error on idle client for db ${databaseName}`, { error: err });
-        });
-        guardPoolAgainstDirtyRelease(pool, `pg-pool:${databaseName}`);
-
-        this.pools.set(databaseName, pool);
-        return 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.
-     */
-    public async disconnectDatabase(databaseName: string): Promise<void> {
-        const pool = this.pools.get(databaseName);
-        if (pool) {
-            await pool.end();
-            this.pools.delete(databaseName);
-            this.drizzleInstances.delete(databaseName);
-        }
-    }
-
-    /** Check if a pool exists for a given database name. */
-    public hasPool(databaseName: string): boolean {
-        return this.pools.has(databaseName);
-    }
-
-    public async shutdown(): Promise<void> {
-        const promises = [];
-        for (const [dbName, pool] of this.pools.entries()) {
-            logger.info(`[DatabasePoolManager] Shutting down pool for ${dbName}`);
-            promises.push(pool.end());
-        }
-        await Promise.all(promises);
-        this.pools.clear();
-        this.drizzleInstances.clear();
-    }
-}

package/src/history/HistoryService.ts

@@ -1,254 +0,0 @@
-import { sql } from "drizzle-orm";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { logger } from "@rebasepro/server";
-import type { EntityHistoryEntry } from "@rebasepro/types";
-
-export type {
-    RecordHistoryParams,
-    FetchHistoryOptions,
-    HistoryRetentionConfig
-} from "@rebasepro/types";
-import type { RecordHistoryParams, FetchHistoryOptions, HistoryRetentionConfig } from "@rebasepro/types";
-
-/**
- * A Postgres history row is already the wire shape — `updated_at` comes back
- * from the driver as a string. Kept as an alias because the name is used
- * throughout this package and in `PostgresBackendDriver`.
- */
-export type HistoryEntry = EntityHistoryEntry;
-
-const DEFAULT_RETENTION: HistoryRetentionConfig = {
-    maxEntries: 200,
-    ttlDays: 90
-};
-
-/**
- * Service for recording and querying row change history.
- * Stores history entries in the `rebase.entity_history` table.
- */
-export class HistoryService {
-    public retention: HistoryRetentionConfig;
-
-    constructor(
-        private db: NodePgDatabase,
-        retention?: Partial<HistoryRetentionConfig>
-    ) {
-        this.retention = { ...DEFAULT_RETENTION,
-...retention };
-    }
-
-    /**
-     * 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.
-     */
-    async recordHistory(params: RecordHistoryParams): Promise<void> {
-        const {
-            tableName,
-            id,
-            action,
-            values,
-            previousValues,
-            updatedBy
-        } = params;
-
-        const changedFields = previousValues && values
-            ? findChangedFields(previousValues, values)
-            : null;
-
-
-        // Skip recording if this is an update with zero actual changes
-
-        if (action === "update" && (!changedFields || changedFields.length === 0)) {
-            return;
-        }
-
-        try {
-            await this.db.execute(sql`
-                INSERT INTO rebase.entity_history 
-                    (table_name, entity_id, action, changed_fields, "values", previous_values, updated_by)
-                VALUES (
-                    ${tableName},
-                    ${String(id)},
-                    ${action},
-                    ${changedFields ? sql`ARRAY[${sql.join(changedFields.map(f => sql`${f}`), sql`, `)}]::text[]` : sql`NULL`},
-                    ${values ? sql`${JSON.stringify(values)}::jsonb` : sql`NULL`},
-                    ${previousValues ? sql`${JSON.stringify(previousValues)}::jsonb` : sql`NULL`},
-                    ${updatedBy ?? null}
-                )
-            `);
-
-            // Non-blocking prune for this specific row
-            this.pruneEntity(tableName, id).catch(err =>
-                logger.error("History prune failed", { error: err })
-            );
-        } catch (error) {
-            logger.error("Failed to record row history", { error: error });
-        }
-    }
-
-    /**
-     * Fetch history entries for an row, ordered by most recent first.
-     */
-    async fetchHistory(
-        tableName: string,
-        id: string,
-        options: FetchHistoryOptions = {}
-    ): Promise<{ data: HistoryEntry[]; total: number }> {
-        const limit = options.limit ?? 20;
-        const offset = options.offset ?? 0;
-
-        const [countResult, dataResult] = await Promise.all([
-            this.db.execute(sql`
-                SELECT COUNT(*) as count
-                FROM rebase.entity_history
-                WHERE table_name = ${tableName}
-                  AND entity_id = ${String(id)}
-            `),
-            this.db.execute(sql`
-                SELECT id, table_name, entity_id, action, changed_fields,
-                       "values", previous_values, updated_by, updated_at
-                FROM rebase.entity_history
-                WHERE table_name = ${tableName}
-                  AND entity_id = ${String(id)}
-                ORDER BY updated_at DESC
-                LIMIT ${limit}
-                OFFSET ${offset}
-            `)
-        ]);
-
-        const total = parseInt(
-            (countResult.rows[0] as Record<string, string>)?.count ?? "0",
-            10
-        );
-
-        return {
-            data: dataResult.rows as unknown as HistoryEntry[],
-            total
-        };
-    }
-
-    /**
-     * Fetch a single history entry by ID.
-     */
-    async fetchHistoryEntry(historyId: string): Promise<HistoryEntry | null> {
-        const result = await this.db.execute(sql`
-            SELECT id, table_name, entity_id, action, changed_fields,
-                   "values", previous_values, updated_by, updated_at
-            FROM rebase.entity_history
-            WHERE id = ${historyId}
-        `);
-
-        if (result.rows.length === 0) return null;
-        return result.rows[0] as unknown as HistoryEntry;
-    }
-
-    // ───────── Retention / Pruning ─────────
-
-    /**
-     * Prune history for a single row: enforce maxEntries and TTL.
-     */
-    async pruneEntity(tableName: string, id: string): Promise<number> {
-        let deleted = 0;
-
-        // 1. TTL — delete entries older than ttlDays
-        const ttlResult = await this.db.execute(sql`
-            DELETE FROM rebase.entity_history
-            WHERE table_name = ${tableName}
-              AND entity_id = ${String(id)}
-              AND updated_at < NOW() - MAKE_INTERVAL(days => ${this.retention.ttlDays})
-        `);
-        deleted += ttlResult.rowCount ?? 0;
-
-        // 2. Max entries — keep the newest maxEntries, delete the rest
-        const maxResult = await this.db.execute(sql`
-            DELETE FROM rebase.entity_history
-            WHERE id IN (
-                SELECT id FROM rebase.entity_history
-                WHERE table_name = ${tableName}
-                  AND entity_id = ${String(id)}
-                ORDER BY updated_at DESC
-                OFFSET ${this.retention.maxEntries}
-            )
-        `);
-        deleted += maxResult.rowCount ?? 0;
-
-        return deleted;
-    }
-
-    /**
-     * Global prune: enforce TTL across ALL rows in a single sweep.
-     * Intended to be called periodically (e.g. once per hour or daily).
-     */
-    async pruneExpired(): Promise<number> {
-        const result = await this.db.execute(sql`
-            DELETE FROM rebase.entity_history
-            WHERE updated_at < NOW() - MAKE_INTERVAL(days => ${this.retention.ttlDays})
-        `);
-        return result.rowCount ?? 0;
-    }
-}
-
-
-/**
- * Deep equality without JSON.stringify.
- * Handles primitives, arrays, Dates, and plain objects recursively.
- */
-function deepEqual(a: unknown, b: unknown): boolean {
-    if (a === b) return true;
-    if (a == null || b == null) return false;
-    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-    if (Array.isArray(a) && Array.isArray(b)) {
-        if (a.length !== b.length) return false;
-        return a.every((v, i) => deepEqual(v, b[i]));
-    }
-    if (typeof a === "object" && typeof b === "object") {
-        const aObj = a as Record<string, unknown>;
-        const bObj = b as Record<string, unknown>;
-        const aKeys = Object.keys(aObj);
-        const bKeys = Object.keys(bObj);
-        if (aKeys.length !== bKeys.length) return false;
-        return aKeys.every(k => deepEqual(aObj[k], bObj[k]));
-    }
-    return false;
-}
-
-/**
- * Shallow comparison to find top-level keys that changed between two objects.
- */
-export function findChangedFields(
-    oldValues: Record<string, unknown>,
-    newValues: Record<string, unknown>
-): string[] | null {
-    const changed: string[] = [];
-    const allKeys = new Set([
-        ...Object.keys(oldValues),
-        ...Object.keys(newValues)
-    ]);
-
-    for (const key of allKeys) {
-        const oldVal = oldValues[key];
-        const newVal = newValues[key];
-
-        // Skip internal metadata
-        if (key.startsWith("__")) continue;
-
-        if (oldVal !== newVal) {
-            // For objects/arrays, use structural comparison
-            if (
-                typeof oldVal === "object" && oldVal !== null &&
-                typeof newVal === "object" && newVal !== null
-            ) {
-                if (!deepEqual(oldVal, newVal)) {
-                    changed.push(key);
-                }
-            } else {
-                changed.push(key);
-            }
-        }
-    }
-
-    return changed.length > 0 ? changed : null;
-}

package/src/history/ensure-history-table.ts

@@ -1,53 +0,0 @@
-import { sql } from "drizzle-orm";
-import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { logger } from "@rebasepro/server";
-import { revokeInternalTableSql } from "@rebasepro/common";
-
-/**
- * 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 async function ensureHistoryTableExists(db: NodePgDatabase): Promise<void> {
-    logger.debug("🔍 Checking row history table...");
-
-    try {
-        // Create the rebase schema (idempotent — may already exist from auth init)
-        await db.execute(sql`CREATE SCHEMA IF NOT EXISTS rebase`);
-
-        await db.execute(sql`
-            CREATE TABLE IF NOT EXISTS rebase.entity_history (
-                id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
-                table_name TEXT NOT NULL,
-                entity_id TEXT NOT NULL,
-                action TEXT NOT NULL,
-                changed_fields TEXT[],
-                "values" JSONB,
-                previous_values JSONB,
-                updated_by TEXT,
-                updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-            )
-        `);
-
-        await db.execute(sql`
-            CREATE INDEX IF NOT EXISTS idx_history_entity
-            ON rebase.entity_history(table_name, entity_id)
-        `);
-
-        await db.execute(sql`
-            CREATE INDEX IF NOT EXISTS idx_history_time
-            ON rebase.entity_history(table_name, entity_id, updated_at DESC)
-        `);
-
-        // Every previous value of every audited row, in one table with no RLS
-        // and no tenant scoping — so a readable copy defeats the row policies on
-        // the tables it shadows. The driver's schema-wide grant reaches it
-        // (created here, after that grant ran), so take it back.
-        await db.execute(sql.raw(revokeInternalTableSql("rebase", "entity_history")));
-
-        logger.debug("✅ Entity history table ready");
-    } catch (error) {
-        logger.error("❌ Failed to create row history table", { error: error });
-        logger.warn("⚠️ Continuing without creating history table.");
-    }
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-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";
-// The channel bus is a public extension point: a transport published as its own
-// package implements `ChannelBus` (declared in @rebasepro/types and re-exported
-// here) and is passed to `realtime.bus`. Without this export it would be one.
-export * from "./services/channel-bus";
-export * from "./websocket";
-export * from "./collections/PostgresCollectionRegistry";
-export * from "./services/BranchService";
-export * from "./backup";
-export * from "./PostgresBootstrapper";
-export * from "./PostgresAdapter";

package/src/interfaces.ts

@@ -1,60 +0,0 @@
-/**
- * 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 {
-    Entity,
-    CollectionConfig,
-    FilterValues,
-    WhereFilterOp,
-    DatabaseConnection,
-    QueryFilter,
-    FetchCollectionOptions,
-    SearchOptions,
-    CountOptions,
-    ConditionBuilder,
-    ConditionBuilderStatic,
-    DataRepository,
-    CollectionSubscriptionConfig,
-    SingleSubscriptionConfig,
-    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,
-    DataRepository,
-    CollectionSubscriptionConfig,
-    SingleSubscriptionConfig,
-    RealtimeProvider,
-    CollectionRegistryInterface,
-    DataTransformer,
-    BackendConfig,
-    BackendInstance,
-    BackendFactory
-};

package/src/module-dir.ts

@@ -1,7 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-
-// Isolated in its own module so the jest CommonJS transform can swap it for a
-// __dirname shim via moduleNameMapper — `import.meta` is a syntax error once
-// ts-jest transpiles to CJS.
-export const moduleDir = path.dirname(fileURLToPath(import.meta.url));

package/src/schema/atlas-argv.ts

@@ -1,94 +0,0 @@
-/**
- * The argv `runAtlas` hands the Atlas binary, as a pure function.
- *
- * Split out of `cli.ts` because the flags an Atlas subcommand accepts are not
- * uniform and getting one wrong is fatal rather than degraded: Atlas rejects an
- * unknown flag before doing any work, so a flag on the wrong subcommand takes
- * the whole command down.
- *
- * `--exclude` is the one that bit. Of the six invocations here, exactly one
- * accepts it. The guard this replaces was `args.includes("apply") ||
- * args.includes("diff")`, and reading it as a *subcommand* test is the trap:
- * `migrate apply` passes `args.includes("apply")` just as `schema apply` does.
- * So the flag went onto three invocations, two of which reject it, and both
- * `rebase db generate` and `rebase db migrate` exited 1 with `unknown flag:
- * --exclude` for every project declaring a `search` block.
- *
- * The domain is half the identity of an Atlas subcommand, and a guard that
- * looks only at `args` cannot tell `schema apply` from `migrate apply`.
- *
- * Nothing here touches a database or the filesystem, so the whole matrix is
- * unit-tested in `atlas-argv.test.ts`.
- */
-
-export interface AtlasInvocation {
-    /** `schema` or `migrate`. */
-    domain: string;
-    /** The subcommand and its own flags, e.g. `["diff", "--dir", "file://…"]`. */
-    args: string[];
-    /** The target database, already rewritten for libpq. */
-    url: string;
-    /** The database Atlas plans against, already rewritten for libpq. */
-    devUrl: string;
-    /**
-     * Everything the caller resolved for `--exclude`, in the order it should
-     * appear. Dropped entirely when the subcommand does not accept the flag —
-     * see {@link acceptsExcludeFlag}.
-     */
-    excludes?: string[];
-}
-
-/**
- * Does this Atlas invocation accept `--exclude`?
- *
- * Only `atlas schema apply` does, on the pinned 1.2.3. Measured against the
- * binary: `migrate diff` and `migrate apply` both answer `unknown flag:
- * --exclude`, and neither lists it in `--help` (`migrate apply` offers
- * `--url/--dir/--format/--revisions-schema/--dry-run/--lock-name/--lock-timeout/`
- * `--skip-lock/--baseline/--to-version/--tx-mode/--exec-order/--allow-dirty`).
- * Hence `domain === "schema"` and not just the subcommand.
- *
- * The `exclude` attribute of an `atlas.hcl` `env` block is not a way round it
- * either: measured, it is accepted and then ignored on the diff path, which is
- * the silent-no-match shape that costs the most time to notice.
- *
- * So the diff keeps the carved-out objects out of the migration afterwards
- * instead, with `stripCarvedOutStatements`.
- */
-export function acceptsExcludeFlag(domain: string, args: string[]): boolean {
-    return domain === "schema" && args.includes("apply");
-}
-
-/** Assemble the full argv, connection flags and all. */
-export function buildAtlasArgs(invocation: AtlasInvocation): string[] {
-    const { domain, args, url, devUrl, excludes = [] } = invocation;
-    const argv = [domain, ...args];
-
-    if (domain === "schema") {
-        if (args.includes("apply")) {
-            argv.push("--url", url, "--dev-url", devUrl);
-        } else if (args.includes("clean") || args.includes("inspect")) {
-            argv.push("--url", url);
-        }
-    } else if (domain === "migrate") {
-        if (args.includes("diff")) {
-            argv.push("--dev-url", devUrl);
-        } else if (args.includes("apply") || args.includes("status")) {
-            argv.push("--url", url, "--revisions-schema", "rebase");
-            if (args.includes("apply")) {
-                argv.push("--allow-dirty");
-            }
-        }
-    }
-
-    // Second line of defence, deliberately not a caller's responsibility: a
-    // future caller that resolves excludes for the diff path gets them dropped
-    // here rather than a command that will not run.
-    if (acceptsExcludeFlag(domain, args)) {
-        for (const exclude of excludes) {
-            argv.push("--exclude", exclude);
-        }
-    }
-
-    return argv;
-}