@aws-sdk/eventstream-handler-node 3.178.0 → 3.183.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.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
+
+
+
+
+
 # [3.178.0](https://github.com/aws/aws-sdk-js-v3/compare/v3.177.0...v3.178.0) (2022-09-23)
 
 **Note:** Version bump only for package @aws-sdk/eventstream-handler-node

package/dist-es/EventSigningStream.js

@@ -1,57 +1,49 @@
-import { __assign, __awaiter, __extends, __generator } from "tslib";
 import { Transform } from "stream";
-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;
+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;
     }
-    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];
-                }
+    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,
             });
-        });
-    };
-    return EventSigningStream;
-}(Transform));
-export { EventSigningStream };
+            this.priorSignature = signature;
+            const serializedSigned = this.eventStreamCodec.encode({
+                headers: {
+                    ...dateHeader,
+                    ":chunk-signature": {
+                        type: "binary",
+                        value: getSignatureBinary(signature),
+                    },
+                },
+                body: chunk,
+            });
+            this.push(serializedSigned);
+            return callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
 function getSignatureBinary(signature) {
-    var buf = Buffer.from(signature, "hex");
+    const buf = Buffer.from(signature, "hex");
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
 }

package/dist-es/EventStreamPayloadHandler.js

@@ -1,62 +1,41 @@
-import { __awaiter, __generator } from "tslib";
 import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
 import { PassThrough, pipeline, Readable } from "stream";
 import { EventSigningStream } from "./EventSigningStream";
-var EventStreamPayloadHandler = (function () {
-    function EventStreamPayloadHandler(options) {
+export class EventStreamPayloadHandler {
+    constructor(options) {
         this.eventSigner = options.eventSigner;
         this.eventStreamCodec = new EventStreamCodec(options.utf8Encoder, options.utf8Decoder);
     }
-    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];
-                }
-            });
+    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,
         });
-    };
-    return EventStreamPayloadHandler;
-}());
-export { EventStreamPayloadHandler };
+        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;
+    }
+}

package/dist-es/provider.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-sdk/eventstream-handler-node",
-  "version": "3.178.0",
+  "version": "3.183.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.178.0",
-    "@aws-sdk/types": "3.178.0",
+    "@aws-sdk/eventstream-codec": "3.183.0",
+    "@aws-sdk/types": "3.183.0",
     "tslib": "^2.3.1"
   },
   "devDependencies": {
-    "@aws-sdk/util-utf8-node": "3.170.0",
+    "@aws-sdk/util-utf8-node": "3.183.0",
     "@tsconfig/recommended": "1.0.1",
     "@types/node": "^12.0.0",
     "concurrently": "7.0.0",