pgsql-test 2.9.0 → 2.11.0

package/admin.d.ts

@@ -1,9 +1,11 @@
+import { PgTestConnectionOptions } from '@launchql/types';
 import { PgConfig } from 'pg-env';
 import { SeedAdapter } from './seed/types';
 export declare class DbAdmin {
     private config;
     private verbose;
-    constructor(config: PgConfig, verbose?: boolean);
+    private roleConfig?;
+    constructor(config: PgConfig, verbose?: boolean, roleConfig?: PgTestConnectionOptions);
     private getEnv;
     private run;
     private safeDropDb;

package/admin.js

@@ -5,14 +5,17 @@ const logger_1 = require("@launchql/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;
-    constructor(config, verbose = false) {
+    roleConfig;
+    constructor(config, verbose = false, roleConfig) {
         this.config = config;
         this.verbose = verbose;
+        this.roleConfig = roleConfig;
         this.config = (0, pg_env_1.getPgEnvOptions)(config);
     }
     getEnv() {
@@ -103,13 +106,15 @@ class DbAdmin {
         await this.streamSql(sql, db);
     }
     async createUserRole(user, password, dbName) {
+        const anonRole = (0, roles_1.getRoleName)('anonymous', this.roleConfig);
+        const authRole = (0, roles_1.getRoleName)('authenticated', this.roleConfig);
         const sql = `
       DO $$
       BEGIN
         IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${user}') THEN
           CREATE ROLE ${user} LOGIN PASSWORD '${password}';
-          GRANT anonymous TO ${user};
-          GRANT authenticated TO ${user};
+          GRANT ${anonRole} TO ${user};
+          GRANT ${authRole} TO ${user};
         END IF;
       END $$;
     `.trim();

package/connect.js

@@ -7,13 +7,14 @@ const pg_cache_1 = require("pg-cache");
 const pg_env_1 = require("pg-env");
 const admin_1 = require("./admin");
 const manager_1 = require("./manager");
+const roles_1 = require("./roles");
 const seed_1 = require("./seed");
 let manager;
 const getPgRootAdmin = (connOpts = {}) => {
     const opts = (0, pg_env_1.getPgEnvOptions)({
         database: connOpts.rootDb
     });
-    const admin = new admin_1.DbAdmin(opts);
+    const admin = new admin_1.DbAdmin(opts, false, connOpts);
     return admin;
 };
 exports.getPgRootAdmin = getPgRootAdmin;
@@ -34,7 +35,7 @@ const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.launchql()])
     const connOpts = cn.db;
     const root = (0, exports.getPgRootAdmin)(connOpts);
     await root.createUserRole(connOpts.connection.user, connOpts.connection.password, connOpts.rootDb);
-    const admin = new admin_1.DbAdmin(config);
+    const admin = new admin_1.DbAdmin(config, false, connOpts);
     if (process.env.TEST_DB) {
         config.database = process.env.TEST_DB;
     }
@@ -67,12 +68,16 @@ const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.launchql()])
             throw error;
         }
     }
-    const db = manager.getClient({
+    const dbConfig = {
         ...config,
         user: connOpts.connection.user,
         password: connOpts.connection.password
+    };
+    const db = manager.getClient(dbConfig, {
+        auth: connOpts.auth,
+        roles: connOpts.roles
     });
-    db.setContext({ role: 'anonymous' });
+    db.setContext({ role: (0, roles_1.getDefaultRole)(connOpts) });
     return { pg, db, teardown, manager, admin };
 };
 exports.getConnections = getConnections;

package/esm/admin.js

@@ -2,14 +2,17 @@ import { Logger } from '@launchql/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;
-    constructor(config, verbose = false) {
+    roleConfig;
+    constructor(config, verbose = false, roleConfig) {
         this.config = config;
         this.verbose = verbose;
+        this.roleConfig = roleConfig;
         this.config = getPgEnvOptions(config);
     }
     getEnv() {
@@ -100,13 +103,15 @@ export class DbAdmin {
         await this.streamSql(sql, db);
     }
     async createUserRole(user, password, dbName) {
+        const anonRole = getRoleName('anonymous', this.roleConfig);
+        const authRole = getRoleName('authenticated', this.roleConfig);
         const sql = `
       DO $$
       BEGIN
         IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = '${user}') THEN
           CREATE ROLE ${user} LOGIN PASSWORD '${password}';
-          GRANT anonymous TO ${user};
-          GRANT authenticated TO ${user};
+          GRANT ${anonRole} TO ${user};
+          GRANT ${authRole} TO ${user};
         END IF;
       END $$;
     `.trim();

package/esm/connect.js

@@ -4,13 +4,14 @@ 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 = (connOpts = {}) => {
     const opts = getPgEnvOptions({
         database: connOpts.rootDb
     });
-    const admin = new DbAdmin(opts);
+    const admin = new DbAdmin(opts, false, connOpts);
     return admin;
 };
 const getConnOopts = (cn = {}) => {
@@ -30,7 +31,7 @@ export const getConnections = async (cn = {}, seedAdapters = [seed.launchql()])
     const connOpts = cn.db;
     const root = getPgRootAdmin(connOpts);
     await root.createUserRole(connOpts.connection.user, connOpts.connection.password, connOpts.rootDb);
-    const admin = new DbAdmin(config);
+    const admin = new DbAdmin(config, false, connOpts);
     if (process.env.TEST_DB) {
         config.database = process.env.TEST_DB;
     }
@@ -63,11 +64,15 @@ export const getConnections = async (cn = {}, seedAdapters = [seed.launchql()])
             throw error;
         }
     }
-    const db = manager.getClient({
+    const dbConfig = {
         ...config,
         user: connOpts.connection.user,
         password: connOpts.connection.password
+    };
+    const db = manager.getClient(dbConfig, {
+        auth: connOpts.auth,
+        roles: connOpts.roles
     });
-    db.setContext({ role: 'anonymous' });
+    db.setContext({ role: getDefaultRole(connOpts) });
     return { pg, db, teardown, manager, admin };
 };

package/esm/index.js

@@ -1,5 +1,6 @@
 export * from './admin';
 export * from './connect';
 export * from './manager';
+export * from './roles';
 export * from './seed';
 export * from './test-client';

package/esm/manager.js

@@ -68,11 +68,14 @@ export class PgTestConnector {
         }
         return this.pgPools.get(key);
     }
-    getClient(config) {
+    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) });
+        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);

package/esm/roles.js

@@ -0,0 +1,32 @@
+/**
+ * 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/test-client.js

@@ -1,11 +1,15 @@
 import { Client } from 'pg';
+import { getRoleName } from './roles';
 export class PgTestClient {
     config;
     client;
+    opts;
     ctxStmts = '';
+    contextSettings = {};
     _ended = false;
     connectPromise = null;
     constructor(config, opts = {}) {
+        this.opts = opts;
         this.config = config;
         this.client = new Client({
             host: this.config.host,
@@ -56,12 +60,53 @@ export class PgTestClient {
         await this.commit();
     }
     setContext(ctx) {
-        this.ctxStmts = Object.entries(ctx)
+        Object.assign(this.contextSettings, ctx);
+        this.ctxStmts = Object.entries(this.contextSettings)
             .map(([key, val]) => val === null
             ? `SELECT set_config('${key}', NULL, true);`
             : `SELECT set_config('${key}', '${val}', true);`)
             .join('\n');
     }
+    /**
+     * Set authentication context for the current session.
+     * Configures role and user ID using cascading defaults from options → opts.auth → RoleMapping.
+     */
+    auth(options = {}) {
+        const role = options.role ?? this.opts.auth?.role ?? getRoleName('authenticated', this.opts);
+        const userIdKey = options.userIdKey ?? this.opts.auth?.userIdKey ?? 'jwt.claims.user_id';
+        const userId = options.userId ?? this.opts.auth?.userId ?? null;
+        this.setContext({
+            role,
+            [userIdKey]: userId !== null ? String(userId) : null
+        });
+    }
+    /**
+     * Commit current transaction to make data visible to other connections, then start fresh transaction.
+     * Maintains test isolation by creating a savepoint and reapplying session context.
+     */
+    async publish() {
+        await this.commit(); // make data visible to other sessions
+        await this.begin(); // fresh tx
+        await this.savepoint(); // keep rollback harness
+        await this.ctxQuery(); // reapply all setContext()
+    }
+    /**
+     * Clear all session context variables and reset to default anonymous role.
+     */
+    clearContext() {
+        const defaultRole = getRoleName('anonymous', this.opts);
+        const nulledSettings = {};
+        Object.keys(this.contextSettings).forEach(key => {
+            nulledSettings[key] = null;
+        });
+        nulledSettings.role = defaultRole;
+        this.ctxStmts = Object.entries(nulledSettings)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+        this.contextSettings = { role: defaultRole };
+    }
     async any(query, values) {
         const result = await this.query(query, values);
         return result.rows;

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './admin';
 export * from './connect';
 export * from './manager';
+export * from './roles';
 export * from './seed';
 export * from './test-client';

package/index.js

@@ -17,5 +17,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __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);

package/manager.d.ts

@@ -1,6 +1,6 @@
 import { Pool } from 'pg';
 import { PgConfig } from 'pg-env';
-import { PgTestClient } from './test-client';
+import { PgTestClient, PgTestClientOpts } from './test-client';
 export declare class PgTestConnector {
     private static instance;
     private readonly clients;
@@ -17,7 +17,7 @@ export declare class PgTestConnector {
     private registerConnect;
     private awaitPendingConnects;
     getPool(config: PgConfig): Pool;
-    getClient(config: PgConfig): PgTestClient;
+    getClient(config: PgConfig, opts?: Partial<PgTestClientOpts>): PgTestClient;
     closeAll(): Promise<void>;
     close(): void;
     drop(config: PgConfig): void;

package/manager.js

@@ -71,11 +71,14 @@ class PgTestConnector {
         }
         return this.pgPools.get(key);
     }
-    getClient(config) {
+    getClient(config, opts = {}) {
         if (this.shuttingDown) {
             throw new Error('PgTestConnector is shutting down; no new clients allowed');
         }
-        const client = new test_client_1.PgTestClient(config, { trackConnect: (p) => this.registerConnect(p) });
+        const client = new test_client_1.PgTestClient(config, {
+            trackConnect: (p) => this.registerConnect(p),
+            ...opts
+        });
         this.clients.add(client);
         const key = this.dbKey(config);
         this.seenDbConfigs.set(key, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "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,14 +60,14 @@
     "@types/pg-copy-streams": "^1.2.5"
   },
   "dependencies": {
-    "@launchql/core": "^2.10.0",
-    "@launchql/env": "^2.3.0",
-    "@launchql/server-utils": "^2.3.0",
-    "@launchql/types": "^2.4.0",
+    "@launchql/core": "^2.11.1",
+    "@launchql/env": "^2.4.1",
+    "@launchql/server-utils": "^2.4.1",
+    "@launchql/types": "^2.6.0",
     "pg": "^8.16.0",
-    "pg-cache": "^1.2.0",
+    "pg-cache": "^1.3.1",
     "pg-copy-streams": "^6.0.6",
     "pg-env": "^1.1.0"
   },
-  "gitHead": "7c440e3f4ab8a4395adf489a0c6000d52805937d"
+  "gitHead": "6b7bfcdaef0133012fd4b0cbe2aea185d77de3ed"
 }

package/roles.d.ts

@@ -0,0 +1,17 @@
+import { PgTestConnectionOptions, RoleMapping } from '@launchql/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

@@ -0,0 +1,38 @@
+"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/test-client.d.ts

@@ -1,13 +1,16 @@
 import { Client, QueryResult } from 'pg';
 import { PgConfig } from 'pg-env';
-type PgTestClientOpts = {
+import { AuthOptions, PgTestConnectionOptions } from '@launchql/types';
+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);
@@ -20,6 +23,20 @@ export declare class PgTestClient {
     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>;
@@ -30,4 +47,3 @@ export declare class PgTestClient {
     query<T = any>(query: string, values?: any[]): Promise<QueryResult<T>>;
     ctxQuery(): Promise<void>;
 }
-export {};

package/test-client.js

@@ -2,13 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PgTestClient = void 0;
 const pg_1 = require("pg");
+const roles_1 = require("./roles");
 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,
@@ -59,12 +63,53 @@ class PgTestClient {
         await this.commit();
     }
     setContext(ctx) {
-        this.ctxStmts = Object.entries(ctx)
+        Object.assign(this.contextSettings, ctx);
+        this.ctxStmts = Object.entries(this.contextSettings)
             .map(([key, val]) => val === null
             ? `SELECT set_config('${key}', NULL, true);`
             : `SELECT set_config('${key}', '${val}', true);`)
             .join('\n');
     }
+    /**
+     * 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 = Object.entries(nulledSettings)
+            .map(([key, val]) => val === null
+            ? `SELECT set_config('${key}', NULL, true);`
+            : `SELECT set_config('${key}', '${val}', true);`)
+            .join('\n');
+        this.contextSettings = { role: defaultRole };
+    }
     async any(query, values) {
         const result = await this.query(query, values);
         return result.rows;