@aws-sdk/middleware-sdk-transcribe-streaming 3.33.0 → 3.37.0

package/CHANGELOG.md

@@ -3,6 +3,44 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.37.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.36.1...v3.37.0) (2021-10-15)
+
+**Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming
+
+
+
+
+
+# [3.36.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.35.0...v3.36.0) (2021-10-08)
+
+
+### Features
+
+* publish files in dist-* only ([#2873](https://github.com/aws/aws-sdk-js-v3/issues/2873)) ([53b4243](https://github.com/aws/aws-sdk-js-v3/commit/53b4243b066f25ff2412d5f0dea1036054b2df32))
+
+
+
+
+
+# [3.35.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.34.0...v3.35.0) (2021-10-04)
+
+**Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming
+
+
+
+
+
+# [3.34.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.33.0...v3.34.0) (2021-09-24)
+
+
+### Features
+
+* **non-clients:** remove comments from transpiled JS files ([#2813](https://github.com/aws/aws-sdk-js-v3/issues/2813)) ([e6fc7f3](https://github.com/aws/aws-sdk-js-v3/commit/e6fc7f3e0fa74785590ac19e7ed143c916bb9b6e))
+
+
+
+
+
 # [3.33.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.32.0...v3.33.0) (2021-09-21)
 
 **Note:** Version bump only for package @aws-sdk/middleware-sdk-transcribe-streaming

package/dist-cjs/configuration.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWebSocketConfig = void 0;
+const signer_1 = require("./signer");
+const resolveWebSocketConfig = (input) => {
+    var _a;
+    return ((_a = input.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.handlerProtocol) !== "websocket"
+        ? input
+        : {
+            ...input,
+            signer: async () => {
+                const signerObj = await input.signer();
+                if (validateSigner(signerObj)) {
+                    return new signer_1.SignatureV4({ signer: signerObj });
+                }
+                throw new Error("Expected SignatureV4 signer, please check the client constructor.");
+            },
+        };
+};
+exports.resolveWebSocketConfig = resolveWebSocketConfig;
+const validateSigner = (signer) => !!signer;

package/dist-cjs/eventstream-handler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventStreamPayloadHandler = void 0;
+exports.eventStreamPayloadHandler = {
+    handle: (next, args) => next(args),
+};

package/dist-cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./websocket-handler"), exports);
+tslib_1.__exportStar(require("./eventstream-handler"), exports);
+tslib_1.__exportStar(require("./signer"), exports);
+tslib_1.__exportStar(require("./configuration"), exports);
+tslib_1.__exportStar(require("./middleware-endpoint"), exports);
+tslib_1.__exportStar(require("./middleware-session-id"), exports);
+tslib_1.__exportStar(require("./plugin"), exports);

package/dist-cjs/middleware-endpoint.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketURLMiddlewareOptions = exports.websocketURLMiddleware = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const websocketURLMiddleware = (options) => (next) => (args) => {
+    var _a;
+    const { request } = args;
+    if (protocol_http_1.HttpRequest.isInstance(request) && ((_a = options.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.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];
+            }
+        }
+        if (headers["x-amz-user-agent"]) {
+            request.query["user-agent"] = headers["x-amz-user-agent"];
+        }
+        request.headers = { host: request.hostname };
+    }
+    return next(args);
+};
+exports.websocketURLMiddleware = websocketURLMiddleware;
+exports.websocketURLMiddlewareOptions = {
+    name: "websocketURLMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    relation: "after",
+    toMiddleware: "eventStreamHeaderMiddleware",
+    override: true,
+};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectSessionIdMiddlewareOptions = exports.injectSessionIdMiddleware = void 0;
+const uuid_1 = require("uuid");
+const injectSessionIdMiddleware = (config) => (next) => async (args) => {
+    if (args.input.SessionId === undefined && isWebSocket(config)) {
+        args.input.SessionId = uuid_1.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;
+};
+exports.injectSessionIdMiddleware = injectSessionIdMiddleware;
+const isWebSocket = (config) => { var _a; return ((_a = config.requestHandler.metadata) === null || _a === void 0 ? void 0 : _a.handlerProtocol) === "websocket"; };
+exports.injectSessionIdMiddlewareOptions = {
+    step: "initialize",
+    name: "injectSessionIdMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    override: true,
+};

package/dist-cjs/plugin.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWebSocketPlugin = void 0;
+const middleware_endpoint_1 = require("./middleware-endpoint");
+const middleware_session_id_1 = require("./middleware-session-id");
+const getWebSocketPlugin = (config) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(middleware_endpoint_1.websocketURLMiddleware(config), middleware_endpoint_1.websocketURLMiddlewareOptions);
+        clientStack.add(middleware_session_id_1.injectSessionIdMiddleware(config), middleware_session_id_1.injectSessionIdMiddlewareOptions);
+    },
+});
+exports.getWebSocketPlugin = getWebSocketPlugin;

package/dist-cjs/signer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureV4 = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+class SignatureV4 {
+    constructor(options) {
+        this.signer = options.signer;
+    }
+    presign(originalRequest, options = {}) {
+        return this.signer.presign(originalRequest, options);
+    }
+    async sign(toSign, options) {
+        if (protocol_http_1.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 {
+                ...signedRequest,
+                body: toSign.body,
+            };
+        }
+        else {
+            return this.signer.sign(toSign, options);
+        }
+    }
+}
+exports.SignatureV4 = SignatureV4;

package/dist-cjs/websocket-handler.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+const eventstream_serde_browser_1 = require("@aws-sdk/eventstream-serde-browser");
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const util_format_url_1 = require("@aws-sdk/util-format-url");
+class WebSocketHandler {
+    constructor({ connectionTimeout } = {}) {
+        this.metadata = {
+            handlerProtocol: "websocket",
+        };
+        this.connectionTimeout = connectionTimeout || 2000;
+    }
+    destroy() { }
+    async handle(request) {
+        const url = util_format_url_1.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 protocol_http_1.HttpResponse({
+                statusCode: 200,
+                body: outputPayload,
+            }),
+        };
+    }
+}
+exports.WebSocketHandler = WebSocketHandler;
+const waitForReady = (socket, connectionTimeout) => new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+        reject({
+            $metadata: {
+                httpStatusCode: 500,
+            },
+        });
+    }, 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) => {
+                        socket.onclose = null;
+                        socket.close();
+                        reject(error);
+                    };
+                    socket.onclose = () => {
+                        if (streamError) {
+                            reject(streamError);
+                        }
+                        else {
+                            resolve({
+                                done: true,
+                                value: undefined,
+                            });
+                        }
+                    };
+                    socket.onmessage = (event) => {
+                        resolve({
+                            done: false,
+                            value: new Uint8Array(event.data),
+                        });
+                    };
+                });
+            },
+        }),
+    };
+    const send = async () => {
+        try {
+            for await (const inputChunk of data) {
+                socket.send(inputChunk);
+            }
+        }
+        catch (err) {
+            streamError = err;
+        }
+        finally {
+            socket.close(1000);
+        }
+    };
+    send();
+    return outputStream;
+};
+const getIterator = (stream) => {
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    else if (isReadableStream(stream)) {
+        return eventstream_serde_browser_1.readableStreamtoIterable(stream);
+    }
+    else {
+        return {
+            [Symbol.asyncIterator]: async function* () {
+                yield stream;
+            },
+        };
+    }
+};
+const toReadableStream = (asyncIterable) => typeof ReadableStream === "function" ? eventstream_serde_browser_1.iterableToReadableStream(asyncIterable) : asyncIterable;
+const isReadableStream = (payload) => typeof ReadableStream === "function" && payload instanceof ReadableStream;

package/dist-es/configuration.js

@@ -0,0 +1,22 @@
+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 () { 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()];
+                        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

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

package/dist-es/middleware-endpoint.js

@@ -0,0 +1,48 @@
+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 = request.hostname + ":8443";
+                request.path = 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 };
+            }
+            return next(args);
+        };
+    };
+};
+export var websocketURLMiddlewareOptions = {
+    name: "websocketURLMiddleware",
+    tags: ["WEBSOCKET", "EVENT_STREAM"],
+    relation: "after",
+    toMiddleware: "eventStreamHeaderMiddleware",
+    override: true,
+};

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

@@ -0,0 +1,46 @@
+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];
+                }
+            });
+        }); };
+    };
+};
+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"],
+    override: true,
+};

package/dist-es/plugin.js

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

package/dist-es/signer.js

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

package/dist-es/websocket-handler.js

@@ -0,0 +1,172 @@
+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;
+        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,
+                                }),
+                            }];
+                }
+            });
+        });
+    };
+    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 = function () {
+                        if (streamError) {
+                            reject(streamError);
+                        }
+                        else {
+                            resolve({
+                                done: true,
+                                value: undefined,
+                            });
+                        }
+                    };
+                    socket.onmessage = function (event) {
+                        resolve({
+                            done: false,
+                            value: new Uint8Array(event.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];
+            }
+        });
+    }); };
+    send();
+    return outputStream;
+};
+var getIterator = function (stream) {
+    var _a;
+    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];
+                        }
+                    });
+                });
+            },
+            _a;
+    }
+};
+var toReadableStream = function (asyncIterable) {
+    return typeof ReadableStream === "function" ? iterableToReadableStream(asyncIterable) : asyncIterable;
+};
+var isReadableStream = function (payload) {
+    return typeof ReadableStream === "function" && payload instanceof ReadableStream;
+};