diff --git a/src/event-bus/event-bus.ts b/src/event-bus/event-bus.ts
index ad144af2a0342779a756e654e9945a9472caf9c2..b2dac5d189bb2dfd43dd39567ce5e4fd66e28866 100644
--- a/src/event-bus/event-bus.ts
+++ b/src/event-bus/event-bus.ts
@@ -1,5 +1,4 @@
 import { EventType } from './types';
-import { NotImplementedError } from 'funfix';
 
 export abstract class EventBus {
     // register the following:
@@ -7,7 +6,5 @@ export abstract class EventBus {
     // - serviceName - used when subscribing to generate a unique queue for holding
     // incoming messages of the form: `consumer__${eventType}__${serviceName}`
     constructor(readonly eventsToHandle: EventType[], readonly serviceName: string) {}
-    destroy(): Promise<void> {
-        throw new NotImplementedError('destroy() on EventBus');
-    }
+    abstract destroy(): Promise<void>;
 }
diff --git a/src/event-bus/event-factory.ts b/src/event-bus/event-factory.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8c59039a876b6231346be84c6498c36d98afab1b
--- /dev/null
+++ b/src/event-bus/event-factory.ts
@@ -0,0 +1,11 @@
+import { Event } from './types';
+import uuid = require('uuid');
+
+export const eventFactory = <P extends object>(eventType: string, payload: P): Event<P> => {
+    return {
+        eventType,
+        id: uuid.v4(),
+        created: new Date(),
+        payload,
+    };
+};
diff --git a/src/event-bus/index.ts b/src/event-bus/index.ts
index 3067e7534c483db021b200f2c271bbf4327aaef1..999b47ef342e29d44a7577459c88ee32f8847952 100644
--- a/src/event-bus/index.ts
+++ b/src/event-bus/index.ts
@@ -1,2 +1,3 @@
-export * from './event-bus';
 export * from './types';
+export * from './event-bus';
+export * from './event-factory';
diff --git a/src/event-bus/types.test.ts b/src/event-bus/types.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..417323430d5c8104127295566ff16559f8da590d
--- /dev/null
+++ b/src/event-bus/types.test.ts
@@ -0,0 +1,55 @@
+import { EventType, Event } from './types';
+
+const expectedEventProperties = {
+    eventType: true,
+    id: true,
+    created: true,
+    payload: true,
+    version: false,
+    context: false,
+};
+
+function createValidationFunction<T>(properties: Record<keyof T, boolean>): Function {
+    return function<TActual extends T>(value: TActual): T {
+        const result = {} as T;
+        const foundKeys: string[] = [];
+        for (const property of Object.keys(properties) as Array<keyof T>) {
+            if (properties[property]) {
+                if (value[property] === undefined) {
+                    throw new Error(`undefined property '${property}'`);
+                }
+                result[property] = value[property];
+                foundKeys.push(property.toString());
+            } else {
+                if (value[property] !== undefined) {
+                    throw new Error(`not expecting property '${property}'`);
+                }
+            }
+        }
+        const valueKeys = Object.keys(value);
+        const difference = valueKeys.filter(x => !foundKeys.includes(x));
+        if (difference.length) {
+            throw new Error(`extra properties '${JSON.stringify(difference)}'`);
+        }
+        return result;
+    };
+}
+
+describe('Event Bus Types', () => {
+    it('type EventType is string', () => {
+        const et: EventType = 'this is a string';
+        expect(typeof et).toBe('string');
+    });
+
+    it('interface Event contains expected members', () => {
+        class ExpectedToBeAnEvent {
+            id = '234';
+            created: Date = new Date();
+            payload: {} = {};
+            eventType = 'type';
+        }
+        const isValidEvent = createValidationFunction<Event<{}>>(expectedEventProperties);
+        const ee = new ExpectedToBeAnEvent();
+        expect(() => isValidEvent(ee)).not.toThrow();
+    });
+});