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

package/src/collections/PostgresCollectionRegistry.ts

@@ -0,0 +1,96 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { type CollectionWithRelations, type EntityCollection, 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);
+    }
+
+    /**
+     * Finds collections assigned to a specific driver that do not have a registered table.
+     */
+    getCollectionsWithoutTables(driverId = "(default)"): EntityCollection[] {
+        const collections = this.getCollections().filter(
+            c => c.driver === driverId || (!c.driver && driverId === "(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.driver).supportsRelations || !(collection as CollectionWithRelations).relations) return [];
+        return (collection as CollectionWithRelations).relations!.map((r: Relation) => r.relationName || r.localKey || "").filter(Boolean);
+    }
+
+}
+

package/src/connection.ts

@@ -0,0 +1,84 @@
+import { Pool, PoolConfig } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+
+/**
+ * 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-core
+    // (a separate package). The caller can replace these with the structured
+    // logger if desired via pool.on() after creation.
+    pool.on("error", (err) => {
+        console.error("[pg-pool] Unexpected pool error:", err.message);
+        if (err.message.includes("ETIMEDOUT")) {
+            console.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 };
+}