pgsql-seed 0.0.1 → 0.2.0

package/esm/index.js

@@ -1,7 +1,12 @@
-export * from './admin';
-export * from './connect';
-export * from './manager';
-export * from './roles';
-export * from './seed';
-export * from './test-client';
-export { snapshot } from './utils';
+// Re-export everything from pg-seed (core seeding utilities)
+export { 
+// CSV utilities
+exportCsv, loadCsv, loadCsvMap, 
+// JSON utilities
+insertJson, insertJsonMap, 
+// SQL utilities
+execSql, loadSql, loadSqlFiles, 
+// Utility
+unwrapClient } from 'pg-seed';
+// pgpm integration (requires @pgpmjs/core)
+export { deployPgpm, loadPgpm } from './pgpm';

package/esm/pgpm.d.ts

@@ -0,0 +1,37 @@
+import type { PgConfig } from 'pg-env';
+/**
+ * Deploy a pgpm package to a PostgreSQL database.
+ *
+ * @param config - PostgreSQL configuration (host, port, database, user, password)
+ * @param cwd - Current working directory containing the pgpm package (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ *
+ * @example
+ * ```typescript
+ * import { Client } from 'pg';
+ * import { deployPgpm } from 'pgsql-seed';
+ *
+ * const config = {
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'postgres',
+ *   password: 'password'
+ * };
+ *
+ * // Deploy the pgpm package in the current directory
+ * await deployPgpm(config);
+ *
+ * // Deploy from a specific directory
+ * await deployPgpm(config, '/path/to/package');
+ * ```
+ */
+export declare function deployPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;
+/**
+ * Load/deploy a pgpm package - alias for deployPgpm for consistency with other load* functions.
+ *
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory containing the pgpm package
+ * @param cache - Whether to enable caching
+ */
+export declare function loadPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;

package/esm/pgpm.js

@@ -0,0 +1,52 @@
+import { PgpmPackage } from '@pgpmjs/core';
+import { getEnvOptions } from '@pgpmjs/env';
+/**
+ * Deploy a pgpm package to a PostgreSQL database.
+ *
+ * @param config - PostgreSQL configuration (host, port, database, user, password)
+ * @param cwd - Current working directory containing the pgpm package (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ *
+ * @example
+ * ```typescript
+ * import { Client } from 'pg';
+ * import { deployPgpm } from 'pgsql-seed';
+ *
+ * const config = {
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'postgres',
+ *   password: 'password'
+ * };
+ *
+ * // Deploy the pgpm package in the current directory
+ * await deployPgpm(config);
+ *
+ * // Deploy from a specific directory
+ * await deployPgpm(config, '/path/to/package');
+ * ```
+ */
+export async function deployPgpm(config, cwd, cache = false) {
+    const proj = new PgpmPackage(cwd ?? process.cwd());
+    if (!proj.isInModule())
+        return;
+    await proj.deploy(getEnvOptions({
+        pg: config,
+        deployment: {
+            fast: true,
+            usePlan: true,
+            cache
+        }
+    }), proj.getModuleName());
+}
+/**
+ * Load/deploy a pgpm package - alias for deployPgpm for consistency with other load* functions.
+ *
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory containing the pgpm package
+ * @param cache - Whether to enable caching
+ */
+export async function loadPgpm(config, cwd, cache = false) {
+    return deployPgpm(config, cwd, cache);
+}

package/index.d.ts

@@ -1,7 +1,2 @@
-export * from './admin';
-export * from './connect';
-export * from './manager';
-export * from './roles';
-export * from './seed';
-export * from './test-client';
-export { snapshot } from './utils';
+export { exportCsv, loadCsv, loadCsvMap, insertJson, insertJsonMap, execSql, loadSql, loadSqlFiles, type ClientInput, type CopyableClient, type CsvSeedMap, type JsonSeedMap, type QueryableClient, unwrapClient } from 'pg-seed';
+export { deployPgpm, loadPgpm } from './pgpm';

package/index.js

@@ -1,25 +1,22 @@
 "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.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");
-Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return utils_1.snapshot; } });
+exports.loadPgpm = exports.deployPgpm = exports.unwrapClient = exports.loadSqlFiles = exports.loadSql = exports.execSql = exports.insertJsonMap = exports.insertJson = exports.loadCsvMap = exports.loadCsv = exports.exportCsv = void 0;
+// Re-export everything from pg-seed (core seeding utilities)
+var pg_seed_1 = require("pg-seed");
+// CSV utilities
+Object.defineProperty(exports, "exportCsv", { enumerable: true, get: function () { return pg_seed_1.exportCsv; } });
+Object.defineProperty(exports, "loadCsv", { enumerable: true, get: function () { return pg_seed_1.loadCsv; } });
+Object.defineProperty(exports, "loadCsvMap", { enumerable: true, get: function () { return pg_seed_1.loadCsvMap; } });
+// JSON utilities
+Object.defineProperty(exports, "insertJson", { enumerable: true, get: function () { return pg_seed_1.insertJson; } });
+Object.defineProperty(exports, "insertJsonMap", { enumerable: true, get: function () { return pg_seed_1.insertJsonMap; } });
+// SQL utilities
+Object.defineProperty(exports, "execSql", { enumerable: true, get: function () { return pg_seed_1.execSql; } });
+Object.defineProperty(exports, "loadSql", { enumerable: true, get: function () { return pg_seed_1.loadSql; } });
+Object.defineProperty(exports, "loadSqlFiles", { enumerable: true, get: function () { return pg_seed_1.loadSqlFiles; } });
+// Utility
+Object.defineProperty(exports, "unwrapClient", { enumerable: true, get: function () { return pg_seed_1.unwrapClient; } });
+// pgpm integration (requires @pgpmjs/core)
+var pgpm_1 = require("./pgpm");
+Object.defineProperty(exports, "deployPgpm", { enumerable: true, get: function () { return pgpm_1.deployPgpm; } });
+Object.defineProperty(exports, "loadPgpm", { enumerable: true, get: function () { return pgpm_1.loadPgpm; } });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "pgsql-seed",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "author": "Constructive <developers@constructive.io>",
-  "description": "pgsql-seed offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests — giving developers realistic test coverage without external state pollution",
+  "description": "PostgreSQL seeding utilities with pgpm integration - batteries included",
   "main": "index.js",
   "module": "esm/index.js",
   "types": "index.d.ts",
@@ -22,40 +22,35 @@
   "keywords": [
     "postgres",
     "postgresql",
-    "testing",
-    "integration-tests",
-    "database-testing",
-    "pg",
-    "rls",
-    "role-based-access",
-    "test-database",
-    "test-runner",
-    "jest",
-    "mocha",
-    "sqitch",
-    "constructive",
-    "graphile",
-    "typeorm",
-    "knex",
     "seed",
-    "fixtures",
-    "transactions",
-    "rollback",
-    "node-postgres",
-    "pg-pool",
-    "pg-client"
+    "seeding",
+    "csv",
+    "json",
+    "sql",
+    "pgpm",
+    "migrations",
+    "data-loading",
+    "constructive"
   ],
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.16.0",
+    "makage": "^0.1.9"
+  },
   "dependencies": {
-    "@pgpmjs/core": "^4.2.0",
+    "@pgpmjs/core": "^4.3.0",
     "@pgpmjs/env": "^2.8.11",
-    "@pgpmjs/logger": "^1.3.5",
-    "@pgpmjs/server-utils": "^2.8.11",
-    "@pgpmjs/types": "^2.12.8",
-    "csv-parse": "^6.1.0",
     "pg": "^8.16.3",
-    "pg-cache": "^1.6.11",
-    "pg-copy-streams": "^7.0.0",
-    "pg-env": "^1.2.4"
+    "pg-env": "^1.2.4",
+    "pg-seed": "^0.2.0"
   },
-  "gitHead": "9b68e2d19937ad4e2a81a5de110a197a8572e3d9"
+  "gitHead": "7ac931c063d48e281349b748ba2eb9c9f47ffb06"
 }

package/pgpm.d.ts

@@ -0,0 +1,37 @@
+import type { PgConfig } from 'pg-env';
+/**
+ * Deploy a pgpm package to a PostgreSQL database.
+ *
+ * @param config - PostgreSQL configuration (host, port, database, user, password)
+ * @param cwd - Current working directory containing the pgpm package (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ *
+ * @example
+ * ```typescript
+ * import { Client } from 'pg';
+ * import { deployPgpm } from 'pgsql-seed';
+ *
+ * const config = {
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'postgres',
+ *   password: 'password'
+ * };
+ *
+ * // Deploy the pgpm package in the current directory
+ * await deployPgpm(config);
+ *
+ * // Deploy from a specific directory
+ * await deployPgpm(config, '/path/to/package');
+ * ```
+ */
+export declare function deployPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;
+/**
+ * Load/deploy a pgpm package - alias for deployPgpm for consistency with other load* functions.
+ *
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory containing the pgpm package
+ * @param cache - Whether to enable caching
+ */
+export declare function loadPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;

package/pgpm.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployPgpm = deployPgpm;
+exports.loadPgpm = loadPgpm;
+const core_1 = require("@pgpmjs/core");
+const env_1 = require("@pgpmjs/env");
+/**
+ * Deploy a pgpm package to a PostgreSQL database.
+ *
+ * @param config - PostgreSQL configuration (host, port, database, user, password)
+ * @param cwd - Current working directory containing the pgpm package (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ *
+ * @example
+ * ```typescript
+ * import { Client } from 'pg';
+ * import { deployPgpm } from 'pgsql-seed';
+ *
+ * const config = {
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'mydb',
+ *   user: 'postgres',
+ *   password: 'password'
+ * };
+ *
+ * // Deploy the pgpm package in the current directory
+ * await deployPgpm(config);
+ *
+ * // Deploy from a specific directory
+ * await deployPgpm(config, '/path/to/package');
+ * ```
+ */
+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());
+}
+/**
+ * Load/deploy a pgpm package - alias for deployPgpm for consistency with other load* functions.
+ *
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory containing the pgpm package
+ * @param cache - Whether to enable caching
+ */
+async function loadPgpm(config, cwd, cache = false) {
+    return deployPgpm(config, cwd, cache);
+}

package/admin.d.ts

@@ -1,26 +0,0 @@
-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?;
-    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,144 +0,0 @@
-"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;
-    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);
-    }
-    async createSeededTemplate(templateName, adapter) {
-        const seedDb = this.config.database;
-        this.create(seedDb);
-        await adapter.seed({
-            admin: this,
-            config: this.config,
-            pg: null, // placeholder for PgTestClient
-            connect: null // placeholder for connection factory
-        });
-        this.cleanupTemplate(templateName);
-        this.createTemplateFromBase(seedDb, templateName);
-        this.drop(seedDb);
-    }
-}
-exports.DbAdmin = DbAdmin;

package/connect.d.ts

@@ -1,19 +0,0 @@
-import { PgTestConnectionOptions } from '@pgpmjs/types';
-import { PgConfig } from 'pg-env';
-import { DbAdmin } from './admin';
-import { PgTestConnector } from './manager';
-import { SeedAdapter } from './seed/types';
-import { PgTestClient } from './test-client';
-export declare const getPgRootAdmin: (config: PgConfig, connOpts?: PgTestConnectionOptions) => DbAdmin;
-export interface GetConnectionOpts {
-    pg?: Partial<PgConfig>;
-    db?: Partial<PgTestConnectionOptions>;
-}
-export interface GetConnectionResult {
-    pg: PgTestClient;
-    db: PgTestClient;
-    admin: DbAdmin;
-    teardown: () => Promise<void>;
-    manager: PgTestConnector;
-}
-export declare const getConnections: (cn?: GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<GetConnectionResult>;

package/connect.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnections = exports.getPgRootAdmin = void 0;
-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 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 = {}) => {
-    const opts = (0, pg_env_1.getPgEnvOptions)({
-        user: config.user,
-        password: config.password,
-        host: config.host,
-        port: config.port,
-        database: connOpts.rootDb
-    });
-    const admin = new admin_1.DbAdmin(opts, false, connOpts);
-    return admin;
-};
-exports.getPgRootAdmin = getPgRootAdmin;
-const getConnOopts = (cn = {}) => {
-    const connect = (0, env_1.getConnEnvOptions)(cn.db);
-    const config = (0, pg_env_1.getPgEnvOptions)({
-        database: `${connect.prefix}${(0, crypto_1.randomUUID)()}`,
-        ...cn.pg
-    });
-    return {
-        pg: config,
-        db: connect
-    };
-};
-const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.pgpm()]) => {
-    cn = getConnOopts(cn);
-    const config = cn.pg;
-    const connOpts = cn.db;
-    const root = (0, exports.getPgRootAdmin)(config, connOpts);
-    await root.createUserRole(connOpts.connections.app.user, connOpts.connections.app.password, connOpts.rootDb);
-    const admin = new admin_1.DbAdmin(config, false, connOpts);
-    if (process.env.TEST_DB) {
-        config.database = process.env.TEST_DB;
-    }
-    else if (connOpts.template) {
-        admin.createFromTemplate(connOpts.template, config.database);
-    }
-    else {
-        admin.create(config.database);
-        admin.installExtensions(connOpts.extensions);
-    }
-    await admin.grantConnect(connOpts.connections.app.user, config.database);
-    manager = manager_1.PgTestConnector.getInstance(config);
-    const pg = manager.getClient(config);
-    let teardownPromise = null;
-    const teardown = async () => {
-        if (teardownPromise)
-            return teardownPromise;
-        teardownPromise = (async () => {
-            manager.beginTeardown();
-            await (0, pg_cache_1.teardownPgPools)();
-            await manager.closeAll();
-        })();
-        return teardownPromise;
-    };
-    if (seedAdapters.length) {
-        try {
-            await seed_1.seed.compose(seedAdapters).seed({
-                connect: connOpts,
-                admin,
-                config: config,
-                pg: manager.getClient(config)
-            });
-        }
-        catch (error) {
-            const err = error;
-            const msg = err && (err.stack || err.message) ? (err.stack || err.message) : String(err);
-            process.stderr.write(`[pgsql-test] Seed error (continuing): ${msg}\n`);
-            // continue without teardown to allow caller-managed lifecycle
-        }
-    }
-    const dbConfig = {
-        ...config,
-        user: connOpts.connections.app.user,
-        password: connOpts.connections.app.password
-    };
-    const db = manager.getClient(dbConfig, {
-        auth: connOpts.auth,
-        roles: connOpts.roles
-    });
-    db.setContext({ role: (0, roles_1.getDefaultRole)(connOpts) });
-    return { pg, db, teardown, manager, admin };
-};
-exports.getConnections = getConnections;

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');
-}