@aws-sdk/middleware-sdk-transcribe-streaming 3.186.0 → 3.188.0

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.188.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.187.0...v3.188.0) (2022-10-13)
+
+**Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming
+
+
+
+
+
 # [3.186.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.185.0...v3.186.0) (2022-10-06)
 
 **Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming

package/dist-es/configuration.js

@@ -1,22 +1,14 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { SignatureV4 } from "./signer";
-export var resolveWebSocketConfig = function (input) {
-    var _a;
-    return ((_a = input.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.handlerProtocol) !== "websocket"
-        ? input
-        : __assign(__assign({}, input), { signer: function (authScheme) { return __awaiter(void 0, void 0, void 0, function () {
-                var signerObj;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0: return [4, input.signer(authScheme)];
-                        case 1:
-                            signerObj = _a.sent();
-                            if (validateSigner(signerObj)) {
-                                return [2, new SignatureV4({ signer: signerObj })];
-                            }
-                            throw new Error("Expected SignatureV4 signer, please check the client constructor.");
-                    }
-                });
-            }); } });
-};
-var validateSigner = function (signer) { return !!signer; };
+export const resolveWebSocketConfig = (input) => input.requestHandler.metadata?.handlerProtocol !== "websocket"
+    ? input
+    : {
+        ...input,
+        signer: async (authScheme) => {
+            const signerObj = await input.signer(authScheme);
+            if (validateSigner(signerObj)) {
+                return new SignatureV4({ signer: signerObj });
+            }
+            throw new Error("Expected SignatureV4 signer, please check the client constructor.");
+        },
+    };
+const validateSigner = (signer) => !!signer;

package/dist-es/eventstream-handler.js

@@ -1,3 +1,3 @@
-export var eventStreamPayloadHandler = {
-    handle: function (next, args) { return next(args); },
+export const eventStreamPayloadHandler = {
+    handle: (next, args) => next(args),
 };

package/dist-es/middleware-endpoint.js

@@ -1,45 +1,28 @@
-import { __values } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
-export var websocketURLMiddleware = function (options) {
-    return function (next) {
-        return function (args) {
-            var e_1, _a;
-            var _b;
-            var request = args.request;
-            if (HttpRequest.isInstance(request) && ((_b = options.requestHandler.metadata) === null || _b === void 0 ? void 0 : _b.handlerProtocol) === "websocket") {
-                request.protocol = "wss:";
-                request.hostname = "".concat(request.hostname, ":8443");
-                request.path = "".concat(request.path, "-websocket");
-                request.method = "GET";
-                var headers = request.headers;
-                delete headers["Content-Type"];
-                delete headers["x-amz-content-sha256"];
-                try {
-                    for (var _c = __values(Object.keys(headers)), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var name_1 = _d.value;
-                        if (name_1.indexOf("x-amzn-transcribe-") === 0) {
-                            var chunkedName = name_1.replace("x-amzn-transcribe-", "");
-                            request.query[chunkedName] = headers[name_1];
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                if (headers["x-amz-user-agent"]) {
-                    request.query["user-agent"] = headers["x-amz-user-agent"];
-                }
-                request.headers = { host: request.hostname };
+export const websocketURLMiddleware = (options) => (next) => (args) => {
+    const { request } = args;
+    if (HttpRequest.isInstance(request) && options.requestHandler.metadata?.handlerProtocol === "websocket") {
+        request.protocol = "wss:";
+        request.hostname = `${request.hostname}:8443`;
+        request.path = `${request.path}-websocket`;
+        request.method = "GET";
+        const { headers } = request;
+        delete headers["Content-Type"];
+        delete headers["x-amz-content-sha256"];
+        for (const name of Object.keys(headers)) {
+            if (name.indexOf("x-amzn-transcribe-") === 0) {
+                const chunkedName = name.replace("x-amzn-transcribe-", "");
+                request.query[chunkedName] = headers[name];
             }
-            return next(args);
-        };
-    };
+        }
+        if (headers["x-amz-user-agent"]) {
+            request.query["user-agent"] = headers["x-amz-user-agent"];
+        }
+        request.headers = { host: request.hostname };
+    }
+    return next(args);
 };
-export var websocketURLMiddlewareOptions = {
+export const websocketURLMiddlewareOptions = {
     name: "websocketURLMiddleware",
     tags: ["WEBSOCKET", "EVENT_STREAM"],
     relation: "after",

package/dist-es/middleware-session-id.js

@@ -1,44 +1,22 @@
-import { __assign, __awaiter, __generator, __values } from "tslib";
 import { v4 } from "uuid";
-export var injectSessionIdMiddleware = function (config) {
-    return function (next) {
-        return function (args) { return __awaiter(void 0, void 0, void 0, function () {
-            var requestParams, response, output, _a, _b, key;
-            var e_1, _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (args.input.SessionId === undefined && isWebSocket(config)) {
-                            args.input.SessionId = v4();
-                        }
-                        requestParams = __assign({}, args.input);
-                        return [4, next(args)];
-                    case 1:
-                        response = _d.sent();
-                        output = response.output;
-                        try {
-                            for (_a = __values(Object.keys(output)), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                key = _b.value;
-                                if (output[key] === undefined && requestParams[key]) {
-                                    output[key] = requestParams[key];
-                                }
-                            }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                        return [2, response];
-                }
-            });
-        }); };
+export const injectSessionIdMiddleware = (config) => (next) => async (args) => {
+    if (args.input.SessionId === undefined && isWebSocket(config)) {
+        args.input.SessionId = v4();
+    }
+    const requestParams = {
+        ...args.input,
     };
+    const response = await next(args);
+    const output = response.output;
+    for (const key of Object.keys(output)) {
+        if (output[key] === undefined && requestParams[key]) {
+            output[key] = requestParams[key];
+        }
+    }
+    return response;
 };
-var isWebSocket = function (config) { var _a; return ((_a = config.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.handlerProtocol) === "websocket"; };
-export var injectSessionIdMiddlewareOptions = {
+const isWebSocket = (config) => config.requestHandler.metadata?.handlerProtocol === "websocket";
+export const injectSessionIdMiddlewareOptions = {
     step: "initialize",
     name: "injectSessionIdMiddleware",
     tags: ["WEBSOCKET", "EVENT_STREAM"],

package/dist-es/plugin.js

@@ -1,8 +1,8 @@
 import { websocketURLMiddleware, websocketURLMiddlewareOptions } from "./middleware-endpoint";
 import { injectSessionIdMiddleware, injectSessionIdMiddlewareOptions } from "./middleware-session-id";
-export var getWebSocketPlugin = function (config) { return ({
-    applyToStack: function (clientStack) {
+export const getWebSocketPlugin = (config) => ({
+    applyToStack: (clientStack) => {
         clientStack.addRelativeTo(websocketURLMiddleware(config), websocketURLMiddlewareOptions);
         clientStack.add(injectSessionIdMiddleware(config), injectSessionIdMiddlewareOptions);
     },
-}); };
+});

package/dist-es/signer.js

@@ -1,32 +1,24 @@
-import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
-var SignatureV4 = (function () {
-    function SignatureV4(options) {
+export class SignatureV4 {
+    constructor(options) {
         this.signer = options.signer;
     }
-    SignatureV4.prototype.presign = function (originalRequest, options) {
-        if (options === void 0) { options = {}; }
+    presign(originalRequest, options = {}) {
         return this.signer.presign(originalRequest, options);
-    };
-    SignatureV4.prototype.sign = function (toSign, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var signedRequest;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!HttpRequest.isInstance(toSign)) return [3, 2];
-                        return [4, this.signer.presign(__assign(__assign({}, toSign), { body: "" }), {
-                                expiresIn: 5 * 60,
-                                unsignableHeaders: new Set(Object.keys(toSign.headers).filter(function (header) { return header !== "host"; })),
-                            })];
-                    case 1:
-                        signedRequest = _a.sent();
-                        return [2, __assign(__assign({}, signedRequest), { body: toSign.body })];
-                    case 2: return [2, this.signer.sign(toSign, options)];
-                }
+    }
+    async sign(toSign, options) {
+        if (HttpRequest.isInstance(toSign)) {
+            const signedRequest = await this.signer.presign({ ...toSign, body: "" }, {
+                expiresIn: 5 * 60,
+                unsignableHeaders: new Set(Object.keys(toSign.headers).filter((header) => header !== "host")),
             });
-        });
-    };
-    return SignatureV4;
-}());
-export { SignatureV4 };
+            return {
+                ...signedRequest,
+                body: toSign.body,
+            };
+        }
+        else {
+            return this.signer.sign(toSign, options);
+        }
+    }
+}

package/dist-es/websocket-handler.js

@@ -1,73 +1,56 @@
-import { __asyncGenerator, __asyncValues, __await, __awaiter, __generator } from "tslib";
 import { iterableToReadableStream, readableStreamtoIterable } from "@aws-sdk/eventstream-serde-browser";
 import { HttpResponse } from "@aws-sdk/protocol-http";
 import { formatUrl } from "@aws-sdk/util-format-url";
-var WebSocketHandler = (function () {
-    function WebSocketHandler(_a) {
-        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout;
+export class WebSocketHandler {
+    constructor({ connectionTimeout } = {}) {
         this.metadata = {
             handlerProtocol: "websocket",
         };
         this.connectionTimeout = connectionTimeout || 2000;
     }
-    WebSocketHandler.prototype.destroy = function () { };
-    WebSocketHandler.prototype.handle = function (request) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url, socket, body, bodyStream, asyncIterable, outputPayload;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        url = formatUrl(request);
-                        socket = new WebSocket(url);
-                        socket.binaryType = "arraybuffer";
-                        return [4, waitForReady(socket, this.connectionTimeout)];
-                    case 1:
-                        _a.sent();
-                        body = request.body;
-                        bodyStream = getIterator(body);
-                        asyncIterable = connect(socket, bodyStream);
-                        outputPayload = toReadableStream(asyncIterable);
-                        return [2, {
-                                response: new HttpResponse({
-                                    statusCode: 200,
-                                    body: outputPayload,
-                                }),
-                            }];
-                }
-            });
+    destroy() { }
+    async handle(request) {
+        const url = formatUrl(request);
+        const socket = new WebSocket(url);
+        socket.binaryType = "arraybuffer";
+        await waitForReady(socket, this.connectionTimeout);
+        const { body } = request;
+        const bodyStream = getIterator(body);
+        const asyncIterable = connect(socket, bodyStream);
+        const outputPayload = toReadableStream(asyncIterable);
+        return {
+            response: new HttpResponse({
+                statusCode: 200,
+                body: outputPayload,
+            }),
+        };
+    }
+}
+const waitForReady = (socket, connectionTimeout) => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+        reject({
+            $metadata: {
+                httpStatusCode: 500,
+            },
         });
+    }, connectionTimeout);
+    socket.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
     };
-    return WebSocketHandler;
-}());
-export { WebSocketHandler };
-var waitForReady = function (socket, connectionTimeout) {
-    return new Promise(function (resolve, reject) {
-        var timeout = setTimeout(function () {
-            reject({
-                $metadata: {
-                    httpStatusCode: 500,
-                },
-            });
-        }, connectionTimeout);
-        socket.onopen = function () {
-            clearTimeout(timeout);
-            resolve();
-        };
-    });
-};
-var connect = function (socket, data) {
-    var _a;
-    var streamError = undefined;
-    var outputStream = (_a = {},
-        _a[Symbol.asyncIterator] = function () { return ({
-            next: function () {
-                return new Promise(function (resolve, reject) {
-                    socket.onerror = function (error) {
+});
+const connect = (socket, data) => {
+    let streamError = undefined;
+    const outputStream = {
+        [Symbol.asyncIterator]: () => ({
+            next: () => {
+                return new Promise((resolve, reject) => {
+                    socket.onerror = (error) => {
                         socket.onclose = null;
                         socket.close();
                         reject(error);
                     };
-                    socket.onclose = function () {
+                    socket.onclose = () => {
                         if (streamError) {
                             reject(streamError);
                         }
@@ -78,7 +61,7 @@ var connect = function (socket, data) {
                             });
                         }
                     };
-                    socket.onmessage = function (event) {
+                    socket.onmessage = (event) => {
                         resolve({
                             done: false,
                             value: new Uint8Array(event.data),
@@ -86,87 +69,37 @@ var connect = function (socket, data) {
                     };
                 });
             },
-        }); },
-        _a);
-    var send = function () { return __awaiter(void 0, void 0, void 0, function () {
-        var data_1, data_1_1, inputChunk, e_1_1, err_1;
-        var e_1, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 13, 14, 15]);
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 6, 7, 12]);
-                    data_1 = __asyncValues(data);
-                    _b.label = 2;
-                case 2: return [4, data_1.next()];
-                case 3:
-                    if (!(data_1_1 = _b.sent(), !data_1_1.done)) return [3, 5];
-                    inputChunk = data_1_1.value;
-                    socket.send(inputChunk);
-                    _b.label = 4;
-                case 4: return [3, 2];
-                case 5: return [3, 12];
-                case 6:
-                    e_1_1 = _b.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3, 12];
-                case 7:
-                    _b.trys.push([7, , 10, 11]);
-                    if (!(data_1_1 && !data_1_1.done && (_a = data_1.return))) return [3, 9];
-                    return [4, _a.call(data_1)];
-                case 8:
-                    _b.sent();
-                    _b.label = 9;
-                case 9: return [3, 11];
-                case 10:
-                    if (e_1) throw e_1.error;
-                    return [7];
-                case 11: return [7];
-                case 12: return [3, 15];
-                case 13:
-                    err_1 = _b.sent();
-                    streamError = err_1;
-                    return [3, 15];
-                case 14:
-                    socket.close(1000);
-                    return [7];
-                case 15: return [2];
+        }),
+    };
+    const send = async () => {
+        try {
+            for await (const inputChunk of data) {
+                socket.send(inputChunk);
             }
-        });
-    }); };
+        }
+        catch (err) {
+            streamError = err;
+        }
+        finally {
+            socket.close(1000);
+        }
+    };
     send();
     return outputStream;
 };
-var getIterator = function (stream) {
-    var _a;
+const getIterator = (stream) => {
     if (stream[Symbol.asyncIterator])
         return stream;
     else if (isReadableStream(stream)) {
         return readableStreamtoIterable(stream);
     }
     else {
-        return _a = {},
-            _a[Symbol.asyncIterator] = function () {
-                return __asyncGenerator(this, arguments, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4, __await(stream)];
-                            case 1: return [4, _a.sent()];
-                            case 2:
-                                _a.sent();
-                                return [2];
-                        }
-                    });
-                });
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                yield stream;
             },
-            _a;
+        };
     }
 };
-var toReadableStream = function (asyncIterable) {
-    return typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
-};
-var isReadableStream = function (payload) {
-    return typeof ReadableStream === "function" && payload instanceof ReadableStream;
-};
+const toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
+const isReadableStream = (payload) => typeof ReadableStream === "function" && payload instanceof ReadableStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-sdk-transcribe-streaming",
-  "version": "3.186.0",
+  "version": "3.188.0",
   "main": "./dist-cjs/index.js",
   "module": "./dist-es/index.js",
   "types": "./dist-types/index.d.ts",
@@ -20,12 +20,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/eventstream-serde-browser": "3.186.0",
-    "@aws-sdk/middleware-signing": "3.186.0",
-    "@aws-sdk/protocol-http": "3.186.0",
-    "@aws-sdk/signature-v4": "3.186.0",
-    "@aws-sdk/types": "3.186.0",
-    "@aws-sdk/util-format-url": "3.186.0",
+    "@aws-sdk/eventstream-serde-browser": "3.188.0",
+    "@aws-sdk/middleware-signing": "3.188.0",
+    "@aws-sdk/protocol-http": "3.188.0",
+    "@aws-sdk/signature-v4": "3.188.0",
+    "@aws-sdk/types": "3.188.0",
+    "@aws-sdk/util-format-url": "3.188.0",
     "tslib": "^2.3.1",
     "uuid": "^8.3.2"
   },