fix: do not alter an event's data attribute

When setting an event's data attribute we were trying to be really clever
and this is problematic. Instead, keep the data attribute unchanged. Per
the 1.0 specification, the data attribute is still inspected to determine
if it is binary, and if so, a data_base64 attribute is added with the
contents of the data property encoded as base64.

Fixes: #343

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

Author: lance

src/event/cloudevent.ts

@@ -10,8 +10,6 @@ import {
 } from "./interfaces";
 import { validateCloudEvent } from "./spec";
 import { ValidationError, isBinary, asBase64, isValidType } from "./validation";
-import CONSTANTS from "../constants";
-import { isString } from "util";
 
 /**
  * An enum representing the CloudEvent specification version
@@ -92,7 +90,7 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
     this.schemaurl = properties.schemaurl as string;
     delete properties.schemaurl;
 
-    this._setData(properties.data);
+    this.data = properties.data;
     delete properties.data;
 
     // sanity checking
@@ -125,25 +123,11 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
   }
 
   get data(): unknown {
-    if (
-      this.datacontenttype === CONSTANTS.MIME_JSON &&
-      !(this.datacontentencoding === CONSTANTS.ENCODING_BASE64) &&
-      isString(this.#_data)
-    ) {
-      return JSON.parse(this.#_data as string);
-    } else if (isBinary(this.#_data)) {
-      return asBase64(this.#_data as Uint32Array);
-    }
     return this.#_data;
   }
 
   set data(value: unknown) {
-    this._setData(value);
-  }
-
-  private _setData(value: unknown): void {
     if (isBinary(value)) {
-      this.#_data = value;
       this.data_base64 = asBase64(value as Uint32Array);
     }
     this.#_data = value;
@@ -158,7 +142,7 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
   toJSON(): Record<string, unknown> {
     const event = { ...this };
     event.time = new Date(this.time as string).toISOString();
-    event.data = this.data;
+    event.data = !isBinary(this.data) ? this.data : undefined;
     return event;
   }
 

src/message/http/index.ts

@@ -2,16 +2,17 @@ import { CloudEvent, CloudEventV03, CloudEventV1, CONSTANTS, Mode, Version } fro
 import { Message, Headers } from "..";
 
 import { headersFor, sanitize, v03structuredParsers, v1binaryParsers, v1structuredParsers } from "./headers";
-import { asData, isBase64, isString, isStringOrObjectOrThrow, ValidationError } from "../../event/validation";
+import { isBase64, isString, isStringOrObjectOrThrow, ValidationError } from "../../event/validation";
 import { Base64Parser, JSONParser, MappedParser, Parser, parserByContentType } from "../../parsers";
 
 // implements Serializer
 export function binary(event: CloudEvent): Message {
   const contentType: Headers = { [CONSTANTS.HEADER_CONTENT_TYPE]: CONSTANTS.DEFAULT_CONTENT_TYPE };
   const headers: Headers = { ...contentType, ...headersFor(event) };
-  let body = asData(event.data, event.datacontenttype as string);
-  if (typeof body === "object") {
-    body = JSON.stringify(body);
+  let body = event.data;
+  if (typeof event.data === "object" && !(event.data instanceof Uint32Array)) {
+    // we'll stringify objects, but not binary data
+    body = JSON.stringify(event.data);
   }
   return {
     headers,
@@ -89,7 +90,7 @@ function getMode(headers: Headers): Mode {
  * @param {Record<string, unknown>} body the HTTP request body
  * @returns {Version} the CloudEvent specification version
  */
-function getVersion(mode: Mode, headers: Headers, body: string | Record<string, string>) {
+function getVersion(mode: Mode, headers: Headers, body: string | Record<string, string> | unknown) {
   if (mode === Mode.BINARY) {
     // Check the headers for the version
     const versionHeader = headers[CONSTANTS.CE_HEADERS.SPEC_VERSION];
@@ -149,10 +150,12 @@ function parseBinary(message: Message, version: Version): CloudEvent {
 
   if (body) {
     const parser = parserByContentType[eventObj.datacontenttype as string];
-    if (!parser) {
-      throw new ValidationError(`no parser found for content type ${eventObj.datacontenttype}`);
+    if (parser) {
+      parsedPayload = parser.parse(body as string);
+    } else {
+      // Just use the raw body
+      parsedPayload = body;
     }
-    parsedPayload = parser.parse(body);
   }
 
   // Every unprocessed header can be an extension
@@ -201,7 +204,7 @@ function parseStructured(message: Message, version: Version): CloudEvent {
   const contentType = sanitizedHeaders[CONSTANTS.HEADER_CONTENT_TYPE];
   const parser: Parser = contentType ? parserByContentType[contentType] : new JSONParser();
   if (!parser) throw new ValidationError(`invalid content type ${sanitizedHeaders[CONSTANTS.HEADER_CONTENT_TYPE]}`);
-  const incoming = { ...(parser.parse(payload) as Record<string, unknown>) };
+  const incoming = { ...(parser.parse(payload as string) as Record<string, unknown>) };
 
   const eventObj: { [key: string]: unknown } = {};
   const parserMap: Record<string, MappedParser> = version === Version.V1 ? v1structuredParsers : v03structuredParsers;
@@ -221,9 +224,12 @@ function parseStructured(message: Message, version: Version): CloudEvent {
   }
 
   // ensure data content is correctly decoded
-  if (eventObj.data_base64) {
+  if (eventObj.data_base64 || eventObj.datacontentencoding === CONSTANTS.ENCODING_BASE64) {
     const parser = new Base64Parser();
-    eventObj.data = JSON.parse(parser.parse(eventObj.data_base64 as string));
+    // 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)));
     delete eventObj.data_base64;
     delete eventObj.datacontentencoding;
   }

src/message/index.ts

@@ -28,7 +28,7 @@ export interface Headers {
  */
 export interface Message {
   headers: Headers;
-  body: string;
+  body: string | unknown;
 }
 
 /**

test/integration/emitter_factory_test.ts

@@ -50,12 +50,12 @@ function superagentEmitter(message: Message, options?: Options): Promise<unknown
   for (const key of Object.getOwnPropertyNames(message.headers)) {
     post.set(key, message.headers[key]);
   }
-  return post.send(message.body);
+  return post.send(message.body as string);
 }
 
 function gotEmitter(message: Message, options?: Options): Promise<unknown> {
   return Promise.resolve(
-    got.post(sink, { headers: message.headers, body: message.body, ...((options as unknown) as Options) }),
+    got.post(sink, { headers: message.headers, body: message.body as string, ...((options as unknown) as Options) }),
   );
 }
 

test/integration/message_test.ts

@@ -102,7 +102,7 @@ describe("HTTP transport", () => {
 
     it("Binary Messages can be created from a CloudEvent", () => {
       const message: Message = HTTP.binary(fixture);
-      expect(JSON.parse(message.body)).to.deep.equal(data);
+      expect(message.body).to.equal(JSON.stringify(data));
       // validate all headers
       expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(datacontenttype);
       expect(message.headers[CONSTANTS.CE_HEADERS.SPEC_VERSION]).to.equal(Version.V1);
@@ -120,7 +120,7 @@ describe("HTTP transport", () => {
       const message: Message = HTTP.structured(fixture);
       expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(CONSTANTS.DEFAULT_CE_CONTENT_TYPE);
       // Parse the message body as JSON, then validate the attributes
-      const body = JSON.parse(message.body);
+      const body = JSON.parse(message.body as string);
       expect(body[CONSTANTS.CE_ATTRIBUTES.SPEC_VERSION]).to.equal(Version.V1);
       expect(body[CONSTANTS.CE_ATTRIBUTES.ID]).to.equal(id);
       expect(body[CONSTANTS.CE_ATTRIBUTES.TYPE]).to.equal(type);
@@ -147,6 +147,7 @@ describe("HTTP transport", () => {
     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);
       const message = HTTP.structured(event);
       const eventDeserialized = HTTP.toEvent(message);
       expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
@@ -155,9 +156,11 @@ describe("HTTP transport", () => {
     it("Supports Base-64 encoded data in 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);
       const eventDeserialized = HTTP.toEvent(message);
-      expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
+      expect(eventDeserialized.data).to.equal(dataBinary);
     });
   });
 
@@ -196,7 +199,7 @@ describe("HTTP transport", () => {
       const message: Message = HTTP.structured(fixture);
       expect(message.headers[CONSTANTS.HEADER_CONTENT_TYPE]).to.equal(CONSTANTS.DEFAULT_CE_CONTENT_TYPE);
       // Parse the message body as JSON, then validate the attributes
-      const body = JSON.parse(message.body);
+      const body = JSON.parse(message.body as string);
       expect(body[CONSTANTS.CE_ATTRIBUTES.SPEC_VERSION]).to.equal(Version.V03);
       expect(body[CONSTANTS.CE_ATTRIBUTES.ID]).to.equal(id);
       expect(body[CONSTANTS.CE_ATTRIBUTES.TYPE]).to.equal(type);
@@ -221,19 +224,27 @@ describe("HTTP transport", () => {
     });
 
     it("Supports Base-64 encoded data in structured messages", () => {
-      const event = fixture.cloneWith({ data: dataBinary, datacontentencoding });
-      expect(event.data_base64).to.equal(data_base64);
+      const event = fixture.cloneWith({ data: data_base64, datacontentencoding });
       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 eventDeserialized = HTTP.toEvent(message);
       expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
+      expect(eventDeserialized.datacontentencoding).to.be.undefined;
     });
 
     it("Supports Base-64 encoded data in binary messages", () => {
-      const event = fixture.cloneWith({ data: dataBinary, datacontentencoding });
-      expect(event.data_base64).to.equal(data_base64);
+      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
       const eventDeserialized = HTTP.toEvent(message);
       expect(eventDeserialized.data).to.deep.equal({ foo: "bar" });
+      expect(eventDeserialized.datacontentencoding).to.be.undefined;
     });
   });
 });

test/integration/spec_03_tests.ts

@@ -168,12 +168,6 @@ describe("CloudEvents Spec v0.3", () => {
 
         expect(typeof cloudevent.data).to.equal("string");
       });
-
-      it("should convert data with stringified json to a json object", () => {
-        cloudevent = cloudevent.cloneWith({ datacontenttype: Constants.MIME_JSON });
-        cloudevent.data = JSON.stringify(data);
-        expect(cloudevent.data).to.deep.equal(data);
-      });
     });
 
     describe("'subject'", () => {

test/integration/spec_1_tests.ts

@@ -168,11 +168,6 @@ describe("CloudEvents Spec v1.0", () => {
       cloudevent = cloudevent.cloneWith({ datacontenttype: dct });
     });
 
-    it("should convert data with stringified json to a json object", () => {
-      cloudevent = cloudevent.cloneWith({ datacontenttype: Constants.MIME_JSON, data: JSON.stringify(data) });
-      expect(cloudevent.data).to.deep.equal(data);
-    });
-
     it("should be ok when type is 'Uint32Array' for 'Binary'", () => {
       const dataString = ")(*~^my data for ce#@#$%";