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

package/src/collections/PostgresCollectionRegistry.ts

@@ -0,0 +1,103 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { type CollectionConfig, type Relation, getDataSourceCapabilities } from "@rebasepro/types";
+import { PgEnum, PgTable } from "drizzle-orm/pg-core";
+import { Relations } from "drizzle-orm";
+import { CollectionRegistryInterface } from "../interfaces";
+import { getTableName } from "@rebasepro/common";
+
+/**
+ * PostgreSQL-specific collection registry.
+ * Extends the base CollectionRegistry with support for Drizzle ORM tables, enums, and relations.
+ *
+ * Satisfies CollectionRegistryInterface through inheritance from CollectionRegistry.
+ */
+export class PostgresCollectionRegistry extends CollectionRegistry implements CollectionRegistryInterface {
+
+    private tables = new Map<string, PgTable>();
+    private enums = new Map<string, PgEnum<[string, ...string[]]>>();
+    private relations = new Map<string, Relations>();
+
+    registerTable(table: PgTable, tableName: string) {
+        this.tables.set(tableName, table);
+    }
+
+    getTable(tableName: string): PgTable | undefined {
+        return this.tables.get(tableName);
+    }
+
+    /**
+     * Checks if a specific collection has a registered table
+     */
+    hasTableForCollection(tableName: string): boolean {
+        return this.tables.has(tableName);
+    }
+
+    /**
+     * Returns all registered table names.
+     */
+    getTableNames(): string[] {
+        return Array.from(this.tables.keys());
+    }
+
+    /**
+     * Finds collections assigned to a specific data source that do not have a registered table.
+     */
+    getCollectionsWithoutTables(dataSourceKey = "(default)"): CollectionConfig[] {
+        const collections = this.getCollections().filter(
+            c => c.dataSource === dataSourceKey || (!c.dataSource && dataSourceKey === "(default)")
+        );
+        return collections.filter(c => !this.tables.has(getTableName(c)));
+    }
+
+    registerEnums(enums: Record<string, PgEnum<[string, ...string[]]>>) {
+        Object.entries(enums).forEach(([name, value]) => this.enums.set(name, value));
+    }
+
+    registerRelations(relations: Record<string, Relations>) {
+        Object.entries(relations).forEach(([name, value]) => this.relations.set(name, value));
+    }
+
+    getEnum(name: string): PgEnum<[string, ...string[]]> | undefined {
+        return this.enums.get(name);
+    }
+
+    getRelation(name: string): Relations | undefined {
+        return this.relations.get(name);
+    }
+
+    getAllEnums(): Record<string, PgEnum<[string, ...string[]]>> {
+        return Object.fromEntries(this.enums.entries());
+    }
+
+    getAllRelations(): Record<string, Relations> {
+        return Object.fromEntries(this.relations.entries());
+    }
+
+    /**
+     * Get the merged schema object (tables + relations) for use with Drizzle's
+     * relational query API (`db.query`).
+     */
+    getMergedSchema(): Record<string, unknown> {
+        const result: Record<string, unknown> = {};
+        for (const [name, table] of this.tables.entries()) {
+            result[name] = table;
+        }
+        for (const [name, relation] of this.relations.entries()) {
+            result[name] = relation;
+        }
+        return result;
+    }
+
+    /**
+     * 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[] {
+        const collection = this.getCollectionByPath(collectionPath);
+        if (!collection || !getDataSourceCapabilities(collection.engine).supportsRelations || !collection.relations) return [];
+        return collection.relations!.map((r: Relation) => r.relationName || r.localKey || "").filter(Boolean);
+    }
+
+}
+

package/src/connection.ts

@@ -0,0 +1,166 @@
+import { Pool, PoolConfig } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { logger } from "@rebasepro/server";
+
+/**
+ * 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;
+}
+
+const DEFAULT_POOL: Required<PostgresPoolConfig> = {
+    max: 20,
+    idleTimeoutMillis: 30_000,
+    connectionTimeoutMillis: 10_000,
+    queryTimeout: 30_000,
+    statementTimeout: 30_000,
+    keepAlive: true
+};
+
+/**
+ * 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 function createPostgresDatabaseConnection(
+    connectionString: string,
+    schema?: Record<string, unknown>,
+    poolConfig?: PostgresPoolConfig
+) {
+    const opts = { ...DEFAULT_POOL,
+...poolConfig };
+
+    const pgPoolConfig: PoolConfig = {
+        connectionString,
+        max: opts.max,
+        idleTimeoutMillis: opts.idleTimeoutMillis,
+        connectionTimeoutMillis: opts.connectionTimeoutMillis,
+        query_timeout: opts.queryTimeout,
+        statement_timeout: opts.statementTimeout,
+        keepAlive: opts.keepAlive,
+        keepAliveInitialDelayMillis: 0
+    };
+
+    const pool = new Pool(pgPoolConfig);
+
+    // ── Pool event logging ────────────────────────────────────────────────
+    // Uses console.* because the structured logger lives in server
+    // (a separate package). The caller can replace these with the structured
+    // logger if desired via pool.on() after creation.
+    pool.on("error", (err) => {
+        logger.error("[pg-pool] Unexpected pool error", { detail: err.message });
+        if (err.message.includes("ETIMEDOUT")) {
+            logger.warn("[pg-pool] Connection timeout detected — pool will auto-retry");
+        }
+    });
+
+    // Create drizzle instance — pass schema when available to enable db.query relational API
+    const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
+
+    return { db,
+pool,
+connectionString };
+}
+
+/**
+ * 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 function createDirectDatabaseConnection(
+    connectionString: string,
+    schema?: Record<string, unknown>,
+    poolConfig?: PostgresPoolConfig
+) {
+    const opts = {
+        ...DEFAULT_POOL,
+        max: 5,
+        ...poolConfig
+    };
+
+    const pgPoolConfig: PoolConfig = {
+        connectionString,
+        max: opts.max,
+        idleTimeoutMillis: opts.idleTimeoutMillis,
+        connectionTimeoutMillis: opts.connectionTimeoutMillis,
+        query_timeout: opts.queryTimeout,
+        statement_timeout: opts.statementTimeout,
+        keepAlive: opts.keepAlive,
+        keepAliveInitialDelayMillis: 0
+    };
+
+    const pool = new Pool(pgPoolConfig);
+
+    pool.on("error", (err) => {
+        logger.error("[pg-direct-pool] Unexpected pool error", { detail: err.message });
+    });
+
+    const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
+
+    return { db,
+pool,
+connectionString };
+}
+
+/**
+ * Create a read-only connection for routing read queries to replicas.
+ * Uses a moderate pool size since reads are distributed across replicas.
+ */
+export function createReadReplicaConnection(
+    connectionString: string,
+    schema?: Record<string, unknown>,
+    poolConfig?: PostgresPoolConfig
+) {
+    const opts = {
+        ...DEFAULT_POOL,
+        max: 10,
+        ...poolConfig
+    };
+
+    const pgPoolConfig: PoolConfig = {
+        connectionString,
+        max: opts.max,
+        idleTimeoutMillis: opts.idleTimeoutMillis,
+        connectionTimeoutMillis: opts.connectionTimeoutMillis,
+        query_timeout: opts.queryTimeout,
+        statement_timeout: opts.statementTimeout,
+        keepAlive: opts.keepAlive,
+        keepAliveInitialDelayMillis: 0
+    };
+
+    const pool = new Pool(pgPoolConfig);
+
+    pool.on("error", (err) => {
+        logger.error("[pg-replica-pool] Unexpected pool error", { detail: err.message });
+    });
+
+    const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
+
+    return { db,
+pool,
+connectionString };
+}