lib(cloudevent): make extensions a part of the event object

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

Author: lance

src/event/cloudevent.ts

@@ -2,10 +2,11 @@ const { v4: uuidv4 } = require("uuid");
 
 import { CloudEventV1, validateV1, CloudEventV1Attributes } from "./v1";
 import { CloudEventV03, validateV03, CloudEventV03Attributes } from "./v03";
-import Extensions from "./extensions";
+import { ValidationError } from "./validation";
 
 export const enum Version { V1 = "1.0", V03 = "0.3" };
 
+
 /**
  * A CloudEvent describes event data in common formats to provide
  * interoperability across services, platforms and systems.
@@ -22,48 +23,77 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
   time?: string|Date;
   data?: any;
   data_base64?: any;
-  extensions?: Extensions;
+  [key: string]: any; // Extensions should not exist as it's own object, but instead be keyed directly from the event
 
   // V03 deprecated attributes
   schemaurl?: string;
   datacontentencoding?: string;
 
   constructor(event: CloudEventV1 | CloudEventV1Attributes | CloudEventV03 | CloudEventV03Attributes) {
+    // copy the incoming event so that we can delete properties as we go
+    // everything left after we have deleted know properties becomes an extension
+    let properties = { ...event };
+
     // @ts-ignore Attribute types don't have an ID
-    this.id = event.id || uuidv4();
-    this.type = event.type;
-    this.source = event.source;
+    this.id = properties.id || uuidv4();
+    delete properties.id;
+
+    this.type = properties.type;
+    delete properties.type;
+
+    this.source = properties.source;
+    delete properties.source;
+
     // @ts-ignore Attribute types don't have a specversion
-    this.specversion = event.specversion as Version || Version.V1;
-    this.datacontenttype = event.datacontenttype;
-    this.subject = event.subject;
-    this.time = event.time;
-    this.data = event.data;
+    this.specversion = properties.specversion as Version || Version.V1;
+    delete properties.specversion;
+
+    this.datacontenttype = properties.datacontenttype;
+    delete properties.datacontenttype;
+
+    this.subject = properties.subject;
+    delete properties.subject;
+
+    this.time = properties.time;
+    delete properties.time;
+
+    this.data = properties.data;
+    delete properties.data;
+
     // @ts-ignore - dataschema is not on a CloudEventV03
-    this.dataschema = event.dataschema;
+    this.dataschema = properties.dataschema;
+    delete properties.dataschema;
+
     // @ts-ignore - dataBase64 is not on CloudEventV03
-    this.data_base64 = event.data_base64;
+    this.data_base64 = properties.data_base64;
+    delete properties.data_base64;
 
+    // @ts-ignore - dataContentEncoding is not on a CloudEventV1
+    this.datacontentencoding = properties.datacontentencoding;
+    delete properties.datacontentencoding;
+
+    // @ts-ignore - schemaurl is not on a CloudEventV1
+    this.schemaurl = properties.schemaurl;
+    delete properties.schemaurl;
+
+    // Make sure time has a default value and whatever is provided is formatted
     if (!this.time) {
       this.time = new Date().toISOString();
     } else if (this.time instanceof Date) {
       this.time = this.time.toISOString();
     }
 
-    // @ts-ignore - dataContentEncoding is not on a CloudEventV1
-    this.datacontentencoding = event.datacontentencoding;
-    // @ts-ignore - schemaurl is not on a CloudEventV1
-    this.schemaurl = event.schemaurl;
-
-    this.extensions = { ...event.extensions };
-
-    // TODO: Deprecated in 1.0
     // sanity checking
     if (this.specversion === Version.V1 && this.schemaurl) {
       throw new TypeError("cannot set schemaurl on version 1.0 event");
     } else if (this.specversion === Version.V03 && this.dataschema) {
       throw new TypeError("cannot set dataschema on version 0.3 event");
     }
+
+    // finally process any remaining properties - these are extensions
+    for (let [key, value] of Object.entries(properties)) {
+      this[key] = value;
+    }
   }
 
   /**
@@ -76,6 +106,8 @@ export class CloudEvent implements CloudEventV1, CloudEventV03 {
       return validateV1(this);
     } else if (this.specversion === Version.V03) {
       return validateV03(this);
+    } else {
+      throw new ValidationError("invalid payload");
     }
     return false;
   }

src/event/extensions.ts

@@ -1,5 +1,4 @@
 export * from "./cloudevent";
-export * from "./extensions";
 export * from "./validation";
 export * from "./v1";
 export * from "./v03";

src/event/index.ts

@@ -1,5 +1,3 @@
-import Extensions from "../extensions";
-
 /**
  * The object interface for CloudEvents 0.3.
  * @see https://github.com/cloudevents/spec/blob/v0.3/spec.md
@@ -132,5 +130,5 @@ export interface CloudEventV03Attributes {
   /**
    * [OPTIONAL] CloudEvents extension attributes.
    */
-  extensions?: Extensions;
+  [key: string]: any
 }

src/event/v03/cloudevent.ts

@@ -39,9 +39,6 @@ const schemaV03 = {
         type: {
           $ref: "#/definitions/type"
         },
-        extensions: {
-          $ref: "#/definitions/extensions"
-        },
         source: {
           $ref: "#/definitions/source"
         }
@@ -74,9 +71,6 @@ const schemaV03 = {
       type: "string",
       minLength: 1
     },
-    extensions: {
-      type: "object"
-    },
     source: {
       format: "uri-reference",
       type: "string"

src/event/v03/schema.ts

@@ -1,24 +1,11 @@
 import { v4 as uuidv4 } from "uuid";
 import Ajv from "ajv";
-import { ValidationError, isValidType } from "../validation";
+import { ValidationError, isValidType, isBase64 } from "../validation";
 import { CloudEventV03, CloudEventV03Attributes } from "./cloudevent";
 import { CloudEvent } from "../..";
-
-const RESERVED_ATTRIBUTES = {
-  type: "type",
-  specversion: "specversion",
-  source: "source",
-  id: "id",
-  time: "time",
-  schemaurl: "schemaurl",
-  datacontentencoding: "datacontentencoding",
-  datacontenttype: "datacontenttype",
-  subject: "subject",
-  data: "data"
-};
-
 import { schema } from "./schema";
-import Extensions from "../extensions";
+import CONSTANTS from "../../constants";
+
 const ajv = new Ajv({ extendRefs: true });
 const isValidAgainstSchema = ajv.compile(schema);
 
@@ -36,14 +23,21 @@ export function validateV03(event: CloudEventV03): boolean {
   if (!isValidAgainstSchema(event)) {
     throw new ValidationError("invalid payload", isValidAgainstSchema.errors);
   }
-  if (event.extensions) checkExtensions(event.extensions);
-  return true;
+  return checkDataContentEncoding(event);
 }
 
-function checkExtensions(extensions: Extensions) {
-  for (const key in extensions) {
-    if (Object.prototype.hasOwnProperty.call(RESERVED_ATTRIBUTES, key)) {
-      throw new ValidationError(`Reserved attribute name: '${key}'`);
+function checkDataContentEncoding(event: CloudEventV03): boolean {
+  if (event.datacontentencoding) {
+    // we only support base64
+    const encoding = event.datacontentencoding.toLocaleLowerCase("en-US");
+    if (encoding !== CONSTANTS.ENCODING_BASE64) {
+      throw new ValidationError("invalid payload", [`Unsupported content encoding: ${encoding}`]);
+    } else {
+      if (!isBase64(event.data)) {
+        throw new ValidationError("invalid payload", [`Invalid content encoding of data: ${event.data}`]);
+      }
     }
   }
+  return true;
 }
+

src/event/v03/spec.ts

@@ -1,4 +1,3 @@
-import Extensions from "../extensions";
 /**
  * The object interface for CloudEvents 1.0.
  * @see https://github.com/cloudevents/spec/blob/v1.0/spec.md
@@ -128,9 +127,10 @@ export interface CloudEventV1Attributes {
    * data is in binary form.
    * @see https://github.com/cloudevents/spec/blob/v1.0/json-format.md#31-handling-of-data
    */
-  data_base64?: string
+  data_base64?: string;
+
   /**
    * [OPTIONAL] CloudEvents extension attributes.
    */
-  extensions?: Extensions;
+  [key: string]: any;
 }

src/event/v1/cloudevent.ts

@@ -5,25 +5,11 @@ import { CloudEvent } from "../cloudevent";
 import { CloudEventV1, CloudEventV1Attributes } from "./cloudevent";
 import { ValidationError, isValidType } from "../validation";
 
-import Extensions from "../extensions";
 import { schemaV1 } from "./schema";
 
 const ajv = new Ajv({ extendRefs: true });
 const isValidAgainstSchema = ajv.compile(schemaV1);
 
-const RESERVED_ATTRIBUTES = {
-  type: "type",
-  specversion: "specversion",
-  source: "source",
-  id: "id",
-  time: "time",
-  dataschema: "dataschema",
-  datacontenttype: "datacontenttype",
-  subject: "subject",
-  data: "data",
-  data_base64: "data_base64"
-};
-
 export function createV1(attributes: CloudEventV1Attributes): CloudEventV1 {
   const event: CloudEventV1 = {
     specversion: schemaV1.definitions.specversion.const,
@@ -38,14 +24,5 @@ export function validateV1(event: CloudEventV1): boolean {
   if (!isValidAgainstSchema(event)) {
     throw new ValidationError("invalid payload", isValidAgainstSchema.errors);
   }
-  if (event.extensions) checkExtensions(event.extensions);
   return true;
 }
-
-function checkExtensions(extensions: Extensions) {
-  for (const key in extensions) {
-    if (Object.prototype.hasOwnProperty.call(RESERVED_ATTRIBUTES, key) && extensions[key]) {
-      throw new ValidationError(`Reserved attribute name: '${key}'`);
-    }
-  }
-}

src/event/v1/spec.ts

@@ -40,7 +40,7 @@ export class BinaryHTTPReceiver {
     // Clone and low case all headers names
     const sanitizedHeaders = validate(headers);
 
-    const eventObj: { [key: string]: any } = { extensions: {} };
+    const eventObj: { [key: string]: any } = {};
     const parserMap = this.version === Version.V1 ? v1Parsers : v03Parsers;
 
     parserMap.forEach((mappedParser: MappedParser, header: string) => {
@@ -56,7 +56,7 @@ export class BinaryHTTPReceiver {
     // Every unprocessed header can be an extension
     for (const header in sanitizedHeaders) {
       if (header.startsWith(CONSTANTS.EXTENSIONS_PREFIX)) {
-        eventObj.extensions[header.substring(CONSTANTS.EXTENSIONS_PREFIX.length)] = sanitizedHeaders[header];
+        eventObj[header.substring(CONSTANTS.EXTENSIONS_PREFIX.length)] = sanitizedHeaders[header];
       }
     }
 

src/transport/http/binary_receiver.ts

@@ -1,5 +1,5 @@
 import { ValidationError, CloudEvent } from "../..";
-import { headerMap as v1Map } from "./v1";
+import { headerMap as v1Map, headerMap } from "./v1";
 import { headerMap as v03Map } from "./v03";
 import { Version } from "../../event";
 import { MappedParser } from "../../parsers";
@@ -44,28 +44,24 @@ export function validate(headers: Headers): Headers {
  */
 export function headersFor(event: CloudEvent): Headers {
   const headers: Headers = {};
-  let headerMap;
+  let headerMap: Map<string, MappedParser>;
   if (event.specversion === Version.V1) {
     headerMap = v1Map;
   } else {
     headerMap = v03Map;
   }
 
-  headerMap.forEach((mapped: MappedParser, getterName: string) => {
-    // @ts-ignore No index signature with a parameter of type 'string' was found on type 'CloudEvent'.
-    const value = event[getterName];
+  // iterate over the event properties - generate a header for each
+  Object.getOwnPropertyNames(event).forEach((property) => {
+    const value = event[property];
     if (value) {
-      headers[mapped.name] = mapped.parser.parse(value);
-    }
-    if (event.extensions) {
-      Object.keys(event.extensions)
-        .filter((ext) => Object.hasOwnProperty.call(event.extensions, ext))
-        .forEach((ext) => {
-          headers[`ce-${ext}`] = event.extensions![ext];
-        });
+      const map: MappedParser|undefined = headerMap.get(property);
+      if (map) { headers[map.name] = map.parser.parse(value); }
+      else if (property !== CONSTANTS.DATA_ATTRIBUTE && property !== `${CONSTANTS.DATA_ATTRIBUTE}_base64`) {
+        headers[`${CONSTANTS.EXTENSIONS_PREFIX}${property}`] = value;
+      }
     }
   });
-
   return headers;
 }