pgsql-seed 0.0.1 → 0.2.1

package/seed/csv.js

@@ -1,114 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadCsvMap = loadCsvMap;
-exports.csv = csv;
-exports.copyCsvIntoTable = copyCsvIntoTable;
-exports.exportTableToCsv = exportTableToCsv;
-const promises_1 = require("node:stream/promises");
-const logger_1 = require("@pgpmjs/logger");
-const csv_parse_1 = require("csv-parse");
-const fs_1 = require("fs");
-const pg_copy_streams_1 = require("pg-copy-streams");
-const log = new logger_1.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
- */
-async function loadCsvMap(client, tables) {
-    for (const [table, filePath] of Object.entries(tables)) {
-        if (!(0, fs_1.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((0, pg_copy_streams_1.from)(copyCommand));
-        const source = (0, fs_1.createReadStream)(filePath);
-        try {
-            await (0, promises_1.pipeline)(source, stream);
-            log.success(`✅ Successfully seeded "${table}"`);
-        }
-        catch (err) {
-            log.error(`❌ COPY failed for "${table}": ${err.message}`);
-            throw err;
-        }
-    }
-}
-function csv(tables) {
-    return {
-        async seed(ctx) {
-            for (const [table, filePath] of Object.entries(tables)) {
-                if (!(0, fs_1.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 = (0, fs_1.createReadStream)(filePath);
-    const parser = (0, csv_parse_1.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);
-    });
-}
-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((0, pg_copy_streams_1.from)(copyCommand));
-    const source = (0, fs_1.createReadStream)(filePath);
-    try {
-        await (0, promises_1.pipeline)(source, stream);
-        log.success(`✅ Successfully seeded "${table}"`);
-    }
-    catch (err) {
-        log.error(`❌ COPY failed for "${table}": ${err.message}`);
-        throw err;
-    }
-}
-async function exportTableToCsv(pg, table, filePath) {
-    const client = pg.client;
-    const stream = client.query((0, pg_copy_streams_1.to)(`COPY ${table} TO STDOUT WITH CSV HEADER`));
-    const target = (0, fs_1.createWriteStream)(filePath);
-    try {
-        await (0, promises_1.pipeline)(stream, target);
-        log.success(`✅ Exported "${table}" to ${filePath}`);
-    }
-    catch (err) {
-        log.error(`❌ Failed to export "${table}": ${err.message}`);
-        throw err;
-    }
-}

package/seed/index.d.ts

@@ -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 declare const seed: {
-    pgpm: typeof pgpm;
-    json: typeof json;
-    csv: typeof csv;
-    compose: typeof compose;
-    fn: typeof fn;
-    sqlfile: typeof sqlfile;
-};

package/seed/index.js

@@ -1,31 +0,0 @@
-"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 });
-exports.seed = void 0;
-const adapters_1 = require("./adapters");
-const csv_1 = require("./csv");
-const json_1 = require("./json");
-const pgpm_1 = require("./pgpm");
-__exportStar(require("./csv"), exports);
-__exportStar(require("./types"), exports);
-exports.seed = {
-    pgpm: pgpm_1.pgpm,
-    json: json_1.json,
-    csv: csv_1.csv,
-    compose: adapters_1.compose,
-    fn: adapters_1.fn,
-    sqlfile: adapters_1.sqlfile
-};

package/seed/json.d.ts

@@ -1,12 +0,0 @@
-import type { Client } from 'pg';
-import { SeedAdapter } from './types';
-export interface JsonSeedMap {
-    [table: string]: Record<string, any>[];
-}
-/**
- * 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 declare function insertJson(client: Client, data: JsonSeedMap): Promise<void>;
-export declare function json(data: JsonSeedMap): SeedAdapter;

package/seed/json.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.insertJson = insertJson;
-exports.json = json;
-/**
- * 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
- */
-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);
-        }
-    }
-}
-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/seed/pgpm.d.ts

@@ -1,10 +0,0 @@
-import type { PgConfig } from 'pg-env';
-import { SeedAdapter } from './types';
-/**
- * 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 declare function deployPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;
-export declare function pgpm(cwd?: string, cache?: boolean): SeedAdapter;

package/seed/pgpm.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deployPgpm = deployPgpm;
-exports.pgpm = pgpm;
-const core_1 = require("@pgpmjs/core");
-const env_1 = require("@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)
- */
-async function deployPgpm(config, cwd, cache = false) {
-    const proj = new core_1.PgpmPackage(cwd ?? process.cwd());
-    if (!proj.isInModule())
-        return;
-    await proj.deploy((0, env_1.getEnvOptions)({
-        pg: config,
-        deployment: {
-            fast: true,
-            usePlan: true,
-            cache
-        }
-    }), proj.getModuleName());
-}
-function pgpm(cwd, cache = false) {
-    return {
-        async seed(ctx) {
-            await deployPgpm(ctx.config, cwd ?? ctx.connect.cwd, cache);
-        }
-    };
-}

package/seed/sql.d.ts

@@ -1,7 +0,0 @@
-import type { Client } from 'pg';
-/**
- * Standalone helper function to load SQL files into PostgreSQL
- * @param client - PostgreSQL client instance
- * @param files - Array of SQL file paths to execute
- */
-export declare function loadSqlFiles(client: Client, files: string[]): Promise<void>;

package/seed/sql.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadSqlFiles = loadSqlFiles;
-const fs_1 = require("fs");
-/**
- * Standalone helper function to load SQL files into PostgreSQL
- * @param client - PostgreSQL client instance
- * @param files - Array of SQL file paths to execute
- */
-async function loadSqlFiles(client, files) {
-    for (const file of files) {
-        if (!(0, fs_1.existsSync)(file)) {
-            throw new Error(`SQL file not found: ${file}`);
-        }
-        const sql = (0, fs_1.readFileSync)(file, 'utf-8');
-        await client.query(sql);
-    }
-}

package/seed/types.d.ts

@@ -1,13 +0,0 @@
-import { PgTestConnectionOptions } from '@pgpmjs/types';
-import { PgConfig } from 'pg-env';
-import { DbAdmin } from '../admin';
-import { PgTestClient } from '../test-client';
-export interface SeedContext {
-    connect: PgTestConnectionOptions;
-    admin: DbAdmin;
-    config: PgConfig;
-    pg: PgTestClient;
-}
-export interface SeedAdapter {
-    seed(ctx: SeedContext): Promise<void> | void;
-}

package/seed/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/stream.d.ts

@@ -1,33 +0,0 @@
-import { PgConfig } from 'pg-env';
-/**
- * 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 declare function streamSql(config: PgConfig, sql: string): Promise<void>;

package/stream.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamSql = streamSql;
-const child_process_1 = require("child_process");
-const pg_env_1 = require("pg-env");
-const stream_1 = require("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 stream_1.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.
- */
-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 = (0, child_process_1.spawn)('psql', args, {
-            env: (0, pg_env_1.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/test-client.d.ts

@@ -1,55 +0,0 @@
-import { Client, QueryResult } from 'pg';
-import { PgConfig } from 'pg-env';
-import { AuthOptions, PgTestConnectionOptions } from '@pgpmjs/types';
-import { type JsonSeedMap } from './seed/json';
-import { type CsvSeedMap } from './seed/csv';
-export type PgTestClientOpts = {
-    deferConnect?: boolean;
-    trackConnect?: (p: Promise<any>) => void;
-} & Partial<PgTestConnectionOptions>;
-export declare class PgTestClient {
-    config: PgConfig;
-    client: Client;
-    private opts;
-    private ctxStmts;
-    private contextSettings;
-    private _ended;
-    private connectPromise;
-    constructor(config: PgConfig, opts?: PgTestClientOpts);
-    private ensureConnected;
-    close(): Promise<void>;
-    begin(): Promise<void>;
-    savepoint(name?: string): Promise<void>;
-    rollback(name?: string): Promise<void>;
-    commit(): Promise<void>;
-    beforeEach(): Promise<void>;
-    afterEach(): Promise<void>;
-    setContext(ctx: Record<string, string | null>): void;
-    /**
-     * Set authentication context for the current session.
-     * Configures role and user ID using cascading defaults from options → opts.auth → RoleMapping.
-     */
-    auth(options?: AuthOptions): void;
-    /**
-     * 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.
-     */
-    publish(): Promise<void>;
-    /**
-     * Clear all session context variables and reset to default anonymous role.
-     */
-    clearContext(): void;
-    any<T = any>(query: string, values?: any[]): Promise<T[]>;
-    one<T = any>(query: string, values?: any[]): Promise<T>;
-    oneOrNone<T = any>(query: string, values?: any[]): Promise<T | null>;
-    many<T = any>(query: string, values?: any[]): Promise<T[]>;
-    manyOrNone<T = any>(query: string, values?: any[]): Promise<T[]>;
-    none(query: string, values?: any[]): Promise<void>;
-    result(query: string, values?: any[]): Promise<import('pg').QueryResult>;
-    ctxQuery(): Promise<void>;
-    query<T = any>(query: string, values?: any[]): Promise<QueryResult<T>>;
-    loadJson(data: JsonSeedMap): Promise<void>;
-    loadSql(files: string[]): Promise<void>;
-    loadCsv(tables: CsvSeedMap): Promise<void>;
-    loadPgpm(cwd?: string, cache?: boolean): Promise<void>;
-}

package/test-client.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PgTestClient = void 0;
-const pg_1 = require("pg");
-const roles_1 = require("./roles");
-const context_utils_1 = require("./context-utils");
-const json_1 = require("./seed/json");
-const csv_1 = require("./seed/csv");
-const sql_1 = require("./seed/sql");
-const pgpm_1 = require("./seed/pgpm");
-class PgTestClient {
-    config;
-    client;
-    opts;
-    ctxStmts = '';
-    contextSettings = {};
-    _ended = false;
-    connectPromise = null;
-    constructor(config, opts = {}) {
-        this.opts = opts;
-        this.config = config;
-        this.client = new pg_1.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 = (0, context_utils_1.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 ?? (0, roles_1.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 = (0, roles_1.getRoleName)('anonymous', this.opts);
-        const nulledSettings = {};
-        Object.keys(this.contextSettings).forEach(key => {
-            nulledSettings[key] = null;
-        });
-        nulledSettings.role = defaultRole;
-        this.ctxStmts = (0, context_utils_1.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 (0, json_1.insertJson)(this.client, data);
-    }
-    async loadSql(files) {
-        await this.ctxQuery();
-        await (0, sql_1.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 (0, csv_1.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 (0, pgpm_1.deployPgpm)(this.config, cwd, cache);
-    }
-}
-exports.PgTestClient = PgTestClient;