graphile-test 2.1.9 → 2.1.11

package/README.md

@@ -56,8 +56,8 @@ afterEach(() => db.afterEach());
 afterAll(() => teardown());
 
 it('runs a GraphQL mutation', async () => {
-  const res = await query(`mutation { ... }`);
-  expect(res.errors).toBeUndefined();
+  const res = await query(`mutation { ... }`, { input: { ... } });
+  expect(res.data.createUser.username).toBe('alice');
 });
 ```
 
@@ -67,10 +67,16 @@ it('runs a GraphQL mutation', async () => {
 
 Returns an object with:
 
-* `query` – A GraphQL executor function: `query(gqlDoc, variables?)`
+* `query(gqlString, variables?)` – A GraphQL executor function with positional arguments
 * `db`, `pg` – `PgTestClient` instances
 * `teardown()` – Clean up temp DBs
 
+**Basic Usage:**
+```ts
+const result = await query(`mutation { ... }`, { input: { ... } });
+expect(result.data.createUser.username).toBe('alice');
+```
+
 ### `PgTestClient`
 
 Supports:
@@ -86,18 +92,91 @@ Supports:
 ### GraphQL mutation + snapshot
 
 ```ts
-const res = await query(MY_MUTATION, { input: { ... } });
-expect(snapshot(res)).toMatchSnapshot();
+const res = await query(`mutation { ... }`, { input: { ... } });
+expect(snapshot(res.data)).toMatchSnapshot();
 ```
 
 ### RLS testing with role switch
 
 ```ts
 db.setContext({ role: 'anonymous' });
-const res = await query(MY_PROTECTED_QUERY);
+const res = await query(`query { ... }`);
 expect(res.errors[0].message).toMatch(/permission denied/);
 ```
 
+### Typed queries for better safety
+
+```ts
+interface CreateUserVariables {
+  input: {
+    user: {
+      username: string;
+    };
+  };
+}
+
+interface CreateUserResult {
+  createUser: {
+    user: {
+      id: number;
+      username: string;
+    };
+  };
+}
+
+const res = await query<CreateUserResult>(`
+  mutation CreateUser($input: CreateUserInput!) {
+    createUser(input: $input) {
+      user {
+        id
+        username
+      }
+    }
+  }
+`, { input: { user: { username: 'alice' } } });
+
+expect(res.data.createUser.user.username).toBe('alice');
+```
+
+## 🔧 Advanced Connection Options
+
+For specific testing needs, additional connection functions are available:
+
+### Error Handling Variants
+- `getConnectionsUnwrapped()` – Automatically throws on GraphQL errors, returns data directly
+
+### Debugging Variants  
+- `getConnectionsWithLogging()` – Logs all queries and responses
+- `getConnectionsWithTiming()` – Times query execution
+
+### Object-Based API
+- `getConnectionsObject()` – Uses `query({ query: "...", variables: {} })` syntax
+- `getConnectionsObjectUnwrapped()` – Object-based with automatic error throwing
+
+**Unwrapped Example (cleaner assertions):**
+```ts
+import { getConnectionsUnwrapped } from 'graphile-test';
+
+const { query } = await getConnectionsUnwrapped(config);
+
+// Throws automatically on GraphQL errors, returns data directly
+const result = await query(`mutation { ... }`, { input: { ... } });
+expect(result.createUser.username).toBe('alice'); // No .data needed!
+```
+
+**Object-Based Example:**
+```ts
+import { getConnectionsObject } from 'graphile-test';
+
+const { query } = await getConnectionsObject(config);
+
+const result = await query({ 
+  query: `mutation { ... }`, 
+  variables: { input: { ... } } 
+});
+expect(result.data.createUser.username).toBe('alice');
+```
+
 ## 🧱 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).
@@ -108,6 +187,8 @@ expect(res.errors[0].message).toMatch(/permission denied/);
 * Always wrap tests with `beforeEach` / `afterEach`.
 * Use `snapshot()` to track GraphQL result changes.
 * Use `useRoot: true` to test schema visibility without RLS.
+* Start with `getConnections()` for most use cases.
+* Consider `getConnectionsUnwrapped()` for cleaner test assertions.
 
 ## Related LaunchQL Tooling
 

package/connect-unwrapped.d.ts

@@ -0,0 +1,16 @@
+import type { GetConnectionOpts } from 'pgsql-test';
+import type { PgTestClient } from 'pgsql-test/test-client';
+import type { SeedAdapter } from 'pgsql-test/seed/types';
+import type { GraphQLQueryUnwrappedFn, GraphQLQueryUnwrappedFnPos } from './types';
+export interface GetConnectionsInput {
+    useRoot?: boolean;
+    schemas: string[];
+    authRole?: string;
+}
+export declare const getConnectionsUnwrapped: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryUnwrappedFn;
+    queryPositional: GraphQLQueryUnwrappedFnPos;
+}>;

package/connect-unwrapped.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionsUnwrapped = void 0;
+const pgsql_test_1 = require("pgsql-test");
+const graphile_test_1 = require("./graphile-test");
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+const getConnectionsUnwrapped = 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 = async (opts) => unwrap(await gqlContext.query(opts));
+    const queryPositional = async (query, variables, commit, reqOptions) => unwrap(await gqlContext.query({ query, variables, commit, reqOptions }));
+    return {
+        pg,
+        db,
+        teardown,
+        query,
+        queryPositional
+    };
+};
+exports.getConnectionsUnwrapped = getConnectionsUnwrapped;

package/context.d.ts

@@ -2,7 +2,7 @@ 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';
+import { GetConnectionsInput } from './types';
 export declare const runGraphQLInContext: <T = ExecutionResult<{
     [key: string]: any;
 }, {

package/esm/connect-unwrapped.js

@@ -0,0 +1,30 @@
+import { getConnections as getPgConnections } from 'pgsql-test';
+import { GraphQLTest } from './graphile-test';
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+export const getConnectionsUnwrapped = 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 = async (opts) => unwrap(await gqlContext.query(opts));
+    const queryPositional = async (query, variables, commit, reqOptions) => unwrap(await gqlContext.query({ query, variables, commit, reqOptions }));
+    return {
+        pg,
+        db,
+        teardown,
+        query,
+        queryPositional
+    };
+};

package/esm/get-connections.js

@@ -0,0 +1,162 @@
+import { getConnections as getPgConnections } from 'pgsql-test';
+import { GraphQLTest } from './graphile-test';
+// Core unwrapping utility
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+// Base connection setup - shared across all variants
+const createConnectionsBase = 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 baseQuery = (opts) => gqlContext.query(opts);
+    const baseQueryPositional = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        teardown,
+        baseQuery,
+        baseQueryPositional
+    };
+};
+// ============================================================================
+// REGULAR QUERY VERSIONS
+// ============================================================================
+/**
+ * Creates connections with raw GraphQL responses
+ */
+export const getConnectionsObject = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        teardown,
+        query: baseQuery
+    };
+};
+/**
+ * Creates connections with unwrapped GraphQL responses (throws on errors)
+ */
+export const getConnectionsObjectUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => unwrap(await baseQuery(opts));
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+/**
+ * Creates connections with logging for GraphQL queries
+ */
+export const getConnectionsObjectWithLogging = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => {
+        console.log('Executing GraphQL query:', opts.query);
+        const result = await baseQuery(opts);
+        console.log('GraphQL result:', result);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+/**
+ * Creates connections with timing for GraphQL queries
+ */
+export const getConnectionsObjectWithTiming = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => {
+        const start = Date.now();
+        const result = await baseQuery(opts);
+        const duration = Date.now() - start;
+        console.log(`GraphQL query took ${duration}ms`);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+// ============================================================================
+// POSITIONAL QUERY VERSIONS
+// ============================================================================
+/**
+ * Creates connections with raw GraphQL responses (positional API)
+ */
+export const getConnections = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        teardown,
+        query: baseQueryPositional
+    };
+};
+/**
+ * Creates connections with unwrapped GraphQL responses (positional API, throws on errors)
+ */
+export const getConnectionsUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => unwrap(await baseQueryPositional(query, variables, commit, reqOptions));
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+/**
+ * Creates connections with logging for GraphQL queries (positional API)
+ */
+export const getConnectionsWithLogging = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => {
+        console.log('Executing positional GraphQL query:', query);
+        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        console.log('GraphQL result:', result);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+/**
+ * Creates connections with timing for GraphQL queries (positional API)
+ */
+export const getConnectionsWithTiming = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => {
+        const start = Date.now();
+        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        const duration = Date.now() - start;
+        console.log(`Positional GraphQL query took ${duration}ms`);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};

package/esm/index.js

@@ -1,4 +1,5 @@
 export * from './clean';
 export * from './graphile-test';
-export * from './connect';
+export * from './get-connections';
+export * from './types';
 export { seed } from 'pgsql-test';

package/get-connections.d.ts

@@ -0,0 +1,76 @@
+import type { GetConnectionOpts } from 'pgsql-test';
+import type { PgTestClient } from 'pgsql-test/test-client';
+import type { SeedAdapter } from 'pgsql-test/seed/types';
+import type { GraphQLQueryFnObj, GraphQLQueryFn, GraphQLQueryUnwrappedFnObj, GraphQLQueryUnwrappedFn, GetConnectionsInput } from './types';
+/**
+ * Creates connections with raw GraphQL responses
+ */
+export declare const getConnectionsObject: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFnObj;
+}>;
+/**
+ * Creates connections with unwrapped GraphQL responses (throws on errors)
+ */
+export declare const getConnectionsObjectUnwrapped: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryUnwrappedFnObj;
+}>;
+/**
+ * Creates connections with logging for GraphQL queries
+ */
+export declare const getConnectionsObjectWithLogging: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFnObj;
+}>;
+/**
+ * Creates connections with timing for GraphQL queries
+ */
+export declare const getConnectionsObjectWithTiming: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFnObj;
+}>;
+/**
+ * Creates connections with raw GraphQL responses (positional API)
+ */
+export declare const getConnections: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFn;
+}>;
+/**
+ * Creates connections with unwrapped GraphQL responses (positional API, throws on errors)
+ */
+export declare const getConnectionsUnwrapped: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryUnwrappedFn;
+}>;
+/**
+ * Creates connections with logging for GraphQL queries (positional API)
+ */
+export declare const getConnectionsWithLogging: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFn;
+}>;
+/**
+ * Creates connections with timing for GraphQL queries (positional API)
+ */
+export declare const getConnectionsWithTiming: (input: GetConnectionsInput & GetConnectionOpts, seedAdapters?: SeedAdapter[]) => Promise<{
+    pg: PgTestClient;
+    db: PgTestClient;
+    teardown: () => Promise<void>;
+    query: GraphQLQueryFn;
+}>;

package/get-connections.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionsWithTiming = exports.getConnectionsWithLogging = exports.getConnectionsUnwrapped = exports.getConnections = exports.getConnectionsObjectWithTiming = exports.getConnectionsObjectWithLogging = exports.getConnectionsObjectUnwrapped = exports.getConnectionsObject = void 0;
+const pgsql_test_1 = require("pgsql-test");
+const graphile_test_1 = require("./graphile-test");
+// Core unwrapping utility
+const unwrap = (res) => {
+    if (res.errors?.length) {
+        throw new Error(JSON.stringify(res.errors, null, 2));
+    }
+    if (!res.data) {
+        throw new Error('No data returned from GraphQL query');
+    }
+    return res.data;
+};
+// Base connection setup - shared across all variants
+const createConnectionsBase = 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 baseQuery = (opts) => gqlContext.query(opts);
+    const baseQueryPositional = (query, variables, commit, reqOptions) => gqlContext.query({ query, variables, commit, reqOptions });
+    return {
+        pg,
+        db,
+        teardown,
+        baseQuery,
+        baseQueryPositional
+    };
+};
+// ============================================================================
+// REGULAR QUERY VERSIONS
+// ============================================================================
+/**
+ * Creates connections with raw GraphQL responses
+ */
+const getConnectionsObject = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        teardown,
+        query: baseQuery
+    };
+};
+exports.getConnectionsObject = getConnectionsObject;
+/**
+ * Creates connections with unwrapped GraphQL responses (throws on errors)
+ */
+const getConnectionsObjectUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => unwrap(await baseQuery(opts));
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsObjectUnwrapped = getConnectionsObjectUnwrapped;
+/**
+ * Creates connections with logging for GraphQL queries
+ */
+const getConnectionsObjectWithLogging = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => {
+        console.log('Executing GraphQL query:', opts.query);
+        const result = await baseQuery(opts);
+        console.log('GraphQL result:', result);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsObjectWithLogging = getConnectionsObjectWithLogging;
+/**
+ * Creates connections with timing for GraphQL queries
+ */
+const getConnectionsObjectWithTiming = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQuery } = await createConnectionsBase(input, seedAdapters);
+    const query = async (opts) => {
+        const start = Date.now();
+        const result = await baseQuery(opts);
+        const duration = Date.now() - start;
+        console.log(`GraphQL query took ${duration}ms`);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsObjectWithTiming = getConnectionsObjectWithTiming;
+// ============================================================================
+// POSITIONAL QUERY VERSIONS
+// ============================================================================
+/**
+ * Creates connections with raw GraphQL responses (positional API)
+ */
+const getConnections = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    return {
+        pg,
+        db,
+        teardown,
+        query: baseQueryPositional
+    };
+};
+exports.getConnections = getConnections;
+/**
+ * Creates connections with unwrapped GraphQL responses (positional API, throws on errors)
+ */
+const getConnectionsUnwrapped = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => unwrap(await baseQueryPositional(query, variables, commit, reqOptions));
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsUnwrapped = getConnectionsUnwrapped;
+/**
+ * Creates connections with logging for GraphQL queries (positional API)
+ */
+const getConnectionsWithLogging = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => {
+        console.log('Executing positional GraphQL query:', query);
+        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        console.log('GraphQL result:', result);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsWithLogging = getConnectionsWithLogging;
+/**
+ * Creates connections with timing for GraphQL queries (positional API)
+ */
+const getConnectionsWithTiming = async (input, seedAdapters) => {
+    const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
+    const query = async (query, variables, commit, reqOptions) => {
+        const start = Date.now();
+        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        const duration = Date.now() - start;
+        console.log(`Positional GraphQL query took ${duration}ms`);
+        return result;
+    };
+    return {
+        pg,
+        db,
+        teardown,
+        query
+    };
+};
+exports.getConnectionsWithTiming = getConnectionsWithTiming;

package/graphile-test.d.ts

@@ -1,4 +1,4 @@
 import type { GraphQLTestContext } from './types';
-import { GetConnectionsInput } from './connect';
+import { GetConnectionsInput } from './types';
 import { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
 export declare const GraphQLTest: (input: GetConnectionsInput & GetConnectionOpts, conn: GetConnectionResult) => GraphQLTestContext;

package/index.d.ts

@@ -1,4 +1,5 @@
 export * from './clean';
 export * from './graphile-test';
-export * from './connect';
+export * from './get-connections';
+export * from './types';
 export { seed } from 'pgsql-test';

package/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.seed = void 0;
 __exportStar(require("./clean"), exports);
 __exportStar(require("./graphile-test"), exports);
-__exportStar(require("./connect"), exports);
+__exportStar(require("./get-connections"), exports);
+__exportStar(require("./types"), 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.9",
+  "version": "2.1.11",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "description": "PostGraphile Testing",
   "main": "index.js",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@launchql/types": "^2.1.6",
-    "graphile-settings": "^2.1.9",
+    "graphile-settings": "^2.1.10",
     "graphql": "^15.5.2",
     "mock-req": "^0.2.0",
     "pg": "^8.16.0",
@@ -48,5 +48,5 @@
     "launchql",
     "test"
   ],
-  "gitHead": "a763e6c30aa6af1f5c744fa7463fc557def6edb3"
+  "gitHead": "dd29fa9997eb53550eaabd017e2f1664f2eb7267"
 }

package/types.d.ts

@@ -1,12 +1,31 @@
-import { DocumentNode, ExecutionResult } from 'graphql';
-export interface GraphQLQueryOptions {
+import { DocumentNode, GraphQLError } from 'graphql';
+export interface GraphQLQueryOptions<TVariables = Record<string, any>> {
     query: string | DocumentNode;
-    variables?: Record<string, any>;
+    variables?: TVariables;
     commit?: boolean;
     reqOptions?: Record<string, any>;
 }
 export interface GraphQLTestContext {
     setup: () => Promise<void>;
     teardown: () => Promise<void>;
-    query: <T = ExecutionResult>(opts: GraphQLQueryOptions) => Promise<T>;
+    query: <TResult = any, TVariables = Record<string, any>>(opts: GraphQLQueryOptions<TVariables>) => Promise<TResult>;
 }
+export interface GetConnectionsInput {
+    useRoot?: boolean;
+    schemas: string[];
+    authRole?: string;
+}
+export interface GraphQLQueryOptions<TVariables = Record<string, any>> {
+    query: string | DocumentNode;
+    variables?: TVariables;
+    commit?: boolean;
+    reqOptions?: Record<string, any>;
+}
+export interface GraphQLResponse<T> {
+    data?: T;
+    errors?: readonly GraphQLError[];
+}
+export type GraphQLQueryFnObj = <TResult = any, TVariables = Record<string, any>>(opts: GraphQLQueryOptions<TVariables>) => Promise<GraphQLResponse<TResult>>;
+export type GraphQLQueryFn = <TResult = any, TVariables = Record<string, any>>(query: string | DocumentNode, variables?: TVariables, commit?: boolean, reqOptions?: Record<string, any>) => Promise<GraphQLResponse<TResult>>;
+export type GraphQLQueryUnwrappedFnObj = <TResult = any, TVariables = Record<string, any>>(opts: GraphQLQueryOptions<TVariables>) => Promise<TResult>;
+export type GraphQLQueryUnwrappedFn = <TResult = any, TVariables = Record<string, any>>(query: string | DocumentNode, variables?: TVariables, commit?: boolean, reqOptions?: Record<string, any>) => Promise<TResult>;

package/connect.d.ts

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

@@ -1,26 +0,0 @@
-"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/esm/connect.js

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