pgsql-test 2.16.2 → 2.16.3

package/README.md

@@ -60,7 +60,7 @@ Part of the [pgpm](https://pgpm.io) ecosystem, `pgsql-test` is built to pair sea
    * [Programmatic Seeding](#-programmatic-seeding)
    * [CSV Seeding](#️-csv-seeding)
    * [JSON Seeding](#️-json-seeding)
-   * [LaunchQL Seeding](#-launchql-seeding)
+   * [pgpm Seeding](#-pgpm-seeding)
 7. [`getConnections() Options` ](#getconnections-options)
 8. [Disclaimer](#disclaimer)
 
@@ -241,9 +241,9 @@ 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.launchql()`](#-launchql-seeding) – Apply a LaunchQL project or set of packages (compatible with sqitch)
+* [`seed.loadPgpm()`](#-pgpm-seeding) – Apply a pgpm 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.
+> ✨ **Default Behavior:** If no `SeedAdapter[]` is passed, pgpm seeding is assumed. This makes `pgsql-test` zero-config for pgpm-based projects.
 
 This composable system allows you to mix-and-match data setup strategies for flexible, realistic, and fast database tests.
 
@@ -265,7 +265,7 @@ 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.
+> **Note:** `loadCsv()` and `loadPgpm()` do not apply RLS context (PostgreSQL limitation). Use `loadJson()` or `loadSql()` for RLS-aware seeding.
 
 ### 🔌 SQL File Seeding
 
@@ -506,32 +506,32 @@ it('has loaded rows', async () => {
 
 </details>
 
-## 🚀 LaunchQL Seeding
+## 🚀 pgpm Seeding
 
 **Zero Configuration (Default):**
 ```ts
-// LaunchQL migrate is used automatically
+// pgpm migrate is used automatically
 const { db, teardown } = await getConnections();
 ```
 
 **Adapter Pattern (Custom Path):**
 ```ts
 const { db, teardown } = await getConnections({}, [
-  seed.launchql('/path/to/launchql', true) // with cache
+  seed.loadPgpm('/path/to/pgpm-workspace', true) // with cache
 ]);
 ```
 
 **Direct Load Method:**
 ```ts
-await db.loadLaunchql('/path/to/launchql', true); // with cache
+await db.loadPpgm('/path/to/pgpm-workspace', true); // with cache
 ```
 
-> **Note:** LaunchQL deployment has its own client handling and does not apply RLS context.
+> **Note:** pgpm deployment has its own client handling and does not apply RLS context.
 
 <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*:
+If your project uses pgpm modules with a precompiled `pgpm.plan`, you can use `pgsql-test` with **zero configuration**. Just call `getConnections()` — and it *just works*:
 
 ```ts
 import { getConnections } from 'pgsql-test';
@@ -539,50 +539,39 @@ import { getConnections } from 'pgsql-test';
 let db, teardown;
 
 beforeAll(async () => {
-  ({ db, teardown } = await getConnections()); // LaunchQL module is deployed automatically
+  ({ db, teardown } = await getConnections()); // pgpm module is deployed automatically
 });
 ```
 
-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()`).
+pgpm uses Sqitch-compatible syntax with a TypeScript-based migration engine. By default, `pgsql-test` automatically deploys any pgpm module found in the current working directory (`process.cwd()`).
 
-To specify a custom path to your LaunchQL module, use `seed.launchql()` explicitly:
+To specify a custom path to your pgpm module, use `seed.loadPgpm()` explicitly:
 
 ```ts
 import path from 'path';
 import { getConnections, seed } from 'pgsql-test';
 
-const cwd = path.resolve(__dirname, '../path/to/launchql');
+const cwd = path.resolve(__dirname, '../path/to/pgpm-workspace');
 
 beforeAll(async () => {
   ({ db, teardown } = await getConnections({}, [
-    seed.launchql(cwd)
+    seed.loadPgpm(cwd)
   ]));
 });
 ```
 
 </details>
 
-## Why LaunchQL's Approach?
+## Why pgpm's Approach?
 
-LaunchQL provides the best of both worlds:
+pgpm 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:
-
-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.
+By maintaining Sqitch compatibility while supercharging performance, pgpm enables you to keep your existing migration patterns while enjoying the speed benefits of our TypeScript engine.
 
 ## `getConnections` Options
 
@@ -593,7 +582,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 or Sqitch projects                         |
+| `db.cwd`                 | `string`   | `process.cwd()`  | Working directory used for pgpm 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()`                                     |
@@ -720,18 +709,18 @@ Common issues and solutions for pgpm, PostgreSQL, and testing.
 
 ### 🔁 Streaming & Uploads
 
+* [etag-hash](https://github.com/constructive-io/constructive/tree/main/packages/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
+* [etag-stream](https://github.com/constructive-io/constructive/tree/main/packages/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
+* [uuid-hash](https://github.com/constructive-io/constructive/tree/main/packages/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
+* [uuid-stream](https://github.com/constructive-io/constructive/tree/main/packages/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
 * [launchql/s3-streamer](https://github.com/constructive-io/constructive/tree/main/packages/s3-streamer): **📤 Direct S3 streaming** for large files with support for metadata injection and content validation.
-* [launchql/etag-hash](https://github.com/constructive-io/constructive/tree/main/packages/etag-hash): **🏷️ S3-compatible ETags** created by streaming and hashing file uploads in chunks.
-* [launchql/etag-stream](https://github.com/constructive-io/constructive/tree/main/packages/etag-stream): **🔄 ETag computation** via Node stream transformer during upload or transfer.
-* [launchql/uuid-hash](https://github.com/constructive-io/constructive/tree/main/packages/uuid-hash): **🆔 Deterministic UUIDs** generated from hashed content, great for deduplication and asset referencing.
-* [launchql/uuid-stream](https://github.com/constructive-io/constructive/tree/main/packages/uuid-stream): **🌊 Streaming UUID generation** based on piped file content—ideal for upload pipelines.
 * [launchql/upload-names](https://github.com/constructive-io/constructive/tree/main/packages/upload-names): **📂 Collision-resistant filenames** utility for structured and unique file names for uploads.
 
 ### 🧰 CLI & Codegen
 
 * [pgpm](https://github.com/constructive-io/constructive/tree/main/packages/pgpm): **🖥️ PostgreSQL Package Manager** for modular Postgres development. Works with database workspaces, scaffolding, migrations, seeding, and installing database packages.
 * [@launchql/cli](https://github.com/constructive-io/constructive/tree/main/packages/cli): **🖥️ Command-line toolkit** for managing LaunchQL projects—supports database scaffolding, migrations, seeding, code generation, and automation.
-* [constructive-io/constructive-gen](https://github.com/constructive-io/constructive/tree/main/packages/launchql-gen): **✨ Auto-generated GraphQL** mutations and queries dynamically built from introspected schema data.
+* [launchql-gen](https://github.com/constructive-io/constructive/tree/main/packages/launchql-gen): **✨ Auto-generated GraphQL** mutations and queries dynamically built from introspected schema data.
 * [@launchql/query-builder](https://github.com/constructive-io/constructive/tree/main/packages/query-builder): **🏗️ SQL constructor** providing a robust TypeScript-based query builder for dynamic generation of `SELECT`, `INSERT`, `UPDATE`, `DELETE`, and stored procedure calls—supports advanced SQL features like `JOIN`, `GROUP BY`, and schema-qualified queries.
 * [@launchql/query](https://github.com/constructive-io/constructive/tree/main/packages/query): **🧩 Fluent GraphQL builder** for PostGraphile schemas. ⚡ Schema-aware via introspection, 🧩 composable and ergonomic for building deeply nested queries.
 

package/connect.js

@@ -33,7 +33,7 @@ const getConnOopts = (cn = {}) => {
         db: connect
     };
 };
-const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.launchql()]) => {
+const getConnections = async (cn = {}, seedAdapters = [seed_1.seed.pgpm()]) => {
     cn = getConnOopts(cn);
     const config = cn.pg;
     const connOpts = cn.db;

package/esm/connect.js

@@ -29,7 +29,7 @@ const getConnOopts = (cn = {}) => {
         db: connect
     };
 };
-export const getConnections = async (cn = {}, seedAdapters = [seed.launchql()]) => {
+export const getConnections = async (cn = {}, seedAdapters = [seed.pgpm()]) => {
     cn = getConnOopts(cn);
     const config = cn.pg;
     const connOpts = cn.db;

package/esm/seed/index.js

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

package/esm/seed/{launchql.js → pgpm.js}

@@ -1,12 +1,12 @@
 import { PgpmPackage } from '@pgpmjs/core';
 import { getEnvOptions } from '@pgpmjs/env';
 /**
- * Standalone helper function to deploy LaunchQL package
+ * 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 deployLaunchql(config, cwd, cache = false) {
+export async function deployPgpm(config, cwd, cache = false) {
     const proj = new PgpmPackage(cwd ?? process.cwd());
     if (!proj.isInModule())
         return;
@@ -19,10 +19,10 @@ export async function deployLaunchql(config, cwd, cache = false) {
         }
     }), proj.getModuleName());
 }
-export function launchql(cwd, cache = false) {
+export function pgpm(cwd, cache = false) {
     return {
         async seed(ctx) {
-            await deployLaunchql(ctx.config, cwd ?? ctx.connect.cwd, cache);
+            await deployPgpm(ctx.config, cwd ?? ctx.connect.cwd, cache);
         }
     };
 }

package/esm/test-client.js

@@ -4,7 +4,7 @@ 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';
+import { deployPgpm } from './seed/pgpm';
 export class PgTestClient {
     config;
     client;
@@ -159,10 +159,10 @@ export class PgTestClient {
         // because POSTGRES doesn't support row-level security on COPY FROM...
         await loadCsvMap(this.client, tables);
     }
-    async loadLaunchql(cwd, cache = false) {
+    async loadPgpm(cwd, cache = false) {
         // await this.ctxQuery(); // no point to call ctxQuery() here
-        // because deployLaunchql() has it's own way of getting the client...
+        // because deployPgpm() 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);
+        await deployPgpm(this.config, cwd, cache);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgsql-test",
-  "version": "2.16.2",
+  "version": "2.16.3",
   "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,16 @@
     "makage": "^0.1.8"
   },
   "dependencies": {
-    "@pgpmjs/core": "^3.0.2",
-    "@pgpmjs/env": "^2.8.0",
-    "@pgpmjs/logger": "^1.3.1",
-    "@pgpmjs/server-utils": "^2.8.2",
-    "@pgpmjs/types": "^2.12.0",
+    "@pgpmjs/core": "^3.0.3",
+    "@pgpmjs/env": "^2.8.1",
+    "@pgpmjs/logger": "^1.3.2",
+    "@pgpmjs/server-utils": "^2.8.3",
+    "@pgpmjs/types": "^2.12.1",
     "csv-parse": "^6.1.0",
     "pg": "^8.16.3",
-    "pg-cache": "^1.6.2",
+    "pg-cache": "^1.6.3",
     "pg-copy-streams": "^7.0.0",
     "pg-env": "^1.2.1"
   },
-  "gitHead": "0f810b087435df60801bfa63d4f780e95acb6d02"
+  "gitHead": "52828c38b144fdc02b6a9a0c8b0ff795d1752d53"
 }

package/seed/index.d.ts

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

package/seed/index.js

@@ -18,11 +18,11 @@ exports.seed = void 0;
 const adapters_1 = require("./adapters");
 const csv_1 = require("./csv");
 const json_1 = require("./json");
-const launchql_1 = require("./launchql");
+const pgpm_1 = require("./pgpm");
 __exportStar(require("./csv"), exports);
 __exportStar(require("./types"), exports);
 exports.seed = {
-    launchql: launchql_1.launchql,
+    pgpm: pgpm_1.pgpm,
     json: json_1.json,
     csv: csv_1.csv,
     compose: adapters_1.compose,

package/seed/{launchql.d.ts → pgpm.d.ts}

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

package/seed/{launchql.js → pgpm.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deployLaunchql = deployLaunchql;
-exports.launchql = launchql;
+exports.deployPgpm = deployPgpm;
+exports.pgpm = pgpm;
 const core_1 = require("@pgpmjs/core");
 const env_1 = require("@pgpmjs/env");
 /**
- * Standalone helper function to deploy LaunchQL package
+ * 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 deployLaunchql(config, cwd, cache = false) {
+async function deployPgpm(config, cwd, cache = false) {
     const proj = new core_1.PgpmPackage(cwd ?? process.cwd());
     if (!proj.isInModule())
         return;
@@ -23,10 +23,10 @@ async function deployLaunchql(config, cwd, cache = false) {
         }
     }), proj.getModuleName());
 }
-function launchql(cwd, cache = false) {
+function pgpm(cwd, cache = false) {
     return {
         async seed(ctx) {
-            await deployLaunchql(ctx.config, cwd ?? ctx.connect.cwd, cache);
+            await deployPgpm(ctx.config, cwd ?? ctx.connect.cwd, cache);
         }
     };
 }

package/test-client.d.ts

@@ -51,5 +51,5 @@ export declare class PgTestClient {
     loadJson(data: JsonSeedMap): Promise<void>;
     loadSql(files: string[]): Promise<void>;
     loadCsv(tables: CsvSeedMap): Promise<void>;
-    loadLaunchql(cwd?: string, cache?: boolean): Promise<void>;
+    loadPgpm(cwd?: string, cache?: boolean): Promise<void>;
 }

package/test-client.js

@@ -7,7 +7,7 @@ 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");
+const pgpm_1 = require("./seed/pgpm");
 class PgTestClient {
     config;
     client;
@@ -162,11 +162,11 @@ class PgTestClient {
         // because POSTGRES doesn't support row-level security on COPY FROM...
         await (0, csv_1.loadCsvMap)(this.client, tables);
     }
-    async loadLaunchql(cwd, cache = false) {
+    async loadPgpm(cwd, cache = false) {
         // await this.ctxQuery(); // no point to call ctxQuery() here
-        // because deployLaunchql() has it's own way of getting the client...
+        // because deployPgpm() 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);
+        await (0, pgpm_1.deployPgpm)(this.config, cwd, cache);
     }
 }
 exports.PgTestClient = PgTestClient;