graphile-realtime-test 0.3.0 → 0.6.0

package/esm/get-connections.js

@@ -0,0 +1,116 @@
+import { getConnections as getPgConnections } from 'pgsql-test';
+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 { createRealtimeSubscriptionsPlugin } from 'graphile-realtime-subscriptions';
+import { makeRealtimeSmartTagsPlugin } from './smart-tags.js';
+import { createWsTestServer } from './ws-server.js';
+import { nextEvent, collectWsEvents, delay } from './ws-helpers.js';
+import { notify, notifyChange, notifyInvalidate } from './notify.js';
+// --- Types ---
+const MinimalPreset = {
+    extends: [graphileBuildDefaultPreset, graphileBuildPgDefaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+// --- Implementation ---
+export async function getConnections(input, seedAdapters) {
+    const { schemas, preset: userPreset, smartTags, realtimeTables, realtimeOptions, buildPgSettings, } = input;
+    // 1. Database connections (pgsql-test layer)
+    const conn = await getPgConnections(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    const pgPool = conn.manager.getPool(conn.pg.config);
+    // 2. Smart tags
+    const smartTagsMap = {
+        ...(smartTags ?? {}),
+    };
+    for (const table of realtimeTables ?? []) {
+        if (!smartTagsMap[table]) {
+            smartTagsMap[table] = {};
+        }
+        smartTagsMap[table].realtime = true;
+    }
+    const smartTagsPlugin = makeRealtimeSmartTagsPlugin(smartTagsMap);
+    const realtimePlugin = createRealtimeSubscriptionsPlugin(realtimeOptions);
+    // 3. Graphile schema (graphile-test layer)
+    const pgService = makePgService({
+        pool: pgPool,
+        schemas,
+    });
+    const completePreset = {
+        extends: [
+            MinimalPreset,
+            ...(userPreset?.extends ?? []),
+        ],
+        ...(userPreset?.disablePlugins && { disablePlugins: userPreset.disablePlugins }),
+        plugins: [
+            ...(userPreset?.plugins ?? []),
+            smartTagsPlugin,
+            realtimePlugin,
+        ],
+        ...(userPreset?.schema && { schema: userPreset.schema }),
+        ...(userPreset?.grafast && { grafast: userPreset.grafast }),
+        pgServices: [pgService],
+    };
+    const result = await makeSchema(completePreset);
+    const schema = result.schema;
+    const resolvedPreset = result.resolvedPreset;
+    const pgSubscriber = pgService.pgSubscriber;
+    const pgSubscriberKey = pgService.pgSubscriberKey ?? 'pgSubscriber';
+    // 4. WebSocket server (realtime layer)
+    const wsServer = await createWsTestServer({
+        schema,
+        resolvedPreset,
+        pgSubscriber,
+        pgSubscriberKey,
+        buildPgSettings,
+    });
+    await delay(300);
+    // 5. WS handle
+    const ws = {
+        serverUrl: wsServer.serverUrl,
+        createClient: (connectionParams) => wsServer.createClient(connectionParams),
+        nextEvent: (client, query, variables, timeoutMs) => nextEvent(client, query, variables, timeoutMs),
+        collectEvents: (client, query, variables) => collectWsEvents(client, query, variables),
+        dispose: () => wsServer.dispose(),
+    };
+    // 6. Notify helpers
+    const defaultSchema = schemas[0] ?? 'public';
+    const notifyClient = pg.client;
+    // 7. Teardown (idempotent)
+    let tornDown = false;
+    const teardown = async () => {
+        if (tornDown)
+            return;
+        tornDown = true;
+        // Order: clients -> server -> subscriber -> service -> pool -> db
+        await wsServer.dispose();
+        if (pgSubscriber && typeof pgSubscriber.release === 'function') {
+            await pgSubscriber.release();
+        }
+        if (pgService && typeof pgService.release === 'function') {
+            await pgService.release();
+        }
+        await dbTeardown();
+    };
+    return {
+        pg,
+        db,
+        schema,
+        resolvedPreset,
+        pgPool,
+        pgService,
+        pgSubscriber,
+        ws,
+        async notifyChange(table, operation, rowIds, tableSchema) {
+            await notifyChange(notifyClient, tableSchema ?? defaultSchema, table, operation, rowIds);
+        },
+        async notifyInvalidate(table, tableSchema) {
+            await notifyInvalidate(notifyClient, tableSchema ?? defaultSchema, table);
+        },
+        async notify(table, payload, tableSchema) {
+            await notify(notifyClient, tableSchema ?? defaultSchema, table, payload);
+        },
+        teardown,
+    };
+}

package/esm/index.js

@@ -2,3 +2,6 @@ export { createRealtimeTestContext } from './context.js';
 export { makeRealtimeSmartTagsPlugin } from './smart-tags.js';
 export { subscribe, waitForEvent, collectEvents, } from './subscribe.js';
 export { notify, notifyChange, notifyInvalidate, buildPayload, buildInvalidatePayload, } from './notify.js';
+export { nextEvent, collectWsEvents, delay } from './ws-helpers.js';
+export { createWsTestServer } from './ws-server.js';
+export { getConnections } from './get-connections.js';

package/esm/ws-helpers.js

@@ -0,0 +1,48 @@
+/**
+ * Collect the next event from a graphql-ws WebSocket subscription.
+ *
+ * Returns a promise that resolves with the first `next` payload's `data`,
+ * or rejects on error / timeout. The subscription is automatically
+ * unsubscribed after the first event.
+ */
+export function nextEvent(client, query, variables, timeoutMs = 10000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            unsubscribe();
+            reject(new Error(`nextEvent timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const unsubscribe = client.subscribe({ query, variables }, {
+            next(value) {
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(value.data);
+            },
+            error(err) {
+                clearTimeout(timer);
+                unsubscribe();
+                reject(Array.isArray(err) ? err[0] : err);
+            },
+            complete() {
+                clearTimeout(timer);
+                reject(new Error('Subscription completed without yielding a value'));
+            },
+        });
+    });
+}
+/**
+ * Subscribe and collect events into an array until `unsubscribe()` is called.
+ *
+ * Useful for assertions that need to inspect multiple events after the fact.
+ */
+export function collectWsEvents(client, query, variables) {
+    const events = [];
+    const unsubscribe = client.subscribe({ query, variables }, {
+        next(value) {
+            events.push(value.data);
+        },
+        error() { },
+        complete() { },
+    });
+    return { events, unsubscribe };
+}
+export const delay = (ms) => new Promise((r) => setTimeout(r, ms));

package/esm/ws-server.js

@@ -0,0 +1,73 @@
+import { createServer } from 'node:http';
+import { subscribe as grafastSubscribe } from 'grafast';
+import { createClient } from 'graphql-ws';
+import { useServer } from 'graphql-ws/use/ws';
+import { WebSocketServer, WebSocket } from 'ws';
+export async function createWsTestServer(input) {
+    const { schema, resolvedPreset, pgSubscriber, pgSubscriberKey = 'pgSubscriber', buildPgSettings, } = input;
+    const httpServer = createServer();
+    const wss = new WebSocketServer({ server: httpServer, path: '/graphql' });
+    const serverCleanup = useServer({
+        schema,
+        context: async (ctx) => ({
+            connectionParams: ctx.connectionParams,
+        }),
+        subscribe: async (args) => {
+            const params = args.contextValue?.connectionParams;
+            const contextValue = {
+                [pgSubscriberKey]: pgSubscriber,
+                ...(typeof args.contextValue === 'object' && args.contextValue !== null
+                    ? args.contextValue
+                    : {}),
+            };
+            if (buildPgSettings && params) {
+                const pgSettings = buildPgSettings(params);
+                if (pgSettings) {
+                    contextValue['pgSettings'] = pgSettings;
+                }
+            }
+            const result = await grafastSubscribe({
+                schema: args.schema,
+                document: args.document,
+                variableValues: args.variableValues,
+                contextValue,
+                resolvedPreset,
+            });
+            return result;
+        },
+    }, wss);
+    await new Promise((resolve) => {
+        httpServer.listen(0, '127.0.0.1', () => resolve());
+    });
+    const addr = httpServer.address();
+    const serverUrl = `ws://127.0.0.1:${addr.port}/graphql`;
+    const clients = [];
+    return {
+        serverUrl,
+        httpServer,
+        wss,
+        createClient(connectionParams) {
+            const client = createClient({
+                url: serverUrl,
+                webSocketImpl: WebSocket,
+                retryAttempts: 0,
+                connectionParams,
+            });
+            clients.push(client);
+            return client;
+        },
+        async dispose() {
+            for (const client of clients) {
+                try {
+                    await client.dispose();
+                }
+                catch { /* ignore */ }
+            }
+            await serverCleanup.dispose();
+            wss.close();
+            if (httpServer.listening) {
+                await new Promise((resolve) => httpServer.close(() => resolve()));
+            }
+        },
+    };
+}

package/get-connections.d.ts

@@ -0,0 +1,45 @@
+import type { GraphQLSchema } from 'graphql';
+import type { GraphileConfig } from 'graphile-config';
+import type { GetConnectionOpts } from 'pgsql-test';
+import type { SeedAdapter } from 'pgsql-test/seed/types';
+import type { PgTestClient } from 'pgsql-test/test-client';
+import type { Pool } from 'pg';
+import type { Client as GqlWsClient } from 'graphql-ws';
+import { makePgService } from 'postgraphile/adaptors/pg';
+export interface GetConnectionsInput extends GetConnectionOpts {
+    schemas: string[];
+    authRole?: string;
+    useRoot?: boolean;
+    preset?: GraphileConfig.Preset;
+    smartTags?: Record<string, Record<string, unknown>>;
+    realtimeTables?: string[];
+    realtimeOptions?: {
+        overflowThreshold?: number;
+    };
+    buildPgSettings?: (connectionParams: Record<string, string>) => Record<string, string> | undefined;
+}
+export interface WsHandle {
+    serverUrl: string;
+    createClient(connectionParams?: Record<string, unknown>): GqlWsClient;
+    nextEvent<T = Record<string, unknown>>(client: GqlWsClient, query: string, variables?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+    collectEvents<T = Record<string, unknown>>(client: GqlWsClient, query: string, variables?: Record<string, unknown>): {
+        events: T[];
+        unsubscribe: () => void;
+    };
+    dispose(): Promise<void>;
+}
+export interface GetConnectionsResult {
+    pg: PgTestClient;
+    db: PgTestClient;
+    schema: GraphQLSchema;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
+    pgPool: Pool;
+    pgService: ReturnType<typeof makePgService>;
+    pgSubscriber: unknown;
+    ws: WsHandle;
+    notifyChange(table: string, operation: 'INSERT' | 'UPDATE' | 'DELETE', rowIds: string[], schema?: string): Promise<void>;
+    notifyInvalidate(table: string, schema?: string): Promise<void>;
+    notify(table: string, payload: string, schema?: string): Promise<void>;
+    teardown(): Promise<void>;
+}
+export declare function getConnections(input: GetConnectionsInput, seedAdapters?: SeedAdapter[]): Promise<GetConnectionsResult>;

package/get-connections.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnections = getConnections;
+const pgsql_test_1 = require("pgsql-test");
+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 graphile_realtime_subscriptions_1 = require("graphile-realtime-subscriptions");
+const smart_tags_js_1 = require("./smart-tags.js");
+const ws_server_js_1 = require("./ws-server.js");
+const ws_helpers_js_1 = require("./ws-helpers.js");
+const notify_js_1 = require("./notify.js");
+// --- Types ---
+const MinimalPreset = {
+    extends: [graphile_build_2.defaultPreset, graphile_build_pg_1.defaultPreset],
+    disablePlugins: ['NodePlugin'],
+};
+// --- Implementation ---
+async function getConnections(input, seedAdapters) {
+    const { schemas, preset: userPreset, smartTags, realtimeTables, realtimeOptions, buildPgSettings, } = input;
+    // 1. Database connections (pgsql-test layer)
+    const conn = await (0, pgsql_test_1.getConnections)(input, seedAdapters);
+    const { pg, db, teardown: dbTeardown } = conn;
+    const pgPool = conn.manager.getPool(conn.pg.config);
+    // 2. Smart tags
+    const smartTagsMap = {
+        ...(smartTags ?? {}),
+    };
+    for (const table of realtimeTables ?? []) {
+        if (!smartTagsMap[table]) {
+            smartTagsMap[table] = {};
+        }
+        smartTagsMap[table].realtime = true;
+    }
+    const smartTagsPlugin = (0, smart_tags_js_1.makeRealtimeSmartTagsPlugin)(smartTagsMap);
+    const realtimePlugin = (0, graphile_realtime_subscriptions_1.createRealtimeSubscriptionsPlugin)(realtimeOptions);
+    // 3. Graphile schema (graphile-test layer)
+    const pgService = (0, pg_1.makePgService)({
+        pool: pgPool,
+        schemas,
+    });
+    const completePreset = {
+        extends: [
+            MinimalPreset,
+            ...(userPreset?.extends ?? []),
+        ],
+        ...(userPreset?.disablePlugins && { disablePlugins: userPreset.disablePlugins }),
+        plugins: [
+            ...(userPreset?.plugins ?? []),
+            smartTagsPlugin,
+            realtimePlugin,
+        ],
+        ...(userPreset?.schema && { schema: userPreset.schema }),
+        ...(userPreset?.grafast && { grafast: userPreset.grafast }),
+        pgServices: [pgService],
+    };
+    const result = await (0, graphile_build_1.makeSchema)(completePreset);
+    const schema = result.schema;
+    const resolvedPreset = result.resolvedPreset;
+    const pgSubscriber = pgService.pgSubscriber;
+    const pgSubscriberKey = pgService.pgSubscriberKey ?? 'pgSubscriber';
+    // 4. WebSocket server (realtime layer)
+    const wsServer = await (0, ws_server_js_1.createWsTestServer)({
+        schema,
+        resolvedPreset,
+        pgSubscriber,
+        pgSubscriberKey,
+        buildPgSettings,
+    });
+    await (0, ws_helpers_js_1.delay)(300);
+    // 5. WS handle
+    const ws = {
+        serverUrl: wsServer.serverUrl,
+        createClient: (connectionParams) => wsServer.createClient(connectionParams),
+        nextEvent: (client, query, variables, timeoutMs) => (0, ws_helpers_js_1.nextEvent)(client, query, variables, timeoutMs),
+        collectEvents: (client, query, variables) => (0, ws_helpers_js_1.collectWsEvents)(client, query, variables),
+        dispose: () => wsServer.dispose(),
+    };
+    // 6. Notify helpers
+    const defaultSchema = schemas[0] ?? 'public';
+    const notifyClient = pg.client;
+    // 7. Teardown (idempotent)
+    let tornDown = false;
+    const teardown = async () => {
+        if (tornDown)
+            return;
+        tornDown = true;
+        // Order: clients -> server -> subscriber -> service -> pool -> db
+        await wsServer.dispose();
+        if (pgSubscriber && typeof pgSubscriber.release === 'function') {
+            await pgSubscriber.release();
+        }
+        if (pgService && typeof pgService.release === 'function') {
+            await pgService.release();
+        }
+        await dbTeardown();
+    };
+    return {
+        pg,
+        db,
+        schema,
+        resolvedPreset,
+        pgPool,
+        pgService,
+        pgSubscriber,
+        ws,
+        async notifyChange(table, operation, rowIds, tableSchema) {
+            await (0, notify_js_1.notifyChange)(notifyClient, tableSchema ?? defaultSchema, table, operation, rowIds);
+        },
+        async notifyInvalidate(table, tableSchema) {
+            await (0, notify_js_1.notifyInvalidate)(notifyClient, tableSchema ?? defaultSchema, table);
+        },
+        async notify(table, payload, tableSchema) {
+            await (0, notify_js_1.notify)(notifyClient, tableSchema ?? defaultSchema, table, payload);
+        },
+        teardown,
+    };
+}

package/index.d.ts

@@ -4,3 +4,8 @@ export { makeRealtimeSmartTagsPlugin } from './smart-tags.js';
 export { subscribe, waitForEvent, collectEvents, } from './subscribe.js';
 export type { SubscriptionEvent, SubscribeOptions } from './subscribe.js';
 export { notify, notifyChange, notifyInvalidate, buildPayload, buildInvalidatePayload, } from './notify.js';
+export { nextEvent, collectWsEvents, delay } from './ws-helpers.js';
+export { createWsTestServer } from './ws-server.js';
+export type { WsTestServerInput, WsTestServer } from './ws-server.js';
+export { getConnections } from './get-connections.js';
+export type { GetConnectionsInput, GetConnectionsResult, WsHandle, } from './get-connections.js';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildInvalidatePayload = exports.buildPayload = exports.notifyInvalidate = exports.notifyChange = exports.notify = exports.collectEvents = exports.waitForEvent = exports.subscribe = exports.makeRealtimeSmartTagsPlugin = exports.createRealtimeTestContext = void 0;
+exports.getConnections = exports.createWsTestServer = exports.delay = exports.collectWsEvents = exports.nextEvent = exports.buildInvalidatePayload = exports.buildPayload = exports.notifyInvalidate = exports.notifyChange = exports.notify = exports.collectEvents = exports.waitForEvent = exports.subscribe = exports.makeRealtimeSmartTagsPlugin = exports.createRealtimeTestContext = void 0;
 var context_js_1 = require("./context.js");
 Object.defineProperty(exports, "createRealtimeTestContext", { enumerable: true, get: function () { return context_js_1.createRealtimeTestContext; } });
 var smart_tags_js_1 = require("./smart-tags.js");
@@ -15,3 +15,11 @@ Object.defineProperty(exports, "notifyChange", { enumerable: true, get: function
 Object.defineProperty(exports, "notifyInvalidate", { enumerable: true, get: function () { return notify_js_1.notifyInvalidate; } });
 Object.defineProperty(exports, "buildPayload", { enumerable: true, get: function () { return notify_js_1.buildPayload; } });
 Object.defineProperty(exports, "buildInvalidatePayload", { enumerable: true, get: function () { return notify_js_1.buildInvalidatePayload; } });
+var ws_helpers_js_1 = require("./ws-helpers.js");
+Object.defineProperty(exports, "nextEvent", { enumerable: true, get: function () { return ws_helpers_js_1.nextEvent; } });
+Object.defineProperty(exports, "collectWsEvents", { enumerable: true, get: function () { return ws_helpers_js_1.collectWsEvents; } });
+Object.defineProperty(exports, "delay", { enumerable: true, get: function () { return ws_helpers_js_1.delay; } });
+var ws_server_js_1 = require("./ws-server.js");
+Object.defineProperty(exports, "createWsTestServer", { enumerable: true, get: function () { return ws_server_js_1.createWsTestServer; } });
+var get_connections_js_1 = require("./get-connections.js");
+Object.defineProperty(exports, "getConnections", { enumerable: true, get: function () { return get_connections_js_1.getConnections; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphile-realtime-test",
-  "version": "0.3.0",
+  "version": "0.6.0",
   "description": "Subscription testing utilities for graphile-realtime-subscriptions — smart tag injection, grafast.subscribe() helpers, and pg_notify simulation",
   "author": "Constructive <developers@constructive.io>",
   "homepage": "https://github.com/constructive-io/constructive",
@@ -39,7 +39,7 @@
     "url": "https://github.com/constructive-io/constructive/issues"
   },
   "dependencies": {
-    "graphile-realtime-subscriptions": "^0.6.0",
+    "graphile-realtime-subscriptions": "^0.7.0",
     "graphile-test": "^4.15.0"
   },
   "peerDependencies": {
@@ -48,13 +48,20 @@
     "graphile-build-pg": "5.0.0",
     "graphile-config": "1.0.0",
     "graphql": "16.13.0",
+    "graphql-ws": "^6.0.8",
     "pg": "^8.20.0",
-    "postgraphile": "5.0.0"
+    "postgraphile": "5.0.0",
+    "ws": "^8.20.0"
   },
   "devDependencies": {
+    "@types/express": "^5.0.6",
     "@types/pg": "^8.18.0",
+    "@types/ws": "^8.18.1",
+    "express": "^5.2.1",
+    "grafserv": "1.0.0",
     "makage": "^0.3.0",
-    "pgsql-test": "^4.14.0"
+    "pgsql-test": "^4.14.0",
+    "postgraphile": "5.0.0"
   },
-  "gitHead": "50dc1d69049c207b46c237eba1e1b1cb7a5f928f"
+  "gitHead": "79f9109e05713e24fbef527864e0df02634aa891"
 }

package/ws-helpers.d.ts

@@ -0,0 +1,19 @@
+import type { Client as GqlWsClient } from 'graphql-ws';
+/**
+ * Collect the next event from a graphql-ws WebSocket subscription.
+ *
+ * Returns a promise that resolves with the first `next` payload's `data`,
+ * or rejects on error / timeout. The subscription is automatically
+ * unsubscribed after the first event.
+ */
+export declare function nextEvent<T = Record<string, unknown>>(client: GqlWsClient, query: string, variables?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+/**
+ * Subscribe and collect events into an array until `unsubscribe()` is called.
+ *
+ * Useful for assertions that need to inspect multiple events after the fact.
+ */
+export declare function collectWsEvents<T = Record<string, unknown>>(client: GqlWsClient, query: string, variables?: Record<string, unknown>): {
+    events: T[];
+    unsubscribe: () => void;
+};
+export declare const delay: (ms: number) => Promise<void>;

package/ws-helpers.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delay = void 0;
+exports.nextEvent = nextEvent;
+exports.collectWsEvents = collectWsEvents;
+/**
+ * Collect the next event from a graphql-ws WebSocket subscription.
+ *
+ * Returns a promise that resolves with the first `next` payload's `data`,
+ * or rejects on error / timeout. The subscription is automatically
+ * unsubscribed after the first event.
+ */
+function nextEvent(client, query, variables, timeoutMs = 10000) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            unsubscribe();
+            reject(new Error(`nextEvent timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        const unsubscribe = client.subscribe({ query, variables }, {
+            next(value) {
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(value.data);
+            },
+            error(err) {
+                clearTimeout(timer);
+                unsubscribe();
+                reject(Array.isArray(err) ? err[0] : err);
+            },
+            complete() {
+                clearTimeout(timer);
+                reject(new Error('Subscription completed without yielding a value'));
+            },
+        });
+    });
+}
+/**
+ * Subscribe and collect events into an array until `unsubscribe()` is called.
+ *
+ * Useful for assertions that need to inspect multiple events after the fact.
+ */
+function collectWsEvents(client, query, variables) {
+    const events = [];
+    const unsubscribe = client.subscribe({ query, variables }, {
+        next(value) {
+            events.push(value.data);
+        },
+        error() { },
+        complete() { },
+    });
+    return { events, unsubscribe };
+}
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+exports.delay = delay;

package/ws-server.d.ts

@@ -0,0 +1,20 @@
+import { type Server as HttpServer } from 'node:http';
+import type { GraphQLSchema } from 'graphql';
+import type { GraphileConfig } from 'graphile-config';
+import { type Client as GqlWsClient } from 'graphql-ws';
+import { WebSocketServer } from 'ws';
+export interface WsTestServerInput {
+    schema: GraphQLSchema;
+    resolvedPreset: GraphileConfig.ResolvedPreset;
+    pgSubscriber: unknown;
+    pgSubscriberKey?: string;
+    buildPgSettings?: (connectionParams: Record<string, string>) => Record<string, string> | undefined;
+}
+export interface WsTestServer {
+    serverUrl: string;
+    httpServer: HttpServer;
+    wss: WebSocketServer;
+    createClient(connectionParams?: Record<string, unknown>): GqlWsClient;
+    dispose(): Promise<void>;
+}
+export declare function createWsTestServer(input: WsTestServerInput): Promise<WsTestServer>;

package/ws-server.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWsTestServer = createWsTestServer;
+const node_http_1 = require("node:http");
+const grafast_1 = require("grafast");
+const graphql_ws_1 = require("graphql-ws");
+const ws_1 = require("graphql-ws/use/ws");
+const ws_2 = require("ws");
+async function createWsTestServer(input) {
+    const { schema, resolvedPreset, pgSubscriber, pgSubscriberKey = 'pgSubscriber', buildPgSettings, } = input;
+    const httpServer = (0, node_http_1.createServer)();
+    const wss = new ws_2.WebSocketServer({ server: httpServer, path: '/graphql' });
+    const serverCleanup = (0, ws_1.useServer)({
+        schema,
+        context: async (ctx) => ({
+            connectionParams: ctx.connectionParams,
+        }),
+        subscribe: async (args) => {
+            const params = args.contextValue?.connectionParams;
+            const contextValue = {
+                [pgSubscriberKey]: pgSubscriber,
+                ...(typeof args.contextValue === 'object' && args.contextValue !== null
+                    ? args.contextValue
+                    : {}),
+            };
+            if (buildPgSettings && params) {
+                const pgSettings = buildPgSettings(params);
+                if (pgSettings) {
+                    contextValue['pgSettings'] = pgSettings;
+                }
+            }
+            const result = await (0, grafast_1.subscribe)({
+                schema: args.schema,
+                document: args.document,
+                variableValues: args.variableValues,
+                contextValue,
+                resolvedPreset,
+            });
+            return result;
+        },
+    }, wss);
+    await new Promise((resolve) => {
+        httpServer.listen(0, '127.0.0.1', () => resolve());
+    });
+    const addr = httpServer.address();
+    const serverUrl = `ws://127.0.0.1:${addr.port}/graphql`;
+    const clients = [];
+    return {
+        serverUrl,
+        httpServer,
+        wss,
+        createClient(connectionParams) {
+            const client = (0, graphql_ws_1.createClient)({
+                url: serverUrl,
+                webSocketImpl: ws_2.WebSocket,
+                retryAttempts: 0,
+                connectionParams,
+            });
+            clients.push(client);
+            return client;
+        },
+        async dispose() {
+            for (const client of clients) {
+                try {
+                    await client.dispose();
+                }
+                catch { /* ignore */ }
+            }
+            await serverCleanup.dispose();
+            wss.close();
+            if (httpServer.listening) {
+                await new Promise((resolve) => httpServer.close(() => resolve()));
+            }
+        },
+    };
+}