pgsql-seed 0.0.1

package/esm/utils.js

@@ -0,0 +1,91 @@
+const uuidRegexp = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const idReplacement = (v, idHash) => {
+    if (!v)
+        return v;
+    if (!idHash)
+        return '[ID]';
+    const key = String(v);
+    return idHash[key] !== undefined ? `[ID-${idHash[key]}]` : '[ID]';
+};
+function mapValues(obj, fn) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        acc[key] = fn(value, key);
+        return acc;
+    }, {});
+}
+export const pruneDates = (row) => mapValues(row, (v, k) => {
+    if (!v) {
+        return v;
+    }
+    if (v instanceof Date) {
+        return '[DATE]';
+    }
+    else if (typeof v === 'string' &&
+        /(_at|At)$/.test(k) &&
+        /^20[0-9]{2}-[0-9]{2}-[0-9]{2}/.test(v)) {
+        return '[DATE]';
+    }
+    return v;
+});
+export const pruneIds = (row, idHash) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
+    (typeof v === 'string' || typeof v === 'number')
+    ? idReplacement(v, idHash)
+    : v);
+export const pruneIdArrays = (row) => mapValues(row, (v, k) => typeof k === 'string' && k.endsWith('_ids') && Array.isArray(v)
+    ? `[UUIDs-${v.length}]`
+    : v);
+export const pruneUUIDs = (row) => mapValues(row, (v, k) => {
+    if (typeof v !== 'string') {
+        return v;
+    }
+    if (['uuid', 'queue_name'].includes(k) && uuidRegexp.test(v)) {
+        return '[UUID]';
+    }
+    if (k === 'gravatar' && /^[0-9a-f]{32}$/i.test(v)) {
+        return '[gUUID]';
+    }
+    return v;
+});
+export const pruneHashes = (row) => mapValues(row, (v, k) => typeof k === 'string' &&
+    k.endsWith('_hash') &&
+    typeof v === 'string' &&
+    v.startsWith('$')
+    ? '[hash]'
+    : v);
+export const pruneSchemas = (row) => mapValues(row, (v, k) => typeof v === 'string' && /^zz-/.test(v) ? '[schemahash]' : v);
+export const prunePeoplestamps = (row) => mapValues(row, (v, k) => k.endsWith('_by') && typeof v === 'string' ? '[peoplestamp]' : v);
+export const pruneTokens = (row) => mapValues(row, (v, k) => (k === 'token' || k.endsWith('_token')) && typeof v === 'string'
+    ? '[token]'
+    : v);
+export const composePruners = (...pruners) => (row) => pruners.reduce((acc, pruner) => pruner(acc), row);
+// Default pruners used by prune/snapshot (without IdHash)
+export const defaultPruners = [
+    pruneTokens,
+    prunePeoplestamps,
+    pruneDates,
+    pruneIdArrays,
+    pruneUUIDs,
+    pruneHashes
+];
+// Compose pruners and apply pruneIds with IdHash support
+export const prune = (row, idHash) => {
+    const pruned = composePruners(...defaultPruners)(row);
+    return pruneIds(pruned, idHash);
+};
+// Factory to create a snapshot function with custom pruners
+export const createSnapshot = (pruners) => {
+    const pruneFn = composePruners(...pruners);
+    const snap = (obj, idHash) => {
+        if (Array.isArray(obj)) {
+            return obj.map((el) => snap(el, idHash));
+        }
+        else if (obj && typeof obj === 'object') {
+            const pruned = pruneFn(obj);
+            const prunedWithIds = pruneIds(pruned, idHash);
+            return mapValues(prunedWithIds, (v) => snap(v, idHash));
+        }
+        return obj;
+    };
+    return snap;
+};
+export const snapshot = createSnapshot(defaultPruners);

package/index.d.ts

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

package/index.js

@@ -0,0 +1,25 @@
+"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; } });

package/manager.d.ts

@@ -0,0 +1,26 @@
+import { Pool } from 'pg';
+import { PgConfig } from 'pg-env';
+import { PgTestClient, PgTestClientOpts } from './test-client';
+export declare class PgTestConnector {
+    private static instance;
+    private readonly clients;
+    private readonly pgPools;
+    private readonly seenDbConfigs;
+    private readonly pendingConnects;
+    private config;
+    private verbose;
+    private shuttingDown;
+    private constructor();
+    static getInstance(config: PgConfig, verbose?: boolean): PgTestConnector;
+    private poolKey;
+    private dbKey;
+    beginTeardown(): void;
+    private registerConnect;
+    private awaitPendingConnects;
+    getPool(config: PgConfig): Pool;
+    getClient(config: PgConfig, opts?: Partial<PgTestClientOpts>): PgTestClient;
+    closeAll(): Promise<void>;
+    close(): void;
+    drop(config: PgConfig): void;
+    kill(client: PgTestClient): Promise<void>;
+}

package/manager.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgTestConnector = void 0;
+const logger_1 = require("@pgpmjs/logger");
+const pg_1 = require("pg");
+const pg_env_1 = require("pg-env");
+const admin_1 = require("./admin");
+const test_client_1 = require("./test-client");
+const log = new logger_1.Logger('test-connector');
+const SYS_EVENTS = ['SIGTERM'];
+const end = (pool) => {
+    try {
+        if (pool.ended || pool.ending) {
+            log.warn('⚠️ pg pool already ended or ending');
+            return;
+        }
+        pool.end();
+    }
+    catch (err) {
+        log.error('❌ pg pool termination error:', err);
+    }
+};
+class PgTestConnector {
+    static instance;
+    clients = new Set();
+    pgPools = new Map();
+    seenDbConfigs = new Map();
+    pendingConnects = new Set();
+    config;
+    verbose = false;
+    shuttingDown = false;
+    constructor(config, verbose = false) {
+        this.verbose = verbose;
+        this.config = config;
+        SYS_EVENTS.forEach((event) => {
+            process.on(event, () => {
+                log.info(`⏹ Received ${event}, closing all connections...`);
+                this.closeAll();
+            });
+        });
+    }
+    static getInstance(config, verbose = false) {
+        if (!PgTestConnector.instance) {
+            PgTestConnector.instance = new PgTestConnector(config, verbose);
+        }
+        return PgTestConnector.instance;
+    }
+    poolKey(config) {
+        return `${config.user}@${config.host}:${config.port}/${config.database}`;
+    }
+    dbKey(config) {
+        return `${config.host}:${config.port}/${config.database}`;
+    }
+    beginTeardown() {
+        this.shuttingDown = true;
+    }
+    registerConnect(p) {
+        this.pendingConnects.add(p);
+        p.finally(() => this.pendingConnects.delete(p));
+    }
+    async awaitPendingConnects() {
+        const arr = Array.from(this.pendingConnects);
+        if (arr.length) {
+            await Promise.allSettled(arr);
+        }
+    }
+    getPool(config) {
+        const key = this.poolKey(config);
+        if (!this.pgPools.has(key)) {
+            const pool = new pg_1.Pool(config);
+            this.pgPools.set(key, pool);
+            log.info(`📘 Created new pg pool: ${key}`);
+        }
+        return this.pgPools.get(key);
+    }
+    getClient(config, opts = {}) {
+        if (this.shuttingDown) {
+            throw new Error('PgTestConnector is shutting down; no new clients allowed');
+        }
+        const client = new test_client_1.PgTestClient(config, {
+            trackConnect: (p) => this.registerConnect(p),
+            ...opts
+        });
+        this.clients.add(client);
+        const key = this.dbKey(config);
+        this.seenDbConfigs.set(key, config);
+        log.info(`🔌 New PgTestClient connected to ${config.database}`);
+        return client;
+    }
+    async closeAll() {
+        this.beginTeardown();
+        await this.awaitPendingConnects();
+        log.info('🧹 Closing all PgTestClients...');
+        await Promise.all(Array.from(this.clients).map(async (client) => {
+            try {
+                await client.close();
+                log.success(`✅ Closed client for ${client.config.database}`);
+            }
+            catch (err) {
+                log.error(`❌ Error closing PgTestClient for ${client.config.database}:`, err);
+            }
+        }));
+        this.clients.clear();
+        log.info('🧯 Disposing pg pools...');
+        for (const [key, pool] of this.pgPools.entries()) {
+            log.debug(`🧯 Disposing pg pool [${key}]`);
+            end(pool);
+        }
+        this.pgPools.clear();
+        log.info('🗑️ Dropping seen databases...');
+        await Promise.all(Array.from(this.seenDbConfigs.values()).map(async (config) => {
+            try {
+                const rootPg = (0, pg_env_1.getPgEnvOptions)(this.config);
+                const admin = new admin_1.DbAdmin({ ...config, user: rootPg.user, password: rootPg.password }, this.verbose);
+                admin.drop();
+                log.warn(`🧨 Dropped database: ${config.database}`);
+            }
+            catch (err) {
+                log.error(`❌ Failed to drop database ${config.database}:`, err);
+            }
+        }));
+        this.seenDbConfigs.clear();
+        log.success('✅ All PgTestClients closed, pools disposed, databases dropped.');
+        this.pendingConnects.clear();
+        this.shuttingDown = false;
+    }
+    close() {
+        this.closeAll();
+    }
+    drop(config) {
+        const key = this.dbKey(config);
+        const admin = new admin_1.DbAdmin(config, this.verbose);
+        admin.drop();
+        log.warn(`🧨 Dropped database: ${config.database}`);
+        this.seenDbConfigs.delete(key);
+    }
+    async kill(client) {
+        await client.close();
+        this.drop(client.config);
+    }
+}
+exports.PgTestConnector = PgTestConnector;

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "pgsql-seed",
+  "version": "0.0.1",
+  "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",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "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"
+  ],
+  "dependencies": {
+    "@pgpmjs/core": "^4.2.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"
+  },
+  "gitHead": "9b68e2d19937ad4e2a81a5de110a197a8572e3d9"
+}

package/roles.d.ts

@@ -0,0 +1,17 @@
+import { PgTestConnectionOptions, RoleMapping } from '@pgpmjs/types';
+/**
+ * Default role mapping configuration
+ */
+export declare const DEFAULT_ROLE_MAPPING: Required<RoleMapping>;
+/**
+ * Get resolved role mapping with defaults
+ */
+export declare const getRoleMapping: (options?: PgTestConnectionOptions) => Required<RoleMapping>;
+/**
+ * Get role name by key with fallback to default mapping
+ */
+export declare const getRoleName: (roleKey: keyof Omit<RoleMapping, "default">, options?: PgTestConnectionOptions) => string;
+/**
+ * Get default role name
+ */
+export declare const getDefaultRole: (options?: PgTestConnectionOptions) => string;

package/roles.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultRole = exports.getRoleName = exports.getRoleMapping = exports.DEFAULT_ROLE_MAPPING = void 0;
+/**
+ * Default role mapping configuration
+ */
+exports.DEFAULT_ROLE_MAPPING = {
+    anonymous: 'anonymous',
+    authenticated: 'authenticated',
+    administrator: 'administrator',
+    default: 'anonymous'
+};
+/**
+ * Get resolved role mapping with defaults
+ */
+const getRoleMapping = (options) => {
+    return {
+        ...exports.DEFAULT_ROLE_MAPPING,
+        ...(options?.roles || {})
+    };
+};
+exports.getRoleMapping = getRoleMapping;
+/**
+ * Get role name by key with fallback to default mapping
+ */
+const getRoleName = (roleKey, options) => {
+    const mapping = (0, exports.getRoleMapping)(options);
+    return mapping[roleKey];
+};
+exports.getRoleName = getRoleName;
+/**
+ * Get default role name
+ */
+const getDefaultRole = (options) => {
+    const mapping = (0, exports.getRoleMapping)(options);
+    return mapping.default;
+};
+exports.getDefaultRole = getDefaultRole;

package/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/adapters.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlfile = sqlfile;
+exports.fn = fn;
+exports.compose = compose;
+function sqlfile(files) {
+    return {
+        seed(ctx) {
+            for (const file of files) {
+                ctx.admin.loadSql(file, ctx.config.database);
+            }
+        }
+    };
+}
+function fn(fn) {
+    return {
+        seed: fn
+    };
+}
+function compose(adapters) {
+    return {
+        async seed(ctx) {
+            for (const adapter of adapters) {
+                await adapter.seed(ctx);
+            }
+        }
+    };
+}

package/seed/csv.d.ts

@@ -0,0 +1,15 @@
+import { Client } from 'pg';
+import type { PgTestClient } from '../test-client';
+import { SeedAdapter } from './types';
+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>;

package/seed/csv.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCsvMap = loadCsvMap;
+exports.csv = csv;
+exports.copyCsvIntoTable = copyCsvIntoTable;
+exports.exportTableToCsv = exportTableToCsv;
+const promises_1 = require("node:stream/promises");
+const logger_1 = require("@pgpmjs/logger");
+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) {
+            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}`);
+                await copyCsvIntoTable(ctx.pg, table, filePath);
+            }
+        }
+    };
+}
+async function parseCsvHeader(filePath) {
+    const file = (0, fs_1.createReadStream)(filePath);
+    const parser = (0, csv_parse_1.parse)({
+        bom: true,
+        to_line: 1,
+        skip_empty_lines: true,
+    });
+    return new Promise((resolve, reject) => {
+        const cleanup = (err) => {
+            parser.destroy();
+            file.destroy();
+            if (err)
+                reject(err);
+        };
+        parser.on('readable', () => {
+            const row = parser.read();
+            if (!row)
+                return;
+            if (row.length === 0) {
+                cleanup(new Error('CSV header has no columns'));
+                return;
+            }
+            cleanup();
+            resolve(row);
+        });
+        parser.on('error', cleanup);
+        file.on('error', cleanup);
+        file.pipe(parser);
+    });
+}
+async function copyCsvIntoTable(pg, table, filePath) {
+    const client = pg.client;
+    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;
+    }
+}
+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, fs_1.createWriteStream)(filePath);
+    try {
+        await (0, promises_1.pipeline)(stream, target);
+        log.success(`✅ Exported "${table}" to ${filePath}`);
+    }
+    catch (err) {
+        log.error(`❌ Failed to export "${table}": ${err.message}`);
+        throw err;
+    }
+}

package/seed/index.d.ts

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

package/seed/index.js

@@ -0,0 +1,31 @@
+"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 pgpm_1 = require("./pgpm");
+__exportStar(require("./csv"), exports);
+__exportStar(require("./types"), exports);
+exports.seed = {
+    pgpm: pgpm_1.pgpm,
+    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,12 @@
+import type { Client } from 'pg';
+import { SeedAdapter } from './types';
+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;

package/seed/json.js

@@ -0,0 +1,40 @@
+"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) {
+            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);
+                }
+            }
+        }
+    };
+}