@1mill/cloudevents 4.0.0 → 4.1.0

package/src/index.js

@@ -1,12 +1,13 @@
+import { fetchNodeEnv } from './utils/fetchNodeEnv/index.js'
 import { nanoid } from 'nanoid'
-
-const fetchNodeEnv = name => (typeof process !== 'undefined') && process && process.env && process.env[name]
+import { setAttribute } from './utils/setAttribute/index.js'
 
 export class Cloudevent {
 	constructor({
 		data,
 		datacontenttype,
 		dataschema,
+		originatorid,
 		originid,
 		originsource,
 		origintime,
@@ -16,54 +17,58 @@ export class Cloudevent {
 		subject,
 		type,
 	}) {
-		// * Required fields by CloudEvent specification
-		this.id = nanoid(fetchNodeEnv('MILL_CLOUDEVENTS_NANOID_LENGTH') || 21)
-		if (!this.id) throw new Error('Cloudevent "id" is required')
-		if (typeof this.id !== 'string') throw new Error('Cloudevent "id" must be a string')
+		const cloudevent = this
+
+		// *******
+		// * Required fields by Cloudevent v1 specification
+		const idValue = nanoid(fetchNodeEnv('MILL_CLOUDEVENTS_NANOID_LENGTH', 21))
+		setAttribute({ cloudevent, name: 'id', types: ['string'], value: idValue })
+
+		const sourceValue = source || fetchNodeEnv('MILL_CLOUDEVENTS_SOURCE')
+		setAttribute({ cloudevent, name: 'source', types: ['string'], value: sourceValue })
 
-		this.source = source || fetchNodeEnv('MILL_CLOUDEVENTS_SOURCE')
-		if (!this.source) throw new Error('Cloudevent "source" is required')
-		if (typeof this.source !== 'string') throw new Error('Cloudevent "source" must be a string')
+		const typeValue = type
+		setAttribute({ cloudevent, name: 'type', types: ['string'], value: typeValue })
 
-		this.type = type
-		if (!this.type) throw new Error('Cloudevent "type" is required')
-		if (typeof this.type !== 'string') throw new Error('Cloudevent "type" must be a string')
+		const specversionValue = specversion || '1.0'
+		setAttribute({ cloudevent, name: 'specversion', types: ['string'], value: specversionValue })
 
-		this.specversion = specversion || '1.0'
-		if (!this.specversion) throw new Error('Cloudevent "specversion" is required')
-		if (typeof this.specversion !== 'string') throw new Error('Cloudevent "specversion" must be a string')
+		const timeValue = new Date().toISOString()
+		setAttribute({ cloudevent, name: 'time', types: ['string'], value: timeValue })
+		// *******
 
-		// * Optional fields by CloudEvent specification
-		this.data = data
+		// *******
+		// * Optional fields by Cloudevent v1 specification
+		setAttribute({ cloudevent, name: 'data', value: data })
 
-		this.datacontenttype = typeof this.data !== 'undefined'
+		const datacontenttypeValue = typeof data !== 'undefined'
 			? datacontenttype || 'application/json'
 			: datacontenttype
-		if (this.datacontenttype && typeof this.datacontenttype !== 'string') throw new Error('Cloudevent "datacontenttype" must be a string')
+		setAttribute({ cloudevent, name: 'datacontenttype', types: ['string', 'undefined'], value: datacontenttypeValue })
 
-		this.dataschema = dataschema
-		if (this.dataschema && typeof this.dataschema !== 'string') throw new Error('Cloudevent "dataschema" must be a string')
+		setAttribute({ cloudevent, name: 'dataschema', types: ['string', 'undefined'], value: dataschema })
 
-		this.subject = subject
-		if (this.subject && typeof this.subject !== 'string') throw new Error('Cloudevent "subject" must be a string')
+		setAttribute({ cloudevent, name: 'subject', types: ['string', 'undefined'], value: subject })
+		// *******
 
-		this.time = new Date().toISOString()
+		// *******
+		// * Required in-house extentions
+		const origintimeValue = origintime || timeValue
+		setAttribute({ cloudevent, name: 'origintime', types: ['string'], value: origintimeValue })
 
-		// * In-house extentions
-		this.origintime = origintime || this.time
-		if (!this.origintime) throw new Error('Cloudevent "origintime" is required')
-		if (typeof this.origintime !== 'string') throw new Error('Cloudevent "origintime" must be a string')
+		const originidValue = originid || idValue
+		setAttribute({ cloudevent, name: 'originid', types: ['string'], value: originidValue })
 
-		this.originid = originid || this.id
-		if (!this.originid) throw new Error('Cloudevent "originid" is required')
-		if (typeof this.originid !== 'string') throw new Error('Cloudevent "originid" must be a string')
+		const originsourceValue = originsource || sourceValue
+		setAttribute({ cloudevent, name: 'originsource', types: ['string'], value: originsourceValue })
 
-		this.originsource = originsource || this.source
-		if (!this.originsource) throw new Error('Cloudevent "originsource" is required')
-		if (typeof this.originsource !== 'string') throw new Error('Cloudevent "originsource" must be a string')
+		const origintypeValue = origintype || typeValue
+		setAttribute({ cloudevent, name: 'origintype', types: ['string'], value: origintypeValue })
+		// *******
 
-		this.origintype = origintype || this.type
-		if (!this.origintype) throw new Error('Cloudevent "origintype" is required')
-		if (typeof this.origintype !== 'string') throw new Error('Cloudevent "origintype" must be a string')
+		// *******
+		// * Optional in-house extentions
+		setAttribute({ cloudevent, name: 'originatorid', types: ['string', 'undefined'], value: originatorid })
+		// *******
 	}
 }

package/src/tests/data.test.js

@@ -0,0 +1,29 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#data', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when a #data value is not input', () => {
+		it('returns undefined', () => {
+			const { data } = new Cloudevent(params)
+			expect(data).to.be.undefined
+		})
+	})
+
+	describe('when a #data value is input', () => {
+		it('returns the input value', () => {
+			params.data = JSON.stringify({ someData: 'yes' })
+			const { data } = new Cloudevent(params)
+			expect(data).to.eq(params.data)
+		})
+	})
+})

package/src/tests/datacontenttype.test.js

@@ -0,0 +1,77 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#datacontenttype', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when a #data value is not input', () => {
+		describe('when #datacontenttype is not input', () => {
+			it('returns undefined', () => {
+				const { datacontenttype } = new Cloudevent(params)
+				expect(datacontenttype).to.be.undefined
+			})
+		})
+
+		describe('when #datacontenttype is input', () => {
+			const validValues = ['some-string', undefined]
+
+			validValues.forEach(value => {
+				describe(`when #datacontenttype is a ${typeof value}`, () => {
+					it('returns the input value', () => {
+						params.datacontenttype = value
+						const { datacontenttype } = new Cloudevent(params)
+						expect(datacontenttype).to.eq(params.datacontenttype)
+					})
+				})
+			})
+
+			describe(`when #datacontenttype is not of type ${validValues.map(item => typeof item).join(' or ')}`, () => {
+				it('throws the proper error', () => {
+					const expected = `Cloudevent "datacontenttype" must be of type STRING or UNDEFINED`
+					params.datacontenttype = 1234
+					expect(() => new Cloudevent(params)).to.throw(expected)
+				})
+			})
+		})
+	})
+
+	describe('when a #data value is input', () => {
+		describe('when #datacontenttype is not input', () => {
+			it('returns "application/json"', () => {
+				params.data = JSON.stringify({ some: 'data' })
+				const { datacontenttype } = new Cloudevent(params)
+				expect(datacontenttype).to.eq('application/json')
+			})
+		})
+
+		describe('when #datacontenttype is input', () => {
+			const validValues = ['some-string', undefined]
+
+			validValues.forEach(value => {
+				describe(`when #datacontenttype is a ${typeof value}`, () => {
+					it('returns the input value', () => {
+						params.datacontenttype = value
+						const { datacontenttype } = new Cloudevent(params)
+						expect(datacontenttype).to.eq(params.datacontenttype)
+					})
+				})
+			})
+
+			describe(`when #datacontenttype is not of type ${validValues.map(item => typeof item).join(' or ')}`, () => {
+				it('throws the proper error', () => {
+					const expected = `Cloudevent "datacontenttype" must be of type STRING or UNDEFINED`
+					params.datacontenttype = 1234
+					expect(() => new Cloudevent(params)).to.throw(expected)
+				})
+			})
+		})
+	})
+})

package/src/tests/dataschema.test.js

@@ -0,0 +1,39 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#dataschema', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #dataschema is not input', () => {
+		it('returns undefined', () => {
+			const { dataschema } = new Cloudevent(params)
+			expect(dataschema).to.be.undefined
+		})
+	})
+
+	describe('when #dataschema is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "dataschema" must be of type STRING or UNDEFINED'
+				params.dataschema = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent#dataschema to the input value', () => {
+				params.dataschema = 'some-string'
+				const { dataschema } = new Cloudevent(params)
+				expect(dataschema).to.eq(params.dataschema)
+			})
+		})
+	})
+})

package/src/tests/id.test.js

@@ -0,0 +1,45 @@
+import { Cloudevent } from '../index.js'
+import { createSandbox } from 'sinon'
+import { expect } from 'chai'
+
+describe('cloudevent#id', () => {
+	const sandbox = createSandbox()
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	it('returns a string', () => {
+		const { id } = new Cloudevent(params)
+		expect(id).to.be.a('string')
+	})
+
+	describe('when process.env.MILL_CLOUDEVENTS_NANOID_LENGTH is not input', () => {
+		it('returns a string with the proper length', () => {
+			sandbox.stub(process, 'env').value({})
+			const { id } = new Cloudevent(params)
+			expect(id).to.have.lengthOf(21)
+		})
+	})
+
+	describe('when process.env.MILL_CLOUDEVENTS_NANOID_LENGTH is input', () => {
+		it('returns a string with the proper length', () => {
+			const expected = '123'
+
+			const env = { MILL_CLOUDEVENTS_NANOID_LENGTH: expected }
+			sandbox.stub(process, 'env').value(env)
+
+			const { id } = new Cloudevent(params)
+			expect(id).to.have.lengthOf(expected)
+		})
+	})
+})

package/src/tests/originatorid.test.js

@@ -0,0 +1,39 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#originatorid', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #originatorid is not input', () => {
+		it('returns #id', () => {
+			const { originatorid } = new Cloudevent(params)
+			expect(originatorid).to.be.undefined
+		})
+	})
+
+	describe('when #originatorid is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "originatorid" must be of type STRING or UNDEFINED'
+				params.originatorid = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent[originatorid] to the input value', () => {
+				params.originatorid = 'some-originator-id'
+				const { originatorid } = new Cloudevent(params)
+				expect(originatorid).to.eq(params.originatorid)
+			})
+		})
+	})
+})

package/src/tests/originid.test.js

@@ -0,0 +1,40 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#originid', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #originid is not input', () => {
+		it('returns #id', () => {
+			params.originid = null
+			const { id, originid } = new Cloudevent(params)
+			expect(originid).to.eq(id)
+		})
+	})
+
+	describe('when #originid is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "originid" must be of type STRING'
+				params.originid = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent#originid to the input value', () => {
+				params.originid = 'some-origin-id'
+				const { originid } = new Cloudevent(params)
+				expect(originid).to.eq(params.originid)
+			})
+		})
+	})
+})

package/src/tests/originsource.test.js

@@ -0,0 +1,40 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#originsource', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #originsource is not input', () => {
+		it('returns #source', () => {
+			params.originsource = null
+			const { source, originsource } = new Cloudevent(params)
+			expect(originsource).to.eq(source)
+		})
+	})
+
+	describe('when #originsource is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "originsource" must be of type STRING'
+				params.originsource = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent#originsource to the input value', () => {
+				params.originsource = 'some-origin-source'
+				const { originsource } = new Cloudevent(params)
+				expect(originsource).to.eq(params.originsource)
+			})
+		})
+	})
+})

package/src/tests/origintime.test.js

@@ -0,0 +1,39 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#origintime', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #origintime is not input', () => {
+		it('returns #time', () => {
+			const { origintime, time } = new Cloudevent(params)
+			expect(origintime).to.eq(time)
+		})
+	})
+
+	describe('when #origintime is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "origintime" must be of type STRING'
+				params.origintime = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent#origintime to the input value', () => {
+				params.origintime = new Date().toISOString()
+				const { origintime } = new Cloudevent(params)
+				expect(origintime).to.eq(params.origintime)
+			})
+		})
+	})
+})

package/src/tests/origintype.test.js

@@ -0,0 +1,40 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#origintype', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			type: 'some-type',
+			source: 'some-source',
+		}
+	})
+
+	describe('when #origintype is not input', () => {
+		it('returns #type', () => {
+			params.origintype = null
+			const { type, origintype } = new Cloudevent(params)
+			expect(origintype).to.eq(type)
+		})
+	})
+
+	describe('when #origintype is input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "origintype" must be of type STRING'
+				params.origintype = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valtype', () => {
+			it('sets cloudevent#origintype to the input value', () => {
+				params.origintype = 'some-origin-type'
+				const { origintype } = new Cloudevent(params)
+				expect(origintype).to.eq(params.origintype)
+			})
+		})
+	})
+})

package/src/tests/source.test.js

@@ -0,0 +1,63 @@
+import { Cloudevent } from '../index.js'
+import { createSandbox } from 'sinon'
+import { expect } from 'chai'
+
+describe('cloudevent#source', () => {
+	const sandbox = createSandbox()
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	afterEach(() => {
+		sandbox.restore()
+	})
+
+	describe('when a #source value is not input', () => {
+		beforeEach(() => {
+			params.source = null
+		})
+
+		describe('when process.env.MILL_CLOUDEVENTS_SOURCE is not input', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "source" must be of type STRING'
+				sandbox.stub(process, 'env').value({})
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when process.env.MILL_CLOUDEVENTS_SOURCE is input', () => {
+			it('returns the input input value', () => {
+				const expected = 'some-env-var-value'
+
+				const env = { MILL_CLOUDEVENTS_SOURCE: expected }
+				sandbox.stub(process, 'env').value(env)
+
+				const { source } = new Cloudevent(params)
+				expect(source).to.eq(expected)
+			})
+		})
+	})
+
+	describe('when a #source value is input', () => {
+		describe('when the input value is not a string', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "source" must be of type STRING'
+				params.source = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is a string', () => {
+			it('returns the input value', () => {
+				const { source } = new Cloudevent(params)
+				expect(source).to.eq(params.source)
+			})
+		})
+	})
+})

package/src/tests/specversion.test.js

@@ -0,0 +1,41 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#specversion', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when a #specversion value is not input', () => {
+		it('returns the proper value', () => {
+			const expected = '1.0'
+			const { specversion } = new Cloudevent(params)
+			expect(specversion).to.eq(expected)
+		})
+	})
+
+	describe('when a #specversion value is input', () => {
+		describe('when the input value is not a string', () => {
+			it('throws the proper error', () => {
+				params.specversion = 1234
+				const expected = 'Cloudevent "specversion" must be of type STRING'
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is a string', () => {
+			it('returns the input value', () => {
+				const expected = '4.3.2.1'
+				params.specversion = expected
+				const { specversion } = new Cloudevent(params)
+				expect(specversion).to.eq(expected)
+			})
+		})
+	})
+})

package/src/tests/subjest.test.js

@@ -0,0 +1,39 @@
+import { Cloudevent } from '../index.js'
+import { expect } from 'chai'
+
+describe('cloudevent#subject', () => {
+	let params
+
+	beforeEach(() => {
+		params = {
+			// * Required base defaults
+			source: 'some-source',
+			type: 'some-type',
+		}
+	})
+
+	describe('when #subject is not input', () => {
+		it('returns undefined', () => {
+			const { subject } = new Cloudevent(params)
+			expect(subject).to.be.undefined
+		})
+	})
+
+	describe('when #subject is not input', () => {
+		describe('when the input value is invalid', () => {
+			it('throws the proper error', () => {
+				const expected = 'Cloudevent "subject" must be of type STRING or UNDEFINED'
+				params.subject = 1234
+				expect(() => new Cloudevent(params)).to.throw(expected)
+			})
+		})
+
+		describe('when the input value is valid', () => {
+			it('sets cloudevent#subject to the input value', () => {
+				params.subject = 'some-string'
+				const { subject } = new Cloudevent(params)
+				expect(subject).to.eq(params.subject)
+			})
+		})
+	})
+})