@aws-sdk/eventstream-handler-node 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/eventstream-handler-node
+
+
+
+
+
 # [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/eventstream-handler-node

package/dist-es/EventSigningStream.js

@@ -1,49 +1,57 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
 import { Transform } from "stream";
-export class EventSigningStream extends Transform {
-    constructor(options) {
-        super({
-            autoDestroy: true,
-            readableObjectMode: true,
-            writableObjectMode: true,
-            ...options,
-        });
-        this.priorSignature = options.priorSignature;
-        this.eventSigner = options.eventSigner;
-        this.eventStreamCodec = options.eventStreamCodec;
+var EventSigningStream = (function (_super) {
+    __extends(EventSigningStream, _super);
+    function EventSigningStream(options) {
+        var _this = _super.call(this, __assign({ autoDestroy: true, readableObjectMode: true, writableObjectMode: true }, options)) || this;
+        _this.priorSignature = options.priorSignature;
+        _this.eventSigner = options.eventSigner;
+        _this.eventStreamCodec = options.eventStreamCodec;
+        return _this;
     }
-    async _transform(chunk, encoding, callback) {
-        try {
-            const now = new Date();
-            const dateHeader = {
-                ":date": { type: "timestamp", value: now },
-            };
-            const signature = await this.eventSigner.sign({
-                payload: chunk,
-                headers: this.eventStreamCodec.formatHeaders(dateHeader),
-            }, {
-                priorSignature: this.priorSignature,
-                signingDate: now,
-            });
-            this.priorSignature = signature;
-            const serializedSigned = this.eventStreamCodec.encode({
-                headers: {
-                    ...dateHeader,
-                    ":chunk-signature": {
-                        type: "binary",
-                        value: getSignatureBinary(signature),
-                    },
-                },
-                body: chunk,
+    EventSigningStream.prototype._transform = function (chunk, encoding, callback) {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, dateHeader, signature, serializedSigned, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        now = new Date();
+                        dateHeader = {
+                            ":date": { type: "timestamp", value: now },
+                        };
+                        return [4, this.eventSigner.sign({
+                                payload: chunk,
+                                headers: this.eventStreamCodec.formatHeaders(dateHeader),
+                            }, {
+                                priorSignature: this.priorSignature,
+                                signingDate: now,
+                            })];
+                    case 1:
+                        signature = _a.sent();
+                        this.priorSignature = signature;
+                        serializedSigned = this.eventStreamCodec.encode({
+                            headers: __assign(__assign({}, dateHeader), { ":chunk-signature": {
+                                    type: "binary",
+                                    value: getSignatureBinary(signature),
+                                } }),
+                            body: chunk,
+                        });
+                        this.push(serializedSigned);
+                        return [2, callback()];
+                    case 2:
+                        err_1 = _a.sent();
+                        callback(err_1);
+                        return [3, 3];
+                    case 3: return [2];
+                }
             });
-            this.push(serializedSigned);
-            return callback();
-        }
-        catch (err) {
-            callback(err);
-        }
-    }
-}
+        });
+    };
+    return EventSigningStream;
+}(Transform));
+export { EventSigningStream };
 function getSignatureBinary(signature) {
-    const buf = Buffer.from(signature, "hex");
+    var buf = Buffer.from(signature, "hex");
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
 }

package/dist-es/EventStreamPayloadHandler.js

@@ -1,41 +1,62 @@
+import { __awaiter, __generator } from "tslib";
 import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
 import { PassThrough, pipeline, Readable } from "stream";
 import { EventSigningStream } from "./EventSigningStream";
-export class EventStreamPayloadHandler {
-    constructor(options) {
+var EventStreamPayloadHandler = (function () {
+    function EventStreamPayloadHandler(options) {
         this.eventSigner = options.eventSigner;
         this.eventStreamCodec = new EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
     }
-    async handle(next, args, context = {}) {
-        const request = args.request;
-        const { body: payload } = request;
-        if (!(payload instanceof Readable)) {
-            throw new Error("Eventstream payload must be a Readable stream.");
-        }
-        const payloadStream = payload;
-        request.body = new PassThrough({
-            objectMode: true,
+    EventStreamPayloadHandler.prototype.handle = function (next, args, context) {
+        if (context === void 0) { context = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var request, payload, payloadStream, result, e_1, match, priorSignature, signingStream, _a;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        request = args.request;
+                        payload = request.body;
+                        if (!(payload instanceof Readable)) {
+                            throw new Error("Eventstream payload must be a Readable stream.");
+                        }
+                        payloadStream = payload;
+                        request.body = new PassThrough({
+                            objectMode: true,
+                        });
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4, next(args)];
+                    case 2:
+                        result = _c.sent();
+                        return [3, 4];
+                    case 3:
+                        e_1 = _c.sent();
+                        request.body.end();
+                        throw e_1;
+                    case 4:
+                        match = (request.headers["authorization"] || "").match(/Signature=([\w]+)$/);
+                        priorSignature = (match || [])[1];
+                        _a = EventSigningStream.bind;
+                        _b = {
+                            priorSignature: priorSignature,
+                            eventStreamCodec: this.eventStreamCodec
+                        };
+                        return [4, this.eventSigner()];
+                    case 5:
+                        signingStream = new (_a.apply(EventSigningStream, [void 0, (_b.eventSigner = _c.sent(),
+                                _b)]))();
+                        pipeline(payloadStream, signingStream, request.body, function (err) {
+                            if (err) {
+                                throw err;
+                            }
+                        });
+                        return [2, result];
+                }
+            });
         });
-        let result;
-        try {
-            result = await next(args);
-        }
-        catch (e) {
-            request.body.end();
-            throw e;
-        }
-        const match = (request.headers["authorization"] || "").match(/Signature=([\w]+)$/);
-        const priorSignature = (match || [])[1];
-        const signingStream = new EventSigningStream({
-            priorSignature,
-            eventStreamCodec: this.eventStreamCodec,
-            eventSigner: await this.eventSigner(),
-        });
-        pipeline(payloadStream, signingStream, request.body, (err) => {
-            if (err) {
-                throw err;
-            }
-        });
-        return result;
-    }
-}
+    };
+    return EventStreamPayloadHandler;
+}());
+export { EventStreamPayloadHandler };

package/dist-es/provider.js

@@ -1,2 +1,2 @@
 import { EventStreamPayloadHandler } from "./EventStreamPayloadHandler";
-export const eventStreamPayloadHandlerProvider = (options) => new EventStreamPayloadHandler(options);
+export var eventStreamPayloadHandlerProvider = function (options) { return new EventStreamPayloadHandler(options); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/eventstream-handler-node",
-  "version": "3.183.0",
+  "version": "3.186.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -20,12 +20,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@aws-sdk/eventstream-codec": "3.183.0",
-    "@aws-sdk/types": "3.183.0",
+    "@aws-sdk/eventstream-codec": "3.186.0",
+    "@aws-sdk/types": "3.186.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/util-utf8-node": "3.183.0",
+    "@aws-sdk/util-utf8-node": "3.186.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^12.0.0",
     "concurrently": "7.0.0",