pgsql-seed 0.0.1

package/admin.d.ts

@@ -0,0 +1,26 @@
+import { PgTestConnectionOptions } from '@pgpmjs/types';
+import { PgConfig } from 'pg-env';
+import { SeedAdapter } from './seed/types';
+export declare class DbAdmin {
+    private config;
+    private verbose;
+    private roleConfig?;
+    constructor(config: PgConfig, verbose?: boolean, roleConfig?: PgTestConnectionOptions);
+    private getEnv;
+    private run;
+    private safeDropDb;
+    drop(dbName?: string): void;
+    dropTemplate(dbName: string): void;
+    create(dbName?: string): void;
+    createFromTemplate(template: string, dbName?: string): void;
+    installExtensions(extensions: string[] | string, dbName?: string): void;
+    connectionString(dbName?: string): string;
+    createTemplateFromBase(base: string, template: string): void;
+    cleanupTemplate(template: string): void;
+    grantRole(role: string, user: string, dbName?: string): Promise<void>;
+    grantConnect(role: string, dbName?: string): Promise<void>;
+    createUserRole(user: string, password: string, dbName: string, useLocksForRoles?: boolean): Promise<void>;
+    loadSql(file: string, dbName: string): void;
+    streamSql(sql: string, dbName: string): Promise<void>;
+    createSeededTemplate(templateName: string, adapter: SeedAdapter): Promise<void>;
+}

package/admin.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbAdmin = void 0;
+const core_1 = require("@pgpmjs/core");
+const logger_1 = require("@pgpmjs/logger");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const pg_env_1 = require("pg-env");
+const roles_1 = require("./roles");
+const stream_1 = require("./stream");
+const log = new logger_1.Logger('db-admin');
+class DbAdmin {
+    config;
+    verbose;
+    roleConfig;
+    constructor(config, verbose = false, roleConfig) {
+        this.config = config;
+        this.verbose = verbose;
+        this.roleConfig = roleConfig;
+        this.config = (0, pg_env_1.getPgEnvOptions)(config);
+    }
+    getEnv() {
+        return {
+            PGHOST: this.config.host,
+            PGPORT: String(this.config.port),
+            PGUSER: this.config.user,
+            PGPASSWORD: this.config.password
+        };
+    }
+    run(command) {
+        try {
+            (0, child_process_1.execSync)(command, {
+                stdio: this.verbose ? 'inherit' : 'pipe',
+                env: {
+                    ...process.env,
+                    ...this.getEnv()
+                }
+            });
+            if (this.verbose)
+                log.success(`Executed: ${command}`);
+        }
+        catch (err) {
+            log.error(`Command failed: ${command}`);
+            if (this.verbose)
+                log.error(err.message);
+            throw err;
+        }
+    }
+    safeDropDb(name) {
+        try {
+            this.run(`dropdb "${name}"`);
+        }
+        catch (err) {
+            if (!err.message.includes('does not exist')) {
+                log.warn(`Could not drop database ${name}: ${err.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 {
+            log.warn(`Skipping failed UPDATE of datistemplate for ${template}`);
+        }
+        this.safeDropDb(template);
+    }
+    async grantRole(role, user, dbName) {
+        const db = dbName ?? this.config.database;
+        const sql = (0, core_1.generateGrantRoleSQL)(role, 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);
+    }
+    // ONLY granting admin role for testing purposes, normally the db connection for apps won't have admin role
+    // DO NOT USE THIS FOR PRODUCTION
+    async createUserRole(user, password, dbName, useLocksForRoles = false) {
+        const anonRole = (0, roles_1.getRoleName)('anonymous', this.roleConfig);
+        const authRole = (0, roles_1.getRoleName)('authenticated', this.roleConfig);
+        const adminRole = (0, roles_1.getRoleName)('administrator', this.roleConfig);
+        const sql = (0, core_1.generateCreateUserWithGrantsSQL)(user, password, [anonRole, authRole, adminRole], useLocksForRoles);
+        await this.streamSql(sql, dbName);
+    }
+    loadSql(file, dbName) {
+        if (!(0, fs_1.existsSync)(file)) {
+            throw new Error(`Missing SQL file: ${file}`);
+        }
+        this.run(`psql -f ${file} ${dbName}`);
+    }
+    async streamSql(sql, dbName) {
+        await (0, stream_1.streamSql)({
+            ...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, // placeholder for PgTestClient
+            connect: null // placeholder for connection factory
+        });
+        this.cleanupTemplate(templateName);
+        this.createTemplateFromBase(seedDb, templateName);
+        this.drop(seedDb);
+    }
+}
+exports.DbAdmin = DbAdmin;

package/connect.d.ts

@@ -0,0 +1,19 @@
+import { PgTestConnectionOptions } from '@pgpmjs/types';
+import { PgConfig } from 'pg-env';
+import { DbAdmin } from './admin';
+import { PgTestConnector } from './manager';
+import { SeedAdapter } from './seed/types';
+import { PgTestClient } from './test-client';
+export declare const getPgRootAdmin: (config: PgConfig, connOpts?: PgTestConnectionOptions) => DbAdmin;
+export interface GetConnectionOpts {
+    pg?: Partial<PgConfig>;
+    db?: Partial<PgTestConnectionOptions>;
+}
+export interface GetConnectionResult {
+    pg: PgTestClient;
+    db: PgTestClient;
+    admin: DbAdmin;
+    teardown: () => Promise<void>;
+    manager: PgTestConnector;
+}
+export declare const getConnections: (cn?: GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<GetConnectionResult>;

package/connect.js

@@ -0,0 +1,95 @@
+"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 admin_1 = require("./admin");
+const manager_1 = require("./manager");
+const roles_1 = require("./roles");
+const seed_1 = require("./seed");
+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;
+    const teardown = async () => {
+        if (teardownPromise)
+            return teardownPromise;
+        teardownPromise = (async () => {
+            manager.beginTeardown();
+            await (0, pg_cache_1.teardownPgPools)();
+            await manager.closeAll();
+        })();
+        return teardownPromise;
+    };
+    if (seedAdapters.length) {
+        try {
+            await seed_1.seed.compose(seedAdapters).seed({
+                connect: connOpts,
+                admin,
+                config: config,
+                pg: manager.getClient(config)
+            });
+        }
+        catch (error) {
+            const err = error;
+            const msg = err && (err.stack || err.message) ? (err.stack || err.message) : String(err);
+            process.stderr.write(`[pgsql-test] Seed error (continuing): ${msg}\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, roles_1.getDefaultRole)(connOpts) });
+    return { pg, db, teardown, manager, admin };
+};
+exports.getConnections = getConnections;

package/context-utils.d.ts

@@ -0,0 +1,8 @@
+import type { PgTestClientContext } from '@pgpmjs/types';
+/**
+ * Generate SQL statements to set PostgreSQL session context variables
+ * Uses SET LOCAL ROLE for the 'role' key and set_config() for other variables
+ * @param context - Context settings to apply
+ * @returns SQL string with SET LOCAL ROLE and set_config() statements
+ */
+export declare function generateContextStatements(context: PgTestClientContext): string;

package/context-utils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateContextStatements = generateContextStatements;
+/**
+ * Generate SQL statements to set PostgreSQL session context variables
+ * Uses SET LOCAL ROLE for the 'role' key and set_config() for other variables
+ * @param context - Context settings to apply
+ * @returns SQL string with SET LOCAL ROLE and set_config() statements
+ */
+function generateContextStatements(context) {
+    return Object.entries(context)
+        .map(([key, val]) => {
+        if (key === 'role') {
+            if (val === null || val === undefined) {
+                return 'SET LOCAL ROLE NONE;';
+            }
+            const escapedRole = val.replace(/"/g, '""');
+            return `SET LOCAL ROLE "${escapedRole}";`;
+        }
+        // Use set_config for other context variables
+        if (val === null || val === undefined) {
+            return `SELECT set_config('${key}', NULL, true);`;
+        }
+        const escapedVal = val.replace(/'/g, "''");
+        return `SELECT set_config('${key}', '${escapedVal}', true);`;
+    })
+        .join('\n');
+}

package/esm/admin.js

@@ -0,0 +1,140 @@
+import { generateCreateUserWithGrantsSQL, generateGrantRoleSQL } from '@pgpmjs/core';
+import { Logger } from '@pgpmjs/logger';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { getPgEnvOptions } from 'pg-env';
+import { getRoleName } from './roles';
+import { streamSql as stream } from './stream';
+const log = new Logger('db-admin');
+export class DbAdmin {
+    config;
+    verbose;
+    roleConfig;
+    constructor(config, verbose = false, roleConfig) {
+        this.config = config;
+        this.verbose = verbose;
+        this.roleConfig = roleConfig;
+        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) {
+        try {
+            execSync(command, {
+                stdio: this.verbose ? 'inherit' : 'pipe',
+                env: {
+                    ...process.env,
+                    ...this.getEnv()
+                }
+            });
+            if (this.verbose)
+                log.success(`Executed: ${command}`);
+        }
+        catch (err) {
+            log.error(`Command failed: ${command}`);
+            if (this.verbose)
+                log.error(err.message);
+            throw err;
+        }
+    }
+    safeDropDb(name) {
+        try {
+            this.run(`dropdb "${name}"`);
+        }
+        catch (err) {
+            if (!err.message.includes('does not exist')) {
+                log.warn(`Could not drop database ${name}: ${err.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 {
+            log.warn(`Skipping failed UPDATE of datistemplate for ${template}`);
+        }
+        this.safeDropDb(template);
+    }
+    async grantRole(role, user, dbName) {
+        const db = dbName ?? this.config.database;
+        const sql = generateGrantRoleSQL(role, 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);
+    }
+    // ONLY granting admin role for testing purposes, normally the db connection for apps won't have admin role
+    // DO NOT USE THIS FOR PRODUCTION
+    async createUserRole(user, password, dbName, useLocksForRoles = false) {
+        const anonRole = getRoleName('anonymous', this.roleConfig);
+        const authRole = getRoleName('authenticated', this.roleConfig);
+        const adminRole = getRoleName('administrator', this.roleConfig);
+        const sql = generateCreateUserWithGrantsSQL(user, password, [anonRole, authRole, adminRole], useLocksForRoles);
+        await 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, // placeholder for PgTestClient
+            connect: null // placeholder for connection factory
+        });
+        this.cleanupTemplate(templateName);
+        this.createTemplateFromBase(seedDb, templateName);
+        this.drop(seedDb);
+    }
+}

package/esm/connect.js

@@ -0,0 +1,90 @@
+import { getConnEnvOptions } from '@pgpmjs/env';
+import { randomUUID } from 'crypto';
+import { teardownPgPools } from 'pg-cache';
+import { getPgEnvOptions, } from 'pg-env';
+import { DbAdmin } from './admin';
+import { PgTestConnector } from './manager';
+import { getDefaultRole } from './roles';
+import { seed } from './seed';
+let manager;
+export const getPgRootAdmin = (config, connOpts = {}) => {
+    const opts = getPgEnvOptions({
+        user: config.user,
+        password: config.password,
+        host: config.host,
+        port: config.port,
+        database: connOpts.rootDb
+    });
+    const admin = new DbAdmin(opts, false, connOpts);
+    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 = {}, seedAdapters = [seed.pgpm()]) => {
+    cn = getConnOopts(cn);
+    const config = cn.pg;
+    const connOpts = cn.db;
+    const root = getPgRootAdmin(config, connOpts);
+    await root.createUserRole(connOpts.connections.app.user, connOpts.connections.app.password, connOpts.rootDb);
+    const admin = new 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 = PgTestConnector.getInstance(config);
+    const pg = manager.getClient(config);
+    let teardownPromise = null;
+    const teardown = async () => {
+        if (teardownPromise)
+            return teardownPromise;
+        teardownPromise = (async () => {
+            manager.beginTeardown();
+            await teardownPgPools();
+            await manager.closeAll();
+        })();
+        return teardownPromise;
+    };
+    if (seedAdapters.length) {
+        try {
+            await seed.compose(seedAdapters).seed({
+                connect: connOpts,
+                admin,
+                config: config,
+                pg: manager.getClient(config)
+            });
+        }
+        catch (error) {
+            const err = error;
+            const msg = err && (err.stack || err.message) ? (err.stack || err.message) : String(err);
+            process.stderr.write(`[pgsql-test] Seed error (continuing): ${msg}\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: getDefaultRole(connOpts) });
+    return { pg, db, teardown, manager, admin };
+};

package/esm/context-utils.js

@@ -0,0 +1,25 @@
+/**
+ * Generate SQL statements to set PostgreSQL session context variables
+ * Uses SET LOCAL ROLE for the 'role' key and set_config() for other variables
+ * @param context - Context settings to apply
+ * @returns SQL string with SET LOCAL ROLE and set_config() statements
+ */
+export function generateContextStatements(context) {
+    return Object.entries(context)
+        .map(([key, val]) => {
+        if (key === 'role') {
+            if (val === null || val === undefined) {
+                return 'SET LOCAL ROLE NONE;';
+            }
+            const escapedRole = val.replace(/"/g, '""');
+            return `SET LOCAL ROLE "${escapedRole}";`;
+        }
+        // Use set_config for other context variables
+        if (val === null || val === undefined) {
+            return `SELECT set_config('${key}', NULL, true);`;
+        }
+        const escapedVal = val.replace(/'/g, "''");
+        return `SELECT set_config('${key}', '${escapedVal}', true);`;
+    })
+        .join('\n');
+}

package/esm/index.js

@@ -0,0 +1,7 @@
+export * from './admin';
+export * from './connect';
+export * from './manager';
+export * from './roles';
+export * from './seed';
+export * from './test-client';
+export { snapshot } from './utils';