fix: ensure that received binary data remains binary in an event

Unless... its datacontenttype is application/json. In that case it
should be converted into an object.

Signed-off-by: Lance Ball <[email protected]>

Author: lance

src/event/cloudevent.ts

@@ -159,7 +159,6 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
     try {
       return validateCloudEvent(this);
     } catch (e) {
-      console.error(e.errors);
       if (e instanceof ValidationError) {
         throw e;
       } else {

src/message/http/index.ts

@@ -2,8 +2,8 @@ import { CloudEvent, CloudEventV03, CloudEventV1, CONSTANTS, Mode, Version } fro
 import { Message, Headers } from "..";
 
 import { headersFor, sanitize, v03structuredParsers, v1binaryParsers, v1structuredParsers } from "./headers";
-import { isBase64, isString, isStringOrObjectOrThrow, ValidationError } from "../../event/validation";
-import { Base64Parser, JSONParser, MappedParser, Parser, parserByContentType } from "../../parsers";
+import { isBinary, isStringOrObjectOrThrow, ValidationError } from "../../event/validation";
+import { JSONParser, MappedParser, Parser, parserByContentType } from "../../parsers";
 
 // implements Serializer
 export function binary(event: CloudEvent): Message {
@@ -22,6 +22,10 @@ export function binary(event: CloudEvent): Message {
 
 // implements Serializer
 export function structured(event: CloudEvent): Message {
+  if (event.data_base64) {
+    // The event's data is binary - delete it
+    event = event.cloneWith({ data: undefined });
+  }
   return {
     headers: {
       [CONSTANTS.HEADER_CONTENT_TYPE]: CONSTANTS.DEFAULT_CE_CONTENT_TYPE,
@@ -130,8 +134,6 @@ function parseBinary(message: Message, version: Version): CloudEvent {
     throw new ValidationError(`invalid spec version ${headers[CONSTANTS.CE_HEADERS.SPEC_VERSION]}`);
   }
 
-  body = isString(body) && isBase64(body) ? Buffer.from(body as string, "base64").toString() : body;
-
   // Clone and low case all headers names
   const sanitizedHeaders = sanitize(headers);
 
@@ -146,32 +148,34 @@ function parseBinary(message: Message, version: Version): CloudEvent {
     }
   }
 
-  let parsedPayload;
-
-  if (body) {
-    const parser = parserByContentType[eventObj.datacontenttype as string];
-    if (parser) {
-      parsedPayload = parser.parse(body as string);
-    } else {
-      // Just use the raw body
-      parsedPayload = body;
-    }
-  }
-
   // Every unprocessed header can be an extension
   for (const header in sanitizedHeaders) {
     if (header.startsWith(CONSTANTS.EXTENSIONS_PREFIX)) {
       eventObj[header.substring(CONSTANTS.EXTENSIONS_PREFIX.length)] = headers[header];
     }
   }
+
+  if (isBinary(body)) {
+    if (eventObj.datacontenttype === CONSTANTS.MIME_JSON) {
+      // even though the body is binary, it's just JSON - convert to string
+      body = Buffer.from(body as string, "base64").toString();
+    }
+  }
+
+  // If the body is base64 that means we are dealing with binary data
+  const parser = parserByContentType[eventObj.datacontenttype as string];
+  if (parser && body) {
+    body = parser.parse(body as string);
+  }
+
   // At this point, if the datacontenttype is application/json and the datacontentencoding is base64
   // then the data has already been decoded as a string, then parsed as JSON. We don't need to have
   // the datacontentencoding property set - in fact, it's incorrect to do so.
   if (eventObj.datacontenttype === CONSTANTS.MIME_JSON && eventObj.datacontentencoding === CONSTANTS.ENCODING_BASE64) {
     delete eventObj.datacontentencoding;
   }
 
-  return new CloudEvent({ ...eventObj, data: parsedPayload } as CloudEventV1 | CloudEventV03, false);
+  return new CloudEvent({ ...eventObj, data: body } as CloudEventV1 | CloudEventV03, false);
 }
 
 /**
@@ -223,13 +227,19 @@ function parseStructured(message: Message, version: Version): CloudEvent {
     eventObj[key] = incoming[key];
   }
 
-  // ensure data content is correctly decoded
+  // data_base64 is a property that only exists on V1 events. For V03 events,
+  // there will be a .datacontentencoding property, and the .data property
+  // itself will be encoded as base64
   if (eventObj.data_base64 || eventObj.datacontentencoding === CONSTANTS.ENCODING_BASE64) {
-    const parser = new Base64Parser();
-    // data_base64 is a property that only exists on V1 events. For V03 events,
-    // there will be a .datacontentencoding property, and the .data property
-    // itself will be encoded as base64
-    eventObj.data = JSON.parse(parser.parse((eventObj.data_base64 as string) || (eventObj.data as string)));
+    const data = eventObj.data_base64 || eventObj.data;
+
+    // we can choose to decode the binary data as JSON, if datacontentype is application/json
+    if (eventObj.datacontenttype === CONSTANTS.MIME_JSON) {
+      eventObj.data = JSON.parse(Buffer.from(data as string, "base64").toString());
+    } else {
+      eventObj.data = new Uint32Array(Buffer.from(data as string, "base64"));
+    }
+
     delete eventObj.data_base64;
     delete eventObj.datacontentencoding;
   }

src/transport/receiver.ts

@@ -17,7 +17,7 @@ export const Receiver = {
    */
   accept(headers: Headers, body: string | Record<string, unknown> | undefined | null): CloudEvent {
     const cleanHeaders: Headers = sanitize(headers);
-    const cleanBody = body ? (typeof body === "object" ? JSON.stringify(body) : body) : "";
+    const cleanBody = body ? (typeof body === "object" ? JSON.stringify(body) : body) : undefined;
     const message: Message = {
       headers: cleanHeaders,
       body: cleanBody,

test/integration/ce.png

@@ -1,6 +1,10 @@
+import path from "path";
+import fs from "fs";
+
 import { expect } from "chai";
 import { CloudEvent, ValidationError, Version } from "../../src";
 import { CloudEventV03, CloudEventV1 } from "../../src/event/interfaces";
+import { asBase64 } from "../../src/event/validation";
 
 const type = "org.cncf.cloudevents.example";
 const source = "http://unit.test";
@@ -14,6 +18,9 @@ const fixture: CloudEventV1 = {
   data: `"some data"`,
 };
 
+const imageData = new Uint32Array(fs.readFileSync(path.join(process.cwd(), "test", "integration", "ce.png")));
+const image_base64 = asBase64(imageData);
+
 describe("A CloudEvent", () => {
   it("Can be constructed with a typed Message", () => {
     const ce = new CloudEvent(fixture);
@@ -151,6 +158,15 @@ describe("A 1.0 CloudEvent", () => {
     expect(ce.data).to.be.true;
   });
 
+  it("can be constructed with binary data", () => {
+    const ce = new CloudEvent({
+      ...fixture,
+      data: imageData,
+    });
+    expect(ce.data).to.equal(imageData);
+    expect(ce.data_base64).to.equal(image_base64);
+  });
+
   it("can be constructed with extensions", () => {
     const extensions = {
       extensionkey: "extension-value",

test/integration/cloud_event_test.ts

@@ -1,3 +1,6 @@
+import path from "path";
+import fs from "fs";
+
 import { expect } from "chai";
 import { CloudEvent, CONSTANTS, Version } from "../../src";
 import { asBase64 } from "../../src/event/validation";
@@ -16,7 +19,6 @@ const data = {
 
 // Attributes for v03 events
 const schemaurl = "https://cloudevents.io/schema.json";
-const datacontentencoding = "base64";
 
 const ext1Name = "extension1";
 const ext1Value = "foobar";
@@ -25,7 +27,11 @@ const ext2Value = "acme";
 
 // Binary data as base64
 const dataBinary = Uint32Array.from(JSON.stringify(data), (c) => c.codePointAt(0) as number);
-const data_base64 = asBase64(dataBinary);
+
+// Since the above is a special case (string as binary), let's test
+// with a real binary file one is likely to encounter in the wild
+const imageData = new Uint32Array(fs.readFileSync(path.join(process.cwd(), "test", "integration", "ce.png")));
+const image_base64 = asBase64(imageData);
 
 describe("HTTP transport", () => {
   it("Can detect invalid CloudEvent Messages", () => {
@@ -45,6 +51,7 @@ describe("HTTP transport", () => {
       new CloudEvent({
         source: "/message-test",
         type: "example",
+        data,
       }),
     );
     expect(HTTP.isEvent(message)).to.be.true;
@@ -144,23 +151,47 @@ describe("HTTP transport", () => {
       expect(event).to.deep.equal(fixture);
     });
 
-    it("Supports Base-64 encoded data in structured messages", () => {
-      const event = fixture.cloneWith({ data: dataBinary });
-      expect(event.data_base64).to.equal(data_base64);
-      expect(event.data).to.equal(dataBinary);
+    it("Converts binary data to base64 when serializing structured messages", () => {
+      const event = fixture.cloneWith({ data: imageData, datacontenttype: "image/png" });
+      expect(event.data).to.equal(imageData);
       const message = HTTP.structured(event);
+      const messageBody = JSON.parse(message.body as string);
+      expect(messageBody.data_base64).to.equal(image_base64);
+    });
+
+    it("Converts base64 encoded data to binary when deserializing structured messages", () => {
+      const message = HTTP.structured(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
+      const eventDeserialized = HTTP.toEvent(message);
+      expect(eventDeserialized.data).to.deep.equal(imageData);
+      expect(eventDeserialized.data_base64).to.equal(image_base64);
+    });
+
+    it("Parses binary data from structured messages with content type application/json", () => {
+      const message = HTTP.structured(fixture.cloneWith({ data: dataBinary }));
       const eventDeserialized = HTTP.toEvent(message);
       expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
+      expect(eventDeserialized.data_base64).to.be.undefined;
+    });
+
+    it("Converts base64 encoded data to binary when deserializing binary messages", () => {
+      const message = HTTP.binary(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
+      const eventDeserialized = HTTP.toEvent(message);
+      expect(eventDeserialized.data).to.deep.equal(imageData);
+      expect(eventDeserialized.data_base64).to.equal(image_base64);
     });
 
-    it("Supports Base-64 encoded data in binary messages", () => {
+    it("Keeps binary data binary when serializing binary messages", () => {
       const event = fixture.cloneWith({ data: dataBinary });
-      expect(event.data_base64).to.equal(data_base64);
       expect(event.data).to.equal(dataBinary);
       const message = HTTP.binary(event);
       expect(message.body).to.equal(dataBinary);
+    });
+
+    it("Parses binary data from binary messages with content type application/json", () => {
+      const message = HTTP.binary(fixture.cloneWith({ data: dataBinary }));
       const eventDeserialized = HTTP.toEvent(message);
-      expect(eventDeserialized.data).to.equal(dataBinary);
+      expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
+      expect(eventDeserialized.data_base64).to.be.undefined;
     });
   });
 
@@ -223,28 +254,35 @@ describe("HTTP transport", () => {
       expect(event).to.deep.equal(fixture);
     });
 
-    it("Supports Base-64 encoded data in structured messages", () => {
-      const event = fixture.cloneWith({ data: data_base64, datacontentencoding });
+    it("Converts binary data to base64 when serializing structured messages", () => {
+      const event = fixture.cloneWith({ data: imageData, datacontenttype: "image/png" });
+      expect(event.data).to.equal(imageData);
       const message = HTTP.structured(event);
-      expect(JSON.parse(message.body as string).data).to.equal(data_base64);
-      // An incoming event with datacontentencoding set to base64,
-      // and encoded data, should decode the data before setting
-      // the .data property on the event
+      const messageBody = JSON.parse(message.body as string);
+      expect(messageBody.data_base64).to.equal(image_base64);
+    });
+
+    it("Converts base64 encoded data to binary when deserializing structured messages", () => {
+      // Creating an event with binary data automatically produces base64 encoded data
+      // which is then set as the 'data' attribute on the message body
+      const message = HTTP.structured(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
       const eventDeserialized = HTTP.toEvent(message);
-      expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
-      expect(eventDeserialized.datacontentencoding).to.be.undefined;
+      expect(eventDeserialized.data).to.deep.equal(imageData);
+      expect(eventDeserialized.data_base64).to.equal(image_base64);
     });
 
-    it("Supports Base-64 encoded data in binary messages", () => {
-      const event = fixture.cloneWith({ data: data_base64, datacontentencoding });
-      const message = HTTP.binary(event);
-      expect(message.body).to.equal(data_base64);
-      // An incoming event with datacontentencoding set to base64,
-      // and encoded data, should decode the data before setting
-      // the .data property on the event
+    it("Converts base64 encoded data to binary when deserializing binary messages", () => {
+      const message = HTTP.binary(fixture.cloneWith({ data: imageData, datacontenttype: "image/png" }));
       const eventDeserialized = HTTP.toEvent(message);
-      expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
-      expect(eventDeserialized.datacontentencoding).to.be.undefined;
+      expect(eventDeserialized.data).to.deep.equal(imageData);
+      expect(eventDeserialized.data_base64).to.equal(image_base64);
+    });
+
+    it("Keeps binary data binary when serializing binary messages", () => {
+      const event = fixture.cloneWith({ data: dataBinary });
+      expect(event.data).to.equal(dataBinary);
+      const message = HTTP.binary(event);
+      expect(message.body).to.equal(dataBinary);
     });
   });
 });