pgsql-seed 0.0.1 → 0.2.0

package/esm/admin.js

@@ -1,140 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,25 +0,0 @@
-/**
- * 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/manager.js

@@ -1,138 +0,0 @@
-import { Logger } from '@pgpmjs/logger';
-import { Pool } from 'pg';
-import { getPgEnvOptions } from 'pg-env';
-import { DbAdmin } from './admin';
-import { PgTestClient } from './test-client';
-const log = new 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);
-    }
-};
-export 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 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 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 = getPgEnvOptions(this.config);
-                const admin = new 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 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);
-    }
-}

package/esm/roles.js

@@ -1,32 +0,0 @@
-/**
- * Default role mapping configuration
- */
-export const DEFAULT_ROLE_MAPPING = {
-    anonymous: 'anonymous',
-    authenticated: 'authenticated',
-    administrator: 'administrator',
-    default: 'anonymous'
-};
-/**
- * Get resolved role mapping with defaults
- */
-export const getRoleMapping = (options) => {
-    return {
-        ...DEFAULT_ROLE_MAPPING,
-        ...(options?.roles || {})
-    };
-};
-/**
- * Get role name by key with fallback to default mapping
- */
-export const getRoleName = (roleKey, options) => {
-    const mapping = getRoleMapping(options);
-    return mapping[roleKey];
-};
-/**
- * Get default role name
- */
-export const getDefaultRole = (options) => {
-    const mapping = getRoleMapping(options);
-    return mapping.default;
-};

package/esm/seed/adapters.js

@@ -1,23 +0,0 @@
-export function sqlfile(files) {
-    return {
-        seed(ctx) {
-            for (const file of files) {
-                ctx.admin.loadSql(file, ctx.config.database);
-            }
-        }
-    };
-}
-export function fn(fn) {
-    return {
-        seed: fn
-    };
-}
-export function compose(adapters) {
-    return {
-        async seed(ctx) {
-            for (const adapter of adapters) {
-                await adapter.seed(ctx);
-            }
-        }
-    };
-}

package/esm/seed/csv.js

@@ -1,108 +0,0 @@
-import { pipeline } from 'node:stream/promises';
-import { Logger } from '@pgpmjs/logger';
-import { parse } from 'csv-parse';
-import { createReadStream, createWriteStream, existsSync } from 'fs';
-import { from as copyFrom, to as copyTo } from 'pg-copy-streams';
-const log = new Logger('csv');
-/**
- * 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 async function loadCsvMap(client, tables) {
-    for (const [table, filePath] of Object.entries(tables)) {
-        if (!existsSync(filePath)) {
-            throw new Error(`CSV file not found: ${filePath}`);
-        }
-        log.info(`📥 Seeding "${table}" from ${filePath}`);
-        const columns = await parseCsvHeader(filePath);
-        const quotedColumns = columns.map(col => `"${col.replace(/"/g, '""')}"`);
-        const columnList = quotedColumns.join(', ');
-        const copyCommand = `COPY ${table} (${columnList}) FROM STDIN WITH CSV HEADER`;
-        log.info(`Using columns: ${columnList}`);
-        const stream = client.query(copyFrom(copyCommand));
-        const source = createReadStream(filePath);
-        try {
-            await pipeline(source, stream);
-            log.success(`✅ Successfully seeded "${table}"`);
-        }
-        catch (err) {
-            log.error(`❌ COPY failed for "${table}": ${err.message}`);
-            throw err;
-        }
-    }
-}
-export function csv(tables) {
-    return {
-        async seed(ctx) {
-            for (const [table, filePath] of Object.entries(tables)) {
-                if (!existsSync(filePath)) {
-                    throw new Error(`CSV file not found: ${filePath}`);
-                }
-                log.info(`📥 Seeding "${table}" from ${filePath}`);
-                await copyCsvIntoTable(ctx.pg, table, filePath);
-            }
-        }
-    };
-}
-async function parseCsvHeader(filePath) {
-    const file = createReadStream(filePath);
-    const parser = parse({
-        bom: true,
-        to_line: 1,
-        skip_empty_lines: true,
-    });
-    return new Promise((resolve, reject) => {
-        const cleanup = (err) => {
-            parser.destroy();
-            file.destroy();
-            if (err)
-                reject(err);
-        };
-        parser.on('readable', () => {
-            const row = parser.read();
-            if (!row)
-                return;
-            if (row.length === 0) {
-                cleanup(new Error('CSV header has no columns'));
-                return;
-            }
-            cleanup();
-            resolve(row);
-        });
-        parser.on('error', cleanup);
-        file.on('error', cleanup);
-        file.pipe(parser);
-    });
-}
-export async function copyCsvIntoTable(pg, table, filePath) {
-    const client = pg.client;
-    const columns = await parseCsvHeader(filePath);
-    const quotedColumns = columns.map(col => `"${col.replace(/"/g, '""')}"`);
-    const columnList = quotedColumns.join(', ');
-    const copyCommand = `COPY ${table} (${columnList}) FROM STDIN WITH CSV HEADER`;
-    log.info(`Using columns: ${columnList}`);
-    const stream = client.query(copyFrom(copyCommand));
-    const source = createReadStream(filePath);
-    try {
-        await pipeline(source, stream);
-        log.success(`✅ Successfully seeded "${table}"`);
-    }
-    catch (err) {
-        log.error(`❌ COPY failed for "${table}": ${err.message}`);
-        throw err;
-    }
-}
-export async function exportTableToCsv(pg, table, filePath) {
-    const client = pg.client;
-    const stream = client.query(copyTo(`COPY ${table} TO STDOUT WITH CSV HEADER`));
-    const target = createWriteStream(filePath);
-    try {
-        await pipeline(stream, target);
-        log.success(`✅ Exported "${table}" to ${filePath}`);
-    }
-    catch (err) {
-        log.error(`❌ Failed to export "${table}": ${err.message}`);
-        throw err;
-    }
-}

package/esm/seed/index.js

@@ -1,14 +0,0 @@
-import { compose, fn, sqlfile } from './adapters';
-import { csv } from './csv';
-import { json } from './json';
-import { pgpm } from './pgpm';
-export * from './csv';
-export * from './types';
-export const seed = {
-    pgpm,
-    json,
-    csv,
-    compose,
-    fn,
-    sqlfile
-};

package/esm/seed/json.js

@@ -1,36 +0,0 @@
-/**
- * Standalone helper function to insert JSON data into PostgreSQL tables
- * @param client - PostgreSQL client instance
- * @param data - Map of table names to arrays of row objects
- */
-export async function insertJson(client, data) {
-    for (const [table, rows] of Object.entries(data)) {
-        if (!Array.isArray(rows) || rows.length === 0)
-            continue;
-        const columns = Object.keys(rows[0]);
-        const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
-        const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
-        for (const row of rows) {
-            const values = columns.map((c) => row[c]);
-            await client.query(sql, values);
-        }
-    }
-}
-export function json(data) {
-    return {
-        async seed(ctx) {
-            const { pg } = ctx;
-            for (const [table, rows] of Object.entries(data)) {
-                if (!Array.isArray(rows) || rows.length === 0)
-                    continue;
-                const columns = Object.keys(rows[0]);
-                const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
-                const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
-                for (const row of rows) {
-                    const values = columns.map((c) => row[c]);
-                    await pg.query(sql, values);
-                }
-            }
-        }
-    };
-}

package/esm/seed/pgpm.js

@@ -1,28 +0,0 @@
-import { PgpmPackage } from '@pgpmjs/core';
-import { getEnvOptions } from '@pgpmjs/env';
-/**
- * Standalone helper function to deploy pgpm package
- * @param config - PostgreSQL configuration
- * @param cwd - Current working directory (defaults to process.cwd())
- * @param cache - Whether to enable caching (defaults to false)
- */
-export async function deployPgpm(config, cwd, cache = false) {
-    const proj = new PgpmPackage(cwd ?? process.cwd());
-    if (!proj.isInModule())
-        return;
-    await proj.deploy(getEnvOptions({
-        pg: config,
-        deployment: {
-            fast: true,
-            usePlan: true,
-            cache
-        }
-    }), proj.getModuleName());
-}
-export function pgpm(cwd, cache = false) {
-    return {
-        async seed(ctx) {
-            await deployPgpm(ctx.config, cwd ?? ctx.connect.cwd, cache);
-        }
-    };
-}

package/esm/seed/sql.js

@@ -1,15 +0,0 @@
-import { existsSync, readFileSync } from 'fs';
-/**
- * Standalone helper function to load SQL files into PostgreSQL
- * @param client - PostgreSQL client instance
- * @param files - Array of SQL file paths to execute
- */
-export async function loadSqlFiles(client, files) {
-    for (const file of files) {
-        if (!existsSync(file)) {
-            throw new Error(`SQL file not found: ${file}`);
-        }
-        const sql = readFileSync(file, 'utf-8');
-        await client.query(sql);
-    }
-}

package/esm/seed/types.js

@@ -1 +0,0 @@
-export {};