pgsql-test/connect.js

pgsql-test offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests — giving developers realistic test coverage without external state pollution

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getConnections = exports.getPgRootAdmin = void 0;
const env_1 = require("@pgpmjs/env");
const crypto_1 = require("crypto");
const pg_cache_1 = require("pg-cache");
const pg_env_1 = require("pg-env");
const pgsql_client_1 = require("pgsql-client");
const admin_1 = require("./admin");
const manager_1 = require("./manager");
const seed_1 = require("./seed");
const utils_1 = require("./utils");
let manager;
const getPgRootAdmin = (config, connOpts = {}) => {
    const opts = (0, pg_env_1.getPgEnvOptions)({
        user: config.user,
        password: config.password,
        host: config.host,
        port: config.port,
        database: connOpts.rootDb
    });
    const admin = new admin_1.DbAdmin(opts, false, connOpts);
    return admin;
};
exports.getPgRootAdmin = getPgRootAdmin;
const getConnOopts = (cn = {}) => {
    const connect = (0, env_1.getConnEnvOptions)(cn.db);
    const config = (0, pg_env_1.getPgEnvOptions)({
        database: `${connect.prefix}${(0, crypto_1.randomUUID)()}`,
        ...cn.pg
    });
    return {
        pg: config,
        db: connect
    };
};
const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.pgpm()]) => {
    cn = getConnOopts(cn);
    const config = cn.pg;
    const connOpts = cn.db;
    const root = (0, exports.getPgRootAdmin)(config, connOpts);
    await root.createUserRole(connOpts.connections.app.user, connOpts.connections.app.password, connOpts.rootDb);
    const admin = new admin_1.DbAdmin(config, false, connOpts);
    if (process.env.TEST_DB) {
        config.database = process.env.TEST_DB;
    }
    else if (connOpts.template) {
        admin.createFromTemplate(connOpts.template, config.database);
    }
    else {
        admin.create(config.database);
        admin.installExtensions(connOpts.extensions);
    }
    await admin.grantConnect(connOpts.connections.app.user, config.database);
    manager = manager_1.PgTestConnector.getInstance(config);
    const pg = manager.getClient(config);
    let teardownPromise = null;
    let teardownOpts = {};
    const teardown = async (opts = {}) => {
        teardownOpts = opts;
        if (teardownPromise)
            return teardownPromise;
        teardownPromise = (async () => {
            manager.beginTeardown();
            await (0, pg_cache_1.teardownPgPools)();
            await manager.closeAll({ keepDb: teardownOpts.keepDb });
        })();
        return teardownPromise;
    };
    if (seedAdapters.length) {
        try {
            await seed_1.seed.compose(seedAdapters).seed({
                connect: connOpts,
                admin,
                config: config,
                pg: manager.getClient(config)
            });
        }
        catch (error) {
            // Format the error with PostgreSQL extended fields for better debugging
            const formatted = (0, utils_1.formatPgError)(error);
            process.stderr.write(`[pgsql-test] Seed error (continuing):\n${formatted}\n`);
            // continue without teardown to allow caller-managed lifecycle
        }
    }
    const dbConfig = {
        ...config,
        user: connOpts.connections.app.user,
        password: connOpts.connections.app.password
    };
    const db = manager.getClient(dbConfig, {
        auth: connOpts.auth,
        roles: connOpts.roles
    });
    db.setContext({ role: (0, pgsql_client_1.getDefaultRole)(connOpts) });
    return { pg, db, teardown, manager, admin };
};
exports.getConnections = getConnections;