pgsql-test 2.19.0 → 2.20.0

package/README.md

@@ -685,9 +685,14 @@ Common issues and solutions for pgpm, PostgreSQL, and testing.
 
 ## Related Constructive Tooling
 
+### 📦 Package Management
+
+* [pgpm](https://github.com/constructive-io/constructive/tree/main/pgpm/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
+
 ### 🧪 Testing
 
 * [pgsql-test](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-test): **📊 Isolated testing environments** with per-test transaction rollbacks—ideal for integration tests, complex migrations, and RLS simulation.
+* [pgsql-seed](https://github.com/constructive-io/constructive/tree/main/postgres/pgsql-seed): **🌱 PostgreSQL seeding utilities** for CSV, JSON, SQL data loading, and pgpm deployment.
 * [supabase-test](https://github.com/constructive-io/constructive/tree/main/postgres/supabase-test): **🧪 Supabase-native test harness** preconfigured for the local Supabase stack—per-test rollbacks, JWT/role context helpers, and CI/GitHub Actions ready.
 * [graphile-test](https://github.com/constructive-io/constructive/tree/main/graphile/graphile-test): **🔐 Authentication mocking** for Graphile-focused test helpers and emulating row-level security contexts.
 * [pg-query-context](https://github.com/constructive-io/constructive/tree/main/postgres/pg-query-context): **🔒 Session context injection** to add session-local context (e.g., `SET LOCAL`) into queries—ideal for setting `role`, `jwt.claims`, and other session settings.
@@ -701,28 +706,6 @@ Common issues and solutions for pgpm, PostgreSQL, and testing.
 * [@pgsql/types](https://www.npmjs.com/package/@pgsql/types): **📝 Type definitions** for PostgreSQL AST nodes in TypeScript.
 * [@pgsql/utils](https://www.npmjs.com/package/@pgsql/utils): **🛠️ AST utilities** for constructing and transforming PostgreSQL syntax trees.
 
-### 🚀 API & Dev Tools
-
-* [@constructive-io/graphql-server](https://github.com/constructive-io/constructive/tree/main/graphql/server): **⚡ Express-based API server** powered by PostGraphile to expose a secure, scalable GraphQL API over your Postgres database.
-* [@constructive-io/graphql-explorer](https://github.com/constructive-io/constructive/tree/main/graphql/explorer): **🔎 Visual API explorer** with GraphiQL for browsing across all databases and schemas—useful for debugging, documentation, and API prototyping.
-
-### 🔁 Streaming & Uploads
-
-* [etag-hash](https://github.com/constructive-io/constructive/tree/main/streaming/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
-* [etag-stream](https://github.com/constructive-io/constructive/tree/main/streaming/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
-* [uuid-hash](https://github.com/constructive-io/constructive/tree/main/streaming/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
-* [uuid-stream](https://github.com/constructive-io/constructive/tree/main/streaming/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
-* [@constructive-io/s3-streamer](https://github.com/constructive-io/constructive/tree/main/streaming/s3-streamer): **📤 Direct S3 streaming** for large files with support for metadata injection and content validation.
-* [@constructive-io/upload-names](https://github.com/constructive-io/constructive/tree/main/streaming/upload-names): **📂 Collision-resistant filenames** utility for structured and unique file names for uploads.
-
-### 🧰 CLI & Codegen
-
-* [pgpm](https://github.com/constructive-io/constructive/tree/main/pgpm/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
-* [@constructive-io/cli](https://github.com/constructive-io/constructive/tree/main/packages/cli): **🖥️ Command-line toolkit** for managing Constructive projects—supports database scaffolding, migrations, seeding, code generation, and automation.
-* [@constructive-io/graphql-codegen](https://github.com/constructive-io/constructive/tree/main/graphql/codegen): **✨ GraphQL code generation** (types, operations, SDK) from schema/endpoint introspection.
-* [@constructive-io/query-builder](https://github.com/constructive-io/constructive/tree/main/packages/query-builder): **🏗️ SQL constructor** providing a robust TypeScript-based query builder for dynamic generation of `SELECT`, `INSERT`, `UPDATE`, `DELETE`, and stored procedure calls—supports advanced SQL features like `JOIN`, `GROUP BY`, and schema-qualified queries.
-* [@constructive-io/graphql-query](https://github.com/constructive-io/constructive/tree/main/graphql/query): **🧩 Fluent GraphQL builder** for PostGraphile schemas. ⚡ Schema-aware via introspection, 🧩 composable and ergonomic for building deeply nested queries.
-
 ## Credits
 
 **🛠 Built by the [Constructive](https://constructive.io) team — creators of modular Postgres tooling for secure, composable backends. If you like our work, contribute on [GitHub](https://github.com/constructive-io).**

package/admin.d.ts

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

package/admin.js

@@ -1,131 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DbAdmin = void 0;
-const core_1 = require("@pgpmjs/core");
-const logger_1 = require("@pgpmjs/logger");
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const pg_env_1 = require("pg-env");
-const roles_1 = require("./roles");
-const stream_1 = require("./stream");
-const log = new logger_1.Logger('db-admin');
-class DbAdmin {
-    config;
-    verbose;
-    roleConfig;
+const pgsql_client_1 = require("pgsql-client");
+// Extend DbAdmin from pgsql-client with test-specific methods
+class DbAdmin extends pgsql_client_1.DbAdmin {
     constructor(config, verbose = false, roleConfig) {
-        this.config = config;
-        this.verbose = verbose;
-        this.roleConfig = roleConfig;
-        this.config = (0, pg_env_1.getPgEnvOptions)(config);
-    }
-    getEnv() {
-        return {
-            PGHOST: this.config.host,
-            PGPORT: String(this.config.port),
-            PGUSER: this.config.user,
-            PGPASSWORD: this.config.password
-        };
-    }
-    run(command) {
-        try {
-            (0, child_process_1.execSync)(command, {
-                stdio: this.verbose ? 'inherit' : 'pipe',
-                env: {
-                    ...process.env,
-                    ...this.getEnv()
-                }
-            });
-            if (this.verbose)
-                log.success(`Executed: ${command}`);
-        }
-        catch (err) {
-            log.error(`Command failed: ${command}`);
-            if (this.verbose)
-                log.error(err.message);
-            throw err;
-        }
-    }
-    safeDropDb(name) {
-        try {
-            this.run(`dropdb "${name}"`);
-        }
-        catch (err) {
-            if (!err.message.includes('does not exist')) {
-                log.warn(`Could not drop database ${name}: ${err.message}`);
-            }
-        }
-    }
-    drop(dbName) {
-        this.safeDropDb(dbName ?? this.config.database);
-    }
-    dropTemplate(dbName) {
-        this.run(`psql -c "UPDATE pg_database SET datistemplate='false' WHERE datname='${dbName}';"`);
-        this.drop(dbName);
-    }
-    create(dbName) {
-        const db = dbName ?? this.config.database;
-        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} "${db}"`);
-    }
-    createFromTemplate(template, dbName) {
-        const db = dbName ?? this.config.database;
-        this.run(`createdb -U ${this.config.user} -h ${this.config.host} -p ${this.config.port} -e "${db}" -T "${template}"`);
-    }
-    installExtensions(extensions, dbName) {
-        const db = dbName ?? this.config.database;
-        const extList = typeof extensions === 'string' ? extensions.split(',') : extensions;
-        for (const extension of extList) {
-            this.run(`psql --dbname "${db}" -c 'CREATE EXTENSION IF NOT EXISTS "${extension}" CASCADE;'`);
-        }
-    }
-    connectionString(dbName) {
-        const { user, password, host, port } = this.config;
-        const db = dbName ?? this.config.database;
-        return `postgres://${user}:${password}@${host}:${port}/${db}`;
-    }
-    createTemplateFromBase(base, template) {
-        this.run(`createdb -T "${base}" "${template}"`);
-        this.run(`psql -c "UPDATE pg_database SET datistemplate = true WHERE datname = '${template}';"`);
-    }
-    cleanupTemplate(template) {
-        try {
-            this.run(`psql -c "UPDATE pg_database SET datistemplate = false WHERE datname = '${template}'"`);
-        }
-        catch {
-            log.warn(`Skipping failed UPDATE of datistemplate for ${template}`);
-        }
-        this.safeDropDb(template);
-    }
-    async grantRole(role, user, dbName) {
-        const db = dbName ?? this.config.database;
-        const sql = (0, core_1.generateGrantRoleSQL)(role, user);
-        await this.streamSql(sql, db);
-    }
-    async grantConnect(role, dbName) {
-        const db = dbName ?? this.config.database;
-        const sql = `GRANT CONNECT ON DATABASE "${db}" TO ${role};`;
-        await this.streamSql(sql, db);
-    }
-    // ONLY granting admin role for testing purposes, normally the db connection for apps won't have admin role
-    // DO NOT USE THIS FOR PRODUCTION
-    async createUserRole(user, password, dbName, useLocksForRoles = false) {
-        const anonRole = (0, roles_1.getRoleName)('anonymous', this.roleConfig);
-        const authRole = (0, roles_1.getRoleName)('authenticated', this.roleConfig);
-        const adminRole = (0, roles_1.getRoleName)('administrator', this.roleConfig);
-        const sql = (0, core_1.generateCreateUserWithGrantsSQL)(user, password, [anonRole, authRole, adminRole], useLocksForRoles);
-        await this.streamSql(sql, dbName);
-    }
-    loadSql(file, dbName) {
-        if (!(0, fs_1.existsSync)(file)) {
-            throw new Error(`Missing SQL file: ${file}`);
-        }
-        this.run(`psql -f ${file} ${dbName}`);
-    }
-    async streamSql(sql, dbName) {
-        await (0, stream_1.streamSql)({
-            ...this.config,
-            database: dbName
-        }, sql);
+        super(config, verbose, roleConfig);
     }
     async createSeededTemplate(templateName, adapter) {
         const seedDb = this.config.database;

package/connect.d.ts

@@ -9,11 +9,15 @@ export interface GetConnectionOpts {
     pg?: Partial<PgConfig>;
     db?: Partial<PgTestConnectionOptions>;
 }
+export interface TeardownOptions {
+    /** If true, keeps the database after closing connections (default: false) */
+    keepDb?: boolean;
+}
 export interface GetConnectionResult {
     pg: PgTestClient;
     db: PgTestClient;
     admin: DbAdmin;
-    teardown: () => Promise<void>;
+    teardown: (opts?: TeardownOptions) => Promise<void>;
     manager: PgTestConnector;
 }
 export declare const getConnections: (cn?: GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<GetConnectionResult>;

package/connect.js

@@ -5,9 +5,9 @@ const env_1 = require("@pgpmjs/env");
 const crypto_1 = require("crypto");
 const pg_cache_1 = require("pg-cache");
 const pg_env_1 = require("pg-env");
+const pgsql_client_1 = require("pgsql-client");
 const admin_1 = require("./admin");
 const manager_1 = require("./manager");
-const roles_1 = require("./roles");
 const seed_1 = require("./seed");
 let manager;
 const getPgRootAdmin = (config, connOpts = {}) => {
@@ -54,13 +54,15 @@ const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.pgpm()]) => {
     manager = manager_1.PgTestConnector.getInstance(config);
     const pg = manager.getClient(config);
     let teardownPromise = null;
-    const teardown = async () => {
+    let teardownOpts = {};
+    const teardown = async (opts = {}) => {
+        teardownOpts = opts;
         if (teardownPromise)
             return teardownPromise;
         teardownPromise = (async () => {
             manager.beginTeardown();
             await (0, pg_cache_1.teardownPgPools)();
-            await manager.closeAll();
+            await manager.closeAll({ keepDb: teardownOpts.keepDb });
         })();
         return teardownPromise;
     };
@@ -89,7 +91,7 @@ const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.pgpm()]) => {
         auth: connOpts.auth,
         roles: connOpts.roles
     });
-    db.setContext({ role: (0, roles_1.getDefaultRole)(connOpts) });
+    db.setContext({ role: (0, pgsql_client_1.getDefaultRole)(connOpts) });
     return { pg, db, teardown, manager, admin };
 };
 exports.getConnections = getConnections;

package/esm/admin.js

@@ -1,128 +1,8 @@
-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;
+import { DbAdmin as BaseDbAdmin } from 'pgsql-client';
+// Extend DbAdmin from pgsql-client with test-specific methods
+export class DbAdmin extends BaseDbAdmin {
     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);
+        super(config, verbose, roleConfig);
     }
     async createSeededTemplate(templateName, adapter) {
         const seedDb = this.config.database;

package/esm/connect.js

@@ -2,9 +2,9 @@ import { getConnEnvOptions } from '@pgpmjs/env';
 import { randomUUID } from 'crypto';
 import { teardownPgPools } from 'pg-cache';
 import { getPgEnvOptions, } from 'pg-env';
+import { getDefaultRole } from 'pgsql-client';
 import { DbAdmin } from './admin';
 import { PgTestConnector } from './manager';
-import { getDefaultRole } from './roles';
 import { seed } from './seed';
 let manager;
 export const getPgRootAdmin = (config, connOpts = {}) => {
@@ -50,13 +50,15 @@ export const getConnections = async (cn = {}, seedAdapters = [seed.pgpm()]) => {
     manager = PgTestConnector.getInstance(config);
     const pg = manager.getClient(config);
     let teardownPromise = null;
-    const teardown = async () => {
+    let teardownOpts = {};
+    const teardown = async (opts = {}) => {
+        teardownOpts = opts;
         if (teardownPromise)
             return teardownPromise;
         teardownPromise = (async () => {
             manager.beginTeardown();
             await teardownPgPools();
-            await manager.closeAll();
+            await manager.closeAll({ keepDb: teardownOpts.keepDb });
         })();
         return teardownPromise;
     };

package/esm/index.js

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

package/esm/manager.js

@@ -84,7 +84,8 @@ export 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...');
@@ -104,20 +105,28 @@ export 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 = 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);
-            }
-        }));
+        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 = 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.');
+        const action = keepDb ? 'preserved' : 'dropped';
+        log.success(`✅ All PgTestClients closed, pools disposed, databases ${action}.`);
         this.pendingConnects.clear();
         this.shuttingDown = false;
     }

package/esm/test-client.js

@@ -1,60 +1,11 @@
-import { Client } from 'pg';
-import { getRoleName } from './roles';
-import { generateContextStatements } from './context-utils';
+import { PgClient } from 'pgsql-client';
 import { insertJsonMap } from 'pgsql-seed';
 import { loadCsvMap } from 'pgsql-seed';
 import { loadSqlFiles } from 'pgsql-seed';
 import { deployPgpm } from 'pgsql-seed';
-export class PgTestClient {
-    config;
-    client;
-    opts;
-    ctxStmts = '';
-    contextSettings = {};
-    _ended = false;
-    connectPromise = null;
+export class PgTestClient extends PgClient {
     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;');
+        super(config, opts);
     }
     async beforeEach() {
         await this.begin();
@@ -64,23 +15,6 @@ export class PgTestClient {
         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.
@@ -91,60 +25,6 @@ export 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 = 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 insertJsonMap(this.client, data);

package/index.d.ts

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

package/index.js

@@ -18,7 +18,6 @@ exports.snapshot = void 0;
 __exportStar(require("./admin"), exports);
 __exportStar(require("./connect"), exports);
 __exportStar(require("./manager"), exports);
-__exportStar(require("./roles"), exports);
 __exportStar(require("./seed"), exports);
 __exportStar(require("./test-client"), exports);
 var utils_1 = require("./utils");

package/manager.d.ts

@@ -19,7 +19,9 @@ export declare class PgTestConnector {
     private awaitPendingConnects;
     getPool(config: PgConfig): Pool;
     getClient(config: PgConfig, opts?: Partial<PgTestClientOpts>): PgTestClient;
-    closeAll(): Promise<void>;
+    closeAll(opts?: {
+        keepDb?: boolean;
+    }): Promise<void>;
     close(): void;
     drop(config: PgConfig): void;
     kill(client: PgTestClient): Promise<void>;