graphile-test 3.1.0 → 4.0.0

package/clean.js

@@ -24,7 +24,7 @@ const pruneDates = (row) => mapValues(row, (v, k) => {
     return v;
 });
 exports.pruneDates = pruneDates;
-const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
+const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || k === 'rowId' || (typeof k === 'string' && k.endsWith('_id'))) &&
     (typeof v === 'string' || typeof v === 'number')
     ? idReplacement(v)
     : v);

package/context.d.ts

@@ -1,17 +1,30 @@
-import { DocumentNode, ExecutionResult } from 'graphql';
+import type { DocumentNode, ExecutionResult, GraphQLSchema } from 'graphql';
+import type { GraphileConfig } from 'graphile-config';
+import { makePgService } from 'postgraphile/adaptors/pg';
 import type { Client, Pool } from 'pg';
-import { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
-import { PostGraphileOptions } from 'postgraphile';
-import { GetConnectionsInput } from './types';
-export declare const runGraphQLInContext: <T = ExecutionResult>({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions }: {
+import type { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
+import type { GetConnectionsInput } from './types';
+interface RunGraphQLOptions {
     input: GetConnectionsInput & GetConnectionOpts;
     conn: GetConnectionResult;
     pgPool: Pool;
-    schema: any;
-    options: PostGraphileOptions;
+    pgService: ReturnType<typeof makePgService>;
+    schema: GraphQLSchema;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
     authRole: string;
     query: string | DocumentNode;
     variables?: Record<string, any>;
-    reqOptions?: Record<string, any>;
-}) => Promise<T>;
+    reqOptions?: Record<string, unknown>;
+}
+/**
+ * Execute a GraphQL query in the v5 context using grafast's execute function.
+ *
+ * This replaces the v4 withPostGraphileContext pattern with grafast execution.
+ * Uses execute() with withPgClient to ensure proper connection handling and pgSettings.
+ */
+export declare const runGraphQLInContext: <T = ExecutionResult>({ input, conn, schema, resolvedPreset, pgService, authRole, query, variables, reqOptions, }: RunGraphQLOptions) => Promise<T>;
+/**
+ * Set the PostgreSQL role and session settings on a client connection.
+ */
 export declare function setContextOnClient(pgClient: Client, pgSettings: Record<string, string>, role: string): Promise<void>;
+export {};

package/context.js

@@ -1,60 +1,243 @@
 "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");
-// @ts-ignore
-const mock_req_1 = __importDefault(require("mock-req"));
-const postgraphile_1 = require("postgraphile");
-const runGraphQLInContext = async ({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions = {} }) => {
+const grafast_1 = require("grafast");
+/**
+ * Find a field node in the document by following the path.
+ * This is used to derive locations when grafast doesn't provide them.
+ */
+function findFieldNodeByPath(document, path) {
+    if (!path || path.length === 0)
+        return null;
+    // Find the operation definition
+    const operation = document.definitions.find((def) => def.kind === graphql_1.Kind.OPERATION_DEFINITION);
+    if (!operation)
+        return null;
+    // Navigate through the path to find the field
+    let selections = operation.selectionSet.selections;
+    let fieldNode = null;
+    for (const segment of path) {
+        if (typeof segment === 'number') {
+            // Array index - skip, the field is still the same
+            continue;
+        }
+        // Find the field with this name
+        fieldNode = selections.find((sel) => sel.kind === graphql_1.Kind.FIELD && (sel.alias?.value ?? sel.name.value) === segment) ?? null;
+        if (!fieldNode)
+            return null;
+        // Move to nested selections if they exist
+        if (fieldNode.selectionSet) {
+            selections = fieldNode.selectionSet.selections;
+        }
+    }
+    return fieldNode;
+}
+/**
+ * Format a GraphQL error to match the v4 PostGraphile format.
+ *
+ * v5 grafast errors have different formatting:
+ * - They include `extensions: {}` even when empty
+ * - They may have `locations: undefined` instead of omitting the field
+ * - They don't always include locations even when nodes are available
+ *
+ * This normalizes errors to match v4 format for backward compatibility.
+ *
+ * @param error - The GraphQL error to format
+ * @param document - The original document (used to derive locations from path)
+ */
+function formatErrorToV4(error, document) {
+    const formatted = {
+        message: error.message,
+    };
+    // Try to get locations from the error directly first
+    let locations = error.locations;
+    // If no locations but nodes are available, try to extract from nodes
+    if ((!locations || locations.length === 0) && error.nodes && error.nodes.length > 0) {
+        const extractedLocations = error.nodes
+            .filter(node => node.loc)
+            .map(node => {
+            const loc = node.loc;
+            if (loc && loc.source) {
+                // Calculate line and column from the source
+                const { startToken } = loc;
+                if (startToken) {
+                    return { line: startToken.line, column: startToken.column };
+                }
+            }
+            return null;
+        })
+            .filter((loc) => loc !== null);
+        if (extractedLocations.length > 0) {
+            locations = extractedLocations;
+        }
+    }
+    // If still no locations and we have a path and document, try to derive from path
+    if ((!locations || locations.length === 0) && error.path && document) {
+        const fieldNode = findFieldNodeByPath(document, error.path);
+        if (fieldNode?.loc) {
+            const { startToken } = fieldNode.loc;
+            if (startToken) {
+                locations = [{ line: startToken.line, column: startToken.column }];
+            }
+        }
+    }
+    // Only include locations if it's a non-empty array
+    if (locations && Array.isArray(locations) && locations.length > 0) {
+        formatted.locations = locations;
+    }
+    // Only include path if it exists
+    if (error.path && error.path.length > 0) {
+        formatted.path = error.path;
+    }
+    // Only include extensions if it has non-empty content
+    if (error.extensions && Object.keys(error.extensions).length > 0) {
+        formatted.extensions = error.extensions;
+    }
+    return formatted;
+}
+/**
+ * Normalize an ExecutionResult to match v4 PostGraphile output format.
+ * This ensures backward compatibility with existing tests and consumers.
+ *
+ * @param result - The execution result from grafast
+ * @param document - The original document (used to derive locations from path)
+ */
+function normalizeResult(result, document) {
+    const normalized = {
+        data: result.data,
+    };
+    // Format errors to match v4 style
+    if (result.errors && result.errors.length > 0) {
+        normalized.errors = result.errors.map(err => formatErrorToV4(err, document));
+    }
+    // Only include extensions if present and non-empty
+    if (result.extensions && Object.keys(result.extensions).length > 0) {
+        normalized.extensions = result.extensions;
+    }
+    return normalized;
+}
+/**
+ * Execute a GraphQL query in the v5 context using grafast's execute function.
+ *
+ * This replaces the v4 withPostGraphileContext pattern with grafast execution.
+ * Uses execute() with withPgClient to ensure proper connection handling and pgSettings.
+ */
+const runGraphQLInContext = async ({ input, conn, schema, resolvedPreset, pgService, authRole, query, variables, reqOptions = {}, }) => {
     if (!conn.pg.client) {
         throw new Error('pgClient is required and must be provided externally.');
     }
-    const { res: reqRes, ...restReqOptions } = reqOptions ?? {};
-    const req = new mock_req_1.default({
-        url: options.graphqlRoute || '/graphql',
-        method: 'POST',
-        headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-        },
-        ...restReqOptions
-    });
-    const res = reqRes ?? {};
-    const pgSettingsGenerator = options.pgSettings;
-    // @ts-ignore
-    const pgSettings = typeof pgSettingsGenerator === 'function'
-        ? await pgSettingsGenerator(req)
-        : pgSettingsGenerator || {};
-    const contextOptions = { ...options, pgPool, pgSettings, req, res };
-    // @ts-ignore
-    return await (0, postgraphile_1.withPostGraphileContext)(contextOptions, 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 additionalContext = typeof options.additionalGraphQLContextFromRequest === 'function'
-            ? await options.additionalGraphQLContextFromRequest(req, res)
-            : {};
-        const printed = typeof query === 'string' ? query : (0, graphql_1.print)(query);
-        const result = await (0, graphql_1.graphql)({
+    // Get the appropriate connection (root or database-specific)
+    const pgConn = input.useRoot ? conn.pg : conn.db;
+    const pgClient = pgConn.client;
+    // Build pgSettings by merging:
+    // 1. Context from db.setContext() (e.g., role, myapp.user_id)
+    // 2. Settings from reqOptions.pgSettings (explicit overrides)
+    // The role from getContext() takes precedence over authRole default
+    const dbContext = pgConn.getContext();
+    const reqPgSettings = reqOptions.pgSettings ?? {};
+    // Start with authRole as default, then apply db context, then request overrides
+    const pgSettings = {
+        role: authRole,
+        ...Object.fromEntries(Object.entries(dbContext).filter(([, v]) => v !== null)),
+        ...reqPgSettings,
+    };
+    // Set role and context on the client for direct queries
+    await setContextOnClient(pgClient, pgSettings, pgSettings.role);
+    await pgConn.ctxQuery();
+    // Convert query to DocumentNode if it's a string
+    // Also ensure we have location information for error reporting
+    let document;
+    if (typeof query === 'string') {
+        document = (0, graphql_1.parse)(query);
+    }
+    else {
+        // For DocumentNode (from graphql-tag), re-parse from source to get locations
+        // graphql-tag doesn't preserve location info by default
+        const source = (0, graphql_1.print)(query);
+        document = (0, graphql_1.parse)(source);
+    }
+    // Build context with pgSettings and withPgClient
+    // This is the v5 pattern used by executor.ts and api.ts
+    const contextValue = {
+        pgSettings,
+        // Include additional request options (excluding pgSettings to avoid duplication)
+        ...Object.fromEntries(Object.entries(reqOptions).filter(([key]) => key !== 'pgSettings')),
+    };
+    // Provide a custom withPgClient function that uses the test client
+    // This ensures GraphQL operations run within the test transaction
+    // instead of getting a new connection from the pool
+    const withPgClientKey = pgService.withPgClientKey ?? 'withPgClient';
+    contextValue[withPgClientKey] = async (_pgSettings, callback) => {
+        // Simply use the test client - it's already in a transaction
+        // The pgSettings have already been applied above via setContextOnClient
+        return callback(pgClient);
+    };
+    // Check if we're in a transaction by looking at the test client's transaction state
+    // When useRoot is true, we might not be in a transaction
+    // pgsql-test's `db` client is in a transaction, but `pg` (root) client may not be
+    const isInTransaction = !input.useRoot;
+    // Wrap the entire query execution in a savepoint if we're in a transaction
+    // This matches v4 PostGraphile behavior where each mutation is wrapped in a savepoint
+    // allowing the transaction to continue after a database error
+    const executionSavepoint = isInTransaction
+        ? `graphile_exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+        : null;
+    if (executionSavepoint) {
+        await pgClient.query(`SAVEPOINT ${executionSavepoint}`);
+    }
+    let rawResult;
+    try {
+        // Execute using grafast's execute function - the v5 execution engine
+        rawResult = await (0, grafast_1.execute)({
             schema,
-            source: printed,
-            contextValue: { ...context, ...additionalContext, pgClient },
-            variableValues: variables ?? null
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset,
         });
-        return result;
-    });
+    }
+    catch (error) {
+        // Rollback to savepoint on execution error
+        if (executionSavepoint) {
+            await pgClient.query(`ROLLBACK TO SAVEPOINT ${executionSavepoint}`);
+        }
+        throw error;
+    }
+    // Handle streaming results (subscriptions return AsyncGenerator)
+    // For normal queries, we get ExecutionResult directly
+    if (Symbol.asyncIterator in rawResult) {
+        // This is a subscription/streaming result - not supported in test context
+        throw new Error('Streaming results (subscriptions) are not supported in test context');
+    }
+    const result = rawResult;
+    // If there were errors, rollback to savepoint to keep transaction usable
+    // This matches v4 behavior where database errors don't abort the transaction
+    if (executionSavepoint) {
+        if (result.errors && result.errors.length > 0) {
+            try {
+                await pgClient.query(`ROLLBACK TO SAVEPOINT ${executionSavepoint}`);
+            }
+            catch {
+                // Ignore if savepoint doesn't exist
+            }
+        }
+        else {
+            // Release the savepoint on success
+            await pgClient.query(`RELEASE SAVEPOINT ${executionSavepoint}`);
+        }
+    }
+    // Normalize the result to match v4 PostGraphile format for backward compatibility
+    return normalizeResult(result, document);
 };
 exports.runGraphQLInContext = runGraphQLInContext;
-// IS THIS BAD TO HAVE ROLE HERE 
+/**
+ * Set the PostgreSQL role and session settings on a client connection.
+ */
 async function setContextOnClient(pgClient, pgSettings, role) {
-    await pgClient.query(`select set_config('role', $1, true)`, [role]);
+    await pgClient.query('SELECT set_config($1, $2, true)', ['role', role]);
     for (const [key, value] of Object.entries(pgSettings)) {
-        await pgClient.query(`select set_config($1, $2, true)`, [key, String(value)]);
+        await pgClient.query('SELECT set_config($1, $2, true)', [key, String(value)]);
     }
 }

package/esm/clean.js

@@ -20,7 +20,7 @@ export const pruneDates = (row) => mapValues(row, (v, k) => {
     }
     return v;
 });
-export const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || (typeof k === 'string' && k.endsWith('_id'))) &&
+export const pruneIds = (row) => mapValues(row, (v, k) => (k === 'id' || k === 'rowId' || (typeof k === 'string' && k.endsWith('_id'))) &&
     (typeof v === 'string' || typeof v === 'number')
     ? idReplacement(v)
     : v);

package/esm/context.js

@@ -1,52 +1,238 @@
-import { graphql, print } from 'graphql';
-// @ts-ignore
-import MockReq from 'mock-req';
-import { withPostGraphileContext } from 'postgraphile';
-export const runGraphQLInContext = async ({ input, conn, pgPool, schema, options, authRole, query, variables, reqOptions = {} }) => {
+import { parse, print, Kind } from 'graphql';
+import { execute } from 'grafast';
+/**
+ * Find a field node in the document by following the path.
+ * This is used to derive locations when grafast doesn't provide them.
+ */
+function findFieldNodeByPath(document, path) {
+    if (!path || path.length === 0)
+        return null;
+    // Find the operation definition
+    const operation = document.definitions.find((def) => def.kind === Kind.OPERATION_DEFINITION);
+    if (!operation)
+        return null;
+    // Navigate through the path to find the field
+    let selections = operation.selectionSet.selections;
+    let fieldNode = null;
+    for (const segment of path) {
+        if (typeof segment === 'number') {
+            // Array index - skip, the field is still the same
+            continue;
+        }
+        // Find the field with this name
+        fieldNode = selections.find((sel) => sel.kind === Kind.FIELD && (sel.alias?.value ?? sel.name.value) === segment) ?? null;
+        if (!fieldNode)
+            return null;
+        // Move to nested selections if they exist
+        if (fieldNode.selectionSet) {
+            selections = fieldNode.selectionSet.selections;
+        }
+    }
+    return fieldNode;
+}
+/**
+ * Format a GraphQL error to match the v4 PostGraphile format.
+ *
+ * v5 grafast errors have different formatting:
+ * - They include `extensions: {}` even when empty
+ * - They may have `locations: undefined` instead of omitting the field
+ * - They don't always include locations even when nodes are available
+ *
+ * This normalizes errors to match v4 format for backward compatibility.
+ *
+ * @param error - The GraphQL error to format
+ * @param document - The original document (used to derive locations from path)
+ */
+function formatErrorToV4(error, document) {
+    const formatted = {
+        message: error.message,
+    };
+    // Try to get locations from the error directly first
+    let locations = error.locations;
+    // If no locations but nodes are available, try to extract from nodes
+    if ((!locations || locations.length === 0) && error.nodes && error.nodes.length > 0) {
+        const extractedLocations = error.nodes
+            .filter(node => node.loc)
+            .map(node => {
+            const loc = node.loc;
+            if (loc && loc.source) {
+                // Calculate line and column from the source
+                const { startToken } = loc;
+                if (startToken) {
+                    return { line: startToken.line, column: startToken.column };
+                }
+            }
+            return null;
+        })
+            .filter((loc) => loc !== null);
+        if (extractedLocations.length > 0) {
+            locations = extractedLocations;
+        }
+    }
+    // If still no locations and we have a path and document, try to derive from path
+    if ((!locations || locations.length === 0) && error.path && document) {
+        const fieldNode = findFieldNodeByPath(document, error.path);
+        if (fieldNode?.loc) {
+            const { startToken } = fieldNode.loc;
+            if (startToken) {
+                locations = [{ line: startToken.line, column: startToken.column }];
+            }
+        }
+    }
+    // Only include locations if it's a non-empty array
+    if (locations && Array.isArray(locations) && locations.length > 0) {
+        formatted.locations = locations;
+    }
+    // Only include path if it exists
+    if (error.path && error.path.length > 0) {
+        formatted.path = error.path;
+    }
+    // Only include extensions if it has non-empty content
+    if (error.extensions && Object.keys(error.extensions).length > 0) {
+        formatted.extensions = error.extensions;
+    }
+    return formatted;
+}
+/**
+ * Normalize an ExecutionResult to match v4 PostGraphile output format.
+ * This ensures backward compatibility with existing tests and consumers.
+ *
+ * @param result - The execution result from grafast
+ * @param document - The original document (used to derive locations from path)
+ */
+function normalizeResult(result, document) {
+    const normalized = {
+        data: result.data,
+    };
+    // Format errors to match v4 style
+    if (result.errors && result.errors.length > 0) {
+        normalized.errors = result.errors.map(err => formatErrorToV4(err, document));
+    }
+    // Only include extensions if present and non-empty
+    if (result.extensions && Object.keys(result.extensions).length > 0) {
+        normalized.extensions = result.extensions;
+    }
+    return normalized;
+}
+/**
+ * Execute a GraphQL query in the v5 context using grafast's execute function.
+ *
+ * This replaces the v4 withPostGraphileContext pattern with grafast execution.
+ * Uses execute() with withPgClient to ensure proper connection handling and pgSettings.
+ */
+export const runGraphQLInContext = async ({ input, conn, schema, resolvedPreset, pgService, authRole, query, variables, reqOptions = {}, }) => {
     if (!conn.pg.client) {
         throw new Error('pgClient is required and must be provided externally.');
     }
-    const { res: reqRes, ...restReqOptions } = reqOptions ?? {};
-    const req = new MockReq({
-        url: options.graphqlRoute || '/graphql',
-        method: 'POST',
-        headers: {
-            Accept: 'application/json',
-            'Content-Type': 'application/json'
-        },
-        ...restReqOptions
-    });
-    const res = reqRes ?? {};
-    const pgSettingsGenerator = options.pgSettings;
-    // @ts-ignore
-    const pgSettings = typeof pgSettingsGenerator === 'function'
-        ? await pgSettingsGenerator(req)
-        : pgSettingsGenerator || {};
-    const contextOptions = { ...options, pgPool, pgSettings, req, res };
-    // @ts-ignore
-    return await withPostGraphileContext(contextOptions, 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 additionalContext = typeof options.additionalGraphQLContextFromRequest === 'function'
-            ? await options.additionalGraphQLContextFromRequest(req, res)
-            : {};
-        const printed = typeof query === 'string' ? query : print(query);
-        const result = await graphql({
+    // Get the appropriate connection (root or database-specific)
+    const pgConn = input.useRoot ? conn.pg : conn.db;
+    const pgClient = pgConn.client;
+    // Build pgSettings by merging:
+    // 1. Context from db.setContext() (e.g., role, myapp.user_id)
+    // 2. Settings from reqOptions.pgSettings (explicit overrides)
+    // The role from getContext() takes precedence over authRole default
+    const dbContext = pgConn.getContext();
+    const reqPgSettings = reqOptions.pgSettings ?? {};
+    // Start with authRole as default, then apply db context, then request overrides
+    const pgSettings = {
+        role: authRole,
+        ...Object.fromEntries(Object.entries(dbContext).filter(([, v]) => v !== null)),
+        ...reqPgSettings,
+    };
+    // Set role and context on the client for direct queries
+    await setContextOnClient(pgClient, pgSettings, pgSettings.role);
+    await pgConn.ctxQuery();
+    // Convert query to DocumentNode if it's a string
+    // Also ensure we have location information for error reporting
+    let document;
+    if (typeof query === 'string') {
+        document = parse(query);
+    }
+    else {
+        // For DocumentNode (from graphql-tag), re-parse from source to get locations
+        // graphql-tag doesn't preserve location info by default
+        const source = print(query);
+        document = parse(source);
+    }
+    // Build context with pgSettings and withPgClient
+    // This is the v5 pattern used by executor.ts and api.ts
+    const contextValue = {
+        pgSettings,
+        // Include additional request options (excluding pgSettings to avoid duplication)
+        ...Object.fromEntries(Object.entries(reqOptions).filter(([key]) => key !== 'pgSettings')),
+    };
+    // Provide a custom withPgClient function that uses the test client
+    // This ensures GraphQL operations run within the test transaction
+    // instead of getting a new connection from the pool
+    const withPgClientKey = pgService.withPgClientKey ?? 'withPgClient';
+    contextValue[withPgClientKey] = async (_pgSettings, callback) => {
+        // Simply use the test client - it's already in a transaction
+        // The pgSettings have already been applied above via setContextOnClient
+        return callback(pgClient);
+    };
+    // Check if we're in a transaction by looking at the test client's transaction state
+    // When useRoot is true, we might not be in a transaction
+    // pgsql-test's `db` client is in a transaction, but `pg` (root) client may not be
+    const isInTransaction = !input.useRoot;
+    // Wrap the entire query execution in a savepoint if we're in a transaction
+    // This matches v4 PostGraphile behavior where each mutation is wrapped in a savepoint
+    // allowing the transaction to continue after a database error
+    const executionSavepoint = isInTransaction
+        ? `graphile_exec_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+        : null;
+    if (executionSavepoint) {
+        await pgClient.query(`SAVEPOINT ${executionSavepoint}`);
+    }
+    let rawResult;
+    try {
+        // Execute using grafast's execute function - the v5 execution engine
+        rawResult = await execute({
             schema,
-            source: printed,
-            contextValue: { ...context, ...additionalContext, pgClient },
-            variableValues: variables ?? null
+            document,
+            variableValues: variables ?? undefined,
+            contextValue,
+            resolvedPreset,
         });
-        return result;
-    });
+    }
+    catch (error) {
+        // Rollback to savepoint on execution error
+        if (executionSavepoint) {
+            await pgClient.query(`ROLLBACK TO SAVEPOINT ${executionSavepoint}`);
+        }
+        throw error;
+    }
+    // Handle streaming results (subscriptions return AsyncGenerator)
+    // For normal queries, we get ExecutionResult directly
+    if (Symbol.asyncIterator in rawResult) {
+        // This is a subscription/streaming result - not supported in test context
+        throw new Error('Streaming results (subscriptions) are not supported in test context');
+    }
+    const result = rawResult;
+    // If there were errors, rollback to savepoint to keep transaction usable
+    // This matches v4 behavior where database errors don't abort the transaction
+    if (executionSavepoint) {
+        if (result.errors && result.errors.length > 0) {
+            try {
+                await pgClient.query(`ROLLBACK TO SAVEPOINT ${executionSavepoint}`);
+            }
+            catch {
+                // Ignore if savepoint doesn't exist
+            }
+        }
+        else {
+            // Release the savepoint on success
+            await pgClient.query(`RELEASE SAVEPOINT ${executionSavepoint}`);
+        }
+    }
+    // Normalize the result to match v4 PostGraphile format for backward compatibility
+    return normalizeResult(result, document);
 };
-// IS THIS BAD TO HAVE ROLE HERE 
+/**
+ * Set the PostgreSQL role and session settings on a client connection.
+ */
 export async function setContextOnClient(pgClient, pgSettings, role) {
-    await pgClient.query(`select set_config('role', $1, true)`, [role]);
+    await pgClient.query('SELECT set_config($1, $2, true)', ['role', role]);
     for (const [key, value] of Object.entries(pgSettings)) {
-        await pgClient.query(`select set_config($1, $2, true)`, [key, String(value)]);
+        await pgClient.query('SELECT set_config($1, $2, true)', [key, String(value)]);
     }
 }

package/esm/get-connections.js

@@ -28,7 +28,7 @@ const createConnectionsBase = async (input, seedAdapters) => {
         teardown,
         baseQuery,
         baseQueryPositional,
-        gqlContext
+        gqlContext,
     };
 };
 // ============================================================================
@@ -44,7 +44,7 @@ export const getConnectionsObject = async (input, seedAdapters) => {
         db,
         teardown,
         query: baseQuery,
-        gqlContext
+        gqlContext,
     };
 };
 /**
@@ -57,7 +57,7 @@ export const getConnectionsObjectUnwrapped = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 /**
@@ -75,7 +75,7 @@ export const getConnectionsObjectWithLogging = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 /**
@@ -94,7 +94,7 @@ export const getConnectionsObjectWithTiming = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 // ============================================================================
@@ -109,7 +109,7 @@ export const getConnections = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query: baseQueryPositional
+        query: baseQueryPositional,
     };
 };
 /**
@@ -117,12 +117,12 @@ export const getConnections = async (input, seedAdapters) => {
  */
 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));
+    const query = async (queryDoc, variables, commit, reqOptions) => unwrap(await baseQueryPositional(queryDoc, variables, commit, reqOptions));
     return {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 /**
@@ -130,9 +130,9 @@ export const getConnectionsUnwrapped = async (input, seedAdapters) => {
  */
 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);
+    const query = async (queryDoc, variables, commit, reqOptions) => {
+        console.log('Executing positional GraphQL query:', queryDoc);
+        const result = await baseQueryPositional(queryDoc, variables, commit, reqOptions);
         console.log('GraphQL result:', result);
         return result;
     };
@@ -140,7 +140,7 @@ export const getConnectionsWithLogging = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 /**
@@ -148,9 +148,9 @@ export const getConnectionsWithLogging = async (input, seedAdapters) => {
  */
 export const getConnectionsWithTiming = async (input, seedAdapters) => {
     const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
-    const query = async (query, variables, commit, reqOptions) => {
+    const query = async (queryDoc, variables, commit, reqOptions) => {
         const start = Date.now();
-        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        const result = await baseQueryPositional(queryDoc, variables, commit, reqOptions);
         const duration = Date.now() - start;
         console.log(`Positional GraphQL query took ${duration}ms`);
         return result;
@@ -159,6 +159,6 @@ export const getConnectionsWithTiming = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };

package/esm/graphile-test.js

@@ -1,42 +1,73 @@
-import { createPostGraphileSchema } from 'postgraphile';
+import { makeSchema } from 'graphile-build';
+import { defaultPreset as graphileBuildDefaultPreset } from 'graphile-build';
+import { defaultPreset as graphileBuildPgDefaultPreset } from 'graphile-build-pg';
+import { makePgService } from 'postgraphile/adaptors/pg';
 import { runGraphQLInContext } from './context';
+/**
+ * Minimal preset that provides core functionality without Node/Relay.
+ * This matches the pattern from graphile-settings.
+ */
+const MinimalPreset = {
+    extends: [graphileBuildDefaultPreset, graphileBuildPgDefaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+/**
+ * Creates a GraphQL test context using PostGraphile v5 preset-based API.
+ *
+ * @param input - Configuration including schemas and optional preset
+ * @param conn - Database connection result from pgsql-test
+ * @returns GraphQL test context with setup, teardown, and query functions
+ */
 export const GraphQLTest = (input, conn) => {
-    const { schemas, authRole, graphile } = input;
+    const { schemas, authRole, preset: userPreset } = input;
     let schema;
-    let options;
+    let resolvedPreset;
+    let pgService;
     const pgPool = conn.manager.getPool(conn.pg.config);
     const setup = async () => {
-        // Bare-bones configuration - no defaults, only use what's explicitly provided
-        // This gives full control over PostGraphile configuration
-        options = {
-            schema: schemas,
-            // Only apply graphile options if explicitly provided
-            ...(graphile?.appendPlugins && {
-                appendPlugins: graphile.appendPlugins
-            }),
-            ...(graphile?.graphileBuildOptions && {
-                graphileBuildOptions: graphile.graphileBuildOptions
-            }),
-            // Apply any overrideSettings if provided
-            ...(graphile?.overrideSettings || {})
+        // Create the pgService - this will be used for withPgClient
+        pgService = makePgService({
+            pool: pgPool,
+            schemas,
+        });
+        // Build the complete preset by extending the minimal preset
+        // with user-provided preset configuration
+        const completePreset = {
+            extends: [
+                MinimalPreset,
+                ...(userPreset?.extends ?? []),
+            ],
+            ...(userPreset?.disablePlugins && { disablePlugins: userPreset.disablePlugins }),
+            ...(userPreset?.plugins && { plugins: userPreset.plugins }),
+            ...(userPreset?.schema && { schema: userPreset.schema }),
+            ...(userPreset?.grafast && { grafast: userPreset.grafast }),
+            pgServices: [pgService],
         };
-        schema = await createPostGraphileSchema(pgPool, schemas, options);
+        // Use makeSchema from graphile-build to create the schema
+        const result = await makeSchema(completePreset);
+        schema = result.schema;
+        resolvedPreset = result.resolvedPreset;
+    };
+    const teardown = async () => {
+        // Optional cleanup - schema is garbage collected
     };
-    const teardown = async () => { };
     const query = async (opts) => {
         return await runGraphQLInContext({
             input,
             schema,
-            options,
-            authRole,
+            resolvedPreset,
+            authRole: authRole ?? 'anonymous',
             pgPool,
+            pgService,
             conn,
-            ...opts
+            query: opts.query,
+            variables: opts.variables,
+            reqOptions: opts.reqOptions,
         });
     };
     return {
         setup,
         teardown,
-        query
+        query,
     };
 };

package/esm/index.js

@@ -1,5 +1,4 @@
-export * from './context';
-export * from './get-connections';
-export * from './graphile-test';
-export * from './types';
+export { runGraphQLInContext, setContextOnClient } from './context';
+export { getConnections, getConnectionsObject, getConnectionsObjectUnwrapped, getConnectionsObjectWithLogging, getConnectionsObjectWithTiming, getConnectionsUnwrapped, getConnectionsWithLogging, getConnectionsWithTiming, } from './get-connections';
+export { GraphQLTest } from './graphile-test';
 export { seed, snapshot } from 'pgsql-test';

package/get-connections.js

@@ -31,7 +31,7 @@ const createConnectionsBase = async (input, seedAdapters) => {
         teardown,
         baseQuery,
         baseQueryPositional,
-        gqlContext
+        gqlContext,
     };
 };
 // ============================================================================
@@ -47,7 +47,7 @@ const getConnectionsObject = async (input, seedAdapters) => {
         db,
         teardown,
         query: baseQuery,
-        gqlContext
+        gqlContext,
     };
 };
 exports.getConnectionsObject = getConnectionsObject;
@@ -61,7 +61,7 @@ const getConnectionsObjectUnwrapped = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsObjectUnwrapped = getConnectionsObjectUnwrapped;
@@ -80,7 +80,7 @@ const getConnectionsObjectWithLogging = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsObjectWithLogging = getConnectionsObjectWithLogging;
@@ -100,7 +100,7 @@ const getConnectionsObjectWithTiming = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsObjectWithTiming = getConnectionsObjectWithTiming;
@@ -116,7 +116,7 @@ const getConnections = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query: baseQueryPositional
+        query: baseQueryPositional,
     };
 };
 exports.getConnections = getConnections;
@@ -125,12 +125,12 @@ exports.getConnections = getConnections;
  */
 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));
+    const query = async (queryDoc, variables, commit, reqOptions) => unwrap(await baseQueryPositional(queryDoc, variables, commit, reqOptions));
     return {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsUnwrapped = getConnectionsUnwrapped;
@@ -139,9 +139,9 @@ exports.getConnectionsUnwrapped = getConnectionsUnwrapped;
  */
 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);
+    const query = async (queryDoc, variables, commit, reqOptions) => {
+        console.log('Executing positional GraphQL query:', queryDoc);
+        const result = await baseQueryPositional(queryDoc, variables, commit, reqOptions);
         console.log('GraphQL result:', result);
         return result;
     };
@@ -149,7 +149,7 @@ const getConnectionsWithLogging = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsWithLogging = getConnectionsWithLogging;
@@ -158,9 +158,9 @@ exports.getConnectionsWithLogging = getConnectionsWithLogging;
  */
 const getConnectionsWithTiming = async (input, seedAdapters) => {
     const { pg, db, teardown, baseQueryPositional } = await createConnectionsBase(input, seedAdapters);
-    const query = async (query, variables, commit, reqOptions) => {
+    const query = async (queryDoc, variables, commit, reqOptions) => {
         const start = Date.now();
-        const result = await baseQueryPositional(query, variables, commit, reqOptions);
+        const result = await baseQueryPositional(queryDoc, variables, commit, reqOptions);
         const duration = Date.now() - start;
         console.log(`Positional GraphQL query took ${duration}ms`);
         return result;
@@ -169,7 +169,7 @@ const getConnectionsWithTiming = async (input, seedAdapters) => {
         pg,
         db,
         teardown,
-        query
+        query,
     };
 };
 exports.getConnectionsWithTiming = getConnectionsWithTiming;

package/graphile-test.d.ts

@@ -1,4 +1,10 @@
-import { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
-import type { GraphQLTestContext } from './types';
-import { GetConnectionsInput } from './types';
+import type { GetConnectionOpts, GetConnectionResult } from 'pgsql-test';
+import type { GraphQLTestContext, GetConnectionsInput } from './types';
+/**
+ * Creates a GraphQL test context using PostGraphile v5 preset-based API.
+ *
+ * @param input - Configuration including schemas and optional preset
+ * @param conn - Database connection result from pgsql-test
+ * @returns GraphQL test context with setup, teardown, and query functions
+ */
 export declare const GraphQLTest: (input: GetConnectionsInput & GetConnectionOpts, conn: GetConnectionResult) => GraphQLTestContext;

package/graphile-test.js

@@ -1,46 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphQLTest = void 0;
-const postgraphile_1 = require("postgraphile");
+const graphile_build_1 = require("graphile-build");
+const graphile_build_2 = require("graphile-build");
+const graphile_build_pg_1 = require("graphile-build-pg");
+const pg_1 = require("postgraphile/adaptors/pg");
 const context_1 = require("./context");
+/**
+ * Minimal preset that provides core functionality without Node/Relay.
+ * This matches the pattern from graphile-settings.
+ */
+const MinimalPreset = {
+    extends: [graphile_build_2.defaultPreset, graphile_build_pg_1.defaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+/**
+ * Creates a GraphQL test context using PostGraphile v5 preset-based API.
+ *
+ * @param input - Configuration including schemas and optional preset
+ * @param conn - Database connection result from pgsql-test
+ * @returns GraphQL test context with setup, teardown, and query functions
+ */
 const GraphQLTest = (input, conn) => {
-    const { schemas, authRole, graphile } = input;
+    const { schemas, authRole, preset: userPreset } = input;
     let schema;
-    let options;
+    let resolvedPreset;
+    let pgService;
     const pgPool = conn.manager.getPool(conn.pg.config);
     const setup = async () => {
-        // Bare-bones configuration - no defaults, only use what's explicitly provided
-        // This gives full control over PostGraphile configuration
-        options = {
-            schema: schemas,
-            // Only apply graphile options if explicitly provided
-            ...(graphile?.appendPlugins && {
-                appendPlugins: graphile.appendPlugins
-            }),
-            ...(graphile?.graphileBuildOptions && {
-                graphileBuildOptions: graphile.graphileBuildOptions
-            }),
-            // Apply any overrideSettings if provided
-            ...(graphile?.overrideSettings || {})
+        // Create the pgService - this will be used for withPgClient
+        pgService = (0, pg_1.makePgService)({
+            pool: pgPool,
+            schemas,
+        });
+        // Build the complete preset by extending the minimal preset
+        // with user-provided preset configuration
+        const completePreset = {
+            extends: [
+                MinimalPreset,
+                ...(userPreset?.extends ?? []),
+            ],
+            ...(userPreset?.disablePlugins && { disablePlugins: userPreset.disablePlugins }),
+            ...(userPreset?.plugins && { plugins: userPreset.plugins }),
+            ...(userPreset?.schema && { schema: userPreset.schema }),
+            ...(userPreset?.grafast && { grafast: userPreset.grafast }),
+            pgServices: [pgService],
         };
-        schema = await (0, postgraphile_1.createPostGraphileSchema)(pgPool, schemas, options);
+        // Use makeSchema from graphile-build to create the schema
+        const result = await (0, graphile_build_1.makeSchema)(completePreset);
+        schema = result.schema;
+        resolvedPreset = result.resolvedPreset;
+    };
+    const teardown = async () => {
+        // Optional cleanup - schema is garbage collected
     };
-    const teardown = async () => { };
     const query = async (opts) => {
         return await (0, context_1.runGraphQLInContext)({
             input,
             schema,
-            options,
-            authRole,
+            resolvedPreset,
+            authRole: authRole ?? 'anonymous',
             pgPool,
+            pgService,
             conn,
-            ...opts
+            query: opts.query,
+            variables: opts.variables,
+            reqOptions: opts.reqOptions,
         });
     };
     return {
         setup,
         teardown,
-        query
+        query,
     };
 };
 exports.GraphQLTest = GraphQLTest;

package/index.d.ts

@@ -1,5 +1,5 @@
-export * from './context';
-export * from './get-connections';
-export * from './graphile-test';
-export * from './types';
+export { runGraphQLInContext, setContextOnClient } from './context';
+export { getConnections, getConnectionsObject, getConnectionsObjectUnwrapped, getConnectionsObjectWithLogging, getConnectionsObjectWithTiming, getConnectionsUnwrapped, getConnectionsWithLogging, getConnectionsWithTiming, } from './get-connections';
+export { GraphQLTest } from './graphile-test';
+export type { GetConnectionsInput, GraphQLQueryFn, GraphQLQueryFnObj, GraphQLQueryOptions, GraphQLQueryUnwrappedFn, GraphQLQueryUnwrappedFnObj, GraphQLResponse, GraphQLTestContext, LegacyGraphileOptions, Variables, } from './types';
 export { seed, snapshot } from 'pgsql-test';

package/index.js

@@ -1,24 +1,20 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.snapshot = exports.seed = void 0;
-__exportStar(require("./context"), exports);
-__exportStar(require("./get-connections"), exports);
-__exportStar(require("./graphile-test"), exports);
-__exportStar(require("./types"), exports);
+exports.snapshot = exports.seed = exports.GraphQLTest = exports.getConnectionsWithTiming = exports.getConnectionsWithLogging = exports.getConnectionsUnwrapped = exports.getConnectionsObjectWithTiming = exports.getConnectionsObjectWithLogging = exports.getConnectionsObjectUnwrapped = exports.getConnectionsObject = exports.getConnections = exports.setContextOnClient = exports.runGraphQLInContext = void 0;
+var context_1 = require("./context");
+Object.defineProperty(exports, "runGraphQLInContext", { enumerable: true, get: function () { return context_1.runGraphQLInContext; } });
+Object.defineProperty(exports, "setContextOnClient", { enumerable: true, get: function () { return context_1.setContextOnClient; } });
+var get_connections_1 = require("./get-connections");
+Object.defineProperty(exports, "getConnections", { enumerable: true, get: function () { return get_connections_1.getConnections; } });
+Object.defineProperty(exports, "getConnectionsObject", { enumerable: true, get: function () { return get_connections_1.getConnectionsObject; } });
+Object.defineProperty(exports, "getConnectionsObjectUnwrapped", { enumerable: true, get: function () { return get_connections_1.getConnectionsObjectUnwrapped; } });
+Object.defineProperty(exports, "getConnectionsObjectWithLogging", { enumerable: true, get: function () { return get_connections_1.getConnectionsObjectWithLogging; } });
+Object.defineProperty(exports, "getConnectionsObjectWithTiming", { enumerable: true, get: function () { return get_connections_1.getConnectionsObjectWithTiming; } });
+Object.defineProperty(exports, "getConnectionsUnwrapped", { enumerable: true, get: function () { return get_connections_1.getConnectionsUnwrapped; } });
+Object.defineProperty(exports, "getConnectionsWithLogging", { enumerable: true, get: function () { return get_connections_1.getConnectionsWithLogging; } });
+Object.defineProperty(exports, "getConnectionsWithTiming", { enumerable: true, get: function () { return get_connections_1.getConnectionsWithTiming; } });
+var graphile_test_1 = require("./graphile-test");
+Object.defineProperty(exports, "GraphQLTest", { enumerable: true, get: function () { return graphile_test_1.GraphQLTest; } });
 var pgsql_test_1 = require("pgsql-test");
 Object.defineProperty(exports, "seed", { enumerable: true, get: function () { return pgsql_test_1.seed; } });
 Object.defineProperty(exports, "snapshot", { enumerable: true, get: function () { return pgsql_test_1.snapshot; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-test",
-  "version": "3.1.0",
+  "version": "4.0.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostGraphile Testing",
   "main": "index.js",
@@ -31,17 +31,21 @@
   "devDependencies": {
     "@types/pg": "^8.16.0",
     "graphql-tag": "2.12.6",
-    "makage": "^0.1.12"
+    "makage": "^0.1.10"
   },
   "dependencies": {
-    "@constructive-io/graphql-env": "^2.10.0",
-    "@constructive-io/graphql-types": "^2.15.0",
+    "@constructive-io/graphql-env": "^3.0.0",
+    "@constructive-io/graphql-types": "^3.0.0",
     "@pgpmjs/types": "^2.16.0",
-    "graphql": "15.10.1",
+    "grafast": "^1.0.0-rc.4",
+    "graphile-build": "^5.0.0-rc.3",
+    "graphile-build-pg": "^5.0.0-rc.3",
+    "graphile-config": "1.0.0-rc.3",
+    "graphql": "^16.9.0",
     "mock-req": "^0.2.0",
     "pg": "^8.17.1",
-    "pgsql-test": "^3.1.0",
-    "postgraphile": "^4.14.1"
+    "pgsql-test": "^4.0.0",
+    "postgraphile": "^5.0.0-rc.4"
   },
   "keywords": [
     "testing",
@@ -51,5 +55,5 @@
     "pgpm",
     "test"
   ],
-  "gitHead": "048188f6b43ffaa6146e7694b2b0d35d34cb2945"
+  "gitHead": "b2daeefe49cdefb3d01ea63cf778fb9b847ab5fe"
 }

package/types.d.ts

@@ -1,33 +1,81 @@
-import type { GraphileOptions } from '@constructive-io/graphql-types';
-import { DocumentNode, GraphQLError } from 'graphql';
-export interface GraphQLQueryOptions<TVariables = Record<string, any>> {
+import type { GraphileConfig } from 'graphile-config';
+import type { DocumentNode, GraphQLError } from 'graphql';
+/**
+ * Variables type that accepts plain objects and interfaces without requiring
+ * an explicit index signature. Using `Record<string, any>` allows TypeScript
+ * to accept typed interfaces like { username: string } since `any` is bi-directionally
+ * assignable to all types.
+ */
+export type Variables = Record<string, any>;
+export interface GraphQLQueryOptions<TVariables extends Variables = Variables> {
     query: string | DocumentNode;
     variables?: TVariables;
     commit?: boolean;
-    reqOptions?: Record<string, any>;
+    reqOptions?: Record<string, unknown>;
 }
 export interface GraphQLTestContext {
     setup: () => Promise<void>;
     teardown: () => Promise<void>;
-    query: <TResult = any, TVariables = Record<string, any>>(opts: GraphQLQueryOptions<TVariables>) => Promise<TResult>;
+    query: <TResult = unknown, TVariables extends Variables = Variables>(opts: GraphQLQueryOptions<TVariables>) => Promise<TResult>;
 }
+/**
+ * Legacy v4-style GraphQL options for backward compatibility.
+ *
+ * @deprecated Use `preset` instead for v5 configuration.
+ */
+export interface LegacyGraphileOptions {
+    /**
+     * V4-style plugins to append.
+     * These plugins use the builder.hook() API which is NOT compatible with v5.
+     * For v5, convert these to proper v5 plugins and use the `preset` option instead.
+     *
+     * @deprecated Use preset.plugins for v5 plugins
+     */
+    appendPlugins?: any[];
+    /**
+     * V4-style graphile build options.
+     *
+     * @deprecated Use preset.schema for v5 schema options
+     */
+    graphileBuildOptions?: Record<string, any>;
+    /**
+     * V4-style PostGraphile options override.
+     *
+     * @deprecated Use preset for v5 configuration
+     */
+    overrideSettings?: Record<string, any>;
+}
+/**
+ * Input for GraphQL test connections.
+ *
+ * Supports both v5 preset-based configuration (recommended) and
+ * legacy v4-style configuration (deprecated, for backward compatibility).
+ */
 export interface GetConnectionsInput {
     useRoot?: boolean;
     schemas: string[];
     authRole?: string;
-    graphile?: GraphileOptions;
-}
-export interface GraphQLQueryOptions<TVariables = Record<string, any>> {
-    query: string | DocumentNode;
-    variables?: TVariables;
-    commit?: boolean;
-    reqOptions?: Record<string, any>;
+    /**
+     * V5 preset configuration (recommended).
+     * Can include extends, plugins, schema options, etc.
+     */
+    preset?: GraphileConfig.Preset;
+    /**
+     * Legacy v4-style graphile options for backward compatibility.
+     *
+     * NOTE: v4-style plugins (using builder.hook()) are NOT compatible with v5.
+     * If you use appendPlugins with v4 plugins, they will be ignored.
+     * Convert your plugins to v5 format and use the `preset` option instead.
+     *
+     * @deprecated Use preset for v5 configuration
+     */
+    graphile?: LegacyGraphileOptions;
 }
 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>;
+export type GraphQLQueryFnObj = <TResult = unknown, TVariables extends Variables = Variables>(opts: GraphQLQueryOptions<TVariables>) => Promise<GraphQLResponse<TResult>>;
+export type GraphQLQueryFn = <TResult = unknown, TVariables extends Variables = Variables>(query: string | DocumentNode, variables?: TVariables, commit?: boolean, reqOptions?: Record<string, unknown>) => Promise<GraphQLResponse<TResult>>;
+export type GraphQLQueryUnwrappedFnObj = <TResult = unknown, TVariables extends Variables = Variables>(opts: GraphQLQueryOptions<TVariables>) => Promise<TResult>;
+export type GraphQLQueryUnwrappedFn = <TResult = unknown, TVariables extends Variables = Variables>(query: string | DocumentNode, variables?: TVariables, commit?: boolean, reqOptions?: Record<string, unknown>) => Promise<TResult>;