pgsql-test 2.18.18 → 2.19.1

package/esm/seed/csv.js

@@ -1,108 +1,10 @@
-import { pipeline } from 'node:stream/promises';
-import { Logger } from '@pgpmjs/logger';
-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;
-        }
-    }
-}
+import { loadCsv } from 'pgsql-seed';
 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}`);
-                }
-                log.info(`📥 Seeding "${table}" from ${filePath}`);
-                await copyCsvIntoTable(ctx.pg, table, filePath);
+                await loadCsv(ctx.pg, table, filePath);
             }
         }
     };
 }
-async function parseCsvHeader(filePath) {
-    const file = createReadStream(filePath);
-    const parser = 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);
-    });
-}
-export 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(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 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);
-        log.success(`✅ Exported "${table}" to ${filePath}`);
-    }
-    catch (err) {
-        log.error(`❌ Failed to export "${table}": ${err.message}`);
-        throw err;
-    }
-}

package/esm/seed/index.js

@@ -2,7 +2,6 @@ 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 const seed = {
     pgpm,

package/esm/seed/json.js

@@ -1,36 +1,8 @@
-/**
- * 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);
-        }
-    }
-}
+import { insertJsonMap } from 'pgsql-seed';
 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);
-                }
-            }
+            await insertJsonMap(ctx.pg, data);
         }
     };
 }

package/esm/seed/pgpm.js

@@ -1,24 +1,4 @@
-import { PgpmPackage } from '@pgpmjs/core';
-import { getEnvOptions } from '@pgpmjs/env';
-/**
- * Standalone helper function to deploy pgpm 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 deployPgpm(config, cwd, cache = false) {
-    const proj = new PgpmPackage(cwd ?? process.cwd());
-    if (!proj.isInModule())
-        return;
-    await proj.deploy(getEnvOptions({
-        pg: config,
-        deployment: {
-            fast: true,
-            usePlan: true,
-            cache
-        }
-    }), proj.getModuleName());
-}
+import { deployPgpm } from 'pgsql-seed';
 export function pgpm(cwd, cache = false) {
     return {
         async seed(ctx) {

package/esm/test-client.js

@@ -1,10 +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 { deployPgpm } from './seed/pgpm';
+import { insertJsonMap } from 'pgsql-seed';
+import { loadCsvMap } from 'pgsql-seed';
+import { loadSqlFiles } from 'pgsql-seed';
+import { deployPgpm } from 'pgsql-seed';
 export class PgTestClient {
     config;
     client;
@@ -147,7 +147,7 @@ export class PgTestClient {
     }
     async loadJson(data) {
         await this.ctxQuery();
-        await insertJson(this.client, data);
+        await insertJsonMap(this.client, data);
     }
     async loadSql(files) {
         await this.ctxQuery();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.18.18",
+  "version": "2.19.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "pgsql-test offers isolated, role-aware, and rollback-friendly PostgreSQL environments for integration tests — giving developers realistic test coverage without external state pollution",
   "main": "index.js",
@@ -60,16 +60,15 @@
     "makage": "^0.1.9"
   },
   "dependencies": {
-    "@pgpmjs/core": "^4.2.1",
+    "@pgpmjs/core": "^4.4.0",
     "@pgpmjs/env": "^2.8.11",
     "@pgpmjs/logger": "^1.3.5",
     "@pgpmjs/server-utils": "^2.8.11",
     "@pgpmjs/types": "^2.12.8",
-    "csv-parse": "^6.1.0",
     "pg": "^8.16.3",
     "pg-cache": "^1.6.11",
-    "pg-copy-streams": "^7.0.0",
-    "pg-env": "^1.2.4"
+    "pg-env": "^1.2.4",
+    "pgsql-seed": "^0.2.1"
   },
-  "gitHead": "5b93211b63e72bedcfabc7c4aa41c69ed33d0f6c"
+  "gitHead": "bda56442f70c77c98276bc7bab0450308c975df8"
 }

package/seed/csv.d.ts

@@ -1,15 +1,3 @@
-import { Client } from 'pg';
-import type { PgTestClient } from '../test-client';
+import { type CsvSeedMap } from 'pgsql-seed';
 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

@@ -1,114 +1,13 @@
 "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;
-        }
-    }
-}
+const pgsql_seed_1 = require("pgsql-seed");
 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);
+                await (0, pgsql_seed_1.loadCsv)(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

@@ -2,7 +2,6 @@ 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;

package/seed/index.js

@@ -19,7 +19,6 @@ 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,

package/seed/json.d.ts

@@ -1,12 +1,3 @@
-import type { Client } from 'pg';
+import { type JsonSeedMap } from 'pgsql-seed';
 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

@@ -1,40 +1,11 @@
 "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);
-        }
-    }
-}
+const pgsql_seed_1 = require("pgsql-seed");
 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);
-                }
-            }
+            await (0, pgsql_seed_1.insertJsonMap)(ctx.pg, data);
         }
     };
 }

package/seed/pgpm.d.ts

@@ -1,10 +1,2 @@
-import type { PgConfig } from 'pg-env';
 import { SeedAdapter } from './types';
-/**
- * Standalone helper function to deploy pgpm 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 deployPgpm(config: PgConfig, cwd?: string, cache?: boolean): Promise<void>;
 export declare function pgpm(cwd?: string, cache?: boolean): SeedAdapter;

package/seed/pgpm.js

@@ -1,32 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deployPgpm = deployPgpm;
 exports.pgpm = pgpm;
-const core_1 = require("@pgpmjs/core");
-const env_1 = require("@pgpmjs/env");
-/**
- * Standalone helper function to deploy pgpm 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 deployPgpm(config, cwd, cache = false) {
-    const proj = new core_1.PgpmPackage(cwd ?? process.cwd());
-    if (!proj.isInModule())
-        return;
-    await proj.deploy((0, env_1.getEnvOptions)({
-        pg: config,
-        deployment: {
-            fast: true,
-            usePlan: true,
-            cache
-        }
-    }), proj.getModuleName());
-}
+const pgsql_seed_1 = require("pgsql-seed");
 function pgpm(cwd, cache = false) {
     return {
         async seed(ctx) {
-            await deployPgpm(ctx.config, cwd ?? ctx.connect.cwd, cache);
+            await (0, pgsql_seed_1.deployPgpm)(ctx.config, cwd ?? ctx.connect.cwd, cache);
         }
     };
 }

package/test-client.d.ts

@@ -1,8 +1,8 @@
 import { Client, QueryResult } from 'pg';
 import { PgConfig } from 'pg-env';
 import { AuthOptions, PgTestConnectionOptions } from '@pgpmjs/types';
-import { type JsonSeedMap } from './seed/json';
-import { type CsvSeedMap } from './seed/csv';
+import { type JsonSeedMap } from 'pgsql-seed';
+import { type CsvSeedMap } from 'pgsql-seed';
 export type PgTestClientOpts = {
     deferConnect?: boolean;
     trackConnect?: (p: Promise<any>) => void;

package/test-client.js

@@ -4,10 +4,10 @@ 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 pgpm_1 = require("./seed/pgpm");
+const pgsql_seed_1 = require("pgsql-seed");
+const pgsql_seed_2 = require("pgsql-seed");
+const pgsql_seed_3 = require("pgsql-seed");
+const pgsql_seed_4 = require("pgsql-seed");
 class PgTestClient {
     config;
     client;
@@ -150,23 +150,23 @@ class PgTestClient {
     }
     async loadJson(data) {
         await this.ctxQuery();
-        await (0, json_1.insertJson)(this.client, data);
+        await (0, pgsql_seed_1.insertJsonMap)(this.client, data);
     }
     async loadSql(files) {
         await this.ctxQuery();
-        await (0, sql_1.loadSqlFiles)(this.client, files);
+        await (0, pgsql_seed_3.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);
+        await (0, pgsql_seed_2.loadCsvMap)(this.client, tables);
     }
     async loadPgpm(cwd, cache = false) {
         // await this.ctxQuery(); // no point to call ctxQuery() here
         // because deployPgpm() has it's own way of getting the client...
         // so for now, we'll expose this but it's limited
-        await (0, pgpm_1.deployPgpm)(this.config, cwd, cache);
+        await (0, pgsql_seed_4.deployPgpm)(this.config, cwd, cache);
     }
 }
 exports.PgTestClient = PgTestClient;

package/esm/seed/sql.js

@@ -1,15 +0,0 @@
-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/seed/sql.d.ts

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

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