pgsql-seed 0.0.1 → 0.2.0

package/esm/stream.js

@@ -1,96 +0,0 @@
-import { spawn } from 'child_process';
-import { getSpawnEnvWithPg } from 'pg-env';
-import { Readable } from 'stream';
-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;
-}
-/**
- * Executes SQL statements by streaming them to psql.
- *
- * IMPORTANT: PostgreSQL stderr handling
- * -------------------------------------
- * PostgreSQL sends different message types to stderr, not just errors:
- *   - ERROR: Actual SQL errors (should fail)
- *   - WARNING: Potential issues (informational)
- *   - NOTICE: Informational messages (should NOT fail)
- *   - INFO: Informational messages (should NOT fail)
- *   - DEBUG: Debug messages (should NOT fail)
- *
- * Example scenario that previously caused false failures:
- * When running SQL like:
- *   GRANT administrator TO app_user;
- *
- * If app_user is already a member of administrator, PostgreSQL outputs:
- *   NOTICE: role "app_user" is already a member of role "administrator"
- *
- * This is NOT an error - the GRANT succeeded (it's idempotent). But because
- * this message goes to stderr, the old implementation would reject the promise
- * and fail the test, even though nothing was wrong.
- *
- * Solution:
- * 1. Buffer stderr instead of rejecting immediately on any output
- * 2. Use ON_ERROR_STOP=1 so psql exits with non-zero code on actual SQL errors
- * 3. Only reject if the exit code is non-zero, using buffered stderr as the error message
- *
- * This way, NOTICE/WARNING messages are collected but don't cause failures,
- * while actual SQL errors still properly fail with meaningful error messages.
- */
-export async function streamSql(config, sql) {
-    const args = [
-        ...setArgs(config),
-        // ON_ERROR_STOP=1 makes psql exit with a non-zero code when it encounters
-        // an actual SQL error. Without this, psql might continue executing subsequent
-        // statements and exit with code 0 even if some statements failed.
-        '-v', 'ON_ERROR_STOP=1'
-    ];
-    return new Promise((resolve, reject) => {
-        const sqlStream = stringToStream(sql);
-        // Buffer stderr instead of rejecting immediately. This allows us to collect
-        // all output (including harmless NOTICE messages) and only use it for error
-        // reporting if the process actually fails.
-        let stderrBuffer = '';
-        const proc = spawn('psql', args, {
-            env: getSpawnEnvWithPg(config)
-        });
-        sqlStream.pipe(proc.stdin);
-        // Collect stderr output. We don't reject here because stderr may contain
-        // harmless NOTICE/WARNING messages that shouldn't cause test failures.
-        proc.stderr.on('data', (data) => {
-            stderrBuffer += data.toString();
-        });
-        // Determine success/failure based on exit code, not stderr content.
-        // Exit code 0 = success (even if there were NOTICE messages on stderr)
-        // Exit code non-zero = actual error occurred
-        proc.on('close', (code) => {
-            if (code !== 0) {
-                // Include the buffered stderr in the error message for debugging
-                reject(new Error(stderrBuffer || `psql exited with code ${code}`));
-            }
-            else {
-                resolve();
-            }
-        });
-        // Handle spawn errors (e.g., psql not found)
-        proc.on('error', (error) => {
-            reject(error);
-        });
-    });
-}

package/esm/test-client.js

@@ -1,168 +0,0 @@
-import { Client } from 'pg';
-import { getRoleName } from './roles';
-import { generateContextStatements } from './context-utils';
-import { insertJson } from './seed/json';
-import { loadCsvMap } from './seed/csv';
-import { loadSqlFiles } from './seed/sql';
-import { deployPgpm } from './seed/pgpm';
-export class PgTestClient {
-    config;
-    client;
-    opts;
-    ctxStmts = '';
-    contextSettings = {};
-    _ended = false;
-    connectPromise = null;
-    constructor(config, opts = {}) {
-        this.opts = opts;
-        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
-        });
-        if (!opts.deferConnect) {
-            this.connectPromise = this.client.connect();
-            if (opts.trackConnect)
-                opts.trackConnect(this.connectPromise);
-        }
-    }
-    async ensureConnected() {
-        if (this.connectPromise) {
-            try {
-                await this.connectPromise;
-            }
-            catch { }
-        }
-    }
-    async close() {
-        if (!this._ended) {
-            this._ended = true;
-            await this.ensureConnected();
-            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) {
-        Object.assign(this.contextSettings, ctx);
-        this.ctxStmts = generateContextStatements(this.contextSettings);
-    }
-    /**
-     * Set authentication context for the current session.
-     * Configures role and user ID using cascading defaults from options → opts.auth → RoleMapping.
-     */
-    auth(options = {}) {
-        const role = options.role ?? this.opts.auth?.role ?? getRoleName('authenticated', this.opts);
-        const userIdKey = options.userIdKey ?? this.opts.auth?.userIdKey ?? 'jwt.claims.user_id';
-        const userId = options.userId ?? this.opts.auth?.userId ?? null;
-        this.setContext({
-            role,
-            [userIdKey]: userId !== null ? String(userId) : null
-        });
-    }
-    /**
-     * Commit current transaction to make data visible to other connections, then start fresh transaction.
-     * Maintains test isolation by creating a savepoint and reapplying session context.
-     */
-    async publish() {
-        await this.commit(); // make data visible to other sessions
-        await this.begin(); // fresh tx
-        await this.savepoint(); // keep rollback harness
-        await this.ctxQuery(); // reapply all setContext()
-    }
-    /**
-     * Clear all session context variables and reset to default anonymous role.
-     */
-    clearContext() {
-        const defaultRole = getRoleName('anonymous', this.opts);
-        const nulledSettings = {};
-        Object.keys(this.contextSettings).forEach(key => {
-            nulledSettings[key] = null;
-        });
-        nulledSettings.role = defaultRole;
-        this.ctxStmts = generateContextStatements(nulledSettings);
-        this.contextSettings = { role: defaultRole };
-    }
-    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 ctxQuery() {
-        if (this.ctxStmts) {
-            await this.client.query(this.ctxStmts);
-        }
-    }
-    // NOTE: all queries should call ctxQuery() before executing the query
-    async query(query, values) {
-        await this.ctxQuery();
-        const result = await this.client.query(query, values);
-        return result;
-    }
-    async loadJson(data) {
-        await this.ctxQuery();
-        await insertJson(this.client, data);
-    }
-    async loadSql(files) {
-        await this.ctxQuery();
-        await loadSqlFiles(this.client, files);
-    }
-    // NON-RLS load/seed methods:
-    async loadCsv(tables) {
-        // await this.ctxQuery(); // no point to call ctxQuery() here
-        // because POSTGRES doesn't support row-level security on COPY FROM...
-        await loadCsvMap(this.client, tables);
-    }
-    async loadPgpm(cwd, cache = false) {
-        // await this.ctxQuery(); // no point to call ctxQuery() here
-        // because deployPgpm() has it's own way of getting the client...
-        // so for now, we'll expose this but it's limited
-        await deployPgpm(this.config, cwd, cache);
-    }
-}

package/esm/utils.js

@@ -1,91 +0,0 @@
-const uuidRegexp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const idReplacement = (v, idHash) => {
-    if (!v)
-        return v;
-    if (!idHash)
-        return '[ID]';
-    const key = String(v);
-    return idHash[key] !== undefined ? `[ID-${idHash[key]}]` : '[ID]';
-};
-function mapValues(obj, fn) {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        acc[key] = fn(value, key);
-        return acc;
-    }, {});
-}
-export const pruneDates = (row) => mapValues(row, (v, k) => {
-    if (!v) {
-        return v;
-    }
-    if (v instanceof Date) {
-        return '[DATE]';
-    }
-    else if (typeof v === 'string' &&
-        /(_at|At)$/.test(k) &&
-        /^20[0-9]{2}-[0-9]{2}-[0-9]{2}/.test(v)) {
-        return '[DATE]';
-    }
-    return v;
-});
-export const pruneIds = (row, idHash) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
-    (typeof v === 'string' || typeof v === 'number')
-    ? idReplacement(v, idHash)
-    : v);
-export const pruneIdArrays = (row) => mapValues(row, (v, k) => typeof k === 'string' && k.endsWith('_ids') && Array.isArray(v)
-    ? `[UUIDs-${v.length}]`
-    : v);
-export const pruneUUIDs = (row) => mapValues(row, (v, k) => {
-    if (typeof v !== 'string') {
-        return v;
-    }
-    if (['uuid', 'queue_name'].includes(k) && uuidRegexp.test(v)) {
-        return '[UUID]';
-    }
-    if (k === 'gravatar' && /^[0-9a-f]{32}$/i.test(v)) {
-        return '[gUUID]';
-    }
-    return v;
-});
-export const pruneHashes = (row) => mapValues(row, (v, k) => typeof k === 'string' &&
-    k.endsWith('_hash') &&
-    typeof v === 'string' &&
-    v.startsWith('$')
-    ? '[hash]'
-    : v);
-export const pruneSchemas = (row) => mapValues(row, (v, k) => typeof v === 'string' && /^zz-/.test(v) ? '[schemahash]' : v);
-export const prunePeoplestamps = (row) => mapValues(row, (v, k) => k.endsWith('_by') && typeof v === 'string' ? '[peoplestamp]' : v);
-export const pruneTokens = (row) => mapValues(row, (v, k) => (k === 'token' || k.endsWith('_token')) && typeof v === 'string'
-    ? '[token]'
-    : v);
-export const composePruners = (...pruners) => (row) => pruners.reduce((acc, pruner) => pruner(acc), row);
-// Default pruners used by prune/snapshot (without IdHash)
-export const defaultPruners = [
-    pruneTokens,
-    prunePeoplestamps,
-    pruneDates,
-    pruneIdArrays,
-    pruneUUIDs,
-    pruneHashes
-];
-// Compose pruners and apply pruneIds with IdHash support
-export const prune = (row, idHash) => {
-    const pruned = composePruners(...defaultPruners)(row);
-    return pruneIds(pruned, idHash);
-};
-// Factory to create a snapshot function with custom pruners
-export const createSnapshot = (pruners) => {
-    const pruneFn = composePruners(...pruners);
-    const snap = (obj, idHash) => {
-        if (Array.isArray(obj)) {
-            return obj.map((el) => snap(el, idHash));
-        }
-        else if (obj && typeof obj === 'object') {
-            const pruned = pruneFn(obj);
-            const prunedWithIds = pruneIds(pruned, idHash);
-            return mapValues(prunedWithIds, (v) => snap(v, idHash));
-        }
-        return obj;
-    };
-    return snap;
-};
-export const snapshot = createSnapshot(defaultPruners);

package/manager.d.ts

@@ -1,26 +0,0 @@
-import { Pool } from 'pg';
-import { PgConfig } from 'pg-env';
-import { PgTestClient, PgTestClientOpts } from './test-client';
-export declare class PgTestConnector {
-    private static instance;
-    private readonly clients;
-    private readonly pgPools;
-    private readonly seenDbConfigs;
-    private readonly pendingConnects;
-    private config;
-    private verbose;
-    private shuttingDown;
-    private constructor();
-    static getInstance(config: PgConfig, verbose?: boolean): PgTestConnector;
-    private poolKey;
-    private dbKey;
-    beginTeardown(): void;
-    private registerConnect;
-    private awaitPendingConnects;
-    getPool(config: PgConfig): Pool;
-    getClient(config: PgConfig, opts?: Partial<PgTestClientOpts>): PgTestClient;
-    closeAll(): Promise<void>;
-    close(): void;
-    drop(config: PgConfig): void;
-    kill(client: PgTestClient): Promise<void>;
-}

package/manager.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PgTestConnector = void 0;
-const logger_1 = require("@pgpmjs/logger");
-const pg_1 = require("pg");
-const pg_env_1 = require("pg-env");
-const admin_1 = require("./admin");
-const test_client_1 = require("./test-client");
-const log = new logger_1.Logger('test-connector');
-const SYS_EVENTS = ['SIGTERM'];
-const end = (pool) => {
-    try {
-        if (pool.ended || pool.ending) {
-            log.warn('⚠️ pg pool already ended or ending');
-            return;
-        }
-        pool.end();
-    }
-    catch (err) {
-        log.error('❌ pg pool termination error:', err);
-    }
-};
-class PgTestConnector {
-    static instance;
-    clients = new Set();
-    pgPools = new Map();
-    seenDbConfigs = new Map();
-    pendingConnects = new Set();
-    config;
-    verbose = false;
-    shuttingDown = false;
-    constructor(config, verbose = false) {
-        this.verbose = verbose;
-        this.config = config;
-        SYS_EVENTS.forEach((event) => {
-            process.on(event, () => {
-                log.info(`⏹ Received ${event}, closing all connections...`);
-                this.closeAll();
-            });
-        });
-    }
-    static getInstance(config, verbose = false) {
-        if (!PgTestConnector.instance) {
-            PgTestConnector.instance = new PgTestConnector(config, verbose);
-        }
-        return PgTestConnector.instance;
-    }
-    poolKey(config) {
-        return `${config.user}@${config.host}:${config.port}/${config.database}`;
-    }
-    dbKey(config) {
-        return `${config.host}:${config.port}/${config.database}`;
-    }
-    beginTeardown() {
-        this.shuttingDown = true;
-    }
-    registerConnect(p) {
-        this.pendingConnects.add(p);
-        p.finally(() => this.pendingConnects.delete(p));
-    }
-    async awaitPendingConnects() {
-        const arr = Array.from(this.pendingConnects);
-        if (arr.length) {
-            await Promise.allSettled(arr);
-        }
-    }
-    getPool(config) {
-        const key = this.poolKey(config);
-        if (!this.pgPools.has(key)) {
-            const pool = new pg_1.Pool(config);
-            this.pgPools.set(key, pool);
-            log.info(`📘 Created new pg pool: ${key}`);
-        }
-        return this.pgPools.get(key);
-    }
-    getClient(config, opts = {}) {
-        if (this.shuttingDown) {
-            throw new Error('PgTestConnector is shutting down; no new clients allowed');
-        }
-        const client = new test_client_1.PgTestClient(config, {
-            trackConnect: (p) => this.registerConnect(p),
-            ...opts
-        });
-        this.clients.add(client);
-        const key = this.dbKey(config);
-        this.seenDbConfigs.set(key, config);
-        log.info(`🔌 New PgTestClient connected to ${config.database}`);
-        return client;
-    }
-    async closeAll() {
-        this.beginTeardown();
-        await this.awaitPendingConnects();
-        log.info('🧹 Closing all PgTestClients...');
-        await Promise.all(Array.from(this.clients).map(async (client) => {
-            try {
-                await client.close();
-                log.success(`✅ Closed client for ${client.config.database}`);
-            }
-            catch (err) {
-                log.error(`❌ Error closing PgTestClient for ${client.config.database}:`, err);
-            }
-        }));
-        this.clients.clear();
-        log.info('🧯 Disposing pg pools...');
-        for (const [key, pool] of this.pgPools.entries()) {
-            log.debug(`🧯 Disposing pg pool [${key}]`);
-            end(pool);
-        }
-        this.pgPools.clear();
-        log.info('🗑️ Dropping seen databases...');
-        await Promise.all(Array.from(this.seenDbConfigs.values()).map(async (config) => {
-            try {
-                const rootPg = (0, pg_env_1.getPgEnvOptions)(this.config);
-                const admin = new admin_1.DbAdmin({ ...config, user: rootPg.user, password: rootPg.password }, this.verbose);
-                admin.drop();
-                log.warn(`🧨 Dropped database: ${config.database}`);
-            }
-            catch (err) {
-                log.error(`❌ Failed to drop database ${config.database}:`, err);
-            }
-        }));
-        this.seenDbConfigs.clear();
-        log.success('✅ All PgTestClients closed, pools disposed, databases dropped.');
-        this.pendingConnects.clear();
-        this.shuttingDown = false;
-    }
-    close() {
-        this.closeAll();
-    }
-    drop(config) {
-        const key = this.dbKey(config);
-        const admin = new admin_1.DbAdmin(config, this.verbose);
-        admin.drop();
-        log.warn(`🧨 Dropped database: ${config.database}`);
-        this.seenDbConfigs.delete(key);
-    }
-    async kill(client) {
-        await client.close();
-        this.drop(client.config);
-    }
-}
-exports.PgTestConnector = PgTestConnector;

package/roles.d.ts

@@ -1,17 +0,0 @@
-import { PgTestConnectionOptions, RoleMapping } from '@pgpmjs/types';
-/**
- * Default role mapping configuration
- */
-export declare const DEFAULT_ROLE_MAPPING: Required<RoleMapping>;
-/**
- * Get resolved role mapping with defaults
- */
-export declare const getRoleMapping: (options?: PgTestConnectionOptions) => Required<RoleMapping>;
-/**
- * Get role name by key with fallback to default mapping
- */
-export declare const getRoleName: (roleKey: keyof Omit<RoleMapping, "default">, options?: PgTestConnectionOptions) => string;
-/**
- * Get default role name
- */
-export declare const getDefaultRole: (options?: PgTestConnectionOptions) => string;

package/roles.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultRole = exports.getRoleName = exports.getRoleMapping = exports.DEFAULT_ROLE_MAPPING = void 0;
-/**
- * Default role mapping configuration
- */
-exports.DEFAULT_ROLE_MAPPING = {
-    anonymous: 'anonymous',
-    authenticated: 'authenticated',
-    administrator: 'administrator',
-    default: 'anonymous'
-};
-/**
- * Get resolved role mapping with defaults
- */
-const getRoleMapping = (options) => {
-    return {
-        ...exports.DEFAULT_ROLE_MAPPING,
-        ...(options?.roles || {})
-    };
-};
-exports.getRoleMapping = getRoleMapping;
-/**
- * Get role name by key with fallback to default mapping
- */
-const getRoleName = (roleKey, options) => {
-    const mapping = (0, exports.getRoleMapping)(options);
-    return mapping[roleKey];
-};
-exports.getRoleName = getRoleName;
-/**
- * Get default role name
- */
-const getDefaultRole = (options) => {
-    const mapping = (0, exports.getRoleMapping)(options);
-    return mapping.default;
-};
-exports.getDefaultRole = getDefaultRole;

package/seed/adapters.d.ts

@@ -1,4 +0,0 @@
-import { SeedAdapter, SeedContext } from './types';
-export declare function sqlfile(files: string[]): SeedAdapter;
-export declare function fn(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
-export declare function compose(adapters: SeedAdapter[]): SeedAdapter;

package/seed/adapters.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqlfile = sqlfile;
-exports.fn = fn;
-exports.compose = compose;
-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 compose(adapters) {
-    return {
-        async seed(ctx) {
-            for (const adapter of adapters) {
-                await adapter.seed(ctx);
-            }
-        }
-    };
-}

package/seed/csv.d.ts

@@ -1,15 +0,0 @@
-import { Client } from 'pg';
-import type { PgTestClient } from '../test-client';
-import { SeedAdapter } from './types';
-export interface CsvSeedMap {
-    [tableName: string]: string;
-}
-/**
- * Standalone helper function to load CSV files into PostgreSQL tables
- * @param client - PostgreSQL client instance
- * @param tables - Map of table names to CSV file paths
- */
-export declare function loadCsvMap(client: Client, tables: CsvSeedMap): Promise<void>;
-export declare function csv(tables: CsvSeedMap): SeedAdapter;
-export declare function copyCsvIntoTable(pg: PgTestClient, table: string, filePath: string): Promise<void>;
-export declare function exportTableToCsv(pg: PgTestClient, table: string, filePath: string): Promise<void>;