@nestjs/apollo 13.3.0 → 13.4.1

package/dist/tests/tests/subscriptions/app/notification.resolver.js

@@ -0,0 +1,50 @@
+"use strict";
+var NotificationResolver_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationResolver = exports.pubSub = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const graphql_1 = require("@nestjs/graphql");
+const graphql_subscriptions_1 = require("graphql-subscriptions");
+const auth_guard_1 = require("./auth.guard");
+const notification_1 = require("./notification");
+exports.pubSub = new graphql_subscriptions_1.PubSub();
+let NotificationResolver = NotificationResolver_1 = class NotificationResolver {
+    constructor() {
+        this.logger = new common_1.Logger(NotificationResolver_1.name);
+    }
+    getNotification() {
+        return {
+            message: 'Hello!',
+        };
+    }
+    newNotification(id) {
+        this.logger.log('User subscribed to newNotification');
+        return exports.pubSub.asyncIterableIterator('newNotification');
+    }
+};
+exports.NotificationResolver = NotificationResolver;
+tslib_1.__decorate([
+    (0, graphql_1.Query)(() => notification_1.Notification),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], NotificationResolver.prototype, "getNotification", null);
+tslib_1.__decorate([
+    (0, common_1.UseGuards)(auth_guard_1.AuthGuard),
+    (0, graphql_1.Subscription)(() => notification_1.Notification, {
+        filter(payload, variables, context) {
+            return (context.user === payload.newNotification.recipient &&
+                payload.newNotification.id === variables.id);
+        },
+    }),
+    tslib_1.__param(0, (0, graphql_1.Args)('id', {
+        nullable: false,
+    })),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", void 0)
+], NotificationResolver.prototype, "newNotification", null);
+exports.NotificationResolver = NotificationResolver = NotificationResolver_1 = tslib_1.__decorate([
+    (0, graphql_1.Resolver)(() => notification_1.Notification)
+], NotificationResolver);

package/dist/tests/tests/subscriptions/async-iterator.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=async-iterator.spec.d.ts.map

package/dist/tests/tests/subscriptions/async-iterator.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-iterator.spec.d.ts","sourceRoot":"","sources":["../../../../tests/subscriptions/async-iterator.spec.ts"],"names":[],"mappings":""}

package/dist/tests/tests/subscriptions/async-iterator.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+// Old implementation of with-filter was leaking memory with was visible
+// in case with long lived subscriptions where filter is skipping most of messages
+Object.defineProperty(exports, "__esModule", { value: true });
+const iterall_1 = require("iterall");
+const v8_1 = require("v8");
+const vm_1 = require("vm");
+const async_iterator_util_1 = require("../../lib/utils/async-iterator.util");
+(0, v8_1.setFlagsFromString)('--expose_gc');
+const gc = (0, vm_1.runInNewContext)('gc');
+// https://github.com/apollographql/graphql-subscriptions/issues/212
+it('does not leak memory with promise chain #memory', async function () {
+    vi.setConfig({ testTimeout: 5000 });
+    let stopped = false;
+    let index = 0;
+    const asyncIterator = {
+        async next() {
+            if (stopped) {
+                return Promise.resolve({ done: true, value: undefined });
+            }
+            index += 1;
+            return new Promise((resolve) => setImmediate(resolve)).then(() => ({
+                done: false,
+                value: index,
+            }));
+        },
+        return() {
+            return Promise.resolve({ value: undefined, done: true });
+        },
+        throw(error) {
+            return Promise.reject(error);
+        },
+        [iterall_1.$$asyncIterator]() {
+            return this;
+        },
+    };
+    const filteredAsyncIterator = await (0, async_iterator_util_1.createAsyncIterator)(Promise.resolve(asyncIterator), () => stopped);
+    gc();
+    const heapUsed = process.memoryUsage().heapUsed;
+    const nextPromise = filteredAsyncIterator.next();
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+    gc();
+    const heapUsed2 = process.memoryUsage().heapUsed;
+    stopped = true;
+    await nextPromise;
+    // Heap memory goes up for less than 1%
+    expect(Math.max(0, heapUsed2 - heapUsed) / heapUsed).toBeLessThan(0.01);
+});

package/dist/tests/tests/subscriptions/federation-app/federation-app.module.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModule } from '@nestjs/common';
+import { ApolloDriverConfig } from '../../../lib';
+export type FederationAppModuleConfig = {
+    subscriptions?: ApolloDriverConfig['subscriptions'];
+};
+export declare class FederationAppModule {
+    static forRoot(options?: FederationAppModuleConfig): DynamicModule;
+}
+//# sourceMappingURL=federation-app.module.d.ts.map

package/dist/tests/tests/subscriptions/federation-app/federation-app.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-app.module.d.ts","sourceRoot":"","sources":["../../../../../tests/subscriptions/federation-app/federation-app.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAIlD,MAAM,MAAM,yBAAyB,GAAG;IACtC,aAAa,CAAC,EAAE,kBAAkB,CAAC,eAAe,CAAC,CAAC;CACrD,CAAC;AAEF,qBACa,mBAAmB;IAC9B,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,aAAa;CAcnE"}

package/dist/tests/tests/subscriptions/federation-app/federation-app.module.js

@@ -0,0 +1,29 @@
+"use strict";
+var FederationAppModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FederationAppModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const graphql_1 = require("@nestjs/graphql");
+const drivers_1 = require("../../../lib/drivers");
+const notification_module_1 = require("./notification.module");
+let FederationAppModule = FederationAppModule_1 = class FederationAppModule {
+    static forRoot(options) {
+        return {
+            module: FederationAppModule_1,
+            imports: [
+                notification_module_1.NotificationModule,
+                graphql_1.GraphQLModule.forRoot({
+                    driver: drivers_1.ApolloFederationDriver,
+                    autoSchemaFile: true,
+                    includeStacktraceInErrorResponses: false,
+                    subscriptions: options?.subscriptions,
+                }),
+            ],
+        };
+    }
+};
+exports.FederationAppModule = FederationAppModule;
+exports.FederationAppModule = FederationAppModule = FederationAppModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], FederationAppModule);

package/dist/tests/tests/subscriptions/federation-app/notification.d.ts

@@ -0,0 +1,6 @@
+export declare class Notification {
+    id: string;
+    recipient: string;
+    message: string;
+}
+//# sourceMappingURL=notification.d.ts.map

package/dist/tests/tests/subscriptions/federation-app/notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.d.ts","sourceRoot":"","sources":["../../../../../tests/subscriptions/federation-app/notification.ts"],"names":[],"mappings":"AAEA,qBACa,YAAY;IAEvB,EAAE,EAAE,MAAM,CAAC;IAGX,SAAS,EAAE,MAAM,CAAC;IAGlB,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/tests/tests/subscriptions/federation-app/notification.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notification = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("@nestjs/graphql");
+let Notification = class Notification {
+};
+exports.Notification = Notification;
+tslib_1.__decorate([
+    (0, graphql_1.Field)({ nullable: false }),
+    tslib_1.__metadata("design:type", String)
+], Notification.prototype, "id", void 0);
+tslib_1.__decorate([
+    (0, graphql_1.Field)({ nullable: false }),
+    tslib_1.__metadata("design:type", String)
+], Notification.prototype, "recipient", void 0);
+tslib_1.__decorate([
+    (0, graphql_1.Field)({ nullable: false }),
+    tslib_1.__metadata("design:type", String)
+], Notification.prototype, "message", void 0);
+exports.Notification = Notification = tslib_1.__decorate([
+    (0, graphql_1.ObjectType)()
+], Notification);

package/dist/tests/tests/subscriptions/federation-app/notification.module.d.ts

@@ -0,0 +1,3 @@
+export declare class NotificationModule {
+}
+//# sourceMappingURL=notification.module.d.ts.map

package/dist/tests/tests/subscriptions/federation-app/notification.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.module.d.ts","sourceRoot":"","sources":["../../../../../tests/subscriptions/federation-app/notification.module.ts"],"names":[],"mappings":"AAGA,qBAGa,kBAAkB;CAAG"}

package/dist/tests/tests/subscriptions/federation-app/notification.module.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const notification_resolver_1 = require("./notification.resolver");
+let NotificationModule = class NotificationModule {
+};
+exports.NotificationModule = NotificationModule;
+exports.NotificationModule = NotificationModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [notification_resolver_1.NotificationResolver],
+    })
+], NotificationModule);

package/dist/tests/tests/subscriptions/federation-app/notification.resolver.d.ts

@@ -0,0 +1,8 @@
+import { PubSub } from 'graphql-subscriptions';
+import { Notification } from './notification';
+export declare const pubSub: PubSub<Record<string, never>>;
+export declare class NotificationResolver {
+    getFederatedNotification(): Notification;
+    newFederatedNotification(id: string, recipient: string): import("graphql-subscriptions/dist/pubsub-async-iterable-iterator").PubSubAsyncIterableIterator<unknown>;
+}
+//# sourceMappingURL=notification.resolver.d.ts.map

package/dist/tests/tests/subscriptions/federation-app/notification.resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification.resolver.d.ts","sourceRoot":"","sources":["../../../../../tests/subscriptions/federation-app/notification.resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,MAAM,+BAAe,CAAC;AAEnC,qBACa,oBAAoB;IAE/B,wBAAwB,IAAI,YAAY;IAYxC,wBAAwB,CACW,EAAE,EAAE,MAAM,EACH,SAAS,EAAE,MAAM;CAI5D"}

package/dist/tests/tests/subscriptions/federation-app/notification.resolver.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationResolver = exports.pubSub = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("@nestjs/graphql");
+const graphql_subscriptions_1 = require("graphql-subscriptions");
+const notification_1 = require("./notification");
+exports.pubSub = new graphql_subscriptions_1.PubSub();
+let NotificationResolver = class NotificationResolver {
+    getFederatedNotification() {
+        return { id: '0', recipient: 'system', message: 'ok' };
+    }
+    newFederatedNotification(id, recipient) {
+        return exports.pubSub.asyncIterableIterator('newFederatedNotification');
+    }
+};
+exports.NotificationResolver = NotificationResolver;
+tslib_1.__decorate([
+    (0, graphql_1.Query)(() => notification_1.Notification),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", notification_1.Notification)
+], NotificationResolver.prototype, "getFederatedNotification", null);
+tslib_1.__decorate([
+    (0, graphql_1.Subscription)(() => notification_1.Notification, {
+        filter(payload, variables) {
+            return (payload.newFederatedNotification.id === variables.id &&
+                payload.newFederatedNotification.recipient === variables.recipient);
+        },
+    }),
+    tslib_1.__param(0, (0, graphql_1.Args)('id', { nullable: false })),
+    tslib_1.__param(1, (0, graphql_1.Args)('recipient', { nullable: false })),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, String]),
+    tslib_1.__metadata("design:returntype", void 0)
+], NotificationResolver.prototype, "newFederatedNotification", null);
+exports.NotificationResolver = NotificationResolver = tslib_1.__decorate([
+    (0, graphql_1.Resolver)(() => notification_1.Notification)
+], NotificationResolver);

package/dist/tests/tests/subscriptions/federation-graphql-ws.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=federation-graphql-ws.spec.d.ts.map

package/dist/tests/tests/subscriptions/federation-graphql-ws.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-graphql-ws.spec.d.ts","sourceRoot":"","sources":["../../../../tests/subscriptions/federation-graphql-ws.spec.ts"],"names":[],"mappings":""}

package/dist/tests/tests/subscriptions/federation-graphql-ws.spec.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const testing_1 = require("@nestjs/testing");
+const apollo_cache_inmemory_1 = require("apollo-cache-inmemory");
+const apollo_client_1 = tslib_1.__importDefault(require("apollo-client"));
+const graphql_tag_1 = require("graphql-tag");
+const graphql_ws_1 = require("graphql-ws");
+const supertest_1 = tslib_1.__importDefault(require("supertest"));
+const ws_1 = tslib_1.__importDefault(require("ws"));
+const federation_app_module_1 = require("./federation-app/federation-app.module");
+const notification_resolver_1 = require("./federation-app/notification.resolver");
+const graphql_ws_link_1 = require("./utils/graphql-ws.link");
+const subscriptionQuery = (0, graphql_tag_1.gql) `
+  subscription FederatedSubscription($id: String!, $recipient: String!) {
+    newFederatedNotification(id: $id, recipient: $recipient) {
+      id
+      recipient
+      message
+    }
+  }
+`;
+describe('GraphQL Federation - graphql-ws subscriptions', () => {
+    let app;
+    let wsClient;
+    let port;
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            imports: [
+                federation_app_module_1.FederationAppModule.forRoot({
+                    subscriptions: { 'graphql-ws': {} },
+                }),
+            ],
+        }).compile();
+        app = module.createNestApplication();
+        await app.init();
+        await app.listen(0);
+        port = app.getHttpServer().address().port;
+    });
+    afterEach(async () => {
+        try {
+            await wsClient?.dispose();
+        }
+        catch { }
+        await app.close();
+    });
+    it('should connect and receive a filtered notification', async () => {
+        wsClient = (0, graphql_ws_1.createClient)({
+            url: `ws://localhost:${port}/graphql`,
+            webSocketImpl: ws_1.default,
+            retryAttempts: 0,
+        });
+        wsClient.on('connected', () => {
+            setTimeout(() => {
+                notification_resolver_1.pubSub.publish('newFederatedNotification', {
+                    newFederatedNotification: {
+                        id: '99',
+                        recipient: 'alice',
+                        message: 'wrong id',
+                    },
+                });
+                notification_resolver_1.pubSub.publish('newFederatedNotification', {
+                    newFederatedNotification: {
+                        id: '1',
+                        recipient: 'bob',
+                        message: 'wrong recipient',
+                    },
+                });
+                notification_resolver_1.pubSub.publish('newFederatedNotification', {
+                    newFederatedNotification: {
+                        id: '1',
+                        recipient: 'alice',
+                        message: 'Hello from federation',
+                    },
+                });
+            }, 100);
+        });
+        const apolloClient = new apollo_client_1.default({
+            link: new graphql_ws_link_1.GraphQLWsLink(wsClient),
+            cache: new apollo_cache_inmemory_1.InMemoryCache(),
+        });
+        await new Promise((resolve, reject) => {
+            apolloClient
+                .subscribe({
+                query: subscriptionQuery,
+                variables: { id: '1', recipient: 'alice' },
+            })
+                .subscribe({
+                next(value) {
+                    try {
+                        expect(value.data.newFederatedNotification.id).toEqual('1');
+                        expect(value.data.newFederatedNotification.recipient).toEqual('alice');
+                        expect(value.data.newFederatedNotification.message).toEqual('Hello from federation');
+                        resolve();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                },
+                complete() { },
+                error: reject,
+            });
+        });
+    });
+    it('should expose the Subscription type in the federation SDL', async () => {
+        const response = await (0, supertest_1.default)(app.getHttpServer())
+            .post('/graphql')
+            .send({ query: '{ _service { sdl } }' })
+            .expect(200);
+        const sdl = response.body.data._service.sdl;
+        expect(sdl).toContain('type Subscription');
+        expect(sdl).toContain('newFederatedNotification');
+    });
+});

package/dist/tests/tests/subscriptions/graphql-ws.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=graphql-ws.spec.d.ts.map

package/dist/tests/tests/subscriptions/graphql-ws.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-ws.spec.d.ts","sourceRoot":"","sources":["../../../../tests/subscriptions/graphql-ws.spec.ts"],"names":[],"mappings":""}

package/dist/tests/tests/subscriptions/graphql-ws.spec.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const testing_1 = require("@nestjs/testing");
+const apollo_cache_inmemory_1 = require("apollo-cache-inmemory");
+const apollo_client_1 = tslib_1.__importStar(require("apollo-client"));
+const graphql_tag_1 = require("graphql-tag");
+const graphql_ws_1 = require("graphql-ws");
+const ws_1 = tslib_1.__importDefault(require("ws"));
+const app_module_1 = require("./app/app.module");
+const notification_resolver_1 = require("./app/notification.resolver");
+const graphql_ws_link_1 = require("./utils/graphql-ws.link");
+const malformed_token_exception_1 = require("./utils/malformed-token.exception");
+const subscriptionQuery = (0, graphql_tag_1.gql) `
+  subscription TestSubscription($id: String!) {
+    newNotification(id: $id) {
+      id
+      message
+    }
+  }
+`;
+describe('graphql-ws protocol', () => {
+    let app;
+    let wsClient;
+    let port;
+    beforeEach(async () => {
+        const module = await testing_1.Test.createTestingModule({
+            imports: [
+                app_module_1.AppModule.forRoot({
+                    context: (context) => {
+                        const { authorization } = context?.connectionParams ?? {};
+                        if (authorization) {
+                            return { user: authorization.split('Bearer ')[1] };
+                        }
+                        else {
+                            return {};
+                        }
+                    },
+                    subscriptions: {
+                        'graphql-ws': {
+                            onConnect: (context) => {
+                                if (!context.connectionParams.authorization) {
+                                    return context.extra.socket.close(4000, 'Missing authorization');
+                                }
+                                const authorization = context.connectionParams
+                                    .authorization;
+                                if (!authorization.startsWith('Bearer ')) {
+                                    throw new malformed_token_exception_1.MalformedTokenException();
+                                }
+                                return true;
+                            },
+                        },
+                    },
+                }),
+            ],
+        }).compile();
+        app = module.createNestApplication();
+        await app.init();
+        await app.listen(0);
+        port = app.getHttpServer().address().port;
+    });
+    it('should receive an error if missing token', async () => {
+        wsClient = (0, graphql_ws_1.createClient)({
+            url: `ws://localhost:${port}/graphql`,
+            webSocketImpl: ws_1.default,
+            connectionParams: {},
+            retryAttempts: 0,
+        });
+        const closedPromise = new Promise((resolve) => {
+            wsClient.on('closed', (ev) => {
+                expect(ev.code).toEqual(4000);
+                expect(ev.reason).toEqual('Missing authorization');
+                resolve();
+            });
+        });
+        const apolloClient = new apollo_client_1.default({
+            link: new graphql_ws_link_1.GraphQLWsLink(wsClient),
+            cache: new apollo_cache_inmemory_1.InMemoryCache(),
+        });
+        apolloClient
+            .subscribe({
+            query: subscriptionQuery,
+            variables: {
+                id: '1',
+            },
+        })
+            .subscribe({
+            next() { },
+            complete() { },
+            error() { },
+        });
+        await closedPromise;
+    });
+    it('should receive an error if token is malformed', async () => {
+        wsClient = (0, graphql_ws_1.createClient)({
+            url: `ws://localhost:${port}/graphql`,
+            webSocketImpl: ws_1.default,
+            connectionParams: {
+                authorization: 'wrong token',
+            },
+            retryAttempts: 0,
+        });
+        const closedPromise = new Promise((resolve) => {
+            wsClient.on('closed', (ev) => {
+                expect(ev.code).toEqual(4500);
+                expect(ev.reason).toEqual('Malformed token');
+                resolve();
+            });
+        });
+        const apolloClient = new apollo_client_1.default({
+            link: new graphql_ws_link_1.GraphQLWsLink(wsClient),
+            cache: new apollo_cache_inmemory_1.InMemoryCache(),
+        });
+        apolloClient
+            .subscribe({
+            query: subscriptionQuery,
+            variables: {
+                id: '1',
+            },
+        })
+            .subscribe({
+            next() { },
+            complete() { },
+            error() { },
+        });
+        await closedPromise;
+    });
+    it('should receive error on subscription if guard fails', async () => {
+        wsClient = (0, graphql_ws_1.createClient)({
+            url: `ws://localhost:${port}/graphql`,
+            webSocketImpl: ws_1.default,
+            connectionParams: {
+                authorization: 'Bearer notest',
+            },
+            retryAttempts: 0,
+        });
+        const apolloClient = new apollo_client_1.default({
+            link: new graphql_ws_link_1.GraphQLWsLink(wsClient),
+            cache: new apollo_cache_inmemory_1.InMemoryCache(),
+        });
+        await new Promise((resolve, reject) => {
+            apolloClient
+                .subscribe({
+                query: subscriptionQuery,
+                variables: {
+                    id: '1',
+                },
+            })
+                .subscribe({
+                next() { },
+                complete() { },
+                error(error) {
+                    try {
+                        expect(error).toBeInstanceOf(apollo_client_1.ApolloError);
+                        expect(error.graphQLErrors[0].message).toEqual('Forbidden resource');
+                        expect(error.graphQLErrors[0].path[0]).toEqual('newNotification');
+                        resolve();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                },
+            });
+        });
+    });
+    it('should connect to subscriptions', async () => {
+        wsClient = (0, graphql_ws_1.createClient)({
+            url: `ws://localhost:${port}/graphql`,
+            webSocketImpl: ws_1.default,
+            connectionParams: {
+                authorization: 'Bearer test',
+            },
+            retryAttempts: 0,
+        });
+        wsClient.on('connected', () => {
+            // timeout needed to allow the subscription to be established
+            setTimeout(() => {
+                notification_resolver_1.pubSub.publish('newNotification', {
+                    newNotification: {
+                        id: '2',
+                        recipient: 'test',
+                        message: 'wrong message!',
+                    },
+                });
+                notification_resolver_1.pubSub.publish('newNotification', {
+                    newNotification: {
+                        id: '1',
+                        recipient: 'someone-else',
+                        message: 'wrong message!',
+                    },
+                });
+                notification_resolver_1.pubSub.publish('newNotification', {
+                    newNotification: {
+                        id: '1',
+                        recipient: 'test',
+                        message: 'Hello graphql-ws',
+                    },
+                });
+            }, 100);
+        });
+        const apolloClient = new apollo_client_1.default({
+            link: new graphql_ws_link_1.GraphQLWsLink(wsClient),
+            cache: new apollo_cache_inmemory_1.InMemoryCache(),
+        });
+        await new Promise((resolve, reject) => {
+            apolloClient
+                .subscribe({
+                query: subscriptionQuery,
+                variables: {
+                    id: '1',
+                },
+            })
+                .subscribe({
+                next(value) {
+                    try {
+                        expect(value.data.newNotification.id).toEqual('1');
+                        expect(value.data.newNotification.message).toEqual('Hello graphql-ws');
+                        resolve();
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                },
+                complete() { },
+                error(error) {
+                    reject(error);
+                },
+            });
+        });
+    });
+    afterEach(async () => {
+        try {
+            await wsClient.dispose();
+        }
+        catch { }
+        await app.close();
+    });
+});

package/dist/tests/tests/subscriptions/utils/graphql-ws.link.d.ts

@@ -0,0 +1,9 @@
+import { ApolloLink, Operation, FetchResult } from 'apollo-link';
+import { Observable } from 'apollo-client/util/Observable';
+import { Client } from 'graphql-ws';
+export declare class GraphQLWsLink extends ApolloLink {
+    private client;
+    constructor(client: Client);
+    request(operation: Operation): Observable<FetchResult>;
+}
+//# sourceMappingURL=graphql-ws.link.d.ts.map

package/dist/tests/tests/subscriptions/utils/graphql-ws.link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-ws.link.d.ts","sourceRoot":"","sources":["../../../../../tests/subscriptions/utils/graphql-ws.link.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,qBAAa,aAAc,SAAQ,UAAU;IAC3C,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,MAAM;IAKnB,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU,CAAC,WAAW,CAAC;CAY9D"}