auth).type}`);
167 |
168 | throw error;
169 | }
170 |
171 | promise.then(observable => {
172 | handle = observable.subscribe({
173 | next: observer.next.bind(observer),
174 | error: observer.error.bind(observer),
175 | complete: observer.complete.bind(observer),
176 | });
177 | })
178 |
179 | return () => {
180 | if (handle) handle.unsubscribe();
181 | };
182 | });
183 | });
184 | }
185 |
186 | const formatAsRequest = ({ operationName, variables, query }, options) => {
187 | const body = {
188 | operationName,
189 | variables: removeTemporaryVariables(variables),
190 | query: print(query)
191 | };
192 |
193 | return {
194 | body: JSON.stringify(body),
195 | method: 'POST',
196 | ...options,
197 | headers: {
198 | accept: '*/*',
199 | 'content-type': 'application/json; charset=UTF-8',
200 | ...options.headers,
201 | },
202 | };
203 | }
204 |
205 | /**
206 | * Removes all temporary variables (starting with '@@') so that the signature matches the final request.
207 | */
208 | const removeTemporaryVariables = (variables: any) =>
209 | Object.keys(variables)
210 | .filter(key => !key.startsWith("@@"))
211 | .reduce((acc, key) => {
212 | acc[key] = variables[key];
213 | return acc;
214 | }, {});
215 |
216 |
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/src/index.ts:
--------------------------------------------------------------------------------
1 | import { AuthLink, AuthOptions, AUTH_TYPE, USER_AGENT_HEADER, USER_AGENT } from './auth-link';
2 |
3 |
4 | export const createAuthLink = ({ url, region, auth }: { url: string, region: string, auth: AuthOptions }) => new AuthLink({ url, region, auth });
5 |
6 | export { AuthLink, AuthOptions, AUTH_TYPE, USER_AGENT_HEADER, USER_AGENT };
7 | export { Signer } from './signer';
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/src/platform.native.ts:
--------------------------------------------------------------------------------
1 | const userAgent = 'react-native';
2 |
3 | export { userAgent };
4 |
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/src/platform.ts:
--------------------------------------------------------------------------------
1 | const userAgent = '';
2 |
3 | export { userAgent };
4 |
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/src/signer/index.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | export * from './signer';
6 |
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/src/signer/signer.ts:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright 2017 - 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at
4 | http://aws.amazon.com/apache2.0/
5 | or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6 | See the License for the specific language governing permissions and limitations under the License.
7 | */
8 | global.Buffer = global.Buffer || require('buffer').Buffer; // Required for aws sigv4 signing
9 |
10 | var url = require('url');
11 |
12 | var { Sha256 } = require('@aws-crypto/sha256-js')
13 | var { toHex } = require("@aws-sdk/util-hex-encoding");
14 |
15 | var encrypt = function(key, src, encoding = '') {
16 | const hash = new Sha256(key);
17 | hash.update(src);
18 | const result = hash.digestSync();
19 | if (encoding === 'hex') {
20 | return toHex(result)
21 | }
22 | return result;
23 | };
24 |
25 | var hash = function(src) {
26 | const arg = src || '';
27 | const hash = new Sha256();
28 | hash.update(arg);
29 | return toHex(hash.digestSync());
30 | };
31 |
32 | /**
33 | * @private
34 | * Create canonical headers
35 | *
36 |
37 | CanonicalHeaders =
38 | CanonicalHeadersEntry0 + CanonicalHeadersEntry1 + ... + CanonicalHeadersEntryN
39 | CanonicalHeadersEntry =
40 | Lowercase(HeaderName) + ':' + Trimall(HeaderValue) + '\n'
41 |
42 | */
43 | var canonical_headers = function (headers) {
44 | if (!headers || Object.keys(headers).length === 0) { return ''; }
45 |
46 | return Object.keys(headers)
47 | .map(function (key) {
48 | return {
49 | key: key.toLowerCase(),
50 | value: headers[key] ? headers[key].trim().replace(/\s+/g, ' ') : ''
51 | };
52 | })
53 | .sort(function (a, b) {
54 | return a.key < b.key ? -1 : 1;
55 | })
56 | .map(function (item) {
57 | return item.key + ':' + item.value;
58 | })
59 | .join('\n') + '\n';
60 | };
61 |
62 | /**
63 | * List of header keys included in the canonical headers.
64 | * @access private
65 | */
66 | var signed_headers = function (headers) {
67 | return Object.keys(headers)
68 | .map(function (key) { return key.toLowerCase(); })
69 | .sort()
70 | .join(';');
71 | };
72 |
73 | /**
74 | * @private
75 | * Create canonical request
76 | * Refer to {@link http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html|Create a Canonical Request}
77 | *
78 |
79 | CanonicalRequest =
80 | HTTPRequestMethod + '\n' +
81 | CanonicalURI + '\n' +
82 | CanonicalQueryString + '\n' +
83 | CanonicalHeaders + '\n' +
84 | SignedHeaders + '\n' +
85 | HexEncode(Hash(RequestPayload))
86 |
87 | */
88 | var canonical_request = function (request) {
89 | var url_info = url.parse(request.url);
90 |
91 | return [
92 | request.method || '/',
93 | url_info.path,
94 | url_info.query,
95 | canonical_headers(request.headers),
96 | signed_headers(request.headers),
97 | hash(request.body)
98 | ].join('\n');
99 | };
100 |
101 | var parse_service_info = function (request) {
102 | var url_info = url.parse(request.url),
103 | host = url_info.host;
104 |
105 | var matched = host.match(/([^.]+)\.(?:([^.]*)\.)?amazonaws\.com$/),
106 | parsed = (matched || []).slice(1, 3);
107 |
108 | if (parsed[1] === 'es') { // Elastic Search
109 | parsed = parsed.reverse();
110 | }
111 |
112 | return {
113 | service: request.service || parsed[0],
114 | region: request.region || parsed[1]
115 | };
116 | };
117 |
118 | var credential_scope = function (d_str, region, service) {
119 | return [
120 | d_str,
121 | region,
122 | service,
123 | 'aws4_request',
124 | ].join('/');
125 | };
126 |
127 | /**
128 | * @private
129 | * Create a string to sign
130 | * Refer to {@link http://docs.aws.amazon.com/general/latest/gr/sigv4-create-string-to-sign.html|Create String to Sign}
131 | *
132 |
133 | StringToSign =
134 | Algorithm + \n +
135 | RequestDateTime + \n +
136 | CredentialScope + \n +
137 | HashedCanonicalRequest
138 |
139 | */
140 | var string_to_sign = function (algorithm, canonical_request, dt_str, scope) {
141 | return [
142 | algorithm,
143 | dt_str,
144 | scope,
145 | hash(canonical_request)
146 | ].join('\n');
147 | };
148 |
149 | /**
150 | * @private
151 | * Create signing key
152 | * Refer to {@link http://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html|Calculate Signature}
153 | *
154 |
155 | kSecret = your secret access key
156 | kDate = HMAC("AWS4" + kSecret, Date)
157 | kRegion = HMAC(kDate, Region)
158 | kService = HMAC(kRegion, Service)
159 | kSigning = HMAC(kService, "aws4_request")
160 |
161 | */
162 | var get_signing_key = function (secret_key = '', d_str, service_info) {
163 | var k = ('AWS4' + secret_key),
164 | k_date = encrypt(k, d_str),
165 | k_region = encrypt(k_date, service_info.region),
166 | k_service = encrypt(k_region, service_info.service),
167 | k_signing = encrypt(k_service, 'aws4_request');
168 |
169 | return k_signing;
170 | };
171 |
172 | var get_signature = function (signing_key, str_to_sign) {
173 | return encrypt(signing_key, str_to_sign, 'hex');
174 | };
175 |
176 | /**
177 | * @private
178 | * Create authorization header
179 | * Refer to {@link http://docs.aws.amazon.com/general/latest/gr/sigv4-add-signature-to-request.html|Add the Signing Information}
180 | */
181 | var get_authorization_header = function (algorithm, access_key = '', scope, signed_headers, signature) {
182 | return [
183 | algorithm + ' ' + 'Credential=' + access_key + '/' + scope,
184 | 'SignedHeaders=' + signed_headers,
185 | 'Signature=' + signature
186 | ].join(', ');
187 | };
188 |
189 | /**
190 | * Sign a HTTP request, add 'Authorization' header to request param
191 | * @method sign
192 | * @memberof Signer
193 | * @static
194 | *
195 | * @param {object} request - HTTP request object
196 |
197 | request: {
198 | method: GET | POST | PUT ...
199 | url: ...,
200 | headers: {
201 | header1: ...
202 | },
203 | body: data
204 | }
205 |
206 | * @param {object} access_info - AWS access credential info
207 |
208 | access_info: {
209 | access_key: ...,
210 | secret_key: ...,
211 | session_token: ...
212 | }
213 |
214 | * @param {object} [service_info] - AWS service type and region, optional,
215 | * if not provided then parse out from url
216 |
217 | service_info: {
218 | service: ...,
219 | region: ...
220 | }
221 |
222 | *
223 | * @returns {object} Signed HTTP request
224 | */
225 | var sign = function (request, access_info, service_info = null) {
226 | request.headers = request.headers || {};
227 |
228 | // datetime string and date string
229 | var dt = new Date(),
230 | dt_str = dt.toISOString().replace(/[:-]|\.\d{3}/g, ''),
231 | d_str = dt_str.substr(0, 8),
232 | algorithm = 'AWS4-HMAC-SHA256';
233 |
234 | var url_info = url.parse(request.url)
235 | request.headers['host'] = url_info.host;
236 | request.headers['x-amz-date'] = dt_str;
237 | if (access_info.session_token) {
238 | request.headers['X-Amz-Security-Token'] = access_info.session_token;
239 | }
240 |
241 | // Task 1: Create a Canonical Request
242 | var request_str = canonical_request(request);
243 |
244 | // Task 2: Create a String to Sign
245 | service_info = service_info || parse_service_info(request);
246 | var scope = credential_scope(
247 | d_str,
248 | service_info.region,
249 | service_info.service
250 | );
251 | var str_to_sign = string_to_sign(
252 | algorithm,
253 | request_str,
254 | dt_str,
255 | scope
256 | );
257 |
258 | // Task 3: Calculate the Signature
259 | var signing_key = get_signing_key(
260 | access_info.secret_key,
261 | d_str,
262 | service_info
263 | ),
264 | signature = get_signature(signing_key, str_to_sign);
265 |
266 | // Task 4: Adding the Signing information to the Request
267 | var authorization_header = get_authorization_header(
268 | algorithm,
269 | access_info.access_key,
270 | scope,
271 | signed_headers(request.headers),
272 | signature
273 | );
274 | request.headers['Authorization'] = authorization_header;
275 |
276 | return request;
277 | };
278 |
279 | /**
280 | * AWS request signer.
281 | * Refer to {@link http://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html|Signature Version 4}
282 | *
283 | * @class Signer
284 | */
285 | class Signer {
286 | static sign = sign;
287 | }
288 |
289 | export default Signer;
290 | export { Signer };
291 |
--------------------------------------------------------------------------------
/packages/aws-appsync-auth-link/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "outDir": "lib",
4 | "rootDir": "src",
5 | "module": "commonjs",
6 | "target": "es5",
7 | "moduleResolution": "node",
8 | "declaration": true,
9 | "lib": [
10 | "dom",
11 | "es6",
12 | "esnext.asynciterable",
13 | "es2017.object"
14 | ],
15 | "skipLibCheck": true
16 | },
17 | "exclude": [
18 | "lib",
19 | "__tests__"
20 | ],
21 | "compileOnSave": true
22 | }
23 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | lib
3 | *.tgz
4 | .DS_Store
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/.npmignore:
--------------------------------------------------------------------------------
1 | src/
2 | *.tgz
3 | tsconfig.json
4 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Change Log
2 |
3 | All notable changes to this project will be documented in this file.
4 | See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
5 |
6 |
7 | ## [3.1.3](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.1.2...aws-appsync-subscription-link@3.1.3) (2024-01-23)
8 |
9 |
10 | ### Bug Fixes
11 |
12 | * exception due to illegal access to item in an empty map ([#747](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/747)) ([82cb58e](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/82cb58e))
13 |
14 |
15 |
16 |
17 |
18 | ## [3.1.2](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.1.1...aws-appsync-subscription-link@3.1.2) (2022-11-17)
19 |
20 |
21 | ### Bug Fixes
22 |
23 | * added check for observer ([#735](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/735)) ([db8f9ae](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/db8f9ae))
24 |
25 |
26 |
27 |
28 |
29 | ## [3.1.1](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.1.0...aws-appsync-subscription-link@3.1.1) (2022-10-07)
30 |
31 |
32 |
33 |
34 | **Note:** Version bump only for package aws-appsync-subscription-link
35 |
36 |
37 | # [3.1.0](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.11...aws-appsync-subscription-link@3.1.0) (2022-06-24)
38 |
39 |
40 | ### Features
41 |
42 | * Add keepAliveTimeoutMs config for AppSync WebSocket link ([#724](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/724)) ([74b8351](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/74b8351))
43 |
44 |
45 |
46 |
47 |
48 | ## [3.0.11](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.10...aws-appsync-subscription-link@3.0.11) (2022-05-02)
49 |
50 |
51 |
52 |
53 | **Note:** Version bump only for package aws-appsync-subscription-link
54 |
55 |
56 | ## [3.0.10](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.9...aws-appsync-subscription-link@3.0.10) (2022-03-04)
57 |
58 |
59 | ### Bug Fixes
60 |
61 | * Port over Amplify fix for subscription race conditions ([#509](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/509)) ([#704](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/704)) ([92b50c4](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/92b50c4))
62 |
63 |
64 |
65 |
66 |
67 | ## [3.0.9](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.8...aws-appsync-subscription-link@3.0.9) (2021-09-24)
68 |
69 |
70 | ### Bug Fixes
71 |
72 | * add type fix to subscription link to fix 'prepare' script ([#669](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/669)) ([c5202dc](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/c5202dc))
73 | * **aws-appsync-subscription-link:** graphql header refactor to fix IAM-based auth ([#619](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/619)) ([#671](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/671)) ([dbf4959](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/dbf4959))
74 | * remove aws-sdk V2; import aws-sdk V3 packages ([#637](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/637)); refactor auth-link, signer, and types ([0996740](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/0996740))
75 |
76 |
77 |
78 |
79 |
80 | ## [3.0.8](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.7...aws-appsync-subscription-link@3.0.8) (2021-07-28)
81 |
82 |
83 |
84 |
85 | **Note:** Version bump only for package aws-appsync-subscription-link
86 |
87 |
88 | ## [3.0.7](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.6...aws-appsync-subscription-link@3.0.7) (2021-07-09)
89 |
90 |
91 |
92 |
93 | **Note:** Version bump only for package aws-appsync-subscription-link
94 |
95 |
96 | ## [3.0.6](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.5...aws-appsync-subscription-link@3.0.6) (2021-02-12)
97 |
98 |
99 |
100 |
101 | **Note:** Version bump only for package aws-appsync-subscription-link
102 |
103 |
104 | ## [3.0.5](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.4...aws-appsync-subscription-link@3.0.5) (2021-01-26)
105 |
106 |
107 |
108 |
109 | **Note:** Version bump only for package aws-appsync-subscription-link
110 |
111 |
112 | ## [3.0.4](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.3...aws-appsync-subscription-link@3.0.4) (2021-01-08)
113 |
114 |
115 |
116 |
117 | **Note:** Version bump only for package aws-appsync-subscription-link
118 |
119 |
120 | ## [3.0.3](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@3.0.2...aws-appsync-subscription-link@3.0.3) (2020-10-01)
121 |
122 |
123 | ### Bug Fixes
124 |
125 | * Add apollo-utilities dependency to subscription link ([3eeb77e](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/3eeb77e))
126 |
127 |
128 |
129 |
130 |
131 | ## [3.0.2](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@2.2.1...aws-appsync-subscription-link@3.0.2) (2020-10-01)
132 |
133 |
134 |
135 |
136 | **Note:** Version bump only for package aws-appsync-subscription-link
137 |
138 |
139 | ## [2.2.1](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@2.2.0...aws-appsync-subscription-link@2.2.1) (2020-09-10)
140 |
141 |
142 |
143 |
144 | **Note:** Version bump only for package aws-appsync-subscription-link
145 |
146 |
147 | # [2.2.0](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@2.1.0...aws-appsync-subscription-link@2.2.0) (2020-06-24)
148 |
149 |
150 | ### Bug Fixes
151 |
152 | * **aws-appsync-subscription-link:** change relativ ([#564](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/564)) ([f9d95a6](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/f9d95a6))
153 |
154 |
155 | ### Features
156 |
157 | * **aws-appsync-subscription-link:** allow custom headers to be processed by a Subscription resolver's vtl ([#497](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/497)) ([6851a36](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/6851a36))
158 |
159 |
160 |
161 |
162 |
163 | # [2.1.0](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@2.0.1...aws-appsync-subscription-link@2.1.0) (2020-04-15)
164 |
165 |
166 | ### Features
167 |
168 | * **aws-appsync-subscription-link:** add mock support for websocket subscriptions ([#548](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/548)) ([bac8808](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/bac8808))
169 |
170 |
171 |
172 |
173 |
174 | ## [2.0.1](https://github.com/awslabs/aws-mobile-appsync-sdk-js/compare/aws-appsync-subscription-link@1.0.1...aws-appsync-subscription-link@2.0.1) (2019-11-15)
175 |
176 |
177 |
178 |
179 | **Note:** Version bump only for package aws-appsync-subscription-link
180 |
181 |
182 | ## 1.0.1 (2019-10-11)
183 |
184 |
185 | ### Features
186 |
187 | * exporting links ([#470](https://github.com/awslabs/aws-mobile-appsync-sdk-js/issues/470)) ([50185bb](https://github.com/awslabs/aws-mobile-appsync-sdk-js/commit/50185bb))
188 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/__tests__/link/realtime-subscription-handshake-link-test.ts:
--------------------------------------------------------------------------------
1 | import { AUTH_TYPE } from "aws-appsync-auth-link";
2 | import { execute } from "@apollo/client/core";
3 | import gql from 'graphql-tag';
4 | import { AppSyncRealTimeSubscriptionHandshakeLink } from '../../src/realtime-subscription-handshake-link';
5 | import { MESSAGE_TYPES } from "../../src/types";
6 | import { v4 as uuid } from "uuid";
7 | jest.mock('uuid', () => ({ v4: jest.fn() }));
8 |
9 | const query = gql`subscription { someSubscription { aField } }`
10 |
11 | class myWebSocket implements WebSocket {
12 | binaryType: BinaryType;
13 | bufferedAmount: number;
14 | extensions: string;
15 | onclose: (this: WebSocket, ev: CloseEvent) => any;
16 | onerror: (this: WebSocket, ev: Event) => any;
17 | onmessage: (this: WebSocket, ev: MessageEvent) => any;
18 | onopen: (this: WebSocket, ev: Event) => any;
19 | protocol: string;
20 | readyState: number;
21 | url: string;
22 | close(code?: number, reason?: string): void {
23 | throw new Error("Method not implemented.");
24 | }
25 | send(data: string | ArrayBuffer | Blob | ArrayBufferView): void {
26 | throw new Error("Method not implemented.");
27 | }
28 | CLOSED: number;
29 | CLOSING: number;
30 | CONNECTING: number;
31 | OPEN: number;
32 | addEventListener(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
33 | addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
34 | addEventListener(type: any, listener: any, options?: any) {
35 | throw new Error("Method not implemented.");
36 | }
37 | removeEventListener(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
38 | removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
39 | removeEventListener(type: any, listener: any, options?: any) {
40 | throw new Error("Method not implemented.");
41 | }
42 | dispatchEvent(event: Event): boolean {
43 | throw new Error("Method not implemented.");
44 | }
45 | }
46 |
47 | describe("RealTime subscription link", () => {
48 |
49 | test("Can instantiate link", () => {
50 | expect.assertions(1);
51 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
52 | auth: {
53 | type: AUTH_TYPE.API_KEY,
54 | apiKey: 'xxxxx'
55 | },
56 | region: 'us-west-2',
57 | url: 'https://firsttesturl12345678901234.appsync-api.us-west-2.amazonaws.com/graphql'
58 | });
59 |
60 | expect(link).toBeInstanceOf(AppSyncRealTimeSubscriptionHandshakeLink);
61 | });
62 |
63 | test("Can instantiate link with custom domain", () => {
64 | expect.assertions(1);
65 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
66 | auth: {
67 | type: AUTH_TYPE.API_KEY,
68 | apiKey: 'xxxxx'
69 | },
70 | region: 'us-west-2',
71 | url: 'https://test1.testcustomdomain.com/graphql'
72 | });
73 |
74 | expect(link).toBeInstanceOf(AppSyncRealTimeSubscriptionHandshakeLink);
75 | });
76 |
77 | test("Initialize WebSocket correctly for API KEY", (done) => {
78 | expect.assertions(2);
79 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
80 | return "2019-11-13T18:47:04.733Z";
81 | }));
82 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
83 | expect(url).toBe('wss://apikeytesturl1234567890123.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=eyJob3N0IjoiYXBpa2V5dGVzdHVybDEyMzQ1Njc4OTAxMjMuYXBwc3luYy1hcGkudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20iLCJ4LWFtei1kYXRlIjoiMjAxOTExMTNUMTg0NzA0WiIsIngtYXBpLWtleSI6Inh4eHh4In0=&payload=e30=');
84 | expect(protocol).toBe('graphql-ws');
85 | done();
86 | return new myWebSocket();
87 | });
88 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
89 | auth: {
90 | type: AUTH_TYPE.API_KEY,
91 | apiKey: 'xxxxx'
92 | },
93 | region: 'us-west-2',
94 | url: 'https://apikeytesturl1234567890123.appsync-api.us-west-2.amazonaws.com/graphql'
95 | });
96 |
97 | execute(link, { query }).subscribe({
98 | error: (err) => {
99 | console.log(JSON.stringify(err));
100 | fail;
101 | },
102 | next: (data) => {
103 | console.log({ data });
104 | done();
105 | },
106 | complete: () => {
107 | console.log('done with this');
108 | done();
109 | }
110 |
111 | });
112 | });
113 |
114 | test("Initialize WebSocket correctly for API KEY with custom domain", (done) => {
115 | expect.assertions(2);
116 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
117 | return "2019-11-13T18:47:04.733Z";
118 | }));
119 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
120 | expect(url).toBe('wss://apikeytest.testcustomdomain.com/graphql/realtime?header=eyJob3N0IjoiYXBpa2V5dGVzdC50ZXN0Y3VzdG9tZG9tYWluLmNvbSIsIngtYW16LWRhdGUiOiIyMDE5MTExM1QxODQ3MDRaIiwieC1hcGkta2V5IjoieHh4eHgifQ==&payload=e30=');
121 | expect(protocol).toBe('graphql-ws');
122 | done();
123 | return new myWebSocket();
124 | });
125 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
126 | auth: {
127 | type: AUTH_TYPE.API_KEY,
128 | apiKey: 'xxxxx'
129 | },
130 | region: 'us-west-2',
131 | url: 'https://apikeytest.testcustomdomain.com/graphql'
132 | });
133 |
134 | execute(link, { query }).subscribe({
135 | error: (err) => {
136 | console.log(JSON.stringify(err));
137 | fail;
138 | },
139 | next: (data) => {
140 | console.log({ data });
141 | done();
142 | },
143 | complete: () => {
144 | console.log('done with this');
145 | done();
146 | }
147 |
148 | });
149 | });
150 |
151 | test("Initialize WebSocket correctly for COGNITO USER POOLS", (done) => {
152 | expect.assertions(2);
153 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
154 | return "2019-11-13T18:47:04.733Z";
155 | }));
156 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
157 | expect(url).toBe('wss://cognitouserpooltesturl1234.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0IjoiY29nbml0b3VzZXJwb29sdGVzdHVybDEyMzQuYXBwc3luYy1hcGkudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20ifQ==&payload=e30=');
158 | expect(protocol).toBe('graphql-ws');
159 | done();
160 | return new myWebSocket();
161 | });
162 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
163 | auth: {
164 | type: AUTH_TYPE.AMAZON_COGNITO_USER_POOLS,
165 | jwtToken: 'token'
166 | },
167 | region: 'us-west-2',
168 | url: 'https://cognitouserpooltesturl1234.appsync-api.us-west-2.amazonaws.com/graphql'
169 | });
170 |
171 | execute(link, { query }).subscribe({
172 | error: (err) => {
173 | console.log(JSON.stringify(err));
174 | fail;
175 | },
176 | next: (data) => {
177 | console.log({ data });
178 | done();
179 | },
180 | complete: () => {
181 | console.log('done with this');
182 | done();
183 | }
184 |
185 | });
186 | });
187 |
188 | test("Initialize WebSocket correctly for COGNITO USER POOLS with custom domain", (done) => {
189 | expect.assertions(2);
190 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
191 | return "2019-11-13T18:47:04.733Z";
192 | }));
193 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
194 | expect(url).toBe('wss://cognitouserpools.testcustomdomain.com/graphql/realtime?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0IjoiY29nbml0b3VzZXJwb29scy50ZXN0Y3VzdG9tZG9tYWluLmNvbSJ9&payload=e30=');
195 | expect(protocol).toBe('graphql-ws');
196 | done();
197 | return new myWebSocket();
198 | });
199 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
200 | auth: {
201 | type: AUTH_TYPE.AMAZON_COGNITO_USER_POOLS,
202 | jwtToken: 'token'
203 | },
204 | region: 'us-west-2',
205 | url: 'https://cognitouserpools.testcustomdomain.com/graphql'
206 | });
207 |
208 | execute(link, { query }).subscribe({
209 | error: (err) => {
210 | console.log(JSON.stringify(err));
211 | fail;
212 | },
213 | next: (data) => {
214 | console.log({ data });
215 | done();
216 | },
217 | complete: () => {
218 | console.log('done with this');
219 | done();
220 | }
221 |
222 | });
223 | });
224 |
225 | test("Initialize WebSocket correctly for OPENID_CONNECT", (done) => {
226 | expect.assertions(2);
227 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
228 | return "2019-11-13T18:47:04.733Z";
229 | }));
230 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
231 | expect(url).toBe('wss://openidconnecttesturl123456.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0Ijoib3BlbmlkY29ubmVjdHRlc3R1cmwxMjM0NTYuYXBwc3luYy1hcGkudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20ifQ==&payload=e30=');
232 | expect(protocol).toBe('graphql-ws');
233 | done();
234 | return new myWebSocket();
235 | });
236 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
237 | auth: {
238 | type: AUTH_TYPE.OPENID_CONNECT,
239 | jwtToken: 'token'
240 | },
241 | region: 'us-west-2',
242 | url: 'https://openidconnecttesturl123456.appsync-api.us-west-2.amazonaws.com/graphql'
243 | });
244 |
245 | execute(link, { query }).subscribe({
246 | error: (err) => {
247 | console.log(JSON.stringify(err));
248 | fail;
249 | },
250 | next: (data) => {
251 | console.log({ data });
252 | done();
253 | },
254 | complete: () => {
255 | console.log('done with this');
256 | done();
257 | }
258 |
259 | });
260 | });
261 |
262 | test("Initialize WebSocket correctly for OPENID_CONNECT with custom domain", (done) => {
263 | expect.assertions(2);
264 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
265 | return "2019-11-13T18:47:04.733Z";
266 | }));
267 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
268 | expect(url).toBe('wss://openidconnecttesturl.testcustomdomain.com/graphql/realtime?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0Ijoib3BlbmlkY29ubmVjdHRlc3R1cmwudGVzdGN1c3RvbWRvbWFpbi5jb20ifQ==&payload=e30=');
269 | expect(protocol).toBe('graphql-ws');
270 | done();
271 | return new myWebSocket();
272 | });
273 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
274 | auth: {
275 | type: AUTH_TYPE.OPENID_CONNECT,
276 | jwtToken: 'token'
277 | },
278 | region: 'us-west-2',
279 | url: 'https://openidconnecttesturl.testcustomdomain.com/graphql'
280 | });
281 |
282 | execute(link, { query }).subscribe({
283 | error: (err) => {
284 | console.log(JSON.stringify(err));
285 | fail;
286 | },
287 | next: (data) => {
288 | console.log({ data });
289 | done();
290 | },
291 | complete: () => {
292 | console.log('done with this');
293 | done();
294 | }
295 |
296 | });
297 | });
298 |
299 | test('Initialize WebSocket correctly for AWS_LAMBDA', (done) => {
300 | expect.assertions(2);
301 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
302 | return "2019-11-13T18:47:04.733Z";
303 | }));
304 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
305 | expect(url).toBe('wss://awslambdatesturl1234567890.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0IjoiYXdzbGFtYmRhdGVzdHVybDEyMzQ1Njc4OTAuYXBwc3luYy1hcGkudXMtd2VzdC0yLmFtYXpvbmF3cy5jb20ifQ==&payload=e30=');
306 | expect(protocol).toBe('graphql-ws');
307 | done();
308 | return new myWebSocket();
309 | });
310 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
311 | auth: {
312 | type: AUTH_TYPE.AWS_LAMBDA,
313 | token: 'token'
314 | },
315 | region: 'us-west-2',
316 | url: 'https://awslambdatesturl1234567890.appsync-api.us-west-2.amazonaws.com/graphql'
317 | });
318 |
319 | execute(link, { query }).subscribe({
320 | error: (err) => {
321 | fail;
322 | },
323 | next: (data) => {
324 | done();
325 | },
326 | complete: () => {
327 | done();
328 | }
329 |
330 | });
331 | })
332 |
333 | test('Initialize WebSocket correctly for AWS_LAMBDA with custom domain', (done) => {
334 | expect.assertions(2);
335 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
336 | return "2019-11-13T18:47:04.733Z";
337 | }));
338 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
339 | expect(url).toBe('wss://awslambdatesturl.testcustomdomain.com/graphql/realtime?header=eyJBdXRob3JpemF0aW9uIjoidG9rZW4iLCJob3N0IjoiYXdzbGFtYmRhdGVzdHVybC50ZXN0Y3VzdG9tZG9tYWluLmNvbSJ9&payload=e30=');
340 | expect(protocol).toBe('graphql-ws');
341 | done();
342 | return new myWebSocket();
343 | });
344 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
345 | auth: {
346 | type: AUTH_TYPE.AWS_LAMBDA,
347 | token: 'token'
348 | },
349 | region: 'us-west-2',
350 | url: 'https://awslambdatesturl.testcustomdomain.com/graphql'
351 | });
352 |
353 | execute(link, { query }).subscribe({
354 | error: (err) => {
355 | fail;
356 | },
357 | next: (data) => {
358 | done();
359 | },
360 | complete: () => {
361 | done();
362 | }
363 |
364 | });
365 | });
366 |
367 | test("Can use a custom keepAliveTimeoutMs", (done) => {
368 | const id = "abcd-efgh-ijkl-mnop";
369 | uuid.mockImplementationOnce(() => id);
370 |
371 | expect.assertions(5);
372 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
373 | return "2019-11-13T18:47:04.733Z";
374 | }));
375 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
376 | expect(url).toBe('wss://apikeytest.testcustomdomain.com/graphql/realtime?header=eyJob3N0IjoiYXBpa2V5dGVzdC50ZXN0Y3VzdG9tZG9tYWluLmNvbSIsIngtYW16LWRhdGUiOiIyMDE5MTExM1QxODQ3MDRaIiwieC1hcGkta2V5IjoieHh4eHgifQ==&payload=e30=');
377 | expect(protocol).toBe('graphql-ws');
378 | const socket = new myWebSocket();
379 |
380 | setTimeout(() => {
381 | socket.close = () => {};
382 | socket.onopen.call(socket, (undefined as unknown as Event));
383 | socket.send = (msg: string) => {
384 | const { type } = JSON.parse(msg);
385 |
386 | switch (type) {
387 | case MESSAGE_TYPES.GQL_CONNECTION_INIT:
388 | socket.onmessage.call(socket, {
389 | data: JSON.stringify({
390 | type: MESSAGE_TYPES.GQL_CONNECTION_ACK,
391 | payload: {
392 | connectionTimeoutMs: 99999,
393 | },
394 | })
395 | } as MessageEvent);
396 | setTimeout(() => {
397 | socket.onmessage.call(socket, {
398 | data: JSON.stringify({
399 | id,
400 | type: MESSAGE_TYPES.GQL_DATA,
401 | payload: {
402 | data: { something: 123 },
403 | },
404 | })
405 | } as MessageEvent);
406 |
407 | }, 100);
408 | break;
409 | }
410 | };
411 | }, 100);
412 |
413 | return socket;
414 | });
415 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
416 | auth: {
417 | type: AUTH_TYPE.API_KEY,
418 | apiKey: 'xxxxx'
419 | },
420 | region: 'us-west-2',
421 | url: 'https://apikeytest.testcustomdomain.com/graphql',
422 | keepAliveTimeoutMs: 123456,
423 | });
424 |
425 | expect(link).toBeInstanceOf(AppSyncRealTimeSubscriptionHandshakeLink);
426 | expect((link as any).keepAliveTimeout).toBe(123456);
427 |
428 | const sub = execute(link, { query }).subscribe({
429 | error: (err) => {
430 | console.log(JSON.stringify(err));
431 | fail();
432 | },
433 | next: (data) => {
434 | expect((link as any).keepAliveTimeout).toBe(123456);
435 | done();
436 | sub.unsubscribe();
437 | },
438 | complete: () => {
439 | console.log('done with this');
440 | fail();
441 | }
442 |
443 | });
444 | });
445 |
446 | test("Uses service-provided timeout when no custom keepAliveTimeoutMs is configured", (done) => {
447 | const id = "abcd-efgh-ijkl-mnop";
448 | uuid.mockImplementationOnce(() => id);
449 |
450 | expect.assertions(5);
451 | jest.spyOn(Date.prototype, 'toISOString').mockImplementation(jest.fn(() => {
452 | return "2019-11-13T18:47:04.733Z";
453 | }));
454 | AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket = jest.fn((url, protocol) => {
455 | expect(url).toBe('wss://apikeytest.testcustomdomain.com/graphql/realtime?header=eyJob3N0IjoiYXBpa2V5dGVzdC50ZXN0Y3VzdG9tZG9tYWluLmNvbSIsIngtYW16LWRhdGUiOiIyMDE5MTExM1QxODQ3MDRaIiwieC1hcGkta2V5IjoieHh4eHgifQ==&payload=e30=');
456 | expect(protocol).toBe('graphql-ws');
457 | const socket = new myWebSocket();
458 |
459 | setTimeout(() => {
460 | socket.close = () => {};
461 | socket.onopen.call(socket, (undefined as unknown as Event));
462 | socket.send = (msg: string) => {
463 | const { type } = JSON.parse(msg);
464 |
465 | switch (type) {
466 | case MESSAGE_TYPES.GQL_CONNECTION_INIT:
467 | socket.onmessage.call(socket, {
468 | data: JSON.stringify({
469 | type: MESSAGE_TYPES.GQL_CONNECTION_ACK,
470 | payload: {
471 | connectionTimeoutMs: 99999,
472 | },
473 | })
474 | } as MessageEvent);
475 | setTimeout(() => {
476 | socket.onmessage.call(socket, {
477 | data: JSON.stringify({
478 | id,
479 | type: MESSAGE_TYPES.GQL_DATA,
480 | payload: {
481 | data: { something: 123 },
482 | },
483 | })
484 | } as MessageEvent);
485 |
486 | }, 100);
487 | break;
488 | }
489 | };
490 | }, 100);
491 |
492 | return socket;
493 | });
494 | const link = new AppSyncRealTimeSubscriptionHandshakeLink({
495 | auth: {
496 | type: AUTH_TYPE.API_KEY,
497 | apiKey: 'xxxxx'
498 | },
499 | region: 'us-west-2',
500 | url: 'https://apikeytest.testcustomdomain.com/graphql',
501 | });
502 |
503 | expect(link).toBeInstanceOf(AppSyncRealTimeSubscriptionHandshakeLink);
504 | expect((link as any).keepAliveTimeout).toBeUndefined();
505 |
506 | const sub = execute(link, { query }).subscribe({
507 | error: (err) => {
508 | console.log(JSON.stringify(err));
509 | fail();
510 | },
511 | next: (data) => {
512 | expect((link as any).keepAliveTimeout).toBe(99999);
513 | done();
514 | sub.unsubscribe();
515 | },
516 | complete: () => {
517 | console.log('done with this');
518 | fail();
519 | }
520 |
521 | });
522 | });
523 |
524 |
525 | });
526 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/jest.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | transform: {
3 | "^.+\\.tsx?$": "ts-jest"
4 | },
5 | testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|tsx?)$",
6 | collectCoverageFrom: [
7 | "src/**/*",
8 | "!src/vendor/**"
9 | ],
10 | moduleFileExtensions: [
11 | "ts",
12 | "tsx",
13 | "js",
14 | "jsx",
15 | "json",
16 | "node"
17 | ],
18 | testEnvironment: "node"
19 | };
20 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "aws-appsync-subscription-link",
3 | "version": "3.1.3",
4 | "main": "lib/index.js",
5 | "license": "Apache-2.0",
6 | "description": "AWS Mobile AppSync SDK for JavaScript",
7 | "author": {
8 | "name": "Amazon Web Services",
9 | "url": "https://aws.amazon.com/"
10 | },
11 | "homepage": "https://github.com/awslabs/aws-mobile-appsync-sdk-js.git",
12 | "repository": {
13 | "type": "git",
14 | "url": "https://github.com/awslabs/aws-mobile-appsync-sdk-js.git"
15 | },
16 | "scripts": {
17 | "prepare": "tsc && cp -r src/vendor lib/vendor",
18 | "test": "jest --coverage --coverageReporters=text",
19 | "test-watch": "jest --watch"
20 | },
21 | "dependencies": {
22 | "aws-appsync-auth-link": "^3.0.7",
23 | "debug": "2.6.9",
24 | "url": "^0.11.0",
25 | "zen-observable-ts": "^1.2.5"
26 | },
27 | "devDependencies": {
28 | "@apollo/client": "^3.2.0",
29 | "@redux-offline/redux-offline": "2.5.2-native.0"
30 | },
31 | "peerDependencies": {
32 | "@apollo/client": "3.x"
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/index.ts:
--------------------------------------------------------------------------------
1 | import {
2 | SubscriptionHandshakeLink,
3 | CONTROL_EVENTS_KEY
4 | } from "./subscription-handshake-link";
5 | import { ApolloLink, Observable } from "@apollo/client/core";
6 | import { createHttpLink } from "@apollo/client/link/http";
7 | import { getMainDefinition } from "@apollo/client/utilities";
8 | import { NonTerminatingLink } from "./non-terminating-link";
9 | import type { OperationDefinitionNode } from "graphql";
10 |
11 | import {
12 | AppSyncRealTimeSubscriptionHandshakeLink,
13 | } from "./realtime-subscription-handshake-link";
14 | import { AppSyncRealTimeSubscriptionConfig } from "./types";
15 |
16 | function createSubscriptionHandshakeLink(
17 | args: AppSyncRealTimeSubscriptionConfig,
18 | resultsFetcherLink?: ApolloLink
19 | ): ApolloLink;
20 | function createSubscriptionHandshakeLink(
21 | url: string,
22 | resultsFetcherLink?: ApolloLink
23 | ): ApolloLink;
24 | function createSubscriptionHandshakeLink(
25 | infoOrUrl: AppSyncRealTimeSubscriptionConfig | string,
26 | theResultsFetcherLink?: ApolloLink
27 | ) {
28 | let resultsFetcherLink: ApolloLink, subscriptionLinks: ApolloLink;
29 |
30 | if (typeof infoOrUrl === "string") {
31 | resultsFetcherLink =
32 | theResultsFetcherLink || createHttpLink({ uri: infoOrUrl });
33 | subscriptionLinks = ApolloLink.from([
34 | new NonTerminatingLink("controlMessages", {
35 | link: new ApolloLink(
36 | (operation, _forward) =>
37 | new Observable(observer => {
38 | const {
39 | variables: { [CONTROL_EVENTS_KEY]: controlEvents, ...variables }
40 | } = operation;
41 |
42 | if (typeof controlEvents !== "undefined") {
43 | operation.variables = variables;
44 | }
45 |
46 | observer.next({ [CONTROL_EVENTS_KEY]: controlEvents });
47 |
48 | return () => { };
49 | })
50 | )
51 | }),
52 | new NonTerminatingLink("subsInfo", { link: resultsFetcherLink }),
53 | new SubscriptionHandshakeLink("subsInfo")
54 | ]);
55 | } else {
56 | const { url } = infoOrUrl;
57 | resultsFetcherLink = theResultsFetcherLink || createHttpLink({ uri: url });
58 | subscriptionLinks = new AppSyncRealTimeSubscriptionHandshakeLink(infoOrUrl);
59 | }
60 |
61 | return ApolloLink.split(
62 | operation => {
63 | const { query } = operation;
64 | const { kind, operation: graphqlOperation } = getMainDefinition(
65 | query
66 | ) as OperationDefinitionNode;
67 | const isSubscription =
68 | kind === "OperationDefinition" && graphqlOperation === "subscription";
69 |
70 | return isSubscription;
71 | },
72 | subscriptionLinks,
73 | resultsFetcherLink
74 | );
75 | }
76 |
77 | export { CONTROL_EVENTS_KEY, createSubscriptionHandshakeLink };
78 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/non-terminating-http-link.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | import { createHttpLink, HttpOptions } from '@apollo/client/link/http';
6 | import { NonTerminatingLink } from './non-terminating-link';
7 |
8 | export class NonTerminatingHttpLink extends NonTerminatingLink {
9 | constructor(contextKey: string, options: HttpOptions) {
10 | const link = createHttpLink(options);
11 |
12 | super(contextKey, { link });
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/non-terminating-link.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | import { ApolloLink } from '@apollo/client/core';
6 | import type { NextLink, FetchResult } from '@apollo/client/core';
7 | import { setContext } from '@apollo/client/link/context';
8 | import type { Observable } from 'zen-observable-ts';
9 |
10 | export class NonTerminatingLink extends ApolloLink {
11 |
12 | private contextKey: string;
13 | private link: ApolloLink;
14 |
15 | constructor(contextKey: string, { link }: { link: ApolloLink }) {
16 | super();
17 |
18 | this.contextKey = contextKey;
19 | this.link = link;
20 | }
21 |
22 | request(operation, forward?: NextLink): Observable {
23 | return (setContext(async (_request, prevContext) => {
24 | const result = await new Promise((resolve, reject) => {
25 | this.link.request(operation).subscribe({
26 | next: resolve,
27 | error: reject,
28 | });
29 | });
30 |
31 | return {
32 | ...prevContext,
33 | [this.contextKey]: result,
34 | }
35 | })).request(operation, forward);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/realtime-subscription-handshake-link.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | import { ApolloLink, Observable, Operation, FetchResult } from "@apollo/client/core";
6 |
7 | import { rootLogger } from "./utils";
8 |
9 | import {
10 | Signer,
11 | AuthOptions,
12 | AUTH_TYPE,
13 | USER_AGENT_HEADER,
14 | USER_AGENT
15 | } from "aws-appsync-auth-link";
16 | import { GraphQLError, print } from "graphql";
17 | import * as url from "url";
18 | import { v4 as uuid } from "uuid";
19 | import {
20 | AppSyncRealTimeSubscriptionConfig,
21 | SOCKET_STATUS,
22 | ObserverQuery,
23 | SUBSCRIPTION_STATUS,
24 | MESSAGE_TYPES,
25 | CONTROL_MSG
26 | } from "./types";
27 | import { jitteredExponentialRetry, NonRetryableError } from "./utils/retry";
28 |
29 | const logger = rootLogger.extend("subscriptions");
30 |
31 | export const CONTROL_EVENTS_KEY = "@@controlEvents";
32 |
33 | const NON_RETRYABLE_CODES = [400, 401, 403];
34 |
35 | const SERVICE = "appsync";
36 |
37 | const APPSYNC_REALTIME_HEADERS = {
38 | accept: 'application/json, text/javascript',
39 | 'content-encoding': 'amz-1.0',
40 | 'content-type': 'application/json; charset=UTF-8'
41 | };
42 |
43 | /**
44 | * Time in milliseconds to wait for GQL_CONNECTION_INIT message
45 | */
46 | const CONNECTION_INIT_TIMEOUT = 15000;
47 |
48 | /**
49 | * Time in milliseconds to wait for GQL_START_ACK message
50 | */
51 | const START_ACK_TIMEOUT = 15000;
52 |
53 | /**
54 | * Frequency in milliseconds in which the server sends GQL_CONNECTION_KEEP_ALIVE messages
55 | */
56 | const SERVER_KEEP_ALIVE_TIMEOUT = 1 * 60 * 1000;
57 |
58 | /**
59 | * Default Time in milliseconds to wait for GQL_CONNECTION_KEEP_ALIVE message
60 | */
61 | const DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1000;
62 |
63 | const standardDomainPattern = /^https:\/\/\w{26}\.appsync\-api\.\w{2}(?:(?:\-\w{2,})+)\-\d\.amazonaws.com\/graphql$/i;
64 |
65 | const customDomainPath = '/realtime';
66 |
67 | export class AppSyncRealTimeSubscriptionHandshakeLink extends ApolloLink {
68 | private url: string;
69 | private region: string;
70 | private auth: AuthOptions;
71 | private awsRealTimeSocket: WebSocket;
72 | private socketStatus: SOCKET_STATUS = SOCKET_STATUS.CLOSED;
73 | private keepAliveTimeoutId;
74 | private keepAliveTimeout?: number = undefined;
75 | private subscriptionObserverMap: Map = new Map();
76 | private promiseArray: Array<{ res: Function; rej: Function }> = [];
77 |
78 | constructor({ url: theUrl, region: theRegion, auth: theAuth, keepAliveTimeoutMs }: AppSyncRealTimeSubscriptionConfig) {
79 | super();
80 | this.url = theUrl;
81 | this.region = theRegion;
82 | this.auth = theAuth;
83 | this.keepAliveTimeout = keepAliveTimeoutMs;
84 |
85 | if (this.keepAliveTimeout < SERVER_KEEP_ALIVE_TIMEOUT) {
86 | let configName: keyof AppSyncRealTimeSubscriptionConfig = 'keepAliveTimeoutMs';
87 |
88 | throw new Error(`${configName} must be greater than or equal to ${SERVER_KEEP_ALIVE_TIMEOUT} (${this.keepAliveTimeout} used).`);
89 | }
90 | }
91 |
92 | // Check if url matches standard domain pattern
93 | private isCustomDomain(url: string): boolean {
94 | return url.match(standardDomainPattern) === null;
95 | }
96 |
97 | request(operation: Operation) {
98 | const { query, variables } = operation;
99 | const {
100 | controlMessages: { [CONTROL_EVENTS_KEY]: controlEvents } = {
101 | [CONTROL_EVENTS_KEY]: undefined
102 | },
103 | headers
104 | } = operation.getContext();
105 | return new Observable(observer => {
106 | if (!this.url) {
107 | observer.error({
108 | errors: [
109 | {
110 | ...new GraphQLError(
111 | `Subscribe only available for AWS AppSync endpoint`
112 | ),
113 | },
114 | ],
115 | });
116 | observer.complete();
117 | } else {
118 | const subscriptionId = uuid();
119 | let token = this.auth.type === AUTH_TYPE.AMAZON_COGNITO_USER_POOLS ||
120 | this.auth.type === AUTH_TYPE.OPENID_CONNECT
121 | ? this.auth.jwtToken
122 | : null;
123 |
124 | token = this.auth.type === AUTH_TYPE.AWS_LAMBDA ? this.auth.token : token;
125 |
126 | const options = {
127 | appSyncGraphqlEndpoint: this.url,
128 | authenticationType: this.auth.type,
129 | query: print(query),
130 | region: this.region,
131 | graphql_headers: () => (headers),
132 | variables,
133 | apiKey: this.auth.type === AUTH_TYPE.API_KEY ? this.auth.apiKey : "",
134 | credentials:
135 | this.auth.type === AUTH_TYPE.AWS_IAM ? this.auth.credentials : null,
136 | token
137 | };
138 |
139 | this._startSubscriptionWithAWSAppSyncRealTime({
140 | options,
141 | observer,
142 | subscriptionId
143 | });
144 |
145 | return async () => {
146 | // Cleanup after unsubscribing or observer.complete was called after _startSubscriptionWithAWSAppSyncRealTime
147 | try {
148 | this._verifySubscriptionAlreadyStarted(subscriptionId);
149 | const { subscriptionState } = this.subscriptionObserverMap.get(
150 | subscriptionId
151 | );
152 | if (subscriptionState === SUBSCRIPTION_STATUS.CONNECTED) {
153 | this._sendUnsubscriptionMessage(subscriptionId);
154 | } else {
155 | throw new Error(
156 | "Subscription has failed, starting to remove subscription."
157 | );
158 | }
159 | } catch (err) {
160 | this._removeSubscriptionObserver(subscriptionId);
161 | return;
162 | }
163 | };
164 | }
165 | }).filter(data => {
166 | const { extensions: { controlMsgType = undefined } = {} } = data;
167 | const isControlMsg = typeof controlMsgType !== "undefined";
168 |
169 | return controlEvents === true || !isControlMsg;
170 | });
171 | }
172 |
173 | private async _verifySubscriptionAlreadyStarted(subscriptionId) {
174 | const { subscriptionState } = this.subscriptionObserverMap.get(
175 | subscriptionId
176 | );
177 | // This in case unsubscribe is invoked before sending start subscription message
178 | if (subscriptionState === SUBSCRIPTION_STATUS.PENDING) {
179 | return new Promise((res, rej) => {
180 | const {
181 | observer,
182 | subscriptionState,
183 | variables,
184 | query
185 | } = this.subscriptionObserverMap.get(subscriptionId);
186 | this.subscriptionObserverMap.set(subscriptionId, {
187 | observer,
188 | subscriptionState,
189 | variables,
190 | query,
191 | subscriptionReadyCallback: res,
192 | subscriptionFailedCallback: rej
193 | });
194 | });
195 | }
196 | }
197 |
198 | private _sendUnsubscriptionMessage(subscriptionId) {
199 | try {
200 | if (
201 | this.awsRealTimeSocket &&
202 | this.awsRealTimeSocket.readyState === WebSocket.OPEN &&
203 | this.socketStatus === SOCKET_STATUS.READY
204 | ) {
205 | // Preparing unsubscribe message to stop receiving messages for that subscription
206 | const unsubscribeMessage = {
207 | id: subscriptionId,
208 | type: MESSAGE_TYPES.GQL_STOP
209 | };
210 | const stringToAWSRealTime = JSON.stringify(unsubscribeMessage);
211 | this.awsRealTimeSocket.send(stringToAWSRealTime);
212 |
213 | this._removeSubscriptionObserver(subscriptionId);
214 | }
215 | } catch (err) {
216 | // If GQL_STOP is not sent because of disconnection issue, then there is nothing the client can do
217 | logger({ err });
218 | }
219 | }
220 |
221 | private _removeSubscriptionObserver(subscriptionId) {
222 | this.subscriptionObserverMap.delete(subscriptionId);
223 | // Verifying for 1000ms after removing subscription in case there are new subscriptions on mount / unmount
224 | setTimeout(this._closeSocketIfRequired.bind(this), 1000);
225 | }
226 |
227 | private _closeSocketIfRequired() {
228 | if (this.subscriptionObserverMap.size > 0) {
229 | // There are active subscriptions on the WebSocket
230 | return;
231 | }
232 |
233 | if (!this.awsRealTimeSocket) {
234 | this.socketStatus = SOCKET_STATUS.CLOSED;
235 | return;
236 | }
237 | if (this.awsRealTimeSocket.bufferedAmount > 0) {
238 | // There is still data on the WebSocket
239 | setTimeout(this._closeSocketIfRequired.bind(this), 1000);
240 | } else {
241 | logger("closing WebSocket...");
242 | clearTimeout(this.keepAliveTimeoutId);
243 | const tempSocket = this.awsRealTimeSocket;
244 | tempSocket.close(1000);
245 | this.awsRealTimeSocket = null;
246 | this.socketStatus = SOCKET_STATUS.CLOSED;
247 | }
248 | }
249 |
250 | private async _startSubscriptionWithAWSAppSyncRealTime({
251 | options,
252 | observer,
253 | subscriptionId
254 | }) {
255 | const {
256 | appSyncGraphqlEndpoint,
257 | authenticationType,
258 | query,
259 | variables,
260 | apiKey,
261 | region,
262 | graphql_headers = () => ({}),
263 | credentials,
264 | token
265 | } = options;
266 | const subscriptionState: SUBSCRIPTION_STATUS = SUBSCRIPTION_STATUS.PENDING;
267 | const data = {
268 | query,
269 | variables
270 | };
271 | // Having a subscription id map will make it simple to forward messages received
272 | this.subscriptionObserverMap.set(subscriptionId, {
273 | observer,
274 | query,
275 | variables,
276 | subscriptionState,
277 | startAckTimeoutId: null,
278 | });
279 |
280 | // Preparing payload for subscription message
281 |
282 | const dataString = JSON.stringify(data);
283 | const headerObj = {
284 | ...(await this._awsRealTimeHeaderBasedAuth({
285 | apiKey,
286 | appSyncGraphqlEndpoint,
287 | authenticationType,
288 | payload: dataString,
289 | canonicalUri: "",
290 | region,
291 | credentials,
292 | token,
293 | graphql_headers
294 | })),
295 | [USER_AGENT_HEADER]: USER_AGENT
296 | };
297 |
298 | const subscriptionMessage = {
299 | id: subscriptionId,
300 | payload: {
301 | data: dataString,
302 | extensions: {
303 | authorization: {
304 | ...headerObj
305 | }
306 | }
307 | },
308 | type: MESSAGE_TYPES.GQL_START
309 | };
310 |
311 | const stringToAWSRealTime = JSON.stringify(subscriptionMessage);
312 |
313 | try {
314 | await this._initializeWebSocketConnection({
315 | apiKey,
316 | appSyncGraphqlEndpoint,
317 | authenticationType,
318 | region,
319 | credentials,
320 | token
321 | });
322 | } catch (err) {
323 | const { message = "" } = err;
324 | observer.error({
325 | errors: [
326 | {
327 | ...new GraphQLError(`Connection failed: ${message}`)
328 | }
329 | ]
330 | });
331 | observer.complete();
332 |
333 | const { subscriptionFailedCallback } =
334 | this.subscriptionObserverMap.get(subscriptionId) || {};
335 |
336 | // Notify concurrent unsubscription
337 | if (typeof subscriptionFailedCallback === "function") {
338 | subscriptionFailedCallback();
339 | }
340 | return;
341 | }
342 |
343 | // There could be a race condition when unsubscribe gets called during _initializeWebSocketConnection
344 | // For example if unsubscribe gets invoked before it finishes WebSocket handshake or START_ACK
345 | // subscriptionFailedCallback subscriptionReadyCallback are used to synchonized that
346 |
347 | const {
348 | subscriptionFailedCallback,
349 | subscriptionReadyCallback
350 | } = this.subscriptionObserverMap.get(subscriptionId) || {};
351 |
352 | // This must be done before sending the message in order to be listening immediately
353 | this.subscriptionObserverMap.set(subscriptionId, {
354 | observer,
355 | subscriptionState,
356 | variables,
357 | query,
358 | subscriptionReadyCallback,
359 | subscriptionFailedCallback,
360 | startAckTimeoutId: (setTimeout(() => {
361 | this._timeoutStartSubscriptionAck.call(this, subscriptionId);
362 | }, START_ACK_TIMEOUT) as unknown) as number
363 | });
364 |
365 | if (this.awsRealTimeSocket) {
366 | this.awsRealTimeSocket.send(stringToAWSRealTime);
367 | }
368 | }
369 |
370 | private _initializeWebSocketConnection({
371 | appSyncGraphqlEndpoint,
372 | authenticationType,
373 | apiKey,
374 | region,
375 | credentials,
376 | token
377 | }): Promise {
378 | if (this.socketStatus === SOCKET_STATUS.READY) {
379 | return;
380 | }
381 | return new Promise(async (res, rej) => {
382 | this.promiseArray.push({ res, rej });
383 |
384 | if (this.socketStatus === SOCKET_STATUS.CLOSED) {
385 | try {
386 | this.socketStatus = SOCKET_STATUS.CONNECTING;
387 |
388 | const payloadString = "{}";
389 | const headerString = JSON.stringify(
390 | await this._awsRealTimeHeaderBasedAuth({
391 | authenticationType,
392 | payload: payloadString,
393 | canonicalUri: "/connect",
394 | apiKey,
395 | appSyncGraphqlEndpoint,
396 | region,
397 | credentials,
398 | token,
399 | graphql_headers: () => { }
400 | })
401 | );
402 | const headerQs = Buffer.from(headerString).toString("base64");
403 |
404 | const payloadQs = Buffer.from(payloadString).toString("base64");
405 |
406 | let discoverableEndpoint = appSyncGraphqlEndpoint;
407 |
408 | if (this.isCustomDomain(discoverableEndpoint)) {
409 | discoverableEndpoint = discoverableEndpoint.concat(
410 | customDomainPath
411 | );
412 | } else {
413 | discoverableEndpoint = discoverableEndpoint.replace('appsync-api', 'appsync-realtime-api').replace('gogi-beta', 'grt-beta');
414 | }
415 |
416 | discoverableEndpoint = discoverableEndpoint
417 | .replace("https://", "wss://")
418 | .replace('http://', 'ws://')
419 |
420 | const awsRealTimeUrl = `${discoverableEndpoint}?header=${headerQs}&payload=${payloadQs}`;
421 |
422 | await this._initializeRetryableHandshake({ awsRealTimeUrl });
423 |
424 | this.promiseArray.forEach(({ res }) => {
425 | logger("Notifying connection successful");
426 | res();
427 | });
428 | this.socketStatus = SOCKET_STATUS.READY;
429 | this.promiseArray = [];
430 | } catch (err) {
431 | this.promiseArray.forEach(({ rej }) => rej(err));
432 | this.promiseArray = [];
433 | if (
434 | this.awsRealTimeSocket &&
435 | this.awsRealTimeSocket.readyState === WebSocket.OPEN
436 | ) {
437 | this.awsRealTimeSocket.close(3001);
438 | }
439 | this.awsRealTimeSocket = null;
440 | this.socketStatus = SOCKET_STATUS.CLOSED;
441 | }
442 | }
443 | });
444 | }
445 |
446 | private async _awsRealTimeHeaderBasedAuth({
447 | authenticationType,
448 | payload,
449 | canonicalUri,
450 | appSyncGraphqlEndpoint,
451 | apiKey,
452 | region,
453 | credentials,
454 | token,
455 | graphql_headers
456 | }) {
457 | const headerHandler: Record<
458 | string,
459 | (info: any) => Promise>
460 | > = {
461 | API_KEY: this._awsRealTimeApiKeyHeader.bind(this),
462 | AWS_IAM: this._awsRealTimeIAMHeader.bind(this),
463 | OPENID_CONNECT: this._awsRealTimeAuthorizationHeader.bind(this),
464 | AMAZON_COGNITO_USER_POOLS: this._awsRealTimeAuthorizationHeader.bind(this),
465 | AWS_LAMBDA: this._awsRealTimeAuthorizationHeader.bind(this)
466 | };
467 |
468 | const handler = headerHandler[authenticationType];
469 |
470 | if (typeof handler !== "function") {
471 | logger(`Authentication type ${authenticationType} not supported`);
472 | return {};
473 | }
474 |
475 | const { host } = url.parse(appSyncGraphqlEndpoint);
476 |
477 | const result = await handler({
478 | payload,
479 | canonicalUri,
480 | appSyncGraphqlEndpoint,
481 | apiKey,
482 | region,
483 | host,
484 | credentials,
485 | token,
486 | graphql_headers
487 | });
488 |
489 | return result;
490 | }
491 |
492 | private async _awsRealTimeAuthorizationHeader({
493 | host,
494 | token,
495 | graphql_headers
496 | }): Promise> {
497 | return {
498 | Authorization:
499 | typeof token === "function"
500 | ? await token.call(undefined)
501 | : await token,
502 | host,
503 | ...(await graphql_headers())
504 | };
505 | }
506 |
507 | private async _awsRealTimeApiKeyHeader({
508 | apiKey,
509 | host,
510 | graphql_headers
511 | }): Promise> {
512 | const dt = new Date();
513 | const dtStr = dt.toISOString().replace(/[:\-]|\.\d{3}/g, "");
514 |
515 | return {
516 | host,
517 | "x-amz-date": dtStr,
518 | "x-api-key": apiKey,
519 | ...(await graphql_headers()),
520 | };
521 | }
522 |
523 | private async _awsRealTimeIAMHeader({
524 | payload,
525 | canonicalUri,
526 | appSyncGraphqlEndpoint,
527 | region,
528 | credentials
529 | }): Promise> {
530 | const endpointInfo = {
531 | region,
532 | service: SERVICE
533 | };
534 |
535 | let creds =
536 | typeof credentials === "function"
537 | ? credentials.call()
538 | : credentials || {};
539 |
540 | if (creds && typeof creds.getPromise === "function") {
541 | await creds.getPromise();
542 | }
543 |
544 | if (!creds) {
545 | throw new Error("No credentials");
546 | }
547 | const { accessKeyId, secretAccessKey, sessionToken } = await creds;
548 |
549 | const formattedCredentials = {
550 | access_key: accessKeyId,
551 | secret_key: secretAccessKey,
552 | session_token: sessionToken
553 | };
554 |
555 | const request = {
556 | url: `${appSyncGraphqlEndpoint}${canonicalUri}`,
557 | body: payload,
558 | method: "POST",
559 | headers: { ...APPSYNC_REALTIME_HEADERS }
560 | };
561 |
562 | const signed_params = Signer.sign(
563 | request,
564 | formattedCredentials,
565 | endpointInfo
566 | );
567 | return signed_params.headers;
568 | }
569 |
570 | private async _initializeRetryableHandshake({ awsRealTimeUrl }) {
571 | logger(`Initializaling retryable Handshake`);
572 | await jitteredExponentialRetry(this._initializeHandshake.bind(this), [
573 | { awsRealTimeUrl }
574 | ]);
575 | }
576 |
577 | private async _initializeHandshake({ awsRealTimeUrl }) {
578 | logger(`Initializing handshake ${awsRealTimeUrl}`);
579 | // Because connecting the socket is async, is waiting until connection is open
580 | // Step 1: connect websocket
581 | try {
582 | await (() => {
583 | return new Promise((res, rej) => {
584 | const newSocket = AppSyncRealTimeSubscriptionHandshakeLink.createWebSocket(awsRealTimeUrl, "graphql-ws");
585 | newSocket.onerror = () => {
586 | logger(`WebSocket connection error`);
587 | };
588 | newSocket.onclose = () => {
589 | rej(new Error("Connection handshake error"));
590 | };
591 | newSocket.onopen = () => {
592 | this.awsRealTimeSocket = newSocket;
593 | return res();
594 | };
595 | });
596 | })();
597 |
598 |
599 | // Step 2: wait for ack from AWS AppSyncReaTime after sending init
600 | await (() => {
601 | return new Promise((res, rej) => {
602 | let ackOk = false;
603 | this.awsRealTimeSocket.onerror = error => {
604 | logger(`WebSocket closed ${JSON.stringify(error)}`);
605 | };
606 | this.awsRealTimeSocket.onclose = event => {
607 | logger(`WebSocket closed ${event.reason}`);
608 | rej(new Error(JSON.stringify(event)));
609 | };
610 |
611 | this.awsRealTimeSocket.onmessage = (message: MessageEvent) => {
612 | logger(
613 | `subscription message from AWS AppSyncRealTime: ${message.data} `
614 | );
615 | const data = JSON.parse(message.data);
616 | const {
617 | type,
618 | payload: { connectionTimeoutMs = DEFAULT_KEEP_ALIVE_TIMEOUT } = {}
619 | } = data;
620 | if (type === MESSAGE_TYPES.GQL_CONNECTION_ACK) {
621 | ackOk = true;
622 | this.keepAliveTimeout = this.keepAliveTimeout ?? connectionTimeoutMs;
623 | this.awsRealTimeSocket.onmessage = this._handleIncomingSubscriptionMessage.bind(
624 | this
625 | );
626 |
627 | this.awsRealTimeSocket.onerror = err => {
628 | logger(err);
629 | this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
630 | };
631 |
632 | this.awsRealTimeSocket.onclose = event => {
633 | logger(`WebSocket closed ${event.reason}`);
634 | this._errorDisconnect(CONTROL_MSG.CONNECTION_CLOSED);
635 | };
636 |
637 | res("Cool, connected to AWS AppSyncRealTime");
638 | return;
639 | }
640 |
641 | if (type === MESSAGE_TYPES.GQL_CONNECTION_ERROR) {
642 | const {
643 | payload: {
644 | errors: [{ errorType = "", errorCode = 0 } = {}] = []
645 | } = {}
646 | } = data;
647 |
648 | rej({ errorType, errorCode });
649 | }
650 | };
651 |
652 | const gqlInit = {
653 | type: MESSAGE_TYPES.GQL_CONNECTION_INIT
654 | };
655 | this.awsRealTimeSocket.send(JSON.stringify(gqlInit));
656 |
657 | function checkAckOk() {
658 | if (!ackOk) {
659 | rej(
660 | new Error(
661 | `Connection timeout: ack from AWSRealTime was not received on ${CONNECTION_INIT_TIMEOUT} ms`
662 | )
663 | );
664 | }
665 | }
666 |
667 | setTimeout(checkAckOk.bind(this), CONNECTION_INIT_TIMEOUT);
668 | });
669 | })();
670 | } catch (err) {
671 | const { errorType, errorCode } = err;
672 |
673 | if (NON_RETRYABLE_CODES.indexOf(errorCode) >= 0) {
674 | throw new NonRetryableError(errorType);
675 | } else if (errorType) {
676 | throw new Error(errorType);
677 | } else {
678 | throw err;
679 | }
680 | }
681 | }
682 |
683 | private _handleIncomingSubscriptionMessage(message: MessageEvent) {
684 | logger(`subscription message from AWS AppSync RealTime: ${message.data}`);
685 | const { id = "", payload, type } = JSON.parse(message.data);
686 | const {
687 | observer = null,
688 | query = "",
689 | variables = {},
690 | startAckTimeoutId = 0,
691 | subscriptionReadyCallback = null,
692 | subscriptionFailedCallback = null
693 | } = this.subscriptionObserverMap.get(id) || {};
694 |
695 | logger({ id, observer, query, variables });
696 |
697 | if (type === MESSAGE_TYPES.GQL_DATA && payload && payload.data) {
698 | if (observer) {
699 | observer.next(payload);
700 | } else {
701 | logger(`observer not found for id: ${id}`);
702 | }
703 | return;
704 | }
705 |
706 | if (type === MESSAGE_TYPES.GQL_START_ACK) {
707 | logger(`subscription ready for ${JSON.stringify({ query, variables })}`);
708 | if (typeof subscriptionReadyCallback === "function") {
709 | subscriptionReadyCallback();
710 | }
711 | clearTimeout(startAckTimeoutId as number);
712 | if (observer) {
713 | observer.next({
714 | data: payload,
715 | extensions: {
716 | controlMsgType: "CONNECTED"
717 | }
718 | });
719 | } else {
720 | logger(`observer not found for id: ${id}`);
721 | }
722 |
723 | const subscriptionState = SUBSCRIPTION_STATUS.CONNECTED;
724 | this.subscriptionObserverMap.set(id, {
725 | observer,
726 | query,
727 | variables,
728 | startAckTimeoutId: null,
729 | subscriptionState,
730 | subscriptionReadyCallback,
731 | subscriptionFailedCallback
732 | });
733 |
734 | return;
735 | }
736 |
737 | if (type === MESSAGE_TYPES.GQL_CONNECTION_KEEP_ALIVE) {
738 | clearTimeout(this.keepAliveTimeoutId);
739 | this.keepAliveTimeoutId = setTimeout(
740 | this._errorDisconnect.bind(this, CONTROL_MSG.TIMEOUT_DISCONNECT),
741 | this.keepAliveTimeout
742 | );
743 | return;
744 | }
745 |
746 | if (type === MESSAGE_TYPES.GQL_ERROR) {
747 | const subscriptionState = SUBSCRIPTION_STATUS.FAILED;
748 | this.subscriptionObserverMap.set(id, {
749 | observer,
750 | query,
751 | variables,
752 | startAckTimeoutId,
753 | subscriptionReadyCallback,
754 | subscriptionFailedCallback,
755 | subscriptionState
756 | });
757 |
758 | clearTimeout(startAckTimeoutId);
759 |
760 | if (observer) {
761 | observer.error({
762 | errors: [
763 | {
764 | ...new GraphQLError(`Connection failed: ${JSON.stringify(payload)}`)
765 | }
766 | ]
767 | });
768 | observer.complete();
769 | } else {
770 | logger(`observer not found for id: ${id}`);
771 | }
772 |
773 | if (typeof subscriptionFailedCallback === "function") {
774 | subscriptionFailedCallback();
775 | }
776 | }
777 | }
778 |
779 | private _errorDisconnect(msg: string) {
780 | logger(`Disconnect error: ${msg}`);
781 | this.subscriptionObserverMap.forEach(({ observer }) => {
782 | if (observer && !observer.closed) {
783 | observer.error({
784 | errors: [{ ...new GraphQLError(msg) }],
785 | });
786 | }
787 | });
788 | this.subscriptionObserverMap.clear();
789 | if (this.awsRealTimeSocket) {
790 | this.awsRealTimeSocket.close();
791 | }
792 |
793 | this.socketStatus = SOCKET_STATUS.CLOSED;
794 | }
795 |
796 | private _timeoutStartSubscriptionAck(subscriptionId) {
797 | const { observer, query, variables } =
798 | this.subscriptionObserverMap.get(subscriptionId) || {};
799 |
800 | if (!observer) {
801 | return;
802 | }
803 |
804 | this.subscriptionObserverMap.set(subscriptionId, {
805 | observer,
806 | query,
807 | variables,
808 | subscriptionState: SUBSCRIPTION_STATUS.FAILED
809 | });
810 |
811 | if (observer && !observer.closed) {
812 | observer.error({
813 | errors: [
814 | {
815 | ...new GraphQLError(
816 | `Subscription timeout ${JSON.stringify({ query, variables })}`
817 | )
818 | }
819 | ]
820 | });
821 | // Cleanup will be automatically executed
822 | observer.complete();
823 | }
824 | logger("timeoutStartSubscription", JSON.stringify({ query, variables }));
825 | }
826 |
827 | static createWebSocket(awsRealTimeUrl: string, protocol: string): WebSocket {
828 | return new WebSocket(awsRealTimeUrl, protocol);
829 | }
830 | }
831 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/subscription-handshake-link.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | import { ApolloLink, Observable, Operation, FetchResult, ApolloError } from "@apollo/client/core";
6 | import * as ZenObservable from 'zen-observable-ts';
7 |
8 | import { rootLogger } from "./utils";
9 | import * as Paho from './vendor/paho-mqtt';
10 | import type { FieldNode } from "graphql";
11 | import { getMainDefinition } from "@apollo/client/utilities";
12 |
13 | const logger = rootLogger.extend('subscriptions');
14 | const mqttLogger = logger.extend('mqtt');
15 |
16 | type SubscriptionExtension = {
17 | mqttConnections: MqttConnectionInfo[],
18 | newSubscriptions: NewSubscriptions,
19 | }
20 |
21 | type MqttConnectionInfo = {
22 | client: string,
23 | url: string,
24 | topics: string[],
25 | };
26 |
27 | type NewSubscriptions = {
28 | [key: string]: {
29 | topic: string,
30 | expireTime: number,
31 | }
32 | };
33 |
34 | type ClientObservers = {
35 | client: any,
36 | observers: Set>,
37 | }
38 |
39 | export const CONTROL_EVENTS_KEY = '@@controlEvents';
40 |
41 | export class SubscriptionHandshakeLink extends ApolloLink {
42 |
43 | private subsInfoContextKey: string;
44 |
45 | private topicObservers: Map>> = new Map();
46 |
47 | private clientObservers: Map = new Map();
48 |
49 | constructor(subsInfoContextKey) {
50 | super();
51 | this.subsInfoContextKey = subsInfoContextKey;
52 | }
53 |
54 | request(operation: Operation): Observable | null {
55 | const {
56 | [this.subsInfoContextKey]: subsInfo,
57 | controlMessages: { [CONTROL_EVENTS_KEY]: controlEvents } = { [CONTROL_EVENTS_KEY]: undefined }
58 | } = operation.getContext();
59 | const {
60 | extensions: {
61 | subscription: { newSubscriptions, mqttConnections }
62 | } = { subscription: { newSubscriptions: {}, mqttConnections: [] } },
63 | errors = [],
64 | }: {
65 | extensions?: {
66 | subscription: SubscriptionExtension
67 | },
68 | errors: any[]
69 | } = subsInfo;
70 |
71 | if (errors && errors.length) {
72 | return new Observable(observer => {
73 | observer.error(new ApolloError({
74 | errorMessage: 'Error during subscription handshake',
75 | extraInfo: { errors },
76 | graphQLErrors: errors
77 | }));
78 |
79 | return () => { };
80 | });
81 | }
82 |
83 | const newSubscriptionTopics = Object.keys(newSubscriptions).map(subKey => newSubscriptions[subKey].topic);
84 | const existingTopicsWithObserver = new Set(newSubscriptionTopics.filter(t => this.topicObservers.has(t)));
85 | const newTopics = new Set(newSubscriptionTopics.filter(t => !existingTopicsWithObserver.has(t)));
86 |
87 | return new Observable(observer => {
88 | existingTopicsWithObserver.forEach(t => {
89 | this.topicObservers.get(t).add(observer);
90 | const anObserver = Array.from(this.topicObservers.get(t)).find(() => true);
91 |
92 | const [clientId] = Array.from(this.clientObservers).find(([, { observers }]) => observers.has(anObserver));
93 | this.clientObservers.get(clientId).observers.add(observer);
94 | });
95 |
96 | const newTopicsConnectionInfo = mqttConnections
97 | .filter(c => c.topics.some(t => newTopics.has(t)))
98 | .map(({ topics, ...rest }) => ({
99 | ...rest,
100 | topics: topics.filter(t => newTopics.has(t))
101 | } as MqttConnectionInfo));
102 |
103 | this.connectNewClients(newTopicsConnectionInfo, observer, operation);
104 |
105 | return () => {
106 | const clientsForCurrentObserver = Array.from(this.clientObservers).filter(([, { observers }]) => observers.has(observer));
107 | clientsForCurrentObserver.forEach(([clientId]) => this.clientObservers.get(clientId).observers.delete(observer));
108 |
109 | this.clientObservers.forEach(({ observers, client }) => {
110 | if (observers.size === 0) {
111 | if (client.isConnected()) {
112 | client.disconnect();
113 | }
114 | this.clientObservers.delete(client.clientId);
115 | }
116 | });
117 | this.clientObservers = new Map(
118 | Array.from(this.clientObservers).filter(([, { observers }]) => observers.size > 0)
119 | );
120 |
121 | this.topicObservers.forEach(observers => observers.delete(observer));
122 |
123 | this.topicObservers = new Map(
124 | Array.from(this.topicObservers)
125 | .filter(([, observers]) => observers.size > 0)
126 | );
127 | };
128 | }).filter(data => {
129 | const { extensions: { controlMsgType = undefined } = {} } = data;
130 | const isControlMsg = typeof controlMsgType !== 'undefined';
131 |
132 | return controlEvents === true || !isControlMsg;
133 | });
134 | }
135 |
136 | async connectNewClients(connectionInfo: MqttConnectionInfo[], observer: ZenObservable.Observer, operation: Operation) {
137 | const { query } = operation;
138 | const selectionNames = (getMainDefinition(query).selectionSet.selections as FieldNode[]).map(({ name: { value } }) => value);
139 |
140 | const result = Promise.all(connectionInfo.map(c => this.connectNewClient(c, observer, selectionNames)));
141 |
142 | const data = selectionNames.reduce(
143 | (acc, name) => (acc[name] = acc[name] || null, acc),
144 | {}
145 | );
146 |
147 | observer.next({
148 | data,
149 | extensions: {
150 | controlMsgType: 'CONNECTED',
151 | controlMsgInfo: {
152 | connectionInfo,
153 | },
154 | }
155 | });
156 |
157 | return result
158 | };
159 |
160 | async connectNewClient(connectionInfo: MqttConnectionInfo, observer: ZenObservable.Observer, selectionNames: string[]) {
161 | const { client: clientId, url, topics } = connectionInfo;
162 | const client: any = new Paho.Client(url, clientId);
163 |
164 | client.trace = mqttLogger.bind(null, clientId);
165 | client.onConnectionLost = ({ errorCode, ...args }) => {
166 | if (errorCode !== 0) {
167 | topics.forEach(t => {
168 | if (this.topicObservers.has(t)) {
169 | this.topicObservers.get(t).forEach(observer => observer.error({ ...args, permanent: true }));
170 | }
171 | });
172 | }
173 |
174 | topics.forEach(t => this.topicObservers.delete(t));
175 | };
176 |
177 | (client as any).onMessageArrived = ({ destinationName, payloadString }) => this.onMessage(destinationName, payloadString, selectionNames);
178 |
179 | await new Promise((resolve, reject) => {
180 | client.connect({
181 | useSSL: url.indexOf('wss://') === 0,
182 | mqttVersion: 3,
183 | onSuccess: () => resolve(client),
184 | onFailure: reject,
185 | });
186 | });
187 |
188 | await this.subscribeToTopics(client, topics, observer);
189 |
190 | return client;
191 | }
192 |
193 | subscribeToTopics(client, topics: string[], observer: ZenObservable.Observer) {
194 | return Promise.all(topics.map(topic => this.subscribeToTopic(client, topic, observer)));
195 | }
196 |
197 | subscribeToTopic(client, topic: string, observer: ZenObservable.Observer) {
198 | return new Promise((resolve, reject) => {
199 | (client as any).subscribe(topic, {
200 | onSuccess: () => {
201 | if (!this.topicObservers.has(topic)) {
202 | this.topicObservers.set(topic, new Set());
203 | }
204 | if (!this.clientObservers.has(client.clientId)) {
205 | this.clientObservers.set(client.clientId, { client, observers: new Set() });
206 | }
207 |
208 | this.topicObservers.get(topic).add(observer);
209 | this.clientObservers.get(client.clientId).observers.add(observer);
210 |
211 | resolve(topic);
212 | },
213 | onFailure: reject,
214 | });
215 | });
216 | }
217 |
218 | onMessage = (topic: string, message: string, selectionNames: string[]) => {
219 | const parsedMessage = JSON.parse(message);
220 | const observers = this.topicObservers.get(topic);
221 |
222 | const data = selectionNames.reduce(
223 | (acc, name) => (acc[name] = acc[name] || null, acc),
224 | parsedMessage.data || {}
225 | );
226 |
227 | logger('Message received', { data, topic, observers });
228 |
229 | observers.forEach(observer => {
230 | try {
231 | observer.next({
232 | ...parsedMessage,
233 | ...{ data },
234 | })
235 | } catch (err) {
236 | logger(err);
237 | }
238 | });
239 | }
240 | }
241 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/types/index.ts:
--------------------------------------------------------------------------------
1 | import { AuthOptions } from "aws-appsync-auth-link";
2 | import * as ZenObservable from 'zen-observable-ts';
3 |
4 | //#region Subscription link enums
5 |
6 | export enum SUBSCRIPTION_STATUS {
7 | PENDING,
8 | CONNECTED,
9 | FAILED
10 | }
11 |
12 | export enum SOCKET_STATUS {
13 | CLOSED,
14 | READY,
15 | CONNECTING
16 | }
17 |
18 | export enum MESSAGE_TYPES {
19 | /**
20 | * Client -> Server message.
21 | * This message type is the first message after handshake and this will initialize AWS AppSync RealTime communication
22 | */
23 | GQL_CONNECTION_INIT = "connection_init",
24 | /**
25 | * Server -> Client message
26 | * This message type is in case there is an issue with AWS AppSync RealTime when establishing connection
27 | */
28 | GQL_CONNECTION_ERROR = "connection_error",
29 | /**
30 | * Server -> Client message.
31 | * This message type is for the ack response from AWS AppSync RealTime for GQL_CONNECTION_INIT message
32 | */
33 | GQL_CONNECTION_ACK = "connection_ack",
34 | /**
35 | * Client -> Server message.
36 | * This message type is for register subscriptions with AWS AppSync RealTime
37 | */
38 | GQL_START = "start",
39 | /**
40 | * Server -> Client message.
41 | * This message type is for the ack response from AWS AppSync RealTime for GQL_START message
42 | */
43 | GQL_START_ACK = "start_ack",
44 | /**
45 | * Server -> Client message.
46 | * This message type is for subscription message from AWS AppSync RealTime
47 | */
48 | GQL_DATA = "data",
49 | /**
50 | * Server -> Client message.
51 | * This message type helps the client to know is still receiving messages from AWS AppSync RealTime
52 | */
53 | GQL_CONNECTION_KEEP_ALIVE = "ka",
54 | /**
55 | * Client -> Server message.
56 | * This message type is for unregister subscriptions with AWS AppSync RealTime
57 | */
58 | GQL_STOP = "stop",
59 | /**
60 | * Server -> Client message.
61 | * This message type is for the ack response from AWS AppSync RealTime for GQL_STOP message
62 | */
63 | GQL_COMPLETE = "complete",
64 | /**
65 | * Server -> Client message.
66 | * This message type is for sending error messages from AWS AppSync RealTime to the client
67 | */
68 | GQL_ERROR = "error" // Server -> Client
69 | }
70 |
71 | export enum CONTROL_MSG {
72 | CONNECTION_CLOSED = 'Connection closed',
73 | TIMEOUT_DISCONNECT = 'Timeout disconnect',
74 | SUBSCRIPTION_ACK = 'Subscription ack',
75 | }
76 |
77 | //#endregion
78 |
79 | //#region Subscription link types
80 |
81 | export type UrlInfo = {
82 | url: string;
83 | auth: AuthOptions;
84 | region: string;
85 | };
86 |
87 | export type AppSyncRealTimeSubscriptionConfig = UrlInfo & {
88 | keepAliveTimeoutMs?: number;
89 | };
90 |
91 | export type ObserverQuery = {
92 | observer: ZenObservable.SubscriptionObserver;
93 | query: string;
94 | variables: object;
95 | subscriptionState: SUBSCRIPTION_STATUS;
96 | subscriptionReadyCallback?: Function;
97 | subscriptionFailedCallback?: Function;
98 | startAckTimeoutId?: number;
99 | };
100 |
101 | //#endregion
102 |
103 | //#region Retry logic types
104 |
105 | export type DelayFunction = (
106 | attempt: number,
107 | args?: any[],
108 | error?: Error
109 | ) => number | false;
110 |
111 | //#endregion
112 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/utils/index.ts:
--------------------------------------------------------------------------------
1 | /*!
2 | * Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 | * SPDX-License-Identifier: Apache-2.0
4 | */
5 | export { default as rootLogger } from './logger';
6 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/utils/logger.ts:
--------------------------------------------------------------------------------
1 | import debug from 'debug';
2 |
3 | export type Logger = Function & {
4 | extend(category: string): Logger;
5 | };
6 |
7 | const debugLogger = debug('aws-appsync') as Logger;
8 |
9 | const extend = function (category = '') {
10 | const newCategory = category ? [...this.namespace.split(':'), category].join(':') : this.namespace;
11 |
12 | const result = debug(newCategory);
13 | result.extend = extend.bind(result);
14 |
15 | return result;
16 | };
17 | debugLogger.extend = extend.bind(debugLogger);
18 |
19 | export default debugLogger;
20 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/src/utils/retry.ts:
--------------------------------------------------------------------------------
1 | import { rootLogger } from "./index";
2 | import { DelayFunction } from "../types";
3 |
4 | const logger = rootLogger.extend("retry");
5 |
6 | const MAX_DELAY_MS = 5000;
7 |
8 | /**
9 | * Internal use of Subscription link
10 | * @private
11 | */
12 | export class NonRetryableError extends Error {
13 | public readonly nonRetryable = true;
14 | constructor(message: string) {
15 | super(message);
16 | }
17 | }
18 |
19 | const isNonRetryableError = (obj: any): obj is NonRetryableError => {
20 | const key: keyof NonRetryableError = "nonRetryable";
21 | return obj && obj[key];
22 | };
23 |
24 | /**
25 | * @private
26 | * Internal use of Subscription link
27 | */
28 | export async function retry(
29 | functionToRetry: Function,
30 | args: any[],
31 | delayFn: DelayFunction,
32 | attempt: number = 1
33 | ) {
34 | logger(`Attempt #${attempt} for this vars: ${JSON.stringify(args)}`);
35 | try {
36 | await functionToRetry.apply(undefined, args);
37 | } catch (err) {
38 | logger(`error ${err}`);
39 | if (isNonRetryableError(err)) {
40 | logger("non retryable error");
41 | throw err;
42 | }
43 |
44 | const retryIn = delayFn(attempt, args, err);
45 | logger("retryIn ", retryIn);
46 | if (retryIn !== false) {
47 | await new Promise(res => setTimeout(res, retryIn));
48 | return await retry(functionToRetry, args, delayFn, attempt + 1);
49 | } else {
50 | throw err;
51 | }
52 | }
53 | }
54 |
55 | function jitteredBackoff(maxDelayMs: number): DelayFunction {
56 | const BASE_TIME_MS = 100;
57 | const JITTER_FACTOR = 100;
58 |
59 | return attempt => {
60 | const delay = 2 ** attempt * BASE_TIME_MS + JITTER_FACTOR * Math.random();
61 | return delay > maxDelayMs ? false : delay;
62 | };
63 | }
64 |
65 | /**
66 | * @private
67 | * Internal use of Subscription link
68 | */
69 | export const jitteredExponentialRetry = (
70 | functionToRetry: Function,
71 | args: any[],
72 | maxDelayMs: number = MAX_DELAY_MS
73 | ) => retry(functionToRetry, args, jitteredBackoff(maxDelayMs));
74 |
--------------------------------------------------------------------------------
/packages/aws-appsync-subscription-link/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "outDir": "lib",
4 | "rootDir": "src",
5 | "module": "commonjs",
6 | "target": "es5",
7 | "moduleResolution": "node",
8 | "declaration": true,
9 | "lib": [
10 | "dom",
11 | "es6",
12 | "esnext.asynciterable",
13 | "es2017.object"
14 | ],
15 | "skipLibCheck": true
16 | },
17 | "exclude": [
18 | "lib",
19 | "__tests__"
20 | ],
21 | "compileOnSave": true
22 | }
23 |
--------------------------------------------------------------------------------