pgsql-test 2.11.13 → 2.12.0

package/README.md

@@ -58,7 +58,6 @@ Part of the [LaunchQL](https://github.com/launchql) ecosystem, `pgsql-test` is b
    * [Programmatic Seeding](#-programmatic-seeding)
    * [CSV Seeding](#️-csv-seeding)
    * [JSON Seeding](#️-json-seeding)
-   * [Sqitch Seeding](#️-sqitch-seeding)
    * [LaunchQL Seeding](#-launchql-seeding)
 7. [`getConnections() Options` ](#getconnections-options)
 8. [Disclaimer](#disclaimer)
@@ -240,16 +239,48 @@ This array lets you fully customize how your test database is seeded. You can co
 * [`seed.fn()`](#-programmatic-seeding) – Run JavaScript/TypeScript logic to programmatically insert data
 * [`seed.csv()`](#️-csv-seeding) – Load tabular data from CSV files
 * [`seed.json()`](#️-json-seeding) – Use in-memory objects as seed data
-* [`seed.sqitch()`](#️-sqitch-seeding) – Deploy a Sqitch-compatible migration project
-* [`seed.launchql()`](#-launchql-seeding) – Apply a LaunchQL module using `deployFast()` (compatible with sqitch)
+* [`seed.launchql()`](#-launchql-seeding) – Apply a LaunchQL project or set of packages (compatible with sqitch)
 
 > ✨ **Default Behavior:** If no `SeedAdapter[]` is passed, LaunchQL seeding is assumed. This makes `pgsql-test` zero-config for LaunchQL-based projects.
 
 This composable system allows you to mix-and-match data setup strategies for flexible, realistic, and fast database tests.
 
+#### Two Seeding Patterns
+
+You can seed data using either approach:
+
+**1. Adapter Pattern** (setup phase via `getConnections`)
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.json({ 'users': [{ id: 1, name: 'Alice' }] })
+]);
+```
+
+**2. Direct Load Methods** (runtime via `PgTestClient`)
+```ts
+await db.loadJson({ 'users': [{ id: 1, name: 'Alice' }] });
+await db.loadCsv({ 'users': '/path/to/users.csv' });
+await db.loadSql(['/path/to/schema.sql']);
+```
+
+> **Note:** `loadCsv()` and `loadLaunchql()` do not apply RLS context (PostgreSQL limitation). Use `loadJson()` or `loadSql()` for RLS-aware seeding.
+
 ### 🔌 SQL File Seeding
 
-Use `.sql` files to set up your database state before tests:
+**Adapter Pattern:**
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.sqlfile(['schema.sql', 'fixtures.sql'])
+]);
+```
+
+**Direct Load Method:**
+```ts
+await db.loadSql(['schema.sql', 'fixtures.sql']);
+```
+
+<details>
+<summary>Full example</summary>
 
 ```ts
 import path from 'path';
@@ -274,9 +305,27 @@ afterAll(async () => {
 });
 ```
 
+</details>
+
 ### 🧠 Programmatic Seeding
 
-Use JavaScript functions to insert seed data:
+**Adapter Pattern:**
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.fn(async ({ pg }) => {
+    await pg.query(`INSERT INTO users (name) VALUES ('Seeded User')`);
+  })
+]);
+```
+
+**Direct Load Method:**
+```ts
+// Use any PgTestClient method directly
+await db.query(`INSERT INTO users (name) VALUES ('Seeded User')`);
+```
+
+<details>
+<summary>Full example</summary>
 
 ```ts
 import { getConnections, seed } from 'pgsql-test';
@@ -295,8 +344,33 @@ beforeAll(async () => {
 });
 ```
 
+</details>
+
 ## 🗃️ CSV Seeding
 
+**Adapter Pattern:**
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.csv({
+    'users': '/path/to/users.csv',
+    'posts': '/path/to/posts.csv'
+  })
+]);
+```
+
+**Direct Load Method:**
+```ts
+await db.loadCsv({
+  'users': '/path/to/users.csv',
+  'posts': '/path/to/posts.csv'
+});
+```
+
+> **Note:** CSV loading uses PostgreSQL COPY which does not support RLS context.
+
+<details>
+<summary>Full example</summary>
+
 You can load tables from CSV files using `seed.csv({ ... })`. CSV headers must match the table column names exactly. This is useful for loading stable fixture data for integration tests or CI environments.
 
 ```ts
@@ -346,8 +420,35 @@ it('has loaded rows', async () => {
 });
 ```
 
+</details>
+
 ## 🗃️ JSON Seeding
 
+**Adapter Pattern:**
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.json({
+    'custom.users': [
+      { id: 1, name: 'Alice' },
+      { id: 2, name: 'Bob' }
+    ]
+  })
+]);
+```
+
+**Direct Load Method:**
+```ts
+await db.loadJson({
+  'custom.users': [
+    { id: 1, name: 'Alice' },
+    { id: 2, name: 'Bob' }
+  ]
+});
+```
+
+<details>
+<summary>Full example</summary>
+
 You can seed tables using in-memory JSON objects. This is useful when you want fast, inline fixtures without managing external files.
 
 ```ts
@@ -401,28 +502,32 @@ it('has loaded rows', async () => {
 });
 ```
 
-## 🏗️ Sqitch Seeding
+</details>
 
-*Note: While compatible with Sqitch syntax, LaunchQL uses its own high-performance [TypeScript-based deploy engine.](#-launchql-seeding) that we encourage using for sqitch projects*
-
-You can seed your test database using a Sqitch project but with significantly improved performance by leveraging LaunchQL's TypeScript deployment engine:
+## 🚀 LaunchQL Seeding
 
+**Zero Configuration (Default):**
 ```ts
-import path from 'path';
-import { getConnections, seed } from 'pgsql-test';
+// LaunchQL migrate is used automatically
+const { db, teardown } = await getConnections();
+```
 
-const cwd = path.resolve(__dirname, '../path/to/sqitch');
+**Adapter Pattern (Custom Path):**
+```ts
+const { db, teardown } = await getConnections({}, [
+  seed.launchql('/path/to/launchql', true) // with cache
+]);
+```
 
-beforeAll(async () => {
-  ({ db, teardown } = await getConnections({}, [
-    seed.sqitch(cwd)
-  ]));
-});
+**Direct Load Method:**
+```ts
+await db.loadLaunchql('/path/to/launchql', true); // with cache
 ```
 
-This works for any Sqitch-compatible module, now accelerated by LaunchQL's deployment tooling.
+> **Note:** LaunchQL deployment has its own client handling and does not apply RLS context.
 
-## 🚀 LaunchQL Seeding
+<details>
+<summary>Full example</summary>
 
 If your project uses LaunchQL modules with a precompiled `launchql.plan`, you can use `pgsql-test` with **zero configuration**. Just call `getConnections()` — and it *just works*:
 
@@ -432,14 +537,13 @@ import { getConnections } from 'pgsql-test';
 let db, teardown;
 
 beforeAll(async () => {
-  ({ db, teardown } = await getConnections()); // 🚀 LaunchQL deployFast() is used automatically - up to 10x faster than traditional Sqitch!
+  ({ db, teardown } = await getConnections()); // LaunchQL module is deployed automatically
 });
 ```
 
-This works out of the box because `pgsql-test` uses the high-speed `deployFast()` function by default, applying any compiled LaunchQL schema located in the current working directory (`process.cwd()`).
-
-If you want to specify a custom path to your LaunchQL module, use `seed.launchql()` explicitly:
+LaunchQL uses Sqitch-compatible syntax with a TypeScript-based migration engine. By default, `pgsql-test` automatically deploys any LaunchQL module found in the current working directory (`process.cwd()`).
 
+To specify a custom path to your LaunchQL module, use `seed.launchql()` explicitly:
 
 ```ts
 import path from 'path';
@@ -449,11 +553,24 @@ const cwd = path.resolve(__dirname, '../path/to/launchql');
 
 beforeAll(async () => {
   ({ db, teardown } = await getConnections({}, [
-    seed.launchql(cwd) // uses deployFast() - up to 10x faster than traditional Sqitch!
+    seed.launchql(cwd)
   ]));
 });
 ```
 
+</details>
+
+## Why LaunchQL's Approach?
+
+LaunchQL provides the best of both worlds:
+
+1. **Sqitch Compatibility**: Keep your familiar Sqitch syntax and migration approach
+2. **TypeScript Performance**: Our TS-rewritten deployment engine delivers up to 10x faster schema deployments
+3. **Developer Experience**: Tight feedback loops with near-instant schema setup for tests
+4. **CI Optimization**: Dramatically reduced test suite run times with optimized deployment
+
+By maintaining Sqitch compatibility while supercharging performance, LaunchQL enables you to keep your existing migration patterns while enjoying the speed benefits of our TypeScript engine.
+
 ## Why LaunchQL's Approach?
 
 LaunchQL provides the best of both worlds:
@@ -474,7 +591,7 @@ This table documents the available options for the `getConnections` function. Th
 | Option                   | Type       | Default          | Description                                                                 |
 | ------------------------ | ---------- | ---------------- | --------------------------------------------------------------------------- |
 | `db.extensions`          | `string[]` | `[]`             | Array of PostgreSQL extensions to include in the test database              |
-| `db.cwd`                 | `string`   | `process.cwd()`  | Working directory used for LaunchQL/Sqitch projects                         |
+| `db.cwd`                 | `string`   | `process.cwd()`  | Working directory used for LaunchQL or Sqitch projects                         |
 | `db.connection.user`     | `string`   | `'app_user'`     | User for simulating RLS via `setContext()`                                  |
 | `db.connection.password` | `string`   | `'app_password'` | Password for RLS test user                                                  |
 | `db.connection.role`     | `string`   | `'anonymous'`    | Default role used during `setContext()`                                     |

package/context-utils.d.ts

@@ -0,0 +1,8 @@
+import type { PgTestClientContext } from '@launchql/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

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

@@ -0,0 +1,25 @@
+/**
+ * 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/seed/csv.js

@@ -4,6 +4,34 @@ import { parse } from 'csv-parse';
 import { createReadStream, createWriteStream, existsSync } from 'fs';
 import { from as copyFrom, to as copyTo } from 'pg-copy-streams';
 const log = new Logger('csv');
+/**
+ * Standalone helper function to load CSV files into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param tables - Map of table names to CSV file paths
+ */
+export async function loadCsvMap(client, tables) {
+    for (const [table, filePath] of Object.entries(tables)) {
+        if (!existsSync(filePath)) {
+            throw new Error(`CSV file not found: ${filePath}`);
+        }
+        log.info(`📥 Seeding "${table}" from ${filePath}`);
+        const columns = await parseCsvHeader(filePath);
+        const quotedColumns = columns.map(col => `"${col.replace(/"/g, '""')}"`);
+        const columnList = quotedColumns.join(', ');
+        const copyCommand = `COPY ${table} (${columnList}) FROM STDIN WITH CSV HEADER`;
+        log.info(`Using columns: ${columnList}`);
+        const stream = client.query(copyFrom(copyCommand));
+        const source = createReadStream(filePath);
+        try {
+            await pipeline(source, stream);
+            log.success(`✅ Successfully seeded "${table}"`);
+        }
+        catch (err) {
+            log.error(`❌ COPY failed for "${table}": ${err.message}`);
+            throw err;
+        }
+    }
+}
 export function csv(tables) {
     return {
         async seed(ctx) {

package/esm/seed/index.js

@@ -2,12 +2,10 @@ import { compose, fn, sqlfile } from './adapters';
 import { csv } from './csv';
 import { json } from './json';
 import { launchql } from './launchql';
-import { sqitch } from './sqitch';
 export * from './csv';
 export * from './types';
 export const seed = {
     launchql,
-    sqitch,
     json,
     csv,
     compose,

package/esm/seed/json.js

@@ -1,3 +1,21 @@
+/**
+ * Standalone helper function to insert JSON data into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param data - Map of table names to arrays of row objects
+ */
+export async function insertJson(client, data) {
+    for (const [table, rows] of Object.entries(data)) {
+        if (!Array.isArray(rows) || rows.length === 0)
+            continue;
+        const columns = Object.keys(rows[0]);
+        const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
+        const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
+        for (const row of rows) {
+            const values = columns.map((c) => row[c]);
+            await client.query(sql, values);
+        }
+    }
+}
 export function json(data) {
     return {
         async seed(ctx) {

package/esm/seed/launchql.js

@@ -1,19 +1,28 @@
 import { LaunchQLPackage } from '@launchql/core';
 import { getEnvOptions } from '@launchql/env';
+/**
+ * Standalone helper function to deploy LaunchQL package
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ */
+export async function deployLaunchql(config, cwd, cache = false) {
+    const proj = new LaunchQLPackage(cwd ?? process.cwd());
+    if (!proj.isInModule())
+        return;
+    await proj.deploy(getEnvOptions({
+        pg: config,
+        deployment: {
+            fast: true,
+            usePlan: true,
+            cache
+        }
+    }), proj.getModuleName());
+}
 export function launchql(cwd, cache = false) {
     return {
         async seed(ctx) {
-            const proj = new LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy(getEnvOptions({
-                pg: ctx.config,
-                deployment: {
-                    fast: true,
-                    usePlan: true,
-                    cache
-                }
-            }), proj.getModuleName());
+            await deployLaunchql(ctx.config, cwd ?? ctx.connect.cwd, cache);
         }
     };
 }

package/esm/seed/sql.js

@@ -0,0 +1,15 @@
+import { existsSync, readFileSync } from 'fs';
+/**
+ * Standalone helper function to load SQL files into PostgreSQL
+ * @param client - PostgreSQL client instance
+ * @param files - Array of SQL file paths to execute
+ */
+export async function loadSqlFiles(client, files) {
+    for (const file of files) {
+        if (!existsSync(file)) {
+            throw new Error(`SQL file not found: ${file}`);
+        }
+        const sql = readFileSync(file, 'utf-8');
+        await client.query(sql);
+    }
+}

package/esm/test-client.js

@@ -1,5 +1,10 @@
 import { Client } from 'pg';
 import { getRoleName } from './roles';
+import { generateContextStatements } from './context-utils';
+import { insertJson } from './seed/json';
+import { loadCsvMap } from './seed/csv';
+import { loadSqlFiles } from './seed/sql';
+import { deployLaunchql } from './seed/launchql';
 export class PgTestClient {
     config;
     client;
@@ -61,11 +66,7 @@ export class PgTestClient {
     }
     setContext(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');
+        this.ctxStmts = generateContextStatements(this.contextSettings);
     }
     /**
      * Set authentication context for the current session.
@@ -100,11 +101,7 @@ export class PgTestClient {
             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.ctxStmts = generateContextStatements(nulledSettings);
         this.contextSettings = { role: defaultRole };
     }
     async any(query, values) {
@@ -137,14 +134,35 @@ export class PgTestClient {
     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 ctxQuery() {
-        if (this.ctxStmts) {
-            await this.client.query(this.ctxStmts);
-        }
+    async loadJson(data) {
+        await this.ctxQuery();
+        await insertJson(this.client, data);
+    }
+    async loadSql(files) {
+        await this.ctxQuery();
+        await loadSqlFiles(this.client, files);
+    }
+    // NON-RLS load/seed methods:
+    async loadCsv(tables) {
+        // await this.ctxQuery(); // no point to call ctxQuery() here
+        // because POSTGRES doesn't support row-level security on COPY FROM...
+        await loadCsvMap(this.client, tables);
+    }
+    async loadLaunchql(cwd, cache = false) {
+        // await this.ctxQuery(); // no point to call ctxQuery() here
+        // because deployLaunchql() has it's own way of getting the client...
+        // so for now, we'll expose this but it's limited
+        await deployLaunchql(this.config, cwd, cache);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.11.13",
+  "version": "2.12.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",
@@ -61,16 +61,16 @@
     "@types/pg-copy-streams": "^1.2.5"
   },
   "dependencies": {
-    "@launchql/core": "^2.12.1",
-    "@launchql/env": "^2.4.4",
+    "@launchql/core": "^2.12.2",
+    "@launchql/env": "^2.4.5",
     "@launchql/logger": "^1.1.2",
-    "@launchql/server-utils": "^2.4.4",
-    "@launchql/types": "^2.6.3",
+    "@launchql/server-utils": "^2.4.5",
+    "@launchql/types": "^2.7.0",
     "csv-parse": "^5.5.5",
     "pg": "^8.16.0",
-    "pg-cache": "^1.3.5",
+    "pg-cache": "^1.3.6",
     "pg-copy-streams": "^6.0.6",
     "pg-env": "^1.1.1"
   },
-  "gitHead": "ab60dc92d8b8a620cf59f7962c213ca70d735406"
+  "gitHead": "7a71d63b0ac5b0ea13f2c55cbb09d5fc0957a4f5"
 }

package/seed/csv.d.ts

@@ -1,9 +1,15 @@
-import { PgTestClient } from '../test-client';
+import { Client } from 'pg';
+import type { PgTestClient } from '../test-client';
 import { SeedAdapter } from './types';
-interface CsvSeedMap {
+export interface CsvSeedMap {
     [tableName: string]: string;
 }
+/**
+ * Standalone helper function to load CSV files into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param tables - Map of table names to CSV file paths
+ */
+export declare function loadCsvMap(client: Client, tables: CsvSeedMap): Promise<void>;
 export declare function csv(tables: CsvSeedMap): SeedAdapter;
 export declare function copyCsvIntoTable(pg: PgTestClient, table: string, filePath: string): Promise<void>;
 export declare function exportTableToCsv(pg: PgTestClient, table: string, filePath: string): Promise<void>;
-export {};

package/seed/csv.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCsvMap = loadCsvMap;
 exports.csv = csv;
 exports.copyCsvIntoTable = copyCsvIntoTable;
 exports.exportTableToCsv = exportTableToCsv;
@@ -9,6 +10,34 @@ const csv_parse_1 = require("csv-parse");
 const fs_1 = require("fs");
 const pg_copy_streams_1 = require("pg-copy-streams");
 const log = new logger_1.Logger('csv');
+/**
+ * Standalone helper function to load CSV files into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param tables - Map of table names to CSV file paths
+ */
+async function loadCsvMap(client, tables) {
+    for (const [table, filePath] of Object.entries(tables)) {
+        if (!(0, fs_1.existsSync)(filePath)) {
+            throw new Error(`CSV file not found: ${filePath}`);
+        }
+        log.info(`📥 Seeding "${table}" from ${filePath}`);
+        const columns = await parseCsvHeader(filePath);
+        const quotedColumns = columns.map(col => `"${col.replace(/"/g, '""')}"`);
+        const columnList = quotedColumns.join(', ');
+        const copyCommand = `COPY ${table} (${columnList}) FROM STDIN WITH CSV HEADER`;
+        log.info(`Using columns: ${columnList}`);
+        const stream = client.query((0, pg_copy_streams_1.from)(copyCommand));
+        const source = (0, fs_1.createReadStream)(filePath);
+        try {
+            await (0, promises_1.pipeline)(source, stream);
+            log.success(`✅ Successfully seeded "${table}"`);
+        }
+        catch (err) {
+            log.error(`❌ COPY failed for "${table}": ${err.message}`);
+            throw err;
+        }
+    }
+}
 function csv(tables) {
     return {
         async seed(ctx) {

package/seed/index.d.ts

@@ -2,12 +2,10 @@ import { compose, fn, sqlfile } from './adapters';
 import { csv } from './csv';
 import { json } from './json';
 import { launchql } from './launchql';
-import { sqitch } from './sqitch';
 export * from './csv';
 export * from './types';
 export declare const seed: {
     launchql: typeof launchql;
-    sqitch: typeof sqitch;
     json: typeof json;
     csv: typeof csv;
     compose: typeof compose;

package/seed/index.js

@@ -19,12 +19,10 @@ const adapters_1 = require("./adapters");
 const csv_1 = require("./csv");
 const json_1 = require("./json");
 const launchql_1 = require("./launchql");
-const sqitch_1 = require("./sqitch");
 __exportStar(require("./csv"), exports);
 __exportStar(require("./types"), exports);
 exports.seed = {
     launchql: launchql_1.launchql,
-    sqitch: sqitch_1.sqitch,
     json: json_1.json,
     csv: csv_1.csv,
     compose: adapters_1.compose,

package/seed/json.d.ts

@@ -1,6 +1,12 @@
+import type { Client } from 'pg';
 import { SeedAdapter } from './types';
-interface JsonSeedMap {
+export interface JsonSeedMap {
     [table: string]: Record<string, any>[];
 }
+/**
+ * Standalone helper function to insert JSON data into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param data - Map of table names to arrays of row objects
+ */
+export declare function insertJson(client: Client, data: JsonSeedMap): Promise<void>;
 export declare function json(data: JsonSeedMap): SeedAdapter;
-export {};

package/seed/json.js

@@ -1,6 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertJson = insertJson;
 exports.json = json;
+/**
+ * Standalone helper function to insert JSON data into PostgreSQL tables
+ * @param client - PostgreSQL client instance
+ * @param data - Map of table names to arrays of row objects
+ */
+async function insertJson(client, data) {
+    for (const [table, rows] of Object.entries(data)) {
+        if (!Array.isArray(rows) || rows.length === 0)
+            continue;
+        const columns = Object.keys(rows[0]);
+        const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
+        const sql = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;
+        for (const row of rows) {
+            const values = columns.map((c) => row[c]);
+            await client.query(sql, values);
+        }
+    }
+}
 function json(data) {
     return {
         async seed(ctx) {

package/seed/launchql.d.ts

@@ -1,2 +1,10 @@
+import type { PgConfig } from 'pg-env';
 import { SeedAdapter } from './types';
+/**
+ * Standalone helper function to deploy LaunchQL package
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ */
+export declare function deployLaunchql(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;
 export declare function launchql(cwd?: string, cache?: boolean): SeedAdapter;

package/seed/launchql.js

@@ -1,22 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployLaunchql = deployLaunchql;
 exports.launchql = launchql;
 const core_1 = require("@launchql/core");
 const env_1 = require("@launchql/env");
+/**
+ * Standalone helper function to deploy LaunchQL package
+ * @param config - PostgreSQL configuration
+ * @param cwd - Current working directory (defaults to process.cwd())
+ * @param cache - Whether to enable caching (defaults to false)
+ */
+async function deployLaunchql(config, cwd, cache = false) {
+    const proj = new core_1.LaunchQLPackage(cwd ?? process.cwd());
+    if (!proj.isInModule())
+        return;
+    await proj.deploy((0, env_1.getEnvOptions)({
+        pg: config,
+        deployment: {
+            fast: true,
+            usePlan: true,
+            cache
+        }
+    }), proj.getModuleName());
+}
 function launchql(cwd, cache = false) {
     return {
         async seed(ctx) {
-            const proj = new core_1.LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy((0, env_1.getEnvOptions)({
-                pg: ctx.config,
-                deployment: {
-                    fast: true,
-                    usePlan: true,
-                    cache
-                }
-            }), proj.getModuleName());
+            await deployLaunchql(ctx.config, cwd ?? ctx.connect.cwd, cache);
         }
     };
 }

package/seed/sql.d.ts

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

package/seed/sql.js

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

package/test-client.d.ts

@@ -1,6 +1,8 @@
 import { Client, QueryResult } from 'pg';
 import { PgConfig } from 'pg-env';
 import { AuthOptions, PgTestConnectionOptions } from '@launchql/types';
+import { type JsonSeedMap } from './seed/json';
+import { type CsvSeedMap } from './seed/csv';
 export type PgTestClientOpts = {
     deferConnect?: boolean;
     trackConnect?: (p: Promise<any>) => void;
@@ -44,6 +46,10 @@ export declare class PgTestClient {
     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>;
-    query<T = any>(query: string, values?: any[]): Promise<QueryResult<T>>;
     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>;
+    loadLaunchql(cwd?: string, cache?: boolean): Promise<void>;
 }

package/test-client.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PgTestClient = void 0;
 const pg_1 = require("pg");
 const roles_1 = require("./roles");
+const context_utils_1 = require("./context-utils");
+const json_1 = require("./seed/json");
+const csv_1 = require("./seed/csv");
+const sql_1 = require("./seed/sql");
+const launchql_1 = require("./seed/launchql");
 class PgTestClient {
     config;
     client;
@@ -64,11 +69,7 @@ class PgTestClient {
     }
     setContext(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');
+        this.ctxStmts = (0, context_utils_1.generateContextStatements)(this.contextSettings);
     }
     /**
      * Set authentication context for the current session.
@@ -103,11 +104,7 @@ class PgTestClient {
             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.ctxStmts = (0, context_utils_1.generateContextStatements)(nulledSettings);
         this.contextSettings = { role: defaultRole };
     }
     async any(query, values) {
@@ -140,15 +137,36 @@ class PgTestClient {
     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 ctxQuery() {
-        if (this.ctxStmts) {
-            await this.client.query(this.ctxStmts);
-        }
+    async loadJson(data) {
+        await this.ctxQuery();
+        await (0, json_1.insertJson)(this.client, data);
+    }
+    async loadSql(files) {
+        await this.ctxQuery();
+        await (0, sql_1.loadSqlFiles)(this.client, files);
+    }
+    // NON-RLS load/seed methods:
+    async loadCsv(tables) {
+        // await this.ctxQuery(); // no point to call ctxQuery() here
+        // because POSTGRES doesn't support row-level security on COPY FROM...
+        await (0, csv_1.loadCsvMap)(this.client, tables);
+    }
+    async loadLaunchql(cwd, cache = false) {
+        // await this.ctxQuery(); // no point to call ctxQuery() here
+        // because deployLaunchql() has it's own way of getting the client...
+        // so for now, we'll expose this but it's limited
+        await (0, launchql_1.deployLaunchql)(this.config, cwd, cache);
     }
 }
 exports.PgTestClient = PgTestClient;

package/esm/seed/sqitch.js

@@ -1,17 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import { getEnvOptions } from '@launchql/env';
-export function sqitch(cwd) {
-    return {
-        async seed(ctx) {
-            const proj = new LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy(getEnvOptions({
-                pg: ctx.config,
-                deployment: {
-                    fast: false
-                }
-            }), proj.getModuleName(), true);
-        }
-    };
-}

package/seed/sqitch.d.ts

@@ -1,2 +0,0 @@
-import { SeedAdapter } from './types';
-export declare function sqitch(cwd?: string): SeedAdapter;

package/seed/sqitch.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqitch = sqitch;
-const core_1 = require("@launchql/core");
-const env_1 = require("@launchql/env");
-function sqitch(cwd) {
-    return {
-        async seed(ctx) {
-            const proj = new core_1.LaunchQLPackage(cwd ?? ctx.connect.cwd);
-            if (!proj.isInModule())
-                return;
-            await proj.deploy((0, env_1.getEnvOptions)({
-                pg: ctx.config,
-                deployment: {
-                    fast: false
-                }
-            }), proj.getModuleName(), true);
-        }
-    };
-}