@aws-sdk/middleware-websocket 3.347.0 → 3.351.0

package/dist-cjs/EventStreamPayloadHandler.js

@@ -5,7 +5,7 @@ const eventstream_codec_1 = require("@aws-sdk/eventstream-codec");
 const get_event_signing_stream_1 = require("./get-event-signing-stream");
 class EventStreamPayloadHandler {
     constructor(options) {
-        this.eventSigner = options.eventSigner;
+        this.messageSigner = options.messageSigner;
         this.eventStreamCodec = new eventstream_codec_1.EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
     }
     async handle(next, args, context = {}) {
@@ -26,7 +26,7 @@ class EventStreamPayloadHandler {
         }
         const match = (headers["authorization"] || "").match(/Signature=([\w]+)$/);
         const priorSignature = (match || [])[1] || (query && query["X-Amz-Signature"]) || "";
-        const signingStream = (0, get_event_signing_stream_1.getEventSigningTransformStream)(priorSignature, await this.eventSigner(), this.eventStreamCodec);
+        const signingStream = (0, get_event_signing_stream_1.getEventSigningTransformStream)(priorSignature, await this.messageSigner(), this.eventStreamCodec);
         const signedPayload = payload.pipeThrough(signingStream);
         signedPayload.pipeThrough(placeHolderStream);
         return result;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEventSigningTransformStream = void 0;
 const util_hex_encoding_1 = require("@aws-sdk/util-hex-encoding");
-const getEventSigningTransformStream = (initialSignature, eventSigner, eventStreamCodec) => {
+const getEventSigningTransformStream = (initialSignature, messageSigner, eventStreamCodec) => {
     let priorSignature = initialSignature;
     const transformer = {
         start() { },
@@ -12,20 +12,22 @@ const getEventSigningTransformStream = (initialSignature, eventSigner, eventStre
                 const dateHeader = {
                     ":date": { type: "timestamp", value: now },
                 };
-                const signature = await eventSigner.sign({
-                    payload: chunk,
-                    headers: eventStreamCodec.formatHeaders(dateHeader),
+                const signedMessage = await messageSigner.sign({
+                    message: {
+                        body: chunk,
+                        headers: dateHeader,
+                    },
+                    priorSignature: priorSignature,
                 }, {
-                    priorSignature,
                     signingDate: now,
                 });
-                priorSignature = signature;
+                priorSignature = signedMessage.signature;
                 const serializedSigned = eventStreamCodec.encode({
                     headers: {
                         ...dateHeader,
                         ":chunk-signature": {
                             type: "binary",
-                            value: (0, util_hex_encoding_1.fromHex)(signature),
+                            value: (0, util_hex_encoding_1.fromHex)(signedMessage.signature),
                         },
                     },
                     body: chunk,

package/dist-cjs/websocket-fetch-handler.js

@@ -54,7 +54,8 @@ class WebSocketFetchHandler {
         };
     }
     removeNotUsableSockets(url) {
-        this.sockets[url] = this.sockets[url].filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
+        var _a;
+        this.sockets[url] = ((_a = this.sockets[url]) !== null && _a !== void 0 ? _a : []).filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
     }
     waitForReady(socket, connectionTimeout) {
         return new Promise((resolve, reject) => {
@@ -74,36 +75,40 @@ class WebSocketFetchHandler {
     }
     connect(socket, data) {
         let streamError = undefined;
+        let socketErrorOccurred = false;
+        let reject = () => { };
+        let resolve = () => { };
+        socket.onmessage = (event) => {
+            resolve({
+                done: false,
+                value: new Uint8Array(event.data),
+            });
+        };
+        socket.onerror = (error) => {
+            socketErrorOccurred = true;
+            socket.close();
+            reject(error);
+        };
+        socket.onclose = () => {
+            this.removeNotUsableSockets(socket.url);
+            if (socketErrorOccurred)
+                return;
+            if (streamError) {
+                reject(streamError);
+            }
+            else {
+                resolve({
+                    done: true,
+                    value: undefined,
+                });
+            }
+        };
         const outputStream = {
             [Symbol.asyncIterator]: () => ({
                 next: () => {
-                    return new Promise((resolve, reject) => {
-                        let socketErrorOccurred = false;
-                        socket.onerror = (error) => {
-                            socketErrorOccurred = true;
-                            socket.close();
-                            reject(error);
-                        };
-                        socket.onclose = () => {
-                            this.removeNotUsableSockets(socket.url);
-                            if (socketErrorOccurred)
-                                return;
-                            if (streamError) {
-                                reject(streamError);
-                            }
-                            else {
-                                resolve({
-                                    done: true,
-                                    value: undefined,
-                                });
-                            }
-                        };
-                        socket.onmessage = (event) => {
-                            resolve({
-                                done: false,
-                                value: new Uint8Array(event.data),
-                            });
-                        };
+                    return new Promise((_resolve, _reject) => {
+                        resolve = _resolve;
+                        reject = _reject;
                     });
                 },
             }),

package/dist-es/EventStreamPayloadHandler.js

@@ -2,7 +2,7 @@ import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
 import { getEventSigningTransformStream } from "./get-event-signing-stream";
 export class EventStreamPayloadHandler {
     constructor(options) {
-        this.eventSigner = options.eventSigner;
+        this.messageSigner = options.messageSigner;
         this.eventStreamCodec = new EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
     }
     async handle(next, args, context = {}) {
@@ -23,7 +23,7 @@ export class EventStreamPayloadHandler {
         }
         const match = (headers["authorization"] || "").match(/Signature=([\w]+)$/);
         const priorSignature = (match || [])[1] || (query && query["X-Amz-Signature"]) || "";
-        const signingStream = getEventSigningTransformStream(priorSignature, await this.eventSigner(), this.eventStreamCodec);
+        const signingStream = getEventSigningTransformStream(priorSignature, await this.messageSigner(), this.eventStreamCodec);
         const signedPayload = payload.pipeThrough(signingStream);
         signedPayload.pipeThrough(placeHolderStream);
         return result;

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

@@ -1,5 +1,5 @@
 import { fromHex } from "@aws-sdk/util-hex-encoding";
-export const getEventSigningTransformStream = (initialSignature, eventSigner, eventStreamCodec) => {
+export const getEventSigningTransformStream = (initialSignature, messageSigner, eventStreamCodec) => {
     let priorSignature = initialSignature;
     const transformer = {
         start() { },
@@ -9,20 +9,22 @@ export const getEventSigningTransformStream = (initialSignature, eventSigner, ev
                 const dateHeader = {
                     ":date": { type: "timestamp", value: now },
                 };
-                const signature = await eventSigner.sign({
-                    payload: chunk,
-                    headers: eventStreamCodec.formatHeaders(dateHeader),
+                const signedMessage = await messageSigner.sign({
+                    message: {
+                        body: chunk,
+                        headers: dateHeader,
+                    },
+                    priorSignature: priorSignature,
                 }, {
-                    priorSignature,
                     signingDate: now,
                 });
-                priorSignature = signature;
+                priorSignature = signedMessage.signature;
                 const serializedSigned = eventStreamCodec.encode({
                     headers: {
                         ...dateHeader,
                         ":chunk-signature": {
                             type: "binary",
-                            value: fromHex(signature),
+                            value: fromHex(signedMessage.signature),
                         },
                     },
                     body: chunk,

package/dist-es/websocket-fetch-handler.js

@@ -51,7 +51,7 @@ export class WebSocketFetchHandler {
         };
     }
     removeNotUsableSockets(url) {
-        this.sockets[url] = this.sockets[url].filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
+        this.sockets[url] = (this.sockets[url] ?? []).filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
     }
     waitForReady(socket, connectionTimeout) {
         return new Promise((resolve, reject) => {
@@ -71,36 +71,40 @@ export class WebSocketFetchHandler {
     }
     connect(socket, data) {
         let streamError = undefined;
+        let socketErrorOccurred = false;
+        let reject = () => { };
+        let resolve = () => { };
+        socket.onmessage = (event) => {
+            resolve({
+                done: false,
+                value: new Uint8Array(event.data),
+            });
+        };
+        socket.onerror = (error) => {
+            socketErrorOccurred = true;
+            socket.close();
+            reject(error);
+        };
+        socket.onclose = () => {
+            this.removeNotUsableSockets(socket.url);
+            if (socketErrorOccurred)
+                return;
+            if (streamError) {
+                reject(streamError);
+            }
+            else {
+                resolve({
+                    done: true,
+                    value: undefined,
+                });
+            }
+        };
         const outputStream = {
             [Symbol.asyncIterator]: () => ({
                 next: () => {
-                    return new Promise((resolve, reject) => {
-                        let socketErrorOccurred = false;
-                        socket.onerror = (error) => {
-                            socketErrorOccurred = true;
-                            socket.close();
-                            reject(error);
-                        };
-                        socket.onclose = () => {
-                            this.removeNotUsableSockets(socket.url);
-                            if (socketErrorOccurred)
-                                return;
-                            if (streamError) {
-                                reject(streamError);
-                            }
-                            else {
-                                resolve({
-                                    done: true,
-                                    value: undefined,
-                                });
-                            }
-                        };
-                        socket.onmessage = (event) => {
-                            resolve({
-                                done: false,
-                                value: new Uint8Array(event.data),
-                            });
-                        };
+                    return new Promise((_resolve, _reject) => {
+                        resolve = _resolve;
+                        reject = _reject;
                     });
                 },
             }),

package/dist-types/EventStreamPayloadHandler.d.ts

@@ -1,6 +1,6 @@
-import { Decoder, Encoder, EventSigner, EventStreamPayloadHandler as IEventStreamPayloadHandler, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext, MetadataBearer, Provider } from "@aws-sdk/types";
+import { Decoder, Encoder, EventStreamPayloadHandler as IEventStreamPayloadHandler, FinalizeHandler, FinalizeHandlerArguments, FinalizeHandlerOutput, HandlerExecutionContext, MessageSigner, MetadataBearer, Provider } from "@aws-sdk/types";
 export interface EventStreamPayloadHandlerOptions {
-    eventSigner: Provider<EventSigner>;
+    messageSigner: Provider<MessageSigner>;
     utf8Encoder: Encoder;
     utf8Decoder: Decoder;
 }
@@ -12,7 +12,7 @@ export interface EventStreamPayloadHandlerOptions {
  * 4. Sign the payload after payload stream starting to flow.
  */
 export declare class EventStreamPayloadHandler implements IEventStreamPayloadHandler {
-    private readonly eventSigner;
+    private readonly messageSigner;
     private readonly eventStreamCodec;
     constructor(options: EventStreamPayloadHandlerOptions);
     handle<T extends MetadataBearer>(next: FinalizeHandler<any, T>, args: FinalizeHandlerArguments<any>, context?: HandlerExecutionContext): Promise<FinalizeHandlerOutput<T>>;

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

@@ -1,8 +1,8 @@
 import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
-import { EventSigner } from "@aws-sdk/types";
+import { MessageSigner } from "@aws-sdk/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
  */
-export declare const getEventSigningTransformStream: (initialSignature: string, eventSigner: EventSigner, eventStreamCodec: EventStreamCodec) => TransformStream<Uint8Array, Uint8Array>;
+export declare const getEventSigningTransformStream: (initialSignature: string, messageSigner: MessageSigner, eventStreamCodec: EventStreamCodec) => TransformStream<Uint8Array, Uint8Array>;

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

@@ -1,24 +1,24 @@
 import {
   Decoder,
   Encoder,
-  EventSigner,
   EventStreamPayloadHandler as IEventStreamPayloadHandler,
   FinalizeHandler,
   FinalizeHandlerArguments,
   FinalizeHandlerOutput,
   HandlerExecutionContext,
+  MessageSigner,
   MetadataBearer,
   Provider,
 } from "@aws-sdk/types";
 export interface EventStreamPayloadHandlerOptions {
-  eventSigner: Provider<EventSigner>;
+  messageSigner: Provider<MessageSigner>;
   utf8Encoder: Encoder;
   utf8Decoder: Decoder;
 }
 export declare class EventStreamPayloadHandler
   implements IEventStreamPayloadHandler
 {
-  private readonly eventSigner;
+  private readonly messageSigner;
   private readonly eventStreamCodec;
   constructor(options: EventStreamPayloadHandlerOptions);
   handle<T extends MetadataBearer>(

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

@@ -1,7 +1,7 @@
 import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
-import { EventSigner } from "@aws-sdk/types";
+import { MessageSigner } from "@aws-sdk/types";
 export declare const getEventSigningTransformStream: (
   initialSignature: string,
-  eventSigner: EventSigner,
+  messageSigner: MessageSigner,
   eventStreamCodec: EventStreamCodec
 ) => TransformStream<Uint8Array, Uint8Array>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-websocket",
-  "version": "3.347.0",
+  "version": "3.351.0",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",