@aws-sdk/middleware-websocket 3.972.3 → 3.972.5

package/dist-cjs/index.js

@@ -1,192 +1,21 @@
 'use strict';
 
-var eventstreamCodec = require('@smithy/eventstream-codec');
-var utilHexEncoding = require('@smithy/util-hex-encoding');
-var protocolHttp = require('@smithy/protocol-http');
 var utilFormatUrl = require('@aws-sdk/util-format-url');
 var eventstreamSerdeBrowser = require('@smithy/eventstream-serde-browser');
 var fetchHttpHandler = require('@smithy/fetch-http-handler');
-
-const getEventSigningTransformStream = (initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) => {
-    let priorSignature = initialSignature;
-    const transformer = {
-        start() { },
-        async transform(chunk, controller) {
-            try {
-                const now = new Date(Date.now() + (await systemClockOffsetProvider()));
-                const dateHeader = {
-                    ":date": { type: "timestamp", value: now },
-                };
-                const signedMessage = await messageSigner.sign({
-                    message: {
-                        body: chunk,
-                        headers: dateHeader,
-                    },
-                    priorSignature: priorSignature,
-                }, {
-                    signingDate: now,
-                });
-                priorSignature = signedMessage.signature;
-                const serializedSigned = eventStreamCodec.encode({
-                    headers: {
-                        ...dateHeader,
-                        ":chunk-signature": {
-                            type: "binary",
-                            value: utilHexEncoding.fromHex(signedMessage.signature),
-                        },
-                    },
-                    body: chunk,
-                });
-                controller.enqueue(serializedSigned);
-            }
-            catch (error) {
-                controller.error(error);
-            }
-        },
-    };
-    return new TransformStream({ ...transformer });
-};
-
-class EventStreamPayloadHandler {
-    messageSigner;
-    eventStreamCodec;
-    systemClockOffsetProvider;
-    constructor(options) {
-        this.messageSigner = options.messageSigner;
-        this.eventStreamCodec = new eventstreamCodec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
-        this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
-    }
-    async handle(next, args, context = {}) {
-        const request = args.request;
-        const { body: payload, headers, query } = request;
-        if (!(payload instanceof ReadableStream)) {
-            throw new Error("Eventstream payload must be a ReadableStream.");
-        }
-        const placeHolderStream = new TransformStream();
-        request.body = placeHolderStream.readable;
-        let result;
-        try {
-            result = await next(args);
-        }
-        catch (e) {
-            request.body.cancel();
-            throw e;
-        }
-        const match = (headers["authorization"] || "").match(/Signature=([\w]+)$/);
-        const priorSignature = (match || [])[1] || (query && query["X-Amz-Signature"]) || "";
-        const signingStream = getEventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
-        const signedPayload = payload.pipeThrough(signingStream);
-        signedPayload.pipeThrough(placeHolderStream);
-        return result;
-    }
-}
-
-const eventStreamPayloadHandlerProvider = (options) => new EventStreamPayloadHandler(options);
-
-const injectSessionIdMiddleware = () => (next) => async (args) => {
-    const requestParams = {
-        ...args.input,
-    };
-    const response = await next(args);
-    const output = response.output;
-    if (requestParams.SessionId && output.SessionId == null) {
-        output.SessionId = requestParams.SessionId;
-    }
-    return response;
-};
-const injectSessionIdMiddlewareOptions = {
-    step: "initialize",
-    name: "injectSessionIdMiddleware",
-    tags: ["WEBSOCKET", "EVENT_STREAM"],
-    override: true,
-};
-
-const websocketEndpointMiddleware = (config, options) => (next) => (args) => {
-    const { request } = args;
-    if (protocolHttp.HttpRequest.isInstance(request) &&
-        config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
-        request.protocol = "wss:";
-        request.method = "GET";
-        request.path = `${request.path}-websocket`;
-        const { headers } = request;
-        delete headers["content-type"];
-        delete headers["x-amz-content-sha256"];
-        for (const name of Object.keys(headers)) {
-            if (name.indexOf(options.headerPrefix) === 0) {
-                const chunkedName = name.replace(options.headerPrefix, "");
-                request.query[chunkedName] = headers[name];
-            }
-        }
-        if (headers["x-amz-user-agent"]) {
-            request.query["user-agent"] = headers["x-amz-user-agent"];
-        }
-        request.headers = { host: headers.host ?? request.hostname };
-    }
-    return next(args);
-};
-const websocketEndpointMiddlewareOptions = {
-    name: "websocketEndpointMiddleware",
-    tags: ["WEBSOCKET", "EVENT_STREAM"],
-    relation: "after",
-    toMiddleware: "eventStreamHeaderMiddleware",
-    override: true,
-};
-
-const getWebSocketPlugin = (config, options) => ({
-    applyToStack: (clientStack) => {
-        clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
-        clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
-    },
-});
+var protocolHttp = require('@smithy/protocol-http');
+var utilBase64 = require('@smithy/util-base64');
+var eventstreamCodec = require('@smithy/eventstream-codec');
+var utilHexEncoding = require('@smithy/util-hex-encoding');
 
 const isWebSocketRequest = (request) => request.protocol === "ws:" || request.protocol === "wss:";
 
-class WebsocketSignatureV4 {
-    signer;
-    constructor(options) {
-        this.signer = options.signer;
-    }
-    presign(originalRequest, options = {}) {
-        return this.signer.presign(originalRequest, options);
-    }
-    async sign(toSign, options) {
-        if (protocolHttp.HttpRequest.isInstance(toSign) && isWebSocketRequest(toSign)) {
-            const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
-                ...options,
-                expiresIn: 60,
-                unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host")),
-            });
-            return {
-                ...signedRequest,
-                body: toSign.body,
-            };
-        }
-        else {
-            return this.signer.sign(toSign, options);
-        }
-    }
-}
-
-const resolveWebSocketConfig = (input) => {
-    const { signer } = input;
-    return Object.assign(input, {
-        signer: async (authScheme) => {
-            const signerObj = await signer(authScheme);
-            if (validateSigner(signerObj)) {
-                return new WebsocketSignatureV4({ signer: signerObj });
-            }
-            throw new Error("Expected WebsocketSignatureV4 signer, please check the client constructor.");
-        },
-    });
-};
-const validateSigner = (signer) => !!signer;
-
-const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2000;
+const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 3000;
 class WebSocketFetchHandler {
     metadata = {
         handlerProtocol: "websocket/h1.1",
     };
-    config;
+    config = {};
     configPromise;
     httpHandler;
     sockets = {};
@@ -198,13 +27,20 @@ class WebSocketFetchHandler {
     }
     constructor(options, httpHandler = new fetchHttpHandler.FetchHttpHandler()) {
         this.httpHandler = httpHandler;
+        const setConfig = (opts) => {
+            this.config = {
+                ...(opts ?? {}),
+            };
+            return this.config;
+        };
         if (typeof options === "function") {
             this.config = {};
-            this.configPromise = options().then((opts) => (this.config = opts ?? {}));
+            this.configPromise = options().then((opts) => {
+                return setConfig(opts);
+            });
         }
         else {
-            this.config = options ?? {};
-            this.configPromise = Promise.resolve(this.config);
+            this.configPromise = Promise.resolve(setConfig(options));
         }
     }
     destroy() {
@@ -216,17 +52,20 @@ class WebSocketFetchHandler {
         }
     }
     async handle(request) {
+        this.config = await this.configPromise;
+        const { logger } = this.config;
         if (!isWebSocketRequest(request)) {
+            logger?.debug?.(`@aws-sdk - ws fetching ${request.protocol}${request.hostname}${request.path}`);
             return this.httpHandler.handle(request);
         }
         const url = utilFormatUrl.formatUrl(request);
+        logger?.debug?.(`@aws-sdk - ws connecting ${url.split("?")[0]}`);
         const socket = new WebSocket(url);
         if (!this.sockets[url]) {
             this.sockets[url] = [];
         }
         this.sockets[url].push(socket);
         socket.binaryType = "arraybuffer";
-        this.config = await this.configPromise;
         const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = this.config;
         await this.waitForReady(socket, connectionTimeout);
         const { body } = request;
@@ -259,6 +98,7 @@ class WebSocketFetchHandler {
                 reject({
                     $metadata: {
                         httpStatusCode: 500,
+                        websocketSynthetic500Error: true,
                     },
                 });
             }, connectionTimeout);
@@ -269,53 +109,80 @@ class WebSocketFetchHandler {
         });
     }
     connect(socket, data) {
-        let streamError = undefined;
-        let socketErrorOccurred = false;
-        let reject = () => { };
-        let resolve = () => { };
+        const messageQueue = [];
+        let pendingResolve = null;
+        let pendingReject = null;
+        const push = (item) => {
+            if (pendingResolve) {
+                if (item.error) {
+                    pendingReject(item.error);
+                }
+                else {
+                    pendingResolve({ done: item.done, value: item.value });
+                }
+                pendingResolve = null;
+                pendingReject = null;
+            }
+            else {
+                messageQueue.push(item);
+            }
+        };
         socket.onmessage = (event) => {
-            resolve({
-                done: false,
-                value: new Uint8Array(event.data),
-            });
+            const { data } = event;
+            if (typeof data === "string") {
+                push({
+                    done: false,
+                    value: utilBase64.fromBase64(data),
+                });
+            }
+            else {
+                push({
+                    done: false,
+                    value: new Uint8Array(data),
+                });
+            }
         };
-        socket.onerror = (error) => {
-            socketErrorOccurred = true;
+        socket.onerror = (event) => {
             socket.close();
-            reject(error);
+            push({ done: true, error: event });
         };
         socket.onclose = () => {
             this.removeNotUsableSockets(socket.url);
-            if (socketErrorOccurred)
-                return;
-            if (streamError) {
-                reject(streamError);
-            }
-            else {
-                resolve({
-                    done: true,
-                    value: undefined,
-                });
-            }
+            push({ done: true });
         };
         const outputStream = {
             [Symbol.asyncIterator]: () => ({
-                next: () => {
-                    return new Promise((_resolve, _reject) => {
-                        resolve = _resolve;
-                        reject = _reject;
+                async next() {
+                    if (messageQueue.length > 0) {
+                        const item = messageQueue.shift();
+                        if (item.error) {
+                            throw item.error;
+                        }
+                        return { done: item.done, value: item.value };
+                    }
+                    return new Promise((resolve, reject) => {
+                        pendingResolve = resolve;
+                        pendingReject = reject;
                     });
                 },
             }),
         };
         const send = async () => {
             try {
-                for await (const inputChunk of data) {
-                    socket.send(inputChunk);
+                for await (const chunk of data) {
+                    if (socket.readyState >= WebSocket.CLOSING) {
+                        break;
+                    }
+                    else {
+                        socket.send(chunk);
+                    }
                 }
             }
             catch (err) {
-                streamError = err;
+                push({
+                    done: true,
+                    error: err,
+                });
             }
             finally {
                 socket.close(1000);
@@ -341,6 +208,184 @@ const getIterator = (stream) => {
 const toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? eventstreamSerdeBrowser.iterableToReadableStream(asyncIterable) : asyncIterable;
 const isReadableStream = (payload) => typeof ReadableStream === "function" && payload instanceof ReadableStream;
 
+const websocketEndpointMiddleware = (config, options) => (next) => (args) => {
+    const { request } = args;
+    if (protocolHttp.HttpRequest.isInstance(request) &&
+        config.requestHandler.metadata?.handlerProtocol?.toLowerCase().includes("websocket")) {
+        request.protocol = "wss:";
+        request.method = "GET";
+        request.path = `${request.path}-websocket`;
+        const { headers } = request;
+        delete headers["content-type"];
+        delete headers["x-amz-content-sha256"];
+        for (const name of Object.keys(headers)) {
+            if (name.indexOf(options.headerPrefix) === 0) {
+                const chunkedName = name.replace(options.headerPrefix, "");
+                request.query[chunkedName] = headers[name];
+            }
+        }
+        if (headers["x-amz-user-agent"]) {
+            request.query["user-agent"] = headers["x-amz-user-agent"];
+        }
+        request.headers = { host: headers.host ?? request.hostname };
+    }
+    return next(args);
+};
+const websocketEndpointMiddlewareOptions = {
+    name: "websocketEndpointMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    relation: "after",
+    toMiddleware: "eventStreamHeaderMiddleware",
+    override: true,
+};
+
+const injectSessionIdMiddleware = () => (next) => async (args) => {
+    const requestParams = {
+        ...args.input,
+    };
+    const response = await next(args);
+    const output = response.output;
+    if (requestParams.SessionId && output.SessionId == null) {
+        output.SessionId = requestParams.SessionId;
+    }
+    return response;
+};
+const injectSessionIdMiddlewareOptions = {
+    step: "initialize",
+    name: "injectSessionIdMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    override: true,
+};
+
+const getWebSocketPlugin = (config, options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);
+        clientStack.add(injectSessionIdMiddleware(), injectSessionIdMiddlewareOptions);
+    },
+});
+
+class WebsocketSignatureV4 {
+    signer;
+    constructor(options) {
+        this.signer = options.signer;
+    }
+    presign(originalRequest, options = {}) {
+        return this.signer.presign(originalRequest, options);
+    }
+    async sign(toSign, options) {
+        if (protocolHttp.HttpRequest.isInstance(toSign) && isWebSocketRequest(toSign)) {
+            const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
+                ...options,
+                expiresIn: 60,
+                unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host")),
+            });
+            return {
+                ...signedRequest,
+                body: toSign.body,
+            };
+        }
+        else {
+            return this.signer.sign(toSign, options);
+        }
+    }
+    signMessage(message, args) {
+        return this.signer.signMessage(message, args);
+    }
+}
+
+const resolveWebSocketConfig = (input) => {
+    const { signer } = input;
+    return Object.assign(input, {
+        signer: async (authScheme) => {
+            const signerObj = await signer(authScheme);
+            if (validateSigner(signerObj)) {
+                return new WebsocketSignatureV4({ signer: signerObj });
+            }
+            throw new Error("Expected WebsocketSignatureV4 signer, please check the client constructor.");
+        },
+    });
+};
+const validateSigner = (signer) => !!signer;
+
+class EventSigningTransformStream extends TransformStream {
+    constructor(initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) {
+        let priorSignature = initialSignature;
+        super({
+            start() { },
+            async transform(chunk, controller) {
+                try {
+                    const now = new Date(Date.now() + (await systemClockOffsetProvider()));
+                    const dateHeader = {
+                        ":date": { type: "timestamp", value: now },
+                    };
+                    const signedMessage = await messageSigner.sign({
+                        message: {
+                            body: chunk,
+                            headers: dateHeader,
+                        },
+                        priorSignature: priorSignature,
+                    }, {
+                        signingDate: now,
+                    });
+                    priorSignature = signedMessage.signature;
+                    const serializedSigned = eventStreamCodec.encode({
+                        headers: {
+                            ...dateHeader,
+                            ":chunk-signature": {
+                                type: "binary",
+                                value: utilHexEncoding.fromHex(signedMessage.signature),
+                            },
+                        },
+                        body: chunk,
+                    });
+                    controller.enqueue(serializedSigned);
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+    }
+}
+
+class EventStreamPayloadHandler {
+    messageSigner;
+    eventStreamCodec;
+    systemClockOffsetProvider;
+    constructor(options) {
+        this.messageSigner = options.messageSigner;
+        this.eventStreamCodec = new eventstreamCodec.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
+        this.systemClockOffsetProvider = async () => options.systemClockOffset ?? 0;
+    }
+    async handle(next, args, context = {}) {
+        const request = args.request;
+        const { body: payload, headers, query } = request;
+        if (!(payload instanceof ReadableStream)) {
+            throw new Error("Eventstream payload must be a ReadableStream.");
+        }
+        const placeHolderStream = new TransformStream();
+        request.body = placeHolderStream.readable;
+        const match = (headers?.authorization ?? "").match(/Signature=(\w+)$/);
+        const priorSignature = (match ?? [])[1] ?? (query && query["X-Amz-Signature"]) ?? "";
+        const signingStream = new EventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
+        payload.pipeThrough(signingStream).pipeThrough(placeHolderStream);
+        let result;
+        try {
+            result = await next(args);
+        }
+        catch (e) {
+            const p = payload.cancel?.();
+            if (p instanceof Promise) {
+                p.catch(() => { });
+            }
+            throw e;
+        }
+        return result;
+    }
+}
+
+const eventStreamPayloadHandlerProvider = (options) => new EventStreamPayloadHandler(options);
+
 exports.WebSocketFetchHandler = WebSocketFetchHandler;
 exports.eventStreamPayloadHandlerProvider = eventStreamPayloadHandlerProvider;
 exports.getWebSocketPlugin = getWebSocketPlugin;

package/dist-es/{websocket-fetch-handler.js → WebSocketFetchHandler.js}

@@ -2,13 +2,14 @@ import { formatUrl } from "@aws-sdk/util-format-url";
 import { iterableToReadableStream, readableStreamtoIterable } from "@smithy/eventstream-serde-browser";
 import { FetchHttpHandler } from "@smithy/fetch-http-handler";
 import { HttpResponse } from "@smithy/protocol-http";
+import { fromBase64 } from "@smithy/util-base64";
 import { isWebSocketRequest } from "./utils";
-const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2000;
+const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 3000;
 export class WebSocketFetchHandler {
     metadata = {
         handlerProtocol: "websocket/h1.1",
     };
-    config;
+    config = {};
     configPromise;
     httpHandler;
     sockets = {};
@@ -20,13 +21,20 @@ export class WebSocketFetchHandler {
     }
     constructor(options, httpHandler = new FetchHttpHandler()) {
         this.httpHandler = httpHandler;
+        const setConfig = (opts) => {
+            this.config = {
+                ...(opts ?? {}),
+            };
+            return this.config;
+        };
         if (typeof options === "function") {
             this.config = {};
-            this.configPromise = options().then((opts) => (this.config = opts ?? {}));
+            this.configPromise = options().then((opts) => {
+                return setConfig(opts);
+            });
         }
         else {
-            this.config = options ?? {};
-            this.configPromise = Promise.resolve(this.config);
+            this.configPromise = Promise.resolve(setConfig(options));
         }
     }
     destroy() {
@@ -38,17 +46,20 @@ export class WebSocketFetchHandler {
         }
     }
     async handle(request) {
+        this.config = await this.configPromise;
+        const { logger } = this.config;
         if (!isWebSocketRequest(request)) {
+            logger?.debug?.(`@aws-sdk - ws fetching ${request.protocol}${request.hostname}${request.path}`);
             return this.httpHandler.handle(request);
         }
         const url = formatUrl(request);
+        logger?.debug?.(`@aws-sdk - ws connecting ${url.split("?")[0]}`);
         const socket = new WebSocket(url);
         if (!this.sockets[url]) {
             this.sockets[url] = [];
         }
         this.sockets[url].push(socket);
         socket.binaryType = "arraybuffer";
-        this.config = await this.configPromise;
         const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = this.config;
         await this.waitForReady(socket, connectionTimeout);
         const { body } = request;
@@ -81,6 +92,7 @@ export class WebSocketFetchHandler {
                 reject({
                     $metadata: {
                         httpStatusCode: 500,
+                        websocketSynthetic500Error: true,
                     },
                 });
             }, connectionTimeout);
@@ -91,53 +103,80 @@ export class WebSocketFetchHandler {
         });
     }
     connect(socket, data) {
-        let streamError = undefined;
-        let socketErrorOccurred = false;
-        let reject = () => { };
-        let resolve = () => { };
+        const messageQueue = [];
+        let pendingResolve = null;
+        let pendingReject = null;
+        const push = (item) => {
+            if (pendingResolve) {
+                if (item.error) {
+                    pendingReject(item.error);
+                }
+                else {
+                    pendingResolve({ done: item.done, value: item.value });
+                }
+                pendingResolve = null;
+                pendingReject = null;
+            }
+            else {
+                messageQueue.push(item);
+            }
+        };
         socket.onmessage = (event) => {
-            resolve({
-                done: false,
-                value: new Uint8Array(event.data),
-            });
+            const { data } = event;
+            if (typeof data === "string") {
+                push({
+                    done: false,
+                    value: fromBase64(data),
+                });
+            }
+            else {
+                push({
+                    done: false,
+                    value: new Uint8Array(data),
+                });
+            }
         };
-        socket.onerror = (error) => {
-            socketErrorOccurred = true;
+        socket.onerror = (event) => {
             socket.close();
-            reject(error);
+            push({ done: true, error: event });
         };
         socket.onclose = () => {
             this.removeNotUsableSockets(socket.url);
-            if (socketErrorOccurred)
-                return;
-            if (streamError) {
-                reject(streamError);
-            }
-            else {
-                resolve({
-                    done: true,
-                    value: undefined,
-                });
-            }
+            push({ done: true });
         };
         const outputStream = {
             [Symbol.asyncIterator]: () => ({
-                next: () => {
-                    return new Promise((_resolve, _reject) => {
-                        resolve = _resolve;
-                        reject = _reject;
+                async next() {
+                    if (messageQueue.length > 0) {
+                        const item = messageQueue.shift();
+                        if (item.error) {
+                            throw item.error;
+                        }
+                        return { done: item.done, value: item.value };
+                    }
+                    return new Promise((resolve, reject) => {
+                        pendingResolve = resolve;
+                        pendingReject = reject;
                     });
                 },
             }),
         };
         const send = async () => {
             try {
-                for await (const inputChunk of data) {
-                    socket.send(inputChunk);
+                for await (const chunk of data) {
+                    if (socket.readyState >= WebSocket.CLOSING) {
+                        break;
+                    }
+                    else {
+                        socket.send(chunk);
+                    }
                 }
             }
             catch (err) {
-                streamError = err;
+                push({
+                    done: true,
+                    error: err,
+                });
             }
             finally {
                 socket.close(1000);

package/dist-es/WebsocketSignatureV4.js

@@ -24,4 +24,7 @@ export class WebsocketSignatureV4 {
             return this.signer.sign(toSign, options);
         }
     }
+    signMessage(message, args) {
+        return this.signer.signMessage(message, args);
+    }
 }

package/dist-es/getWebSocketPlugin.js

@@ -1,5 +1,5 @@
-import { injectSessionIdMiddleware, injectSessionIdMiddlewareOptions } from "./middleware-session-id";
-import { websocketEndpointMiddleware, websocketEndpointMiddlewareOptions } from "./middleware-websocket-endpoint";
+import { websocketEndpointMiddleware, websocketEndpointMiddlewareOptions, } from "./middlewares/websocketEndpointMiddleware";
+import { injectSessionIdMiddleware, injectSessionIdMiddlewareOptions, } from "./middlewares/websocketInjectSessionIdMiddleware";
 export const getWebSocketPlugin = (config, options) => ({
     applyToStack: (clientStack) => {
         clientStack.addRelativeTo(websocketEndpointMiddleware(config, options), websocketEndpointMiddlewareOptions);

package/dist-es/index.js

@@ -1,4 +1,4 @@
-export * from "./eventstream-payload-handler-provider";
+export * from "./WebSocketFetchHandler";
 export * from "./getWebSocketPlugin";
-export * from "./websocket-configuration";
-export * from "./websocket-fetch-handler";
+export * from "./resolveWebSocketConfig";
+export * from "./ws-eventstream/eventStreamPayloadHandlerProvider";

package/dist-es/ws-eventstream/EventSigningTransformStream.js

@@ -0,0 +1,41 @@
+import { fromHex } from "@smithy/util-hex-encoding";
+export class EventSigningTransformStream extends TransformStream {
+    constructor(initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) {
+        let priorSignature = initialSignature;
+        super({
+            start() { },
+            async transform(chunk, controller) {
+                try {
+                    const now = new Date(Date.now() + (await systemClockOffsetProvider()));
+                    const dateHeader = {
+                        ":date": { type: "timestamp", value: now },
+                    };
+                    const signedMessage = await messageSigner.sign({
+                        message: {
+                            body: chunk,
+                            headers: dateHeader,
+                        },
+                        priorSignature: priorSignature,
+                    }, {
+                        signingDate: now,
+                    });
+                    priorSignature = signedMessage.signature;
+                    const serializedSigned = eventStreamCodec.encode({
+                        headers: {
+                            ...dateHeader,
+                            ":chunk-signature": {
+                                type: "binary",
+                                value: fromHex(signedMessage.signature),
+                            },
+                        },
+                        body: chunk,
+                    });
+                    controller.enqueue(serializedSigned);
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+    }
+}

package/dist-es/{EventStreamPayloadHandler.js → ws-eventstream/EventStreamPayloadHandler.js}

@@ -1,5 +1,5 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
-import { getEventSigningTransformStream } from "./get-event-signing-stream";
+import { EventSigningTransformStream } from "./EventSigningTransformStream";
 export class EventStreamPayloadHandler {
     messageSigner;
     eventStreamCodec;
@@ -17,19 +17,21 @@ export class EventStreamPayloadHandler {
         }
         const placeHolderStream = new TransformStream();
         request.body = placeHolderStream.readable;
+        const match = (headers?.authorization ?? "").match(/Signature=(\w+)$/);
+        const priorSignature = (match ?? [])[1] ?? (query && query["X-Amz-Signature"]) ?? "";
+        const signingStream = new EventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
+        payload.pipeThrough(signingStream).pipeThrough(placeHolderStream);
         let result;
         try {
             result = await next(args);
         }
         catch (e) {
-            request.body.cancel();
+            const p = payload.cancel?.();
+            if (p instanceof Promise) {
+                p.catch(() => { });
+            }
             throw e;
         }
-        const match = (headers["authorization"] || "").match(/Signature=([\w]+)$/);
-        const priorSignature = (match || [])[1] || (query && query["X-Amz-Signature"]) || "";
-        const signingStream = getEventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec, this.systemClockOffsetProvider);
-        const signedPayload = payload.pipeThrough(signingStream);
-        signedPayload.pipeThrough(placeHolderStream);
         return result;
     }
 }

package/dist-types/{websocket-fetch-handler.d.ts → WebSocketFetchHandler.d.ts}

@@ -1,11 +1,16 @@
-import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
-import { Provider, RequestHandler, RequestHandlerMetadata } from "@smithy/types";
+import type { HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
+import type { Logger, Provider, RequestHandler, RequestHandlerMetadata } from "@smithy/types";
 export interface WebSocketFetchHandlerOptions {
     /**
      * The maximum time in milliseconds that the connection phase of a request
      * may take before the connection attempt is abandoned.
      */
     connectionTimeout?: number;
+    /**
+     * Optional logger.
+     */
+    logger?: Logger;
 }
 /**
  * Base handler for websocket requests and HTTP request. By default, the request input and output

package/dist-types/WebsocketSignatureV4.d.ts

@@ -1,10 +1,20 @@
-import { SignatureV4 as BaseSignatureV4 } from "@smithy/signature-v4";
-import { HttpRequest as IHttpRequest, RequestPresigner, RequestPresigningArguments, RequestSigner, RequestSigningArguments } from "@smithy/types";
-export declare class WebsocketSignatureV4 implements RequestSigner, RequestPresigner {
+import type { SignatureV4 as BaseSignatureV4 } from "@smithy/signature-v4";
+import type { EventSigner, EventSigningArguments, FormattedEvent, HttpRequest as IHttpRequest, MessageSigner, RequestPresigner, RequestPresigningArguments, RequestSigner, RequestSigningArguments, SignableMessage, SignedMessage, SigningArguments, StringSigner } from "@smithy/types";
+/**
+ * Because this signer defers to sigv4, it implements all signing interfaces that
+ * the sigv4 signer does, including message signing.
+ *
+ * @internal
+ */
+export declare class WebsocketSignatureV4 implements RequestPresigner, RequestSigner, StringSigner, EventSigner, MessageSigner {
     private readonly signer;
     constructor(options: {
         signer: BaseSignatureV4;
     });
     presign(originalRequest: IHttpRequest, options?: RequestPresigningArguments): Promise<IHttpRequest>;
-    sign(toSign: IHttpRequest, options?: RequestSigningArguments): Promise<IHttpRequest>;
+    sign(stringToSign: string, options?: SigningArguments): Promise<string>;
+    sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
+    sign(event: SignableMessage, options: SigningArguments): Promise<SignedMessage>;
+    sign(requestToSign: IHttpRequest, options?: RequestSigningArguments): Promise<IHttpRequest>;
+    signMessage(message: SignableMessage, args: SigningArguments): Promise<SignedMessage>;
 }

package/dist-types/getWebSocketPlugin.d.ts

@@ -1,4 +1,4 @@
-import { Pluggable, RequestHandler } from "@smithy/types";
+import type { Pluggable, RequestHandler } from "@smithy/types";
 interface WebSocketResolvedConfig {
     requestHandler: RequestHandler<any, any>;
 }

package/dist-types/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./eventstream-payload-handler-provider";
+export * from "./WebSocketFetchHandler";
 export * from "./getWebSocketPlugin";
-export * from "./websocket-configuration";
-export * from "./websocket-fetch-handler";
+export * from "./resolveWebSocketConfig";
+export * from "./ws-eventstream/eventStreamPayloadHandlerProvider";

package/dist-types/{middleware-websocket-endpoint.d.ts → middlewares/websocketEndpointMiddleware.d.ts}

@@ -1,4 +1,4 @@
-import { BuildMiddleware, RelativeMiddlewareOptions, RequestHandler } from "@smithy/types";
+import type { BuildMiddleware, RelativeMiddlewareOptions, RequestHandler } from "@smithy/types";
 /**
  * Middleware that modify the request to from http to WebSocket
  * This middleware can only be applied to commands that supports bi-directional event streaming via WebSocket.

package/dist-types/{middleware-session-id.d.ts → middlewares/websocketInjectSessionIdMiddleware.d.ts}

@@ -1,4 +1,4 @@
-import { InitializeHandlerOptions, InitializeMiddleware } from "@smithy/types";
+import type { InitializeHandlerOptions, InitializeMiddleware } from "@smithy/types";
 /**
  * Most WebSocket operations contains `SessionId` parameter in both input and
  * output, with the same value. This middleware populates the `SessionId`

package/dist-types/{websocket-configuration.d.ts → resolveWebSocketConfig.d.ts}

@@ -1,4 +1,4 @@
-import { AuthScheme, RequestHandler, RequestSigner } from "@smithy/types";
+import type { AuthScheme, RequestHandler, RequestSigner } from "@smithy/types";
 /**
  * @public
  */

package/dist-types/ts3.4/{websocket-fetch-handler.d.ts → WebSocketFetchHandler.d.ts}

@@ -1,11 +1,14 @@
-import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
+import { HttpRequest } from "@smithy/protocol-http";
+import { HttpResponse } from "@smithy/protocol-http";
 import {
+  Logger,
   Provider,
   RequestHandler,
   RequestHandlerMetadata,
 } from "@smithy/types";
 export interface WebSocketFetchHandlerOptions {
   connectionTimeout?: number;
+  logger?: Logger;
 }
 export declare class WebSocketFetchHandler {
   readonly metadata: RequestHandlerMetadata;

package/dist-types/ts3.4/WebsocketSignatureV4.d.ts

@@ -1,13 +1,26 @@
 import { SignatureV4 as BaseSignatureV4 } from "@smithy/signature-v4";
 import {
+  EventSigner,
+  EventSigningArguments,
+  FormattedEvent,
   HttpRequest as IHttpRequest,
+  MessageSigner,
   RequestPresigner,
   RequestPresigningArguments,
   RequestSigner,
   RequestSigningArguments,
+  SignableMessage,
+  SignedMessage,
+  SigningArguments,
+  StringSigner,
 } from "@smithy/types";
 export declare class WebsocketSignatureV4
-  implements RequestSigner, RequestPresigner
+  implements
+    RequestPresigner,
+    RequestSigner,
+    StringSigner,
+    EventSigner,
+    MessageSigner
 {
   private readonly signer;
   constructor(options: { signer: BaseSignatureV4 });
@@ -15,8 +28,18 @@ export declare class WebsocketSignatureV4
     originalRequest: IHttpRequest,
     options?: RequestPresigningArguments
   ): Promise<IHttpRequest>;
+  sign(stringToSign: string, options?: SigningArguments): Promise<string>;
+  sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
   sign(
-    toSign: IHttpRequest,
+    event: SignableMessage,
+    options: SigningArguments
+  ): Promise<SignedMessage>;
+  sign(
+    requestToSign: IHttpRequest,
     options?: RequestSigningArguments
   ): Promise<IHttpRequest>;
+  signMessage(
+    message: SignableMessage,
+    args: SigningArguments
+  ): Promise<SignedMessage>;
 }

package/dist-types/ts3.4/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./eventstream-payload-handler-provider";
+export * from "./WebSocketFetchHandler";
 export * from "./getWebSocketPlugin";
-export * from "./websocket-configuration";
-export * from "./websocket-fetch-handler";
+export * from "./resolveWebSocketConfig";
+export * from "./ws-eventstream/eventStreamPayloadHandlerProvider";

package/dist-types/ts3.4/ws-eventstream/EventSigningTransformStream.d.ts

@@ -0,0 +1,15 @@
+import { EventStreamCodec } from "@smithy/eventstream-codec";
+import { MessageSigner, Provider } from "@smithy/types";
+export declare class EventSigningTransformStream extends TransformStream<
+  Uint8Array,
+  Uint8Array
+> {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+  constructor(
+    initialSignature: string,
+    messageSigner: MessageSigner,
+    eventStreamCodec: EventStreamCodec,
+    systemClockOffsetProvider: Provider<number>
+  );
+}

package/dist-types/utils.d.ts

@@ -1,2 +1,2 @@
-import { HttpRequest } from "@smithy/types";
+import type { HttpRequest } from "@smithy/types";
 export declare const isWebSocketRequest: (request: HttpRequest) => boolean;

package/dist-types/ws-eventstream/EventSigningTransformStream.d.ts

@@ -0,0 +1,21 @@
+import type { EventStreamCodec } from "@smithy/eventstream-codec";
+import type { MessageSigner, Provider } from "@smithy/types";
+/**
+ * A transform stream that signs the eventstream.
+ *
+ * Implementation replicated from @aws-sdk/eventstream-handler-node::EventSigningStream
+ * but modified to be compatible with web stream interface.
+ *
+ * @internal
+ */
+export declare class EventSigningTransformStream extends TransformStream<Uint8Array, Uint8Array> {
+    /**
+     * @override
+     */
+    readable: ReadableStream<Uint8Array>;
+    /**
+     * @override
+     */
+    writable: WritableStream<Uint8Array>;
+    constructor(initialSignature: string, messageSigner: MessageSigner, eventStreamCodec: EventStreamCodec, systemClockOffsetProvider: Provider<number>);
+}

package/dist-types/{EventStreamPayloadHandler.d.ts → ws-eventstream/EventStreamPayloadHandler.d.ts}

@@ -1,4 +1,7 @@
-import { Decoder, Encoder, EventStreamPayloadHandler as IEventStreamPayloadHandler, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext, MessageSigner, MetadataBearer, Provider } from "@smithy/types";
+import type { Decoder, Encoder, EventStreamPayloadHandler as IEventStreamPayloadHandler, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext, MessageSigner, MetadataBearer, Provider } from "@smithy/types";
+/**
+ * @internal
+ */
 export interface EventStreamPayloadHandlerOptions {
     messageSigner: Provider<MessageSigner>;
     utf8Encoder: Encoder;
@@ -6,11 +9,7 @@ export interface EventStreamPayloadHandlerOptions {
     systemClockOffset?: number;
 }
 /**
- * A handler that control the eventstream payload flow:
- * 1. Pause stream for initial request.
- * 2. Close the stream if initial request fails.
- * 3. Start piping payload when connection is established.
- * 4. Sign the payload after payload stream starting to flow.
+ * @internal
  */
 export declare class EventStreamPayloadHandler implements IEventStreamPayloadHandler {
     private readonly messageSigner;

package/dist-types/ws-eventstream/eventStreamPayloadHandlerProvider.d.ts

@@ -0,0 +1,5 @@
+import type { EventStreamPayloadHandlerProvider } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const eventStreamPayloadHandlerProvider: EventStreamPayloadHandlerProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-websocket",
-  "version": "3.972.3",
+  "version": "3.972.5",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
@@ -32,7 +32,9 @@
     "@smithy/protocol-http": "^5.3.8",
     "@smithy/signature-v4": "^5.3.8",
     "@smithy/types": "^4.12.0",
+    "@smithy/util-base64": "^4.3.0",
     "@smithy/util-hex-encoding": "^4.2.0",
+    "@smithy/util-utf8": "^4.2.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {
@@ -42,8 +44,7 @@
     "mock-socket": "9.1.5",
     "premove": "4.0.0",
     "typescript": "~5.8.3",
-    "vitest-websocket-mock": "0.2.3",
-    "web-streams-polyfill": "3.2.1"
+    "vitest-websocket-mock": "0.2.3"
   },
   "engines": {
     "node": ">= 14.0.0"

package/dist-es/get-event-signing-stream.js

@@ -1,40 +0,0 @@
-import { fromHex } from "@smithy/util-hex-encoding";
-export const getEventSigningTransformStream = (initialSignature, messageSigner, eventStreamCodec, systemClockOffsetProvider) => {
-    let priorSignature = initialSignature;
-    const transformer = {
-        start() { },
-        async transform(chunk, controller) {
-            try {
-                const now = new Date(Date.now() + (await systemClockOffsetProvider()));
-                const dateHeader = {
-                    ":date": { type: "timestamp", value: now },
-                };
-                const signedMessage = await messageSigner.sign({
-                    message: {
-                        body: chunk,
-                        headers: dateHeader,
-                    },
-                    priorSignature: priorSignature,
-                }, {
-                    signingDate: now,
-                });
-                priorSignature = signedMessage.signature;
-                const serializedSigned = eventStreamCodec.encode({
-                    headers: {
-                        ...dateHeader,
-                        ":chunk-signature": {
-                            type: "binary",
-                            value: fromHex(signedMessage.signature),
-                        },
-                    },
-                    body: chunk,
-                });
-                controller.enqueue(serializedSigned);
-            }
-            catch (error) {
-                controller.error(error);
-            }
-        },
-    };
-    return new TransformStream({ ...transformer });
-};

package/dist-types/eventstream-payload-handler-provider.d.ts

@@ -1,3 +0,0 @@
-import { EventStreamPayloadHandlerProvider } from "@smithy/types";
-/** NodeJS event stream utils provider */
-export declare const eventStreamPayloadHandlerProvider: EventStreamPayloadHandlerProvider;

package/dist-types/get-event-signing-stream.d.ts

@@ -1,10 +0,0 @@
-import { EventStreamCodec } from "@smithy/eventstream-codec";
-import { MessageSigner, Provider } from "@smithy/types";
-/**
- * Get a transform stream that signs the eventstream
- * Implementation replicated from @aws-sdk/eventstream-handler-node::EventSigningStream
- * but modified to be compatible with WHATWG stream interface
- *
- * @internal
- */
-export declare const getEventSigningTransformStream: (initialSignature: string, messageSigner: MessageSigner, eventStreamCodec: EventStreamCodec, systemClockOffsetProvider: Provider<number>) => TransformStream<Uint8Array, Uint8Array>;

package/dist-types/ts3.4/get-event-signing-stream.d.ts

@@ -1,8 +0,0 @@
-import { EventStreamCodec } from "@smithy/eventstream-codec";
-import { MessageSigner, Provider } from "@smithy/types";
-export declare const getEventSigningTransformStream: (
-  initialSignature: string,
-  messageSigner: MessageSigner,
-  eventStreamCodec: EventStreamCodec,
-  systemClockOffsetProvider: Provider<number>
-) => TransformStream<Uint8Array, Uint8Array>;