pgsql-test 2.19.0 → 2.20.0

package/manager.js

@@ -87,7 +87,8 @@ class PgTestConnector {
         log.info(`🔌 New PgTestClient connected to ${config.database}`);
         return client;
     }
-    async closeAll() {
+    async closeAll(opts = {}) {
+        const { keepDb = false } = opts;
         this.beginTeardown();
         await this.awaitPendingConnects();
         log.info('🧹 Closing all PgTestClients...');
@@ -107,20 +108,28 @@ class PgTestConnector {
             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);
-            }
-        }));
+        if (keepDb) {
+            log.info('📦 Keeping databases (keepDb=true)...');
+            const dbNames = Array.from(this.seenDbConfigs.values()).map(c => c.database);
+            log.info(`📦 Preserved databases: ${dbNames.join(', ')}`);
+        }
+        else {
+            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.');
+        const action = keepDb ? 'preserved' : 'dropped';
+        log.success(`✅ All PgTestClients closed, pools disposed, databases ${action}.`);
         this.pendingConnects.clear();
         this.shuttingDown = false;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "pgsql-test offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests — giving developers realistic test coverage without external state pollution",
   "main": "index.js",
@@ -60,7 +60,6 @@
     "makage": "^0.1.9"
   },
   "dependencies": {
-    "@pgpmjs/core": "^4.3.0",
     "@pgpmjs/env": "^2.8.11",
     "@pgpmjs/logger": "^1.3.5",
     "@pgpmjs/server-utils": "^2.8.11",
@@ -68,7 +67,8 @@
     "pg": "^8.16.3",
     "pg-cache": "^1.6.11",
     "pg-env": "^1.2.4",
-    "pgsql-seed": "^0.2.0"
+    "pgsql-client": "^1.1.0",
+    "pgsql-seed": "^0.2.2"
   },
-  "gitHead": "7ac931c063d48e281349b748ba2eb9c9f47ffb06"
+  "gitHead": "09721f934b339bd8c55d2e633abaded6d20b0f65"
 }

package/test-client.d.ts

@@ -1,53 +1,17 @@
-import { Client, QueryResult } from 'pg';
 import { PgConfig } from 'pg-env';
-import { AuthOptions, PgTestConnectionOptions } from '@pgpmjs/types';
+import { PgClient, PgClientOpts } from 'pgsql-client';
 import { type JsonSeedMap } from 'pgsql-seed';
 import { type CsvSeedMap } from 'pgsql-seed';
-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;
+export type PgTestClientOpts = PgClientOpts;
+export declare class PgTestClient extends PgClient {
     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>;

package/test-client.js

@@ -1,63 +1,14 @@
 "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 pgsql_client_1 = require("pgsql-client");
 const pgsql_seed_1 = require("pgsql-seed");
 const pgsql_seed_2 = require("pgsql-seed");
 const pgsql_seed_3 = require("pgsql-seed");
 const pgsql_seed_4 = require("pgsql-seed");
-class PgTestClient {
-    config;
-    client;
-    opts;
-    ctxStmts = '';
-    contextSettings = {};
-    _ended = false;
-    connectPromise = null;
+class PgTestClient extends pgsql_client_1.PgClient {
     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;');
+        super(config, opts);
     }
     async beforeEach() {
         await this.begin();
@@ -67,23 +18,6 @@ class PgTestClient {
         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.
@@ -94,60 +28,6 @@ class PgTestClient {
         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, pgsql_seed_1.insertJsonMap)(this.client, data);

package/context-utils.d.ts

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

@@ -1,28 +0,0 @@
-"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/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/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/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/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/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);
-        });
-    });
-}