pgsql-test 2.0.2 → 2.0.4

package/README.md

@@ -17,7 +17,7 @@
 </p>
 
 
-`pgsql-test` provides an isolated PostgreSQL testing environment with per-test transaction rollback, ideal for integration tests involving SQL, roles, simulations, and complex migrations. With automatic rollbacks and isolated contexts, it eliminates test interference while delivering tight feedback loops for happier developers. We made database testing simple so you can focus on writing good tests instead of fighting your environment.
+`pgsql-test` gives you instant, isolated PostgreSQL databases for each test — with automatic transaction rollbacks, context switching, and clean seeding. Forget flaky tests and brittle environments. Write real SQL. Get real coverage. Stay fast.
 
 ## Install
 
@@ -27,30 +27,38 @@ npm install pgsql-test
 
 ## Features
 
-* ⚡ Quick-start setup with `getConnections()`
-* 🧹 Easy teardown and cleanup
-* 🔄 Per-test isolation using transactions and savepoints
-* 🛡️ Role-based context for RLS testing
-* 🌱 Flexible seed support via `.sql` files and programmatic functions
-* 🧪 Auto-generated test databases with `UUID` suffix
-* 📦 Built for tools like `sqitch`, supporting full schema initialization workflows
-* 🧰 Designed for `Jest`, `Mocha`, or any async test runner
+* ⚡ **Instant test DBs** — each one seeded, isolated, and UUID-named
+* 🔄 **Per-test rollback** — every test runs in its own transaction or savepoint
+* 🛡️ **RLS-friendly** — test with role-based auth via `.setContext()`
+* 🌱 **Flexible seeding** — run `.sql` files, programmatic seeds, or even load fixtures
+* 🧪 **Compatible with any async runner** — works with `Jest`, `Mocha`, etc.
+* 🧹 **Auto teardown** — no residue, no reboots, just clean exits
+
+### LaunchQL migrations
+
+Part of the [LaunchQL](https://github.com/launchql) ecosystem, `pgsql-test` is built to pair seamlessly with our TypeScript-based [Sqitch](https://sqitch.org/) engine rewrite:
+
+* 🚀 **Lightning-fast migrations** — powered by LaunchQL’s native deployer (10x faster than legacy Sqitch)
+* 🔧 **Composable test scaffolds** — integrate with full LaunchQL stacks or use standalone
 
 
 ## Table of Contents
 
 1. [Install](#install)
 2. [Features](#features)
-3. [Quick Start](#quick-start)
-4. [getConnections() Overview](#getconnections-overview)
+3. [Quick Start](#-quick-start)
+4. [`getConnections()` Overview](#getconnections-overview)
 5. [PgTestClient API Overview](#pgtestclient-api-overview)
 6. [Usage Examples](#usage-examples)
-   * [Basic Setup](#basic-setup)
-   * [Role-Based Context](#role-based-context)
-   * [SQL File Seeding](#sql-file-seeding)
-   * [Programmatic Seeding](#programmatic-seeding)
-   * [Composed Seeding](#composed-seeding)
-7. [Environment Overrides](#environment-overrides)
+   * [Basic Setup](#-basic-setup)
+   * [Role-Based Context](#-role-based-context)
+   * [SQL File Seeding](#-sql-file-seeding)
+   * [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)
 
 
@@ -202,55 +210,220 @@ beforeAll(async () => {
 });
 ```
 
-### 🧬 Composed Seeding
+## 🗃️ CSV Seeding
 
-Combine multiple seeders with `seed.compose()`:
+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
 import path from 'path';
 import { getConnections, seed } from 'pgsql-test';
 
-const sql = (f: string) => path.join(__dirname, 'sql', f);
+const csv = (file: string) => path.resolve(__dirname, '../csv', file);
 
 let db;
 let teardown;
 
 beforeAll(async () => {
-  ({ db, teardown } = await getConnections({}, seed.compose([
-    seed.sqlfile([
-      sql('schema.sql'),
-      sql('roles.sql')
-    ]),
+  ({ db, teardown } = await getConnections({}, [
+    // Create schema
+    seed.fn(async ({ pg }) => {
+      await pg.query(`
+        CREATE TABLE users (
+          id SERIAL PRIMARY KEY,
+          name TEXT NOT NULL
+        );
+
+        CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          user_id INT REFERENCES users(id),
+          content TEXT NOT NULL
+        );
+      `);
+    }),
+    // Load from CSV
+    seed.csv({
+      users: csv('users.csv'),
+      posts: csv('posts.csv')
+    }),
+    // Adjust SERIAL sequences to avoid conflicts
     seed.fn(async ({ pg }) => {
-      await pg.query(`INSERT INTO users (name) VALUES ('Composed');`);
+      await pg.query(`SELECT setval(pg_get_serial_sequence('users', 'id'), (SELECT MAX(id) FROM users));`);
+      await pg.query(`SELECT setval(pg_get_serial_sequence('posts', 'id'), (SELECT MAX(id) FROM posts));`);
     })
-  ])));
+  ]));
+});
+
+afterAll(() => teardown());
+
+it('has loaded rows', async () => {
+  const res = await db.query('SELECT COUNT(*) FROM users');
+  expect(+res.rows[0].count).toBeGreaterThan(0);
+});
+```
+
+## 🗃️ JSON Seeding
+
+You can seed tables using in-memory JSON objects. This is useful when you want fast, inline fixtures without managing external files.
+
+```ts
+import { getConnections, seed } from 'pgsql-test';
+
+let db;
+let teardown;
+
+beforeAll(async () => {
+  ({ db, teardown } = await getConnections({}, [
+    // Create schema
+    seed.fn(async ({ pg }) => {
+      await pg.query(`
+        CREATE SCHEMA custom;
+        CREATE TABLE custom.users (
+          id SERIAL PRIMARY KEY,
+          name TEXT NOT NULL
+        );
+
+        CREATE TABLE custom.posts (
+          id SERIAL PRIMARY KEY,
+          user_id INT REFERENCES custom.users(id),
+          content TEXT NOT NULL
+        );
+      `);
+    }),
+    // Seed with in-memory JSON
+    seed.json({
+      'custom.users': [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' }
+      ],
+      'custom.posts': [
+        { id: 1, user_id: 1, content: 'Hello world!' },
+        { id: 2, user_id: 2, content: 'Graphile is cool!' }
+      ]
+    }),
+    // Fix SERIAL sequences
+    seed.fn(async ({ pg }) => {
+      await pg.query(`SELECT setval(pg_get_serial_sequence('custom.users', 'id'), (SELECT MAX(id) FROM custom.users));`);
+      await pg.query(`SELECT setval(pg_get_serial_sequence('custom.posts', 'id'), (SELECT MAX(id) FROM custom.posts));`);
+    })
+  ]));
+});
+
+afterAll(() => teardown());
+
+it('has loaded rows', async () => {
+  const res = await db.query('SELECT COUNT(*) FROM custom.users');
+  expect(+res.rows[0].count).toBeGreaterThan(0);
+});
+```
+
+## 🏗️ Sqitch Seeding
+
+*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:
+
+```ts
+import path from 'path';
+import { getConnections, seed } from 'pgsql-test';
+
+const cwd = path.resolve(__dirname, '../path/to/sqitch');
+
+beforeAll(async () => {
+  ({ db, teardown } = await getConnections({}, [
+    seed.sqitch(cwd)
+  ]));
+});
+
+it('runs a schema query', async () => {
+  const res = await db.query('SELECT COUNT(*) FROM myapp.users');
+  expect(+res.rows[0].count).toBeGreaterThanOrEqual(0);
 });
 ```
 
----
+This works for any Sqitch-compatible module, now accelerated by LaunchQL's deployment tooling.
 
-These examples show how flexible `pgsql-test` is for composing repeatable and transactional test database environments.
+## 🚀 LaunchQL Seeding
 
+For LaunchQL modules with precompiled `sqitch.plan`, use `seed.launchql(cwd)` to apply a schema quickly with `deployFast()`:
+For maximum performance with precompiled LaunchQL modules, use `seed.launchql(cwd)` to apply a schema at lightning speed with our TypeScript-powered `deployFast()`:
 
+```ts
+import path from 'path';
+import { getConnections, seed } from 'pgsql-test';
 
-## Environment Overrides
+const cwd = path.resolve(__dirname, '../path/to/launchql');
 
-`pgsql-test` respects the following env vars for DB connectivity:
+beforeAll(async () => {
+  ({ db, teardown } = await getConnections({}, [
+    seed.launchql(cwd) // uses deployFast() - up to 10x faster than traditional Sqitch!
+  ]));
+});
 
-* `PGHOST`
-* `PGPORT`
-* `PGUSER`
-* `PGPASSWORD`
+it('creates user records', async () => {
+  await db.query(`INSERT INTO myapp.users (username, email) VALUES ('testuser', 'test@example.com')`);
+  const res = await db.query(`SELECT COUNT(*) FROM myapp.users`);
+  expect(+res.rows[0].count).toBeGreaterThan(0);
+});
+```
+
+This is the fastest way to bring up a ready-to-query schema from a compiled LaunchQL module - perfect for both development and CI environments.
+
+## 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.
+
+## `getConnections` Options
+
+This table documents the available options for the `getConnections` function. The options are passed as a combination of `pg` and `db` configuration objects.
 
-Override them in your test runner or CI config:
+### `db` Options (PgTestConnectionOptions)
 
-```yaml
-env:
-  PGHOST: localhost
-  PGPORT: 5432
-  PGUSER: postgres
-  PGPASSWORD: password
+| 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.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()`                                     |
+| `db.template`            | `string`   | `undefined`      | Template database used for faster test DB creation                          |
+| `db.rootDb`              | `string`   | `'postgres'`     | Root database used for administrative operations (e.g., creating databases) |
+| `db.prefix`              | `string`   | `'db-'`          | Prefix used when generating test database names                             |
+
+### `pg` Options (PgConfig)
+
+Environment variables will override these options when available:
+
+* `PGHOST`, `PGPORT`, `PGUSER`, `PGPASSWORD`, `PGDATABASE`
+
+| Option        | Type     | Default       | Description                                     |
+| ------------- | -------- | ------------- | ----------------------------------------------- |
+| `pg.user`     | `string` | `'postgres'`  | Superuser for PostgreSQL                        |
+| `pg.password` | `string` | `'password'`  | Password for the PostgreSQL superuser           |
+| `pg.host`     | `string` | `'localhost'` | Hostname for PostgreSQL                         |
+| `pg.port`     | `number` | `5423`        | Port for PostgreSQL                             |
+| `pg.database` | `string` | `'postgres'`  | Default database used when connecting initially |
+
+### Usage
+
+```ts
+const { conn, db, teardown } = await getConnections({
+  pg: { user: 'postgres', password: 'secret' },
+  db: {
+    extensions: ['uuid-ossp'],
+    cwd: '/path/to/project',
+    connection: { user: 'test_user', password: 'secret', role: 'authenticated' },
+    template: 'test_template',
+    prefix: 'test_',
+    rootDb: 'postgres'
+  }
+});
 ```
 
 ## Disclaimer

package/admin.d.ts

@@ -1,5 +1,5 @@
 import { PgConfig } from '@launchql/types';
-import { SeedAdapter } from './seed';
+import { SeedAdapter } from './seed/types';
 export declare class DbAdmin {
     private config;
     private verbose;

package/admin.js

@@ -120,7 +120,8 @@ class DbAdmin {
         await adapter.seed({
             admin: this,
             config: this.config,
-            pg: null // sorry!
+            pg: null, // sorry!
+            connect: null, // sorry!
         });
         this.cleanupTemplate(templateName);
         this.createTemplateFromBase(seedDb, templateName);

package/connect.d.ts

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

package/connect.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConnections = exports.getPgRootAdmin = void 0;
 const admin_1 = require("./admin");
 const types_1 = require("@launchql/types");
-const migrate_1 = require("@launchql/migrate");
 const manager_1 = require("./manager");
 const crypto_1 = require("crypto");
 const server_utils_1 = require("@launchql/server-utils");
+const seed_1 = require("./seed");
 let manager;
 const getPgRootAdmin = (connOpts = {}) => {
     const opts = (0, types_1.getPgEnvOptions)({
@@ -27,53 +27,30 @@ const getConnOopts = (cn = {}) => {
         db: connect
     };
 };
-const getConnections = async (cn = {}, seedAdapter) => {
+const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.launchql()]) => {
     cn = getConnOopts(cn);
     const config = cn.pg;
     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 proj = new migrate_1.LaunchQLProject(connOpts.cwd);
-    if (proj.isInModule()) {
-        admin.create(config.database);
-        admin.installExtensions(connOpts.extensions);
-        const opts = (0, types_1.getEnvOptions)({
-            pg: config
-        });
-        if (connOpts.deployFast) {
-            await (0, migrate_1.deployFast)({
-                opts,
-                name: proj.getModuleName(),
-                database: config.database,
-                dir: proj.modulePath,
-                usePlan: true,
-                verbose: false
-            });
-        }
-        else {
-            await (0, migrate_1.deploy)(opts, proj.getModuleName(), config.database, proj.modulePath);
-        }
+    if (process.env.TEST_DB) {
+        config.database = process.env.TEST_DB;
+    }
+    else if (connOpts.template) {
+        admin.createFromTemplate(connOpts.template, config.database);
     }
     else {
-        // Create the test database
-        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);
-        }
+        admin.create(config.database);
+        admin.installExtensions(connOpts.extensions);
     }
     await admin.grantConnect(connOpts.connection.user, config.database);
     // Main admin client (optional unless needed elsewhere)
     manager = manager_1.PgTestConnector.getInstance();
     const pg = manager.getClient(config);
-    if (seedAdapter) {
-        await seedAdapter.seed({
+    if (seedAdapters.length) {
+        await seed_1.seed.compose(seedAdapters).seed({
+            connect: connOpts,
             admin,
             config: config,
             pg: manager.getClient(config)

package/esm/admin.js

@@ -117,7 +117,8 @@ export class DbAdmin {
         await adapter.seed({
             admin: this,
             config: this.config,
-            pg: null // sorry!
+            pg: null, // sorry!
+            connect: null, // sorry!
         });
         this.cleanupTemplate(templateName);
         this.createTemplateFromBase(seedDb, templateName);

package/esm/connect.js

@@ -1,9 +1,9 @@
 import { DbAdmin } from './admin';
-import { getEnvOptions, getPgEnvOptions, getConnEnvOptions } from '@launchql/types';
-import { deploy, deployFast, LaunchQLProject } from '@launchql/migrate';
+import { getPgEnvOptions, getConnEnvOptions } from '@launchql/types';
 import { PgTestConnector } from './manager';
 import { randomUUID } from 'crypto';
 import { teardownPgPools } from '@launchql/server-utils';
+import { seed } from './seed';
 let manager;
 export const getPgRootAdmin = (connOpts = {}) => {
     const opts = getPgEnvOptions({
@@ -23,53 +23,30 @@ const getConnOopts = (cn = {}) => {
         db: connect
     };
 };
-export const getConnections = async (cn = {}, seedAdapter) => {
+export const getConnections = async (cn = {}, seedAdapters = [seed.launchql()]) => {
     cn = getConnOopts(cn);
     const config = cn.pg;
     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 proj = new LaunchQLProject(connOpts.cwd);
-    if (proj.isInModule()) {
-        admin.create(config.database);
-        admin.installExtensions(connOpts.extensions);
-        const opts = getEnvOptions({
-            pg: config
-        });
-        if (connOpts.deployFast) {
-            await deployFast({
-                opts,
-                name: proj.getModuleName(),
-                database: config.database,
-                dir: proj.modulePath,
-                usePlan: true,
-                verbose: false
-            });
-        }
-        else {
-            await deploy(opts, proj.getModuleName(), config.database, proj.modulePath);
-        }
+    if (process.env.TEST_DB) {
+        config.database = process.env.TEST_DB;
+    }
+    else if (connOpts.template) {
+        admin.createFromTemplate(connOpts.template, config.database);
     }
     else {
-        // Create the test database
-        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);
-        }
+        admin.create(config.database);
+        admin.installExtensions(connOpts.extensions);
     }
     await admin.grantConnect(connOpts.connection.user, config.database);
     // Main admin client (optional unless needed elsewhere)
     manager = PgTestConnector.getInstance();
     const pg = manager.getClient(config);
-    if (seedAdapter) {
-        await seedAdapter.seed({
+    if (seedAdapters.length) {
+        await seed.compose(seedAdapters).seed({
+            connect: connOpts,
             admin,
             config: config,
             pg: manager.getClient(config)

package/esm/{seed.js → seed/adapters.js}

@@ -1,4 +1,4 @@
-function sqlfile(files) {
+export function sqlfile(files) {
     return {
         seed(ctx) {
             for (const file of files) {
@@ -7,18 +7,12 @@ function sqlfile(files) {
         }
     };
 }
-function fn(fn) {
+export function fn(fn) {
     return {
         seed: fn
     };
 }
-function csv(fn) {
-    throw new Error('not yet implemented');
-    return {
-        seed: fn
-    };
-}
-function compose(adapters) {
+export function compose(adapters) {
     return {
         async seed(ctx) {
             for (const adapter of adapters) {
@@ -27,9 +21,3 @@ function compose(adapters) {
         }
     };
 }
-export const seed = {
-    compose,
-    fn,
-    csv,
-    sqlfile
-};

package/esm/seed/csv.js

@@ -0,0 +1,43 @@
+import { createReadStream, existsSync } from 'fs';
+import { pipeline } from 'node:stream/promises';
+import { from as copyFrom, to as copyTo } from 'pg-copy-streams';
+import { createWriteStream } from 'node:fs';
+export function csv(tables) {
+    return {
+        async seed(ctx) {
+            for (const [table, filePath] of Object.entries(tables)) {
+                if (!existsSync(filePath)) {
+                    throw new Error(`❌ CSV file not found: ${filePath}`);
+                }
+                console.log(`📥 Seeding "${table}" from ${filePath}`);
+                await copyCsvIntoTable(ctx.pg, table, filePath);
+            }
+        }
+    };
+}
+export async function copyCsvIntoTable(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query(copyFrom(`COPY ${table} FROM STDIN WITH CSV HEADER`));
+    const source = createReadStream(filePath);
+    try {
+        await pipeline(source, stream);
+        console.log(`✅ Successfully seeded "${table}"`);
+    }
+    catch (err) {
+        console.error(`❌ COPY failed for "${table}":`, err);
+        throw err;
+    }
+}
+export async function exportTableToCsv(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query(copyTo(`COPY ${table} TO STDOUT WITH CSV HEADER`));
+    const target = createWriteStream(filePath);
+    try {
+        await pipeline(stream, target);
+        console.log(`✅ Exported "${table}" to ${filePath}`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to export "${table}":`, err);
+        throw err;
+    }
+}

package/esm/seed/index.js

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

package/esm/seed/json.js

@@ -0,0 +1,18 @@
+export function json(data) {
+    return {
+        async seed(ctx) {
+            const { pg } = ctx;
+            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 pg.query(sql, values);
+                }
+            }
+        }
+    };
+}

package/esm/seed/launchql.js

@@ -0,0 +1,20 @@
+import { getEnvOptions } from '@launchql/types';
+import { LaunchQLProject, deployFast } from '@launchql/migrate';
+export function launchql(cwd) {
+    return {
+        async seed(ctx) {
+            const proj = new LaunchQLProject(cwd ?? ctx.connect.cwd);
+            if (!proj.isInModule())
+                return;
+            const opts = getEnvOptions({ pg: ctx.config });
+            await deployFast({
+                opts,
+                name: proj.getModuleName(),
+                database: ctx.config.database,
+                dir: proj.modulePath,
+                usePlan: true,
+                verbose: false
+            });
+        }
+    };
+}

package/esm/seed/sqitch.js

@@ -0,0 +1,13 @@
+import { getEnvOptions } from '@launchql/types';
+import { LaunchQLProject, deploy } from '@launchql/migrate';
+export function sqitch(cwd) {
+    return {
+        async seed(ctx) {
+            const proj = new LaunchQLProject(cwd ?? ctx.connect.cwd);
+            if (!proj.isInModule())
+                return;
+            const opts = getEnvOptions({ pg: ctx.config });
+            await deploy(opts, proj.getModuleName(), ctx.config.database, proj.modulePath);
+        }
+    };
+}

package/esm/seed/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostgreSQL Testing in TypeScript",
   "main": "index.js",
@@ -29,12 +29,18 @@
     "test": "jest",
     "test:watch": "jest --watch"
   },
+  "devDependencies": {
+    "@types/pg": "^8.15.2",
+    "@types/pg-copy-streams": "^1.2.5"
+  },
   "dependencies": {
-    "@launchql/migrate": "^2.0.12",
-    "@launchql/server-utils": "^2.0.5",
-    "@launchql/types": "^2.0.5",
+    "@launchql/migrate": "^2.0.14",
+    "@launchql/server-utils": "^2.0.7",
+    "@launchql/types": "^2.0.6",
     "chalk": "^4.1.0",
-    "deepmerge": "^4.3.1"
+    "deepmerge": "^4.3.1",
+    "pg": "^8.16.0",
+    "pg-copy-streams": "^6.0.6"
   },
-  "gitHead": "db786d9e5d7a784c57f2bacbf1eb2f4b541cb21e"
+  "gitHead": "b347f01f28aa33c195f78d911eab8757777b0c88"
 }

package/seed/adapters.d.ts

@@ -0,0 +1,4 @@
+import { SeedAdapter, SeedContext } from "./types";
+export declare function sqlfile(files: string[]): SeedAdapter;
+export declare function fn(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
+export declare function compose(adapters: SeedAdapter[]): SeedAdapter;

package/{seed.js → seed/adapters.js}

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.seed = void 0;
+exports.sqlfile = sqlfile;
+exports.fn = fn;
+exports.compose = compose;
 function sqlfile(files) {
     return {
         seed(ctx) {
@@ -15,12 +17,6 @@ function fn(fn) {
         seed: fn
     };
 }
-function csv(fn) {
-    throw new Error('not yet implemented');
-    return {
-        seed: fn
-    };
-}
 function compose(adapters) {
     return {
         async seed(ctx) {
@@ -30,9 +26,3 @@ function compose(adapters) {
         }
     };
 }
-exports.seed = {
-    compose,
-    fn,
-    csv,
-    sqlfile
-};

package/seed/csv.d.ts

@@ -0,0 +1,9 @@
+import { SeedAdapter } from './types';
+import { PgTestClient } from '../test-client';
+interface CsvSeedMap {
+    [tableName: string]: string;
+}
+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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csv = csv;
+exports.copyCsvIntoTable = copyCsvIntoTable;
+exports.exportTableToCsv = exportTableToCsv;
+const fs_1 = require("fs");
+const promises_1 = require("node:stream/promises");
+const pg_copy_streams_1 = require("pg-copy-streams");
+const node_fs_1 = require("node:fs");
+function csv(tables) {
+    return {
+        async seed(ctx) {
+            for (const [table, filePath] of Object.entries(tables)) {
+                if (!(0, fs_1.existsSync)(filePath)) {
+                    throw new Error(`❌ CSV file not found: ${filePath}`);
+                }
+                console.log(`📥 Seeding "${table}" from ${filePath}`);
+                await copyCsvIntoTable(ctx.pg, table, filePath);
+            }
+        }
+    };
+}
+async function copyCsvIntoTable(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query((0, pg_copy_streams_1.from)(`COPY ${table} FROM STDIN WITH CSV HEADER`));
+    const source = (0, fs_1.createReadStream)(filePath);
+    try {
+        await (0, promises_1.pipeline)(source, stream);
+        console.log(`✅ Successfully seeded "${table}"`);
+    }
+    catch (err) {
+        console.error(`❌ COPY failed for "${table}":`, err);
+        throw err;
+    }
+}
+async function exportTableToCsv(pg, table, filePath) {
+    const client = pg.client;
+    const stream = client.query((0, pg_copy_streams_1.to)(`COPY ${table} TO STDOUT WITH CSV HEADER`));
+    const target = (0, node_fs_1.createWriteStream)(filePath);
+    try {
+        await (0, promises_1.pipeline)(stream, target);
+        console.log(`✅ Exported "${table}" to ${filePath}`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to export "${table}":`, err);
+        throw err;
+    }
+}

package/seed/index.d.ts

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

package/seed/index.js

@@ -0,0 +1,32 @@
+"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.seed = void 0;
+const adapters_1 = require("./adapters");
+const csv_1 = require("./csv");
+const json_1 = require("./json");
+const sqitch_1 = require("./sqitch");
+const launchql_1 = require("./launchql");
+__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,
+    fn: adapters_1.fn,
+    sqlfile: adapters_1.sqlfile
+};

package/seed/json.d.ts

@@ -0,0 +1,6 @@
+import { SeedAdapter } from "./types";
+interface JsonSeedMap {
+    [table: string]: Record<string, any>[];
+}
+export declare function json(data: JsonSeedMap): SeedAdapter;
+export {};

package/seed/json.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.json = json;
+function json(data) {
+    return {
+        async seed(ctx) {
+            const { pg } = ctx;
+            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 pg.query(sql, values);
+                }
+            }
+        }
+    };
+}

package/seed/launchql.d.ts

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

package/seed/launchql.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchql = launchql;
+const types_1 = require("@launchql/types");
+const migrate_1 = require("@launchql/migrate");
+function launchql(cwd) {
+    return {
+        async seed(ctx) {
+            const proj = new migrate_1.LaunchQLProject(cwd ?? ctx.connect.cwd);
+            if (!proj.isInModule())
+                return;
+            const opts = (0, types_1.getEnvOptions)({ pg: ctx.config });
+            await (0, migrate_1.deployFast)({
+                opts,
+                name: proj.getModuleName(),
+                database: ctx.config.database,
+                dir: proj.modulePath,
+                usePlan: true,
+                verbose: false
+            });
+        }
+    };
+}

package/seed/sqitch.d.ts

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

package/seed/sqitch.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqitch = sqitch;
+const types_1 = require("@launchql/types");
+const migrate_1 = require("@launchql/migrate");
+function sqitch(cwd) {
+    return {
+        async seed(ctx) {
+            const proj = new migrate_1.LaunchQLProject(cwd ?? ctx.connect.cwd);
+            if (!proj.isInModule())
+                return;
+            const opts = (0, types_1.getEnvOptions)({ pg: ctx.config });
+            await (0, migrate_1.deploy)(opts, proj.getModuleName(), ctx.config.database, proj.modulePath);
+        }
+    };
+}

package/seed/types.d.ts

@@ -0,0 +1,12 @@
+import { PgConfig, PgTestConnectionOptions } from "@launchql/types";
+import { DbAdmin } from "../admin";
+import { PgTestClient } from "../test-client";
+export interface SeedContext {
+    connect: PgTestConnectionOptions;
+    admin: DbAdmin;
+    config: PgConfig;
+    pg: PgTestClient;
+}
+export interface SeedAdapter {
+    seed(ctx: SeedContext): Promise<void> | void;
+}

package/seed/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/test-client.d.ts

@@ -1,8 +1,8 @@
-import { QueryResult } from 'pg';
+import { Client, QueryResult } from 'pg';
 import { PgConfig } from '@launchql/types';
 export declare class PgTestClient {
     config: PgConfig;
-    private client;
+    client: Client;
     private ctxStmts;
     private _ended;
     constructor(config: PgConfig);

package/seed.d.ts

@@ -1,22 +0,0 @@
-import { PgConfig } from "@launchql/types";
-import { DbAdmin } from "./admin";
-import { PgTestClient } from "./test-client";
-interface SeedContext {
-    admin: DbAdmin;
-    config: PgConfig;
-    pg: PgTestClient;
-}
-export interface SeedAdapter {
-    seed(ctx: SeedContext): Promise<void> | void;
-}
-declare function sqlfile(files: string[]): SeedAdapter;
-declare function fn(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
-declare function csv(fn: (ctx: SeedContext) => Promise<void>): SeedAdapter;
-declare function compose(adapters: SeedAdapter[]): SeedAdapter;
-export declare const seed: {
-    compose: typeof compose;
-    fn: typeof fn;
-    csv: typeof csv;
-    sqlfile: typeof sqlfile;
-};
-export {};