@aws-sdk/eventstream-serde-universal - npm Package Compare versions

Comparing version 3.341.0 to 3.342.0

dist-cjs/EventStreamMarshaller.js

@@ -13,24 +13,16 @@ "use strict";
     deserialize(body, deserializer) {
-        const chunkedStream = (0, getChunkedStream_1.getChunkedStream)(body);
-        const unmarshalledStream = (0, getUnmarshalledStream_1.getUnmarshalledStream)(chunkedStream, {
-            eventStreamCodec: this.eventStreamCodec,
-            deserializer,
-            toUtf8: this.utfEncoder,
+        const inputStream = (0, getChunkedStream_1.getChunkedStream)(body);
+        return new eventstream_codec_1.SmithyMessageDecoderStream({
+            messageStream: new eventstream_codec_1.MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
+            deserializer: (0, getUnmarshalledStream_1.getMessageUnmarshaller)(deserializer, this.utfEncoder),
         });
-        return unmarshalledStream;
     }
-    serialize(input, serializer) {
-        const self = this;
-        const serializedIterator = async function* () {
-            for await (const chunk of input) {
-                const payloadBuf = self.eventStreamCodec.encode(serializer(chunk));
-                yield payloadBuf;
-            }
-            yield new Uint8Array(0);
-        };
-        return {
-            [Symbol.asyncIterator]: serializedIterator,
-        };
+    serialize(inputStream, serializer) {
+        return new eventstream_codec_1.MessageEncoderStream({
+            messageStream: new eventstream_codec_1.SmithyMessageEncoderStream({ inputStream, serializer }),
+            encoder: this.eventStreamCodec,
+            includeEndFrame: true,
+        });
     }
 }
 exports.EventStreamMarshaller = EventStreamMarshaller;

dist-cjs/getUnmarshalledStream.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnmarshalledStream = void 0;
+exports.getMessageUnmarshaller = exports.getUnmarshalledStream = void 0;
 function getUnmarshalledStream(source, options) {
+    const messageUnmarshaller = getMessageUnmarshaller(options.deserializer, options.toUtf8);
     return {
@@ -9,31 +10,6 @@ [Symbol.asyncIterator]: async function* () {
                 const message = options.eventStreamCodec.decode(chunk);
-                const { value: messageType } = message.headers[":message-type"];
-                if (messageType === "error") {
-                    const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
-                    unmodeledError.name = message.headers[":error-code"].value;
-                    throw unmodeledError;
-                }
-                else if (messageType === "exception") {
-                    const code = message.headers[":exception-type"].value;
-                    const exception = { [code]: message };
-                    const deserializedException = await options.deserializer(exception);
-                    if (deserializedException.$unknown) {
-                        const error = new Error(options.toUtf8(message.body));
-                        error.name = code;
-                        throw error;
-                    }
-                    throw deserializedException[code];
-                }
-                else if (messageType === "event") {
-                    const event = {
-                        [message.headers[":event-type"].value]: message,
-                    };
-                    const deserialized = await options.deserializer(event);
-                    if (deserialized.$unknown)
-                        continue;
-                    yield deserialized;
-                }
-                else {
-                    throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
-                }
+                const type = await messageUnmarshaller(message);
+                if (type === undefined)
+                    continue;
+                yield type;
             }
@@ -44,1 +20,35 @@ },
 exports.getUnmarshalledStream = getUnmarshalledStream;
+function getMessageUnmarshaller(deserializer, toUtf8) {
+    return async function (message) {
+        const { value: messageType } = message.headers[":message-type"];
+        if (messageType === "error") {
+            const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
+            unmodeledError.name = message.headers[":error-code"].value;
+            throw unmodeledError;
+        }
+        else if (messageType === "exception") {
+            const code = message.headers[":exception-type"].value;
+            const exception = { [code]: message };
+            const deserializedException = await deserializer(exception);
+            if (deserializedException.$unknown) {
+                const error = new Error(toUtf8(message.body));
+                error.name = code;
+                throw error;
+            }
+            throw deserializedException[code];
+        }
+        else if (messageType === "event") {
+            const event = {
+                [message.headers[":event-type"].value]: message,
+            };
+            const deserialized = await deserializer(event);
+            if (deserialized.$unknown)
+                return;
+            return deserialized;
+        }
+        else {
+            throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+        }
+    };
+}
+exports.getMessageUnmarshaller = getMessageUnmarshaller;

dist-es/EventStreamMarshaller.js

@@ -1,4 +0,4 @@
-import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
+import { EventStreamCodec, MessageDecoderStream, MessageEncoderStream, SmithyMessageDecoderStream, SmithyMessageEncoderStream, } from "@aws-sdk/eventstream-codec";
 import { getChunkedStream } from "./getChunkedStream";
-import { getUnmarshalledStream } from "./getUnmarshalledStream";
+import { getMessageUnmarshaller } from "./getUnmarshalledStream";
 export class EventStreamMarshaller {
@@ -10,23 +10,15 @@ constructor({ utf8Encoder, utf8Decoder }) {
     deserialize(body, deserializer) {
-        const chunkedStream = getChunkedStream(body);
-        const unmarshalledStream = getUnmarshalledStream(chunkedStream, {
-            eventStreamCodec: this.eventStreamCodec,
-            deserializer,
-            toUtf8: this.utfEncoder,
+        const inputStream = getChunkedStream(body);
+        return new SmithyMessageDecoderStream({
+            messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
+            deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder),
         });
-        return unmarshalledStream;
     }
-    serialize(input, serializer) {
-        const self = this;
-        const serializedIterator = async function* () {
-            for await (const chunk of input) {
-                const payloadBuf = self.eventStreamCodec.encode(serializer(chunk));
-                yield payloadBuf;
-            }
-            yield new Uint8Array(0);
-        };
-        return {
-            [Symbol.asyncIterator]: serializedIterator,
-        };
+    serialize(inputStream, serializer) {
+        return new MessageEncoderStream({
+            messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
+            encoder: this.eventStreamCodec,
+            includeEndFrame: true,
+        });
     }
 }

dist-es/getUnmarshalledStream.js

 export function getUnmarshalledStream(source, options) {
+    const messageUnmarshaller = getMessageUnmarshaller(options.deserializer, options.toUtf8);
     return {
@@ -6,31 +7,6 @@ [Symbol.asyncIterator]: async function* () {
                 const message = options.eventStreamCodec.decode(chunk);
-                const { value: messageType } = message.headers[":message-type"];
-                if (messageType === "error") {
-                    const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
-                    unmodeledError.name = message.headers[":error-code"].value;
-                    throw unmodeledError;
-                }
-                else if (messageType === "exception") {
-                    const code = message.headers[":exception-type"].value;
-                    const exception = { [code]: message };
-                    const deserializedException = await options.deserializer(exception);
-                    if (deserializedException.$unknown) {
-                        const error = new Error(options.toUtf8(message.body));
-                        error.name = code;
-                        throw error;
-                    }
-                    throw deserializedException[code];
-                }
-                else if (messageType === "event") {
-                    const event = {
-                        [message.headers[":event-type"].value]: message,
-                    };
-                    const deserialized = await options.deserializer(event);
-                    if (deserialized.$unknown)
-                        continue;
-                    yield deserialized;
-                }
-                else {
-                    throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
-                }
+                const type = await messageUnmarshaller(message);
+                if (type === undefined)
+                    continue;
+                yield type;
             }
@@ -40,1 +16,34 @@ },
 }
+export function getMessageUnmarshaller(deserializer, toUtf8) {
+    return async function (message) {
+        const { value: messageType } = message.headers[":message-type"];
+        if (messageType === "error") {
+            const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
+            unmodeledError.name = message.headers[":error-code"].value;
+            throw unmodeledError;
+        }
+        else if (messageType === "exception") {
+            const code = message.headers[":exception-type"].value;
+            const exception = { [code]: message };
+            const deserializedException = await deserializer(exception);
+            if (deserializedException.$unknown) {
+                const error = new Error(toUtf8(message.body));
+                error.name = code;
+                throw error;
+            }
+            throw deserializedException[code];
+        }
+        else if (messageType === "event") {
+            const event = {
+                [message.headers[":event-type"].value]: message,
+            };
+            const deserialized = await deserializer(event);
+            if (deserialized.$unknown)
+                return;
+            return deserialized;
+        }
+        else {
+            throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+        }
+    };
+}

dist-types/EventStreamMarshaller.d.ts

@@ -22,3 +22,3 @@ import { Decoder, Encoder, EventStreamMarshaller as IEventStreamMarshaller, Message } from "@aws-sdk/types";
     deserialize<T>(body: AsyncIterable<Uint8Array>, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
-    serialize<T>(input: AsyncIterable<T>, serializer: (event: T) => Message): AsyncIterable<Uint8Array>;
+    serialize<T>(inputStream: AsyncIterable<T>, serializer: (event: T) => Message): AsyncIterable<Uint8Array>;
 }

dist-types/getUnmarshalledStream.d.ts

@@ -15,1 +15,5 @@ import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
 export declare function getUnmarshalledStream<T extends Record<string, any>>(source: AsyncIterable<Uint8Array>, options: UnmarshalledStreamOptions<T>): AsyncIterable<T>;
+/**
+ * @internal
+ */
+export declare function getMessageUnmarshaller<T extends Record<string, any>>(deserializer: (input: Record<string, Message>) => Promise<T>, toUtf8: Encoder): (input: Message) => Promise<T | undefined>;

dist-types/ts3.4/EventStreamMarshaller.d.ts

@@ -21,5 +21,5 @@ import {
   serialize<T>(
-    input: AsyncIterable<T>,
+    inputStream: AsyncIterable<T>,
     serializer: (event: T) => Message
   ): AsyncIterable<Uint8Array>;
 }

dist-types/ts3.4/getUnmarshalledStream.d.ts

@@ -12,1 +12,5 @@ import { EventStreamCodec } from "@aws-sdk/eventstream-codec";
 ): AsyncIterable<T>;
+export declare function getMessageUnmarshaller<T extends Record<string, any>>(
+  deserializer: (input: Record<string, Message>) => Promise<T>,
+  toUtf8: Encoder
+): (input: Message) => Promise<T | undefined>;

package.json

 {
   "name": "@aws-sdk/eventstream-serde-universal",
-  "version": "3.341.0",
+  "version": "3.342.0",
   "scripts": {
@@ -23,4 +23,4 @@ "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
   "dependencies": {
-    "@aws-sdk/eventstream-codec": "3.341.0",
-    "@aws-sdk/types": "3.341.0",
+    "@aws-sdk/eventstream-codec": "3.342.0",
+    "@aws-sdk/types": "3.342.0",
     "tslib": "^2.5.0"
@@ -27,0 +27,0 @@ },

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

36813

increased by1.66%

Lines of code

540

increased by2.08%

Dependency changes

• + Added@aws-sdk/eventstream-codec@3.342.0(transitive)

• + Added@aws-sdk/types@3.342.0(transitive)

• - Removed@aws-sdk/eventstream-codec@3.341.0(transitive)

• - Removed@aws-sdk/types@3.341.0(transitive)

• Updated@aws-sdk/eventstream-codec@3.342.0

• Updated@aws-sdk/types@3.342.0