graphile-test 2.1.5 → 2.1.7

package/README.md

@@ -16,70 +16,98 @@
   </a>
 </p>
 
-## Install
+`graphile-test` builds on top of [`pgsql-test`](https://github.com/launchql/launchql/tree/main/packages/pgsql-test) to provide robust GraphQL testing utilities for PostGraphile-based projects.
 
-```sh
-npm install graphile-test
-```
+It provides a seamless setup for isolated, seeded, role-aware Postgres databases and injects GraphQL helpers for snapshot testing, role context, and mutation/query assertions.
+
+## 🚀 Features
 
-## How to Use
+* 🔁 **Per-test rollback** via savepoints for isolation
+* 🔐 **RLS-aware context injection** (`setContext`)
+* 🧪 **GraphQL integration testing** with `query()` and snapshot support
+* 📦 **Seed support** for `.sql`, JSON, CSV, LaunchQL, or Sqitch
+* 📊 **Introspection query snapshotting**
+* 🔧 **Raw SQL fallback** via `pg.client.query`
 
-### 1. Create Required Postgres Role
+## 📦 Install
 
-```sql
-CREATE ROLE authenticated;
+```bash
+npm install graphile-test
 ```
 
-### 2. Write a Test
+## ✨ Quick Start
 
 ```ts
-import { GraphQLTest, snapshot } from 'graphile-test';
-import { MyGraphQLQuery } from '../src/queries';
-
-const dbname = 'graphile_test_db';
-const schemas = ['app_public'];
+import { getConnections, seed } from 'graphile-test';
 
-const { setup, teardown, graphQL } = GraphQLTest({
-  dbname,
-  schemas,
-  authRole: 'postgres',
-});
+let db, query, teardown;
 
 beforeAll(async () => {
-  await setup();
-});
-afterAll(async () => {
-  await teardown();
+  ({ db, query, teardown } = await getConnections({
+    schemas: ['app_public'],
+    authRole: 'authenticated'
+  }, [
+    seed.sqlfile(['../sql/test.sql', '../sql/grants.sql'])
+  ]));
 });
 
-it('query', async () => {
-  await graphQL(async query => {
-    const data = await query(MyGraphQLQuery);
-    expect(snapshot(data)).toMatchSnapshot();
-  });
+beforeEach(() => db.beforeEach());
+afterEach(() => db.afterEach());
+afterAll(() => teardown());
+
+it('runs a GraphQL mutation', async () => {
+  const res = await query(`mutation { ... }`);
+  expect(res.errors).toBeUndefined();
 });
 ```
 
-## Testing Setup
+## 📘 API
 
-Before running tests, prepare your database:
+### `getConnections(options, seeders)`
 
-```sh
-createdb graphile_test_db
-psql -f sql/test.sql graphile_test_db
-```
+Returns an object with:
+
+* `query` – A GraphQL executor function: `query(gqlDoc, variables?)`
+* `db`, `pg` – `PgTestClient` instances
+* `teardown()` – Clean up temp DBs
+
+### `PgTestClient`
 
-## Environment Variables
+Supports:
 
-You can override the default Postgres connection settings by setting the following environment variables:
+* `query`, `any`, `one`, etc. (via `pg-promise`-like helpers)
+* `beforeEach()` / `afterEach()` – for savepoint transaction handling
+* `setContext({...})` – sets Postgres config (e.g., `role`, `myapp.user_id`)
 
-```sh
-export PGUSER=your_pg_user
-export PGHOST=your_pg_host
-export PGPORT=your_pg_port
+**See full `PgTestClient` API docs**: [pgsql-test → PgTestClient API Overview](https://www.npmjs.com/package/pgsql-test#pgtestclient-api-overview)
+
+## 🧪 Example Tests
+
+### GraphQL mutation + snapshot
+
+```ts
+const res = await query(MY_MUTATION, { input: { ... } });
+expect(snapshot(res)).toMatchSnapshot();
 ```
 
-Once set, these will be automatically picked up by `graphile-test` when establishing connections.
+### RLS testing with role switch
+
+```ts
+db.setContext({ role: 'anonymous' });
+const res = await query(MY_PROTECTED_QUERY);
+expect(res.errors[0].message).toMatch(/permission denied/);
+```
+
+## 🧱 Under the Hood
+
+`graphile-test` wraps and extends `pgsql-test` with GraphQL helpers like `query()` and introspection snapshot tools. You can drop into raw SQL testing anytime via `pg.client.query()` (superuser) or `db.client.query()` (RLS user).
+
+## ✅ Best Practices
+
+* Use `db.setContext({ role, user_id })` to simulate authentication.
+* Always wrap tests with `beforeEach` / `afterEach`.
+* Use `snapshot()` to track GraphQL result changes.
+* Use `useRoot: true` to test schema visibility without RLS.
 
 ## Related LaunchQL Tooling
 

package/connect.d.ts

@@ -0,0 +1,19 @@
+import type { GetConnectionOpts } from 'pgsql-test';
+import type { PgTestClient } from 'pgsql-test/test-client';
+import type { SeedAdapter } from 'pgsql-test/seed/types';
+import type { DocumentNode, ExecutionResult } from 'graphql';
+export type GraphQLQueryFn<T = ExecutionResult> = (query: string | DocumentNode, variables?: Record<string, any>, commit?: boolean, reqOptions?: Record<string, any>) => Promise<T>;
+export interface GetConnectionsInput {
+    useRoot?: boolean;
+    schemas: string[];
+    authRole?: string;
+}
+/**
+ * Combines PostgreSQL test setup with GraphQL test context
+ */
+export declare const getConnections: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFn;
+}>;

package/connect.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnections = void 0;
+const pgsql_test_1 = require("pgsql-test");
+const graphile_test_1 = require("./graphile-test");
+/**
+ * Combines PostgreSQL test setup with GraphQL test context
+ */
+const getConnections = async (input, seedAdapters) => {
+    const conn = await (0, pgsql_test_1.getConnections)(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    const gqlContext = (0, graphile_test_1.GraphQLTest)(input, conn);
+    await gqlContext.setup();
+    const teardown = async () => {
+        await gqlContext.teardown();
+        await dbTeardown();
+    };
+    const query = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnections = getConnections;

package/context.d.ts

@@ -0,0 +1,21 @@
+import { ExecutionResult, DocumentNode } from 'graphql';
+import { PostGraphileOptions } from 'postgraphile';
+import type { Client, Pool } from 'pg';
+import { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
+import { GetConnectionsInput } from './connect';
+export declare const runGraphQLInContext: <T = ExecutionResult<{
+    [key: string]: any;
+}, {
+    [key: string]: any;
+}>>({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions }: {
+    input: GetConnectionsInput & GetConnectionOpts;
+    conn: GetConnectionResult;
+    pgPool: Pool;
+    schema: any;
+    options: PostGraphileOptions;
+    authRole: string;
+    query: string | DocumentNode;
+    variables?: Record<string, any>;
+    reqOptions?: Record<string, any>;
+}) => Promise<T>;
+export declare function setContextOnClient(pgClient: Client, pgSettings: Record<string, string>, role: string): Promise<void>;

package/context.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGraphQLInContext = void 0;
+exports.setContextOnClient = setContextOnClient;
+const graphql_1 = require("graphql");
+const postgraphile_1 = require("postgraphile");
+// @ts-ignore
+const mock_req_1 = __importDefault(require("mock-req"));
+const runGraphQLInContext = async ({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions = {} }) => {
+    if (!conn.pg.client) {
+        throw new Error('pgClient is required and must be provided externally.');
+    }
+    const req = new mock_req_1.default({
+        url: options.graphqlRoute || '/graphql',
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        },
+        ...reqOptions
+    });
+    const pgSettingsGenerator = options.pgSettings;
+    // @ts-ignore
+    const pgSettings = typeof pgSettingsGenerator === 'function'
+        ? await pgSettingsGenerator(req)
+        : pgSettingsGenerator || {};
+    // @ts-ignore
+    return await (0, postgraphile_1.withPostGraphileContext)({ ...options, pgPool, pgSettings }, async (context) => {
+        const pgConn = input.useRoot ? conn.pg : conn.db;
+        const pgClient = pgConn.client;
+        // IS THIS BAD TO HAVE ROLE HERE 
+        await setContextOnClient(pgClient, pgSettings, authRole);
+        await pgConn.ctxQuery();
+        const printed = typeof query === 'string' ? query : (0, graphql_1.print)(query);
+        const result = await (0, graphql_1.graphql)({
+            schema,
+            source: printed,
+            contextValue: { ...context, pgClient },
+            variableValues: variables ?? null
+        });
+        return result;
+    });
+};
+exports.runGraphQLInContext = runGraphQLInContext;
+// IS THIS BAD TO HAVE ROLE HERE 
+async function setContextOnClient(pgClient, pgSettings, role) {
+    await pgClient.query(`select set_config('role', $1, true)`, [role]);
+    for (const [key, value] of Object.entries(pgSettings)) {
+        await pgClient.query(`select set_config($1, $2, true)`, [key, String(value)]);
+    }
+}

package/esm/connect.js

@@ -0,0 +1,22 @@
+import { getConnections as getPgConnections } from 'pgsql-test';
+import { GraphQLTest } from './graphile-test';
+/**
+ * Combines PostgreSQL test setup with GraphQL test context
+ */
+export const getConnections = async (input, seedAdapters) => {
+    const conn = await getPgConnections(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    const gqlContext = GraphQLTest(input, conn);
+    await gqlContext.setup();
+    const teardown = async () => {
+        await gqlContext.teardown();
+        await dbTeardown();
+    };
+    const query = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};

package/esm/context.js

@@ -0,0 +1,46 @@
+import { graphql, print } from 'graphql';
+import { withPostGraphileContext } from 'postgraphile';
+// @ts-ignore
+import MockReq from 'mock-req';
+export const runGraphQLInContext = async ({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions = {} }) => {
+    if (!conn.pg.client) {
+        throw new Error('pgClient is required and must be provided externally.');
+    }
+    const req = new MockReq({
+        url: options.graphqlRoute || '/graphql',
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json'
+        },
+        ...reqOptions
+    });
+    const pgSettingsGenerator = options.pgSettings;
+    // @ts-ignore
+    const pgSettings = typeof pgSettingsGenerator === 'function'
+        ? await pgSettingsGenerator(req)
+        : pgSettingsGenerator || {};
+    // @ts-ignore
+    return await withPostGraphileContext({ ...options, pgPool, pgSettings }, async (context) => {
+        const pgConn = input.useRoot ? conn.pg : conn.db;
+        const pgClient = pgConn.client;
+        // IS THIS BAD TO HAVE ROLE HERE 
+        await setContextOnClient(pgClient, pgSettings, authRole);
+        await pgConn.ctxQuery();
+        const printed = typeof query === 'string' ? query : print(query);
+        const result = await graphql({
+            schema,
+            source: printed,
+            contextValue: { ...context, pgClient },
+            variableValues: variables ?? null
+        });
+        return result;
+    });
+};
+// IS THIS BAD TO HAVE ROLE HERE 
+export async function setContextOnClient(pgClient, pgSettings, role) {
+    await pgClient.query(`select set_config('role', $1, true)`, [role]);
+    for (const [key, value] of Object.entries(pgSettings)) {
+        await pgClient.query(`select set_config($1, $2, true)`, [key, String(value)]);
+    }
+}

package/esm/graphile-test.js

@@ -1,173 +1,30 @@
-import { getGraphileSettings } from '@launchql/graphile-settings';
-import pg from 'pg';
-import { createPostGraphileSchema, withPostGraphileContext } from 'postgraphile';
-import { graphql } from 'graphql';
-// @ts-ignore
-import MockReq from 'mock-req';
-import { print } from 'graphql/language/printer';
-import { getEnvOptions } from '@launchql/types';
-const opt = getEnvOptions();
-export const GraphQLTest = ({ dbname, schemas, authRole = 'authenticated' }) => {
-    const getDbString = (db) => `postgres://${opt.pg.user}:${opt.pg.password}@${opt.pg.host}:${opt.pg.port}/${db}`;
-    const options = {
-        ...getGraphileSettings({
-            graphile: {
-                schema: schemas
-            }
-        }),
-        graphqlRoute: '/graphql',
-        graphiqlRoute: '/graphiql'
-    };
-    pg.defaults.poolSize = 1;
-    const POSTGRAPHILE_AUTHENTICATOR_ROLE = authRole;
-    let ctx = null;
+import { runGraphQLInContext } from './context';
+import { createPostGraphileSchema } from 'postgraphile';
+import { getGraphileSettings } from 'graphile-settings';
+export const GraphQLTest = (input, conn) => {
+    const { schemas, authRole } = input;
+    let schema;
+    let options;
+    const pgPool = conn.manager.getPool(conn.pg.config);
     const setup = async () => {
-        const rootPgPool = new pg.Pool({
-            connectionString: getDbString(dbname)
-        });
-        const schema = await createPostGraphileSchema(rootPgPool, schemas, options);
-        ctx = { rootPgPool, options, schema };
-    };
-    const teardown = async () => {
-        try {
-            if (!ctx)
-                return;
-            const { rootPgPool } = ctx;
-            ctx = null;
-            await rootPgPool.end();
-        }
-        catch (e) {
-            console.error(e);
-        }
+        options = getGraphileSettings({ graphile: { schema: schemas } });
+        schema = await createPostGraphileSchema(pgPool, schemas, options);
     };
-    const graphQL = async (...args) => {
-        if (!ctx)
-            throw new Error('Context is not initialized. Did you run setup()?');
-        let reqOptions = {};
-        let checker;
-        if (args.length === 1) {
-            checker = args[0];
-        }
-        else if (args.length === 2) {
-            reqOptions = args[0];
-            checker = args[1];
-        }
-        else {
-            throw new Error('Invalid arguments supplied to graphQL');
-        }
-        const { schema, rootPgPool, options } = ctx;
-        const req = new MockReq({
-            url: options.graphqlRoute || '/graphql',
-            method: 'POST',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            },
-            ...reqOptions
-        });
-        const pgSettingsGenerator = options.pgSettings;
-        // @ts-ignore
-        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
-        return await withPostGraphileContext({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
-            const replacementPgClient = await rootPgPool.connect();
-            await replacementPgClient.query('begin');
-            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
-            for (const [key, value] of Object.entries(pgSettings)) {
-                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
-            }
-            try {
-                const query = async (q, variables) => {
-                    if (typeof q !== 'string')
-                        q = print(q);
-                    return await graphql(schema, q, null, { ...context, pgClient: replacementPgClient }, variables);
-                };
-                return await checker(query, replacementPgClient);
-            }
-            finally {
-                await replacementPgClient.query('rollback');
-                replacementPgClient.release();
-            }
+    const teardown = async () => { };
+    const query = async (opts) => {
+        return await runGraphQLInContext({
+            input,
+            schema,
+            options,
+            authRole,
+            pgPool,
+            conn,
+            ...opts
         });
     };
-    async function graphQLQuery(...args) {
-        if (!ctx)
-            throw new Error('Context is not initialized. Did you run setup()?');
-        let reqOptions = {};
-        let Query;
-        let vars;
-        let commit = false;
-        if (args.length === 1) {
-            Query = args[0];
-        }
-        else if (args.length === 2) {
-            if (typeof args[1] === 'boolean') {
-                Query = args[0];
-                commit = args[1];
-            }
-            else {
-                Query = args[0];
-                vars = args[1];
-            }
-        }
-        else if (args.length === 3) {
-            if (typeof args[2] === 'boolean') {
-                Query = args[0];
-                vars = args[1];
-                commit = args[2];
-            }
-            else {
-                reqOptions = args[0];
-                Query = args[1];
-                vars = args[2];
-            }
-        }
-        else if (args.length === 4) {
-            reqOptions = args[0];
-            Query = args[1];
-            vars = args[2];
-            commit = args[3];
-        }
-        else {
-            throw new Error('Invalid arguments supplied to graphQLQuery');
-        }
-        const { schema, rootPgPool, options } = ctx;
-        const req = new MockReq({
-            url: options.graphqlRoute || '/graphql',
-            method: 'POST',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            },
-            ...reqOptions
-        });
-        const pgSettingsGenerator = options.pgSettings;
-        // @ts-ignore
-        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
-        return await withPostGraphileContext({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
-            const replacementPgClient = await rootPgPool.connect();
-            await replacementPgClient.query('begin');
-            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
-            for (const [key, value] of Object.entries(pgSettings)) {
-                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
-            }
-            try {
-                if (typeof Query !== 'string')
-                    Query = print(Query);
-                return await graphql(schema, Query, null, { ...context, pgClient: replacementPgClient }, vars);
-            }
-            finally {
-                await replacementPgClient.query(commit ? 'commit' : 'rollback');
-                replacementPgClient.release();
-            }
-        });
-    }
-    ;
     return {
         setup,
         teardown,
-        graphQL,
-        graphQLQuery,
-        // @ts-ignore
-        withContext: (cb) => cb(ctx)
+        query
     };
 };

package/esm/index.js

@@ -1,2 +1,3 @@
 export * from './clean';
 export * from './graphile-test';
+export { seed } from 'pgsql-test';

package/esm/types.js

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

package/graphile-test.d.ts

@@ -1,20 +1,4 @@
-import { DocumentNode } from 'graphql';
-export interface GraphQLTestOptions {
-    dbname: string;
-    schemas: string[];
-    authRole?: string;
-}
-export declare const GraphQLTest: ({ dbname, schemas, authRole }: GraphQLTestOptions) => {
-    setup: () => Promise<void>;
-    teardown: () => Promise<void>;
-    graphQL: (...args: any[]) => Promise<any>;
-    graphQLQuery: {
-        (Query: string | DocumentNode): Promise<any>;
-        (Query: string | DocumentNode, commit: boolean): Promise<any>;
-        (Query: string | DocumentNode, vars: Record<string, any>): Promise<any>;
-        (Query: string | DocumentNode, vars: Record<string, any>, commit: boolean): Promise<any>;
-        (reqOptions: Record<string, any>, Query: string | DocumentNode, vars: Record<string, any>): Promise<any>;
-        (reqOptions: Record<string, any>, Query: string | DocumentNode, vars: Record<string, any>, commit: boolean): Promise<any>;
-    };
-    withContext: <T>(cb: (ctx: typeof ctx) => T) => T;
-};
+import type { GraphQLTestContext } from './types';
+import { GetConnectionsInput } from './connect';
+import { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
+export declare const GraphQLTest: (input: GetConnectionsInput & GetConnectionOpts, conn: GetConnectionResult) => GraphQLTestContext;

package/graphile-test.js

@@ -1,180 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLTest = void 0;
-const graphile_settings_1 = require("@launchql/graphile-settings");
-const pg_1 = __importDefault(require("pg"));
+const context_1 = require("./context");
 const postgraphile_1 = require("postgraphile");
-const graphql_1 = require("graphql");
-// @ts-ignore
-const mock_req_1 = __importDefault(require("mock-req"));
-const printer_1 = require("graphql/language/printer");
-const types_1 = require("@launchql/types");
-const opt = (0, types_1.getEnvOptions)();
-const GraphQLTest = ({ dbname, schemas, authRole = 'authenticated' }) => {
-    const getDbString = (db) => `postgres://${opt.pg.user}:${opt.pg.password}@${opt.pg.host}:${opt.pg.port}/${db}`;
-    const options = {
-        ...(0, graphile_settings_1.getGraphileSettings)({
-            graphile: {
-                schema: schemas
-            }
-        }),
-        graphqlRoute: '/graphql',
-        graphiqlRoute: '/graphiql'
-    };
-    pg_1.default.defaults.poolSize = 1;
-    const POSTGRAPHILE_AUTHENTICATOR_ROLE = authRole;
-    let ctx = null;
+const graphile_settings_1 = require("graphile-settings");
+const GraphQLTest = (input, conn) => {
+    const { schemas, authRole } = input;
+    let schema;
+    let options;
+    const pgPool = conn.manager.getPool(conn.pg.config);
     const setup = async () => {
-        const rootPgPool = new pg_1.default.Pool({
-            connectionString: getDbString(dbname)
-        });
-        const schema = await (0, postgraphile_1.createPostGraphileSchema)(rootPgPool, schemas, options);
-        ctx = { rootPgPool, options, schema };
-    };
-    const teardown = async () => {
-        try {
-            if (!ctx)
-                return;
-            const { rootPgPool } = ctx;
-            ctx = null;
-            await rootPgPool.end();
-        }
-        catch (e) {
-            console.error(e);
-        }
+        options = (0, graphile_settings_1.getGraphileSettings)({ graphile: { schema: schemas } });
+        schema = await (0, postgraphile_1.createPostGraphileSchema)(pgPool, schemas, options);
     };
-    const graphQL = async (...args) => {
-        if (!ctx)
-            throw new Error('Context is not initialized. Did you run setup()?');
-        let reqOptions = {};
-        let checker;
-        if (args.length === 1) {
-            checker = args[0];
-        }
-        else if (args.length === 2) {
-            reqOptions = args[0];
-            checker = args[1];
-        }
-        else {
-            throw new Error('Invalid arguments supplied to graphQL');
-        }
-        const { schema, rootPgPool, options } = ctx;
-        const req = new mock_req_1.default({
-            url: options.graphqlRoute || '/graphql',
-            method: 'POST',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            },
-            ...reqOptions
-        });
-        const pgSettingsGenerator = options.pgSettings;
-        // @ts-ignore
-        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
-        return await (0, postgraphile_1.withPostGraphileContext)({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
-            const replacementPgClient = await rootPgPool.connect();
-            await replacementPgClient.query('begin');
-            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
-            for (const [key, value] of Object.entries(pgSettings)) {
-                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
-            }
-            try {
-                const query = async (q, variables) => {
-                    if (typeof q !== 'string')
-                        q = (0, printer_1.print)(q);
-                    return await (0, graphql_1.graphql)(schema, q, null, { ...context, pgClient: replacementPgClient }, variables);
-                };
-                return await checker(query, replacementPgClient);
-            }
-            finally {
-                await replacementPgClient.query('rollback');
-                replacementPgClient.release();
-            }
+    const teardown = async () => { };
+    const query = async (opts) => {
+        return await (0, context_1.runGraphQLInContext)({
+            input,
+            schema,
+            options,
+            authRole,
+            pgPool,
+            conn,
+            ...opts
         });
     };
-    async function graphQLQuery(...args) {
-        if (!ctx)
-            throw new Error('Context is not initialized. Did you run setup()?');
-        let reqOptions = {};
-        let Query;
-        let vars;
-        let commit = false;
-        if (args.length === 1) {
-            Query = args[0];
-        }
-        else if (args.length === 2) {
-            if (typeof args[1] === 'boolean') {
-                Query = args[0];
-                commit = args[1];
-            }
-            else {
-                Query = args[0];
-                vars = args[1];
-            }
-        }
-        else if (args.length === 3) {
-            if (typeof args[2] === 'boolean') {
-                Query = args[0];
-                vars = args[1];
-                commit = args[2];
-            }
-            else {
-                reqOptions = args[0];
-                Query = args[1];
-                vars = args[2];
-            }
-        }
-        else if (args.length === 4) {
-            reqOptions = args[0];
-            Query = args[1];
-            vars = args[2];
-            commit = args[3];
-        }
-        else {
-            throw new Error('Invalid arguments supplied to graphQLQuery');
-        }
-        const { schema, rootPgPool, options } = ctx;
-        const req = new mock_req_1.default({
-            url: options.graphqlRoute || '/graphql',
-            method: 'POST',
-            headers: {
-                Accept: 'application/json',
-                'Content-Type': 'application/json'
-            },
-            ...reqOptions
-        });
-        const pgSettingsGenerator = options.pgSettings;
-        // @ts-ignore
-        const pgSettings = typeof pgSettingsGenerator === 'function' ? await pgSettingsGenerator(req) : pgSettingsGenerator || {};
-        return await (0, postgraphile_1.withPostGraphileContext)({ ...options, pgPool: rootPgPool, pgSettings }, async (context) => {
-            const replacementPgClient = await rootPgPool.connect();
-            await replacementPgClient.query('begin');
-            await replacementPgClient.query("select set_config('role', $1, true)", [POSTGRAPHILE_AUTHENTICATOR_ROLE]);
-            for (const [key, value] of Object.entries(pgSettings)) {
-                await replacementPgClient.query("select set_config($1, $2, true)", [key, String(value)]);
-            }
-            try {
-                if (typeof Query !== 'string')
-                    Query = (0, printer_1.print)(Query);
-                return await (0, graphql_1.graphql)(schema, Query, null, { ...context, pgClient: replacementPgClient }, vars);
-            }
-            finally {
-                await replacementPgClient.query(commit ? 'commit' : 'rollback');
-                replacementPgClient.release();
-            }
-        });
-    }
-    ;
     return {
         setup,
         teardown,
-        graphQL,
-        graphQLQuery,
-        // @ts-ignore
-        withContext: (cb) => cb(ctx)
+        query
     };
 };
 exports.GraphQLTest = GraphQLTest;

package/index.d.ts

@@ -1,2 +1,3 @@
 export * from './clean';
 export * from './graphile-test';
+export { seed } from 'pgsql-test';

package/index.js

@@ -14,5 +14,8 @@ 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;
 __exportStar(require("./clean"), exports);
 __exportStar(require("./graphile-test"), exports);
+var pgsql_test_1 = require("pgsql-test");
+Object.defineProperty(exports, "seed", { enumerable: true, get: function () { return pgsql_test_1.seed; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-test",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostGraphile Testing",
   "main": "index.js",
@@ -34,12 +34,12 @@
     "graphql-tag": "2.12.6"
   },
   "dependencies": {
-    "@launchql/graphile-settings": "^2.1.5",
     "@launchql/types": "^2.1.5",
+    "graphile-settings": "^2.1.7",
     "graphql": "^15.5.2",
     "mock-req": "^0.2.0",
     "pg": "^8.16.0",
     "postgraphile": "^4.14.1"
   },
-  "gitHead": "4f0b0637695c6f54c5de85d31776961057c51a08"
+  "gitHead": "8a638ef47a175c964a63431017d83587e62efbb8"
 }

package/types.d.ts

@@ -0,0 +1,12 @@
+import { DocumentNode, ExecutionResult } from 'graphql';
+export interface GraphQLQueryOptions {
+    query: string | DocumentNode;
+    variables?: Record<string, any>;
+    commit?: boolean;
+    reqOptions?: Record<string, any>;
+}
+export interface GraphQLTestContext {
+    setup: () => Promise<void>;
+    teardown: () => Promise<void>;
+    query: <T = ExecutionResult>(opts: GraphQLQueryOptions) => Promise<T>;
+}

package/types.js

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