pgsql-test 0.0.1 → 2.0.1

package/esm/admin.js

@@ -0,0 +1,126 @@
+import { execSync } from 'child_process';
+import { getPgEnvOptions } from '@launchql/types';
+import { existsSync } from 'fs';
+import { streamSql as stream } from './stream';
+export class DbAdmin {
+    config;
+    verbose;
+    constructor(config, verbose = false) {
+        this.config = config;
+        this.verbose = verbose;
+        this.config = getPgEnvOptions(config);
+    }
+    getEnv() {
+        return {
+            PGHOST: this.config.host,
+            PGPORT: String(this.config.port),
+            PGUSER: this.config.user,
+            PGPASSWORD: this.config.password,
+        };
+    }
+    run(command) {
+        execSync(command, {
+            stdio: this.verbose ? 'inherit' : 'pipe',
+            env: {
+                ...process.env,
+                ...this.getEnv(),
+            },
+        });
+    }
+    safeDropDb(name) {
+        try {
+            this.run(`dropdb "${name}"`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (!message.includes('does not exist')) {
+                console.warn(`⚠️  Could not drop database ${name}: ${message}`);
+            }
+        }
+    }
+    drop(dbName) {
+        this.safeDropDb(dbName ?? this.config.database);
+    }
+    dropTemplate(dbName) {
+        this.run(`psql -c "UPDATE pg_database SET datistemplate='false' WHERE datname='${dbName}';"`);
+        this.drop(dbName);
+    }
+    create(dbName) {
+        const db = dbName ?? this.config.database;
+        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} "${db}"`);
+    }
+    createFromTemplate(template, dbName) {
+        const db = dbName ?? this.config.database;
+        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} -e "${db}" -T "${template}"`);
+    }
+    installExtensions(extensions, dbName) {
+        const db = dbName ?? this.config.database;
+        const extList = typeof extensions === 'string' ? extensions.split(',') : extensions;
+        for (const extension of extList) {
+            this.run(`psql --dbname "${db}" -c 'CREATE EXTENSION IF NOT EXISTS "${extension}" CASCADE;'`);
+        }
+    }
+    connectionString(dbName) {
+        const { user, password, host, port } = this.config;
+        const db = dbName ?? this.config.database;
+        return `postgres://${user}:${password}@${host}:${port}/${db}`;
+    }
+    createTemplateFromBase(base, template) {
+        this.run(`createdb -T "${base}" "${template}"`);
+        this.run(`psql -c "UPDATE pg_database SET datistemplate = true WHERE datname = '${template}';"`);
+    }
+    cleanupTemplate(template) {
+        try {
+            this.run(`psql -c "UPDATE pg_database SET datistemplate = false WHERE datname = '${template}'"`);
+        }
+        catch { }
+        this.safeDropDb(template);
+    }
+    async grantRole(role, user, dbName) {
+        const db = dbName ?? this.config.database;
+        const sql = `GRANT ${role} TO ${user};`;
+        await this.streamSql(sql, db);
+    }
+    async grantConnect(role, dbName) {
+        const db = dbName ?? this.config.database;
+        const sql = `GRANT CONNECT ON DATABASE "${db}" TO ${role};`;
+        await this.streamSql(sql, db);
+    }
+    async createUserRole(user, password, dbName) {
+        const sql = `
+  DO $$
+  BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${user}') THEN
+      CREATE ROLE ${user} LOGIN PASSWORD '${password}';
+      GRANT anonymous TO ${user};
+      GRANT authenticated TO ${user};
+    END IF;
+  END $$;
+    `.trim();
+        this.streamSql(sql, dbName);
+    }
+    loadSql(file, dbName) {
+        if (!existsSync(file)) {
+            throw new Error(`Missing SQL file: ${file}`);
+        }
+        this.run(`psql -f ${file} ${dbName}`);
+    }
+    async streamSql(sql, dbName) {
+        await stream({
+            ...this.config,
+            database: dbName
+        }, sql);
+    }
+    async createSeededTemplate(templateName, adapter) {
+        const seedDb = this.config.database;
+        this.create(seedDb);
+        await adapter.seed({
+            admin: this,
+            config: this.config,
+            pg: null // sorry!
+        });
+        this.cleanupTemplate(templateName);
+        this.createTemplateFromBase(seedDb, templateName);
+        this.drop(seedDb);
+    }
+}

package/esm/connect.js

@@ -0,0 +1,90 @@
+import { DbAdmin } from './admin';
+import { getEnvOptions, getPgEnvOptions, getConnEnvOptions } from '@launchql/types';
+import { deploy, deployFast, LaunchQLProject } from '@launchql/migrate';
+import { PgTestConnector } from './manager';
+import { randomUUID } from 'crypto';
+import { teardownPgPools } from '@launchql/server-utils';
+let manager;
+export const getPgRootAdmin = (connOpts = {}) => {
+    const opts = getPgEnvOptions({
+        database: connOpts.rootDb
+    });
+    const admin = new DbAdmin(opts);
+    return admin;
+};
+const getConnOopts = (cn = {}) => {
+    const connect = getConnEnvOptions(cn.db);
+    const config = getPgEnvOptions({
+        database: `${connect.prefix}${randomUUID()}`,
+        ...cn.pg
+    });
+    return {
+        pg: config,
+        db: connect
+    };
+};
+export const getConnections = async (cn = {}, seedAdapter) => {
+    cn = getConnOopts(cn);
+    const config = cn.pg;
+    const connOpts = cn.db;
+    const root = getPgRootAdmin(connOpts);
+    await root.createUserRole(connOpts.connection.user, connOpts.connection.password, connOpts.rootDb);
+    const admin = new DbAdmin(config);
+    const proj = new LaunchQLProject(connOpts.cwd);
+    if (proj.isInModule()) {
+        admin.create(config.database);
+        admin.installExtensions(connOpts.extensions);
+        const opts = getEnvOptions({
+            pg: config
+        });
+        if (connOpts.deployFast) {
+            await deployFast({
+                opts,
+                name: proj.getModuleName(),
+                database: config.database,
+                dir: proj.modulePath,
+                usePlan: true,
+                verbose: false
+            });
+        }
+        else {
+            await deploy(opts, proj.getModuleName(), config.database, proj.modulePath);
+        }
+    }
+    else {
+        // Create the test database
+        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.connection.user, config.database);
+    // Main admin client (optional unless needed elsewhere)
+    manager = PgTestConnector.getInstance();
+    const pg = manager.getClient(config);
+    if (seedAdapter) {
+        await seedAdapter.seed({
+            admin,
+            config: config,
+            pg: manager.getClient(config)
+        });
+    }
+    // App user connection
+    const db = manager.getClient({
+        ...config,
+        user: connOpts.connection.user,
+        password: connOpts.connection.password
+    });
+    db.setContext({ role: 'anonymous' });
+    const teardown = async () => {
+        await teardownPgPools();
+        await manager.closeAll();
+    };
+    return { pg, db, teardown, manager, admin };
+};

package/{src/index.ts → esm/index.js}

@@ -1,2 +1,2 @@
 export * from './legacy-connect';
-export * from './utils';
+export * from './utils';

package/esm/legacy-connect.js

@@ -0,0 +1,25 @@
+import { PgTestConnector } from './manager';
+import { getPgEnvOptions } from '@launchql/types';
+export function connect(config) {
+    const manager = PgTestConnector.getInstance();
+    return manager.getClient(config);
+}
+export function close(client) {
+    client.close();
+}
+const manager = PgTestConnector.getInstance();
+export const Connection = {
+    connect(config) {
+        const creds = getPgEnvOptions(config);
+        return manager.getClient(creds);
+    },
+    close(client) {
+        client.close();
+    },
+    closeAll() {
+        return manager.closeAll();
+    },
+    getManager() {
+        return manager;
+    }
+};

package/esm/manager.js

@@ -0,0 +1,117 @@
+import { Pool } from 'pg';
+import chalk from 'chalk';
+import { DbAdmin } from './admin';
+import { getPgEnvOptions } from '@launchql/types';
+import { PgTestClient } from './test-client';
+const SYS_EVENTS = ['SIGTERM'];
+const end = (pool) => {
+    try {
+        if (pool.ended || pool.ending) {
+            console.warn(chalk.yellow('⚠️ pg pool already ended or ending'));
+            return;
+        }
+        pool.end();
+    }
+    catch (err) {
+        console.error(chalk.red('❌ pg pool termination error:'), err);
+    }
+};
+export class PgTestConnector {
+    static instance;
+    clients = new Set();
+    pgPools = new Map();
+    seenDbConfigs = new Map();
+    verbose = false;
+    constructor(verbose = false) {
+        this.verbose = verbose;
+        SYS_EVENTS.forEach((event) => {
+            process.on(event, () => {
+                this.log(chalk.magenta(`⏹ Received ${event}, closing all connections...`));
+                this.closeAll();
+            });
+        });
+    }
+    static getInstance(verbose = false) {
+        if (!PgTestConnector.instance) {
+            PgTestConnector.instance = new PgTestConnector(verbose);
+        }
+        return PgTestConnector.instance;
+    }
+    log(...args) {
+        if (this.verbose)
+            console.log(...args);
+    }
+    poolKey(config) {
+        return `${config.user}@${config.host}:${config.port}/${config.database}`;
+    }
+    dbKey(config) {
+        return `${config.host}:${config.port}/${config.database}`;
+    }
+    getPool(config) {
+        const key = this.poolKey(config);
+        if (!this.pgPools.has(key)) {
+            const pool = new Pool(config);
+            this.pgPools.set(key, pool);
+            this.log(chalk.blue(`📘 Created new pg pool: ${chalk.white(key)}`));
+        }
+        return this.pgPools.get(key);
+    }
+    getClient(config) {
+        const client = new PgTestClient(config);
+        this.clients.add(client);
+        const key = this.dbKey(config);
+        this.seenDbConfigs.set(key, config);
+        this.log(chalk.green(`🔌 New PgTestClient connected to ${config.database}`));
+        return client;
+    }
+    async closeAll() {
+        this.log(chalk.cyan('\n🧹 Closing all PgTestClients...'));
+        await Promise.all(Array.from(this.clients).map(async (client) => {
+            try {
+                await client.close();
+                this.log(chalk.green(`✅ Closed client for ${client.config.database}`));
+            }
+            catch (err) {
+                console.warn(chalk.red(`❌ Error closing PgTestClient for ${client.config.database}:`), err);
+            }
+        }));
+        this.clients.clear();
+        this.log(chalk.cyan('\n🧯 Disposing pg pools...'));
+        for (const [key, pool] of this.pgPools.entries()) {
+            this.log(chalk.gray(`🧯 Disposing pg pool [${key}]`));
+            end(pool);
+        }
+        this.pgPools.clear();
+        this.log(chalk.cyan('\n🗑️ Dropping seen databases...'));
+        await Promise.all(Array.from(this.seenDbConfigs.values()).map(async (config) => {
+            try {
+                // somehow an "admin" db had app_user creds?
+                const rootPg = getPgEnvOptions();
+                const admin = new DbAdmin({ ...config, user: rootPg.user, password: rootPg.password }, this.verbose);
+                // console.log(config);
+                admin.drop();
+                this.log(chalk.yellow(`🧨 Dropped database: ${chalk.white(config.database)}`));
+            }
+            catch (err) {
+                console.warn(chalk.red(`❌ Failed to drop database ${config.database}:`), err);
+            }
+        }));
+        this.seenDbConfigs.clear();
+        this.log(chalk.green('\n✅ All PgTestClients closed, pools disposed, databases dropped.'));
+    }
+    close() {
+        this.closeAll();
+    }
+    drop(config) {
+        const key = this.dbKey(config);
+        // for drop, no need for conn opts
+        const admin = new DbAdmin(config, this.verbose);
+        admin.drop();
+        this.log(chalk.red(`🧨 Dropped database: ${chalk.white(config.database)}`));
+        this.seenDbConfigs.delete(key);
+    }
+    kill(client) {
+        client.close();
+        this.drop(client.config);
+    }
+}

package/esm/seed.js

@@ -0,0 +1,35 @@
+function sqlfile(files) {
+    return {
+        seed(ctx) {
+            for (const file of files) {
+                ctx.admin.loadSql(file, ctx.config.database);
+            }
+        }
+    };
+}
+function fn(fn) {
+    return {
+        seed: fn
+    };
+}
+function csv(fn) {
+    throw new Error('not yet implemented');
+    return {
+        seed: fn
+    };
+}
+function compose(adapters) {
+    return {
+        async seed(ctx) {
+            for (const adapter of adapters) {
+                await adapter.seed(ctx);
+            }
+        }
+    };
+}
+export const seed = {
+    compose,
+    fn,
+    csv,
+    sqlfile
+};

package/esm/stream.js

@@ -0,0 +1,43 @@
+import { spawn } from 'child_process';
+import { Readable } from 'stream';
+import { getSpawnEnvWithPg } from '@launchql/types';
+function setArgs(config) {
+    const args = [
+        '-U', config.user,
+        '-h', config.host,
+        '-d', config.database
+    ];
+    if (config.port) {
+        args.push('-p', String(config.port));
+    }
+    return args;
+}
+// Converts a string to a readable stream (replaces streamify-string)
+function stringToStream(text) {
+    const stream = new Readable({
+        read() {
+            this.push(text);
+            this.push(null);
+        }
+    });
+    return stream;
+}
+export async function streamSql(config, sql) {
+    const args = setArgs(config);
+    return new Promise((resolve, reject) => {
+        const sqlStream = stringToStream(sql);
+        const proc = spawn('psql', args, {
+            env: getSpawnEnvWithPg(config)
+        });
+        sqlStream.pipe(proc.stdin);
+        proc.on('close', (code) => {
+            resolve();
+        });
+        proc.on('error', (error) => {
+            reject(error);
+        });
+        proc.stderr.on('data', (data) => {
+            reject(new Error(data.toString()));
+        });
+    });
+}

package/esm/test-client.js

@@ -0,0 +1,88 @@
+import { Client } from 'pg';
+export class PgTestClient {
+    config;
+    client;
+    ctxStmts = '';
+    _ended = false;
+    constructor(config) {
+        this.config = config;
+        this.client = new Client({
+            host: this.config.host,
+            port: this.config.port,
+            database: this.config.database,
+            user: this.config.user,
+            password: this.config.password
+        });
+        this.client.connect();
+    }
+    close() {
+        if (!this._ended) {
+            this._ended = true;
+            this.client.end();
+        }
+    }
+    async begin() {
+        await this.client.query('BEGIN;');
+    }
+    async savepoint(name = 'lqlsavepoint') {
+        await this.client.query(`SAVEPOINT "${name}";`);
+    }
+    async rollback(name = 'lqlsavepoint') {
+        await this.client.query(`ROLLBACK TO SAVEPOINT "${name}";`);
+    }
+    async commit() {
+        await this.client.query('COMMIT;');
+    }
+    async beforeEach() {
+        await this.begin();
+        await this.savepoint();
+    }
+    async afterEach() {
+        await this.rollback();
+        await this.commit();
+    }
+    setContext(ctx) {
+        this.ctxStmts = Object.entries(ctx)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+    }
+    async any(query, values) {
+        const result = await this.query(query, values);
+        return result.rows;
+    }
+    async one(query, values) {
+        const rows = await this.any(query, values);
+        if (rows.length !== 1) {
+            throw new Error('Expected exactly one result');
+        }
+        return rows[0];
+    }
+    async oneOrNone(query, values) {
+        const rows = await this.any(query, values);
+        return rows[0] || null;
+    }
+    async many(query, values) {
+        const rows = await this.any(query, values);
+        if (rows.length === 0)
+            throw new Error('Expected many rows, got none');
+        return rows;
+    }
+    async manyOrNone(query, values) {
+        return this.any(query, values);
+    }
+    async none(query, values) {
+        await this.query(query, values);
+    }
+    async result(query, values) {
+        return this.query(query, values);
+    }
+    async query(query, values) {
+        if (this.ctxStmts) {
+            await this.client.query(this.ctxStmts);
+        }
+        const result = await this.client.query(query, values);
+        return result;
+    }
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './legacy-connect';
+export * from './utils';

package/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./legacy-connect"), exports);
+__exportStar(require("./utils"), exports);

package/legacy-connect.d.ts

@@ -0,0 +1,11 @@
+import { PgTestClient } from './test-client';
+import { PgTestConnector } from './manager';
+import { PgConfig } from '@launchql/types';
+export declare function connect(config: PgConfig): PgTestClient;
+export declare function close(client: PgTestClient): void;
+export declare const Connection: {
+    connect(config: Partial<PgConfig>): PgTestClient;
+    close(client: PgTestClient): void;
+    closeAll(): Promise<void>;
+    getManager(): PgTestConnector;
+};

package/legacy-connect.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+exports.connect = connect;
+exports.close = close;
+const manager_1 = require("./manager");
+const types_1 = require("@launchql/types");
+function connect(config) {
+    const manager = manager_1.PgTestConnector.getInstance();
+    return manager.getClient(config);
+}
+function close(client) {
+    client.close();
+}
+const manager = manager_1.PgTestConnector.getInstance();
+exports.Connection = {
+    connect(config) {
+        const creds = (0, types_1.getPgEnvOptions)(config);
+        return manager.getClient(creds);
+    },
+    close(client) {
+        client.close();
+    },
+    closeAll() {
+        return manager.closeAll();
+    },
+    getManager() {
+        return manager;
+    }
+};

package/manager.d.ts

@@ -0,0 +1,21 @@
+import { Pool } from 'pg';
+import { PgConfig } from '@launchql/types';
+import { PgTestClient } from './test-client';
+export declare class PgTestConnector {
+    private static instance;
+    private readonly clients;
+    private readonly pgPools;
+    private readonly seenDbConfigs;
+    private verbose;
+    private constructor();
+    static getInstance(verbose?: boolean): PgTestConnector;
+    private log;
+    private poolKey;
+    private dbKey;
+    getPool(config: PgConfig): Pool;
+    getClient(config: PgConfig): PgTestClient;
+    closeAll(): Promise<void>;
+    close(): void;
+    drop(config: PgConfig): void;
+    kill(client: PgTestClient): void;
+}