@aws-sdk/middleware-sdk-transcribe-streaming 3.183.0 → 3.186.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.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
+
+
+
+
+
 # [3.183.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.182.0...v3.183.0) (2022-10-03)
 
 **Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming

package/dist-es/configuration.js

@@ -1,14 +1,22 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { SignatureV4 } from "./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;
+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; };

package/dist-es/eventstream-handler.js

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

package/dist-es/middleware-endpoint.js

@@ -1,28 +1,45 @@
+import { __values } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
-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];
+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 };
             }
-        }
-        if (headers["x-amz-user-agent"]) {
-            request.query["user-agent"] = headers["x-amz-user-agent"];
-        }
-        request.headers = { host: request.hostname };
-    }
-    return next(args);
+            return next(args);
+        };
+    };
 };
-export const websocketURLMiddlewareOptions = {
+export var websocketURLMiddlewareOptions = {
     name: "websocketURLMiddleware",
     tags: ["WEBSOCKET", "EVENT_STREAM"],
     relation: "after",

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

@@ -1,22 +1,44 @@
+import { __assign, __awaiter, __generator, __values } from "tslib";
 import { v4 } from "uuid";
-export const injectSessionIdMiddleware = (config) => (next) => async (args) => {
-    if (args.input.SessionId === undefined && isWebSocket(config)) {
-        args.input.SessionId = v4();
-    }
-    const requestParams = {
-        ...args.input,
+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];
+                }
+            });
+        }); };
     };
-    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;
 };
-const isWebSocket = (config) => config.requestHandler.metadata?.handlerProtocol === "websocket";
-export const injectSessionIdMiddlewareOptions = {
+var isWebSocket = function (config) { var _a; return ((_a = config.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.handlerProtocol) === "websocket"; };
+export var 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 const getWebSocketPlugin = (config) => ({
-    applyToStack: (clientStack) => {
+export var getWebSocketPlugin = function (config) { return ({
+    applyToStack: function (clientStack) {
         clientStack.addRelativeTo(websocketURLMiddleware(config), websocketURLMiddlewareOptions);
         clientStack.add(injectSessionIdMiddleware(config), injectSessionIdMiddlewareOptions);
     },
-});
+}); };

package/dist-es/signer.js

@@ -1,24 +1,32 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest } from "@aws-sdk/protocol-http";
-export class SignatureV4 {
-    constructor(options) {
+var SignatureV4 = (function () {
+    function SignatureV4(options) {
         this.signer = options.signer;
     }
-    presign(originalRequest, options = {}) {
+    SignatureV4.prototype.presign = function (originalRequest, options) {
+        if (options === void 0) { options = {}; }
         return this.signer.presign(originalRequest, 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")),
+    };
+    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)];
+                }
             });
-            return {
-                ...signedRequest,
-                body: toSign.body,
-            };
-        }
-        else {
-            return this.signer.sign(toSign, options);
-        }
-    }
-}
+        });
+    };
+    return SignatureV4;
+}());
+export { SignatureV4 };

package/dist-es/websocket-handler.js

@@ -1,56 +1,73 @@
+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";
-export class WebSocketHandler {
-    constructor({ connectionTimeout } = {}) {
+var WebSocketHandler = (function () {
+    function WebSocketHandler(_a) {
+        var _b = _a === void 0 ? {} : _a, connectionTimeout = _b.connectionTimeout;
         this.metadata = {
             handlerProtocol: "websocket",
         };
         this.connectionTimeout = connectionTimeout || 2000;
     }
-    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,
-            },
+    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,
+                                }),
+                            }];
+                }
+            });
         });
-    }, connectionTimeout);
-    socket.onopen = () => {
-        clearTimeout(timeout);
-        resolve();
     };
-});
-const connect = (socket, data) => {
-    let streamError = undefined;
-    const outputStream = {
-        [Symbol.asyncIterator]: () => ({
-            next: () => {
-                return new Promise((resolve, reject) => {
-                    socket.onerror = (error) => {
+    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) {
                         socket.onclose = null;
                         socket.close();
                         reject(error);
                     };
-                    socket.onclose = () => {
+                    socket.onclose = function () {
                         if (streamError) {
                             reject(streamError);
                         }
@@ -61,7 +78,7 @@ const connect = (socket, data) => {
                             });
                         }
                     };
-                    socket.onmessage = (event) => {
+                    socket.onmessage = function (event) {
                         resolve({
                             done: false,
                             value: new Uint8Array(event.data),
@@ -69,37 +86,87 @@ const connect = (socket, data) => {
                     };
                 });
             },
-        }),
-    };
-    const send = async () => {
-        try {
-            for await (const inputChunk of data) {
-                socket.send(inputChunk);
+        }); },
+        _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];
             }
-        }
-        catch (err) {
-            streamError = err;
-        }
-        finally {
-            socket.close(1000);
-        }
-    };
+        });
+    }); };
     send();
     return outputStream;
 };
-const getIterator = (stream) => {
+var getIterator = function (stream) {
+    var _a;
     if (stream[Symbol.asyncIterator])
         return stream;
     else if (isReadableStream(stream)) {
         return readableStreamtoIterable(stream);
     }
     else {
-        return {
-            [Symbol.asyncIterator]: async function* () {
-                yield stream;
+        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];
+                        }
+                    });
+                });
             },
-        };
+            _a;
     }
 };
-const toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
-const isReadableStream = (payload) => typeof ReadableStream === "function" && payload instanceof ReadableStream;
+var toReadableStream = function (asyncIterable) {
+    return typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
+};
+var isReadableStream = function (payload) {
+    return typeof ReadableStream === "function" && payload instanceof ReadableStream;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/middleware-sdk-transcribe-streaming",
-  "version": "3.183.0",
+  "version": "3.186.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.183.0",
-    "@aws-sdk/middleware-signing": "3.183.0",
-    "@aws-sdk/protocol-http": "3.183.0",
-    "@aws-sdk/signature-v4": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
-    "@aws-sdk/util-format-url": "3.183.0",
+    "@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",
     "tslib": "^2.3.1",
     "uuid": "^8.3.2"
   },