Event source everything!

EVENT SOURCE EVERYTHING!
AGENDA
▸ EVENT SOURCING BASICS
▸ WHAT ABOUT STORE?
▸ HOW TO HANDLE EVENTS?
▸ VERSIONING
▸ PERFORMANCE
▸ QUESTIONS

ADAM POLAK
HEAD OF NODE.JS
ADAM.POLAK@THESOFTWAREHOUSE.PL
POLAK.ADAM1

▸ CREATE EMPLOYEE
▸ ISSUE VACATION REQUEST
▸ APPROVE/DECLINE VACATION REQUEST
HR MANAGEMENT

EMPLOYEE
class Employee {
constructor(id, firstName, lastName, vacationRequests) {
this._id = id;
this._firstName = firstName;
this._lastName = lastName;
this._vacationRequests = vacationRequests;
}
issueVacationRequest(from, to, comment) { // do business logic and domain validation here then return vacation req or event}
}

ISSUE VACATION REQUEST
const vacationRequest = employee.issueValidationRequest(‘2018-10-01’, ‘2018-11-01’, ‘Japan, here I come!’);
vacationRequestsRepository.persist(vacationRequest); // map vacation request from domain model to db model
const employee = employeeRepository.ﬁndById(id); // map from db model to domain model
| id | employee_id | from | to | comment | create_date | update_date |
| 1 | some-uuid | 2018-10-01 | 2018-11-01 | Japan, here I come! | 2018-01-11 | 2018-01-11 |

IT’S ALL ABOUT
CURRENT STATE

▸ EMPLOYEE EMPLOYED
▸ VACATION REQUEST ISSUED
▸ VACATION REQUEST APPROVED
▸ VACATION REQUEST DECLINED
▸ EMPLOYEE ASSIGNED TO PROJECT
▸ EMPLOYEE DETAILS UPDATED
EVENTS

REBUILD
FROM EVENTSCOMMAND OPERATIONS
WRITE SIDE
EMIT
EVENTS
EVENT STORE

REBUILD
FROM EVENTSCOMMAND OPERATIONS
EMIT
EVENTS
EVENT STORE

router.post('/:id/vacations', celebrate({
body: Joi.object().keys({
from: Joi.date().required(),
to: Joi.date().required(),
comment: Joi.string().allow(null)
})
}), async (req, res, next) => {
const employeeId = req.params.id;
try {
const events = await eventStore.getEventsFor(employeeId);
const employee = Employee.fromEvents(employeeId, events);
employee.issueVacationRequest(req.body.from, req.body.to, req.body.comment);
await eventStore.saveStream(employee.getRecentEvents()).then(events => eventBus.publish(events));
return res.status(204).send();
} catch (error) { next(error);}
});

ISSUE VACATION REQUEST - GET EVENTS FROM STORE
})
try {
});

▸ SINGLE SOURCE OF TRUTH
▸ USED ONLY ON WRITE SIDE
▸ USED DURING READ MODEL REBUILD
EVENT STORE

{
type: ‘EMPLOYEE_EMPLOYED’,
aggregateId: my-uuid,
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
ﬁrstName: ‘Adam’,
lastName: ‘Polak’,
occupation: ‘Head of Node.js’
}
}
EVENTS
{
type: ‘VACATION_REQUEST_ISSUED’,
version: 1,
createDate: ‘2018-01-01 13:23:34’,
payload: {
id: request-uuid,
from: ‘2018-10-01’,
to: ‘2018-11-01’,
days: 24
}
}
{
type: ‘EMPLOYEE_ASSIGNED’
version: 1,
createDate: ‘2018-01-01 14:23:34’,
payload: {
projectId: project-uuid
}
}

▸ EVENT STORE
▸ MONGODB
▸ POSTGRESQL
POSSIBLE SOLUTIONS

class EventStoreRepository {
constructor(db, upcasters) { … }
async saveStream(events) { … }
getAllEvents() { … }
getEventsFor(aggregateId) {
return this.eventsCollection.ﬁnd({ aggregateId })
.sort({ "payload.createDate": 1 })
.then(events => events.map(event => this.upcasters.upcast(event)));
}
}
REPOSITORY

}
REPOSITORY
}

ISSUE VACATION REQUEST - REBUILD AGGREGATE FROM EVENTS
})
try {
a await eventStore.saveStream(employee.getRecentEvents()).then(events => eventBus.publish(events));
});

AGGREGATE ROOT
class Employee {
constructor(id) {
this.id = id;
this.recentEvents = [];
}
static fromEvents(aggregateId, events) { … }
issueVacationRequest(from, to, comment) { … }
apply(event) {…}
getRecentEvents() { … }
}

AGGREGATE ROOT - REBUILD FROM EVENTS
class Employee {
constructor(id) {
this.id = id;
}
issueVacationRequest(from, to, comment) { … }
apply(event) {…}
getRecentEvents() { … }
}
static fromEvents(aggregateId, events) { … }

{
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
occupation: ‘JS Developer’
}
}
{
type: ‘EMPLOYEE_OCCUPATION_CHANGED’,
version: 1,
createDate: ‘2018-01-01 13:23:34’,
payload: {
}
}
{
id: my-uuid,
occupation: ‘JS Developer’
}
{
id: my-uuid,
}

static fromEvents(id, events) {
return events.reduce((employee, event) => {
employee.apply(event);
return employee;
}, new Employee(id))
}

apply(event) {
if (event.type === ‘EMPLOYEE_EMPLOYED’) {
this.ﬁrstName = event.payload.ﬁrstName;
this.lastName = event.payload.lastName;
this.occupation = event.payload.occupation;
} else {
throw new AppException(`Missing handler for event with type ${event.type}`);
}
}
AGGREGATE ROOT - APPLY EVENTS

ISSUE VACATION REQUEST - PERFORM ACTION ON DOMAIN MODEL
})
try {
});

issueVacationRequest(from, to, comment) {
const requestId = uuid.v4();
const days = VacationRequest.calculateDays(from, to);
if (this.vacationDays.availableDays < days) {
throw new Error(`Not enough free days to take vacation for '${days}' days`);
}
const employeeIssuedVacationRequestEvent = employeeIssuedVacationRequest.create( … );
this.recentEvents.push(employeeIssuedVacationRequestEvent);
this.apply(employeeIssuedVacationRequestEvent);
}

ISSUE VACATION REQUEST - EMIT EVENT FROM AGGREGATE
issueVacationRequest(from, to, comment) {
const requestId = uuid.v4();
const days = VacationRequest.calculateDays(from, to);
if (this.vacationDays.availableDays < days) {
throw new Error(`Not enough free days to take vacation for '${days}' days`);
}
}
const employeeIssuedVacationRequestEvent = employeeIssuedVacationRequest.create( … );
this.recentEvents.push(employeeIssuedVacationRequestEvent);
this.apply(employeeIssuedVacationRequestEvent);

ISSUE VACATION REQUEST - SAVE RECENT EVENTS
})
try {
});

getRecentEvents() {
const events = [...this.recentEvents];
return events;
}
AGGREGATE ROOT - GET RECENT EVENTS

async saveStream(events) {
await this.eventsCollection.insert(events);
return events;
}
getEventsForm(aggregateId) { … }
}
REPOSITORY - SAVE STREAM

}
getEventsForm(aggregateId) { … }
}
REPOSITORY - SAVE STREAM
// SAVE IN SINGLE “TRANSACTION”!
return events;
}

| id | aggregateId | aggregateVersion | type | createDate | payload | version |
| 10 | 1 | 10 | EMPLOYEE_UPDATED | 2018-01-11 | { ………………………………… } | 4 |
| 1 | 1 | 1 | EMPLOYEE_EMPLOYED | 2018-01-02 | { ………………………………… } | 1 |
EVENT STORE - PERSISTED EVENTS

▸ HOW TO PAGINATE?
▸ HOW TO DISPLAY SINGLE EMPLOYEE?
▸ HOW TO DISPLAY FILTER EMPLOYEES?
▸ HOW TO DO BASIC UI OPERATIONS?
PROBLEMS

EVENT
BUS
PROJECTION STORAGE UI
READ SIDE

EVENT
BUS
READ SIDE

EVENT BUS
})
try {
});

EVENT BUS
EVENT BUS
PROJECTORS
MAILER
HANDLER
{
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
}
}

EVENTS BUS
class EventBus {
constructor() { this.subscribers = []; }
subscribe(event, handler) {
if (typeof this.subscribers[`${event}`] === 'undeﬁned') {
this.subscribers[`${event}`] = [];
}
this.subscribers[`${event}`].push(handler);
}
publish(events) {
events.forEach(event => {
if (this.subscribers[`${event.type}`]) {
this.subscribers[`${event.type}`].forEach((handler) => handler(event));
}
}
}
}

EVENT
BUS
PROJECTION STORAGE UI

PROJECTOR
const handler = connection => event => {
if (event.type === eventTypes.EMPLOYEE_EMPLOYED) {
return connection.collection(‘employees’).insert({ … });
}
if (event.type === eventTypes.EMPLOYEE_OCCUPATION_CHANGED) {
return connection.collection(‘employees’).update({ … });
}
};

REBUILD PROJECTION
FROM SCRATCH

PROJECTION REBUILD
app.then(async (db) => {
const eventStoreRepository = new EventStoreRepository(db, new Upcasters());
const projector = activeTasksProjector.rebuilder(db);
const events = await eventStoreRepository.getAll();
projector(events).then(() => process.exit(0));
});

▸ IT IS CQRS
▸ REBUILD AGGREGATE FROM PREVIOUS EVENTS
▸ EVERY OPERATION EMITS DOMAIN EVENTS
▸ STORE EVENTS IN EVENT STORE
▸ PUBLISH THEM THROUGH EVENT BUS
▸ BUILD PROJECTIONS FROM PUBLISHED EVENTS
▸ REBUILD PROJECTIONS IF NECESSARY
SUMMARY

▸ REBUILD EVENT STORE (NOT A GOOD IDEA)
▸ UPCAST AT RUNTIME
VERSIONING

UPCASTING
{
type: ‘REQUEST_APPROVED’,
aggregateId: 1,
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
id: ‘some-request-id’
}
}
{
aggregateId: 1,
version: 2,
createDate: ‘2018-01-01 12:23:34’,
payload: {
id: ‘some-request-id’,
approver: ‘Adam Polak’
}
}

UPCASTING
{
aggregateId: 1,
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
id: ‘some-request-id’
}
}
{
aggregateId: 1,
version: 2,
createDate: ‘2018-01-01 12:23:34’,
payload: {
id: ‘some-request-id’,
approver: ‘Adam Polak’
}
}
UPCASTER

}
}
EVENT STORE REPOSITORY

UPCASTER
const eventTypes = require('../employee/events/types');
module.exports = {
canUpcast: (event) => event.version === 1 && event.type === eventTypes.VACATION_REQUEST_APPROVED,
upcast: (event) => ({
...event,
version: 2,
payload: {
...event.payload,
approver: ‘hr-member‘
}
})
};

MORE EVENTS
=
PERFORMANCE LOSS

▸ AVOID LONG LIVING AGGREGATES
▸ SNAPSHOTS
PERFORMANCE IMPROVEMENTS

SNAPSHOTS
{
type: ‘TASK_CREATED,
aggregateId: 1,
aggregateVersion: 1,
version: 1,
createDate: ‘2018-01-01 12:23:34’,
payload: {
title: ‘some-title’
}
}
{
type: ‘TASK_UPDATED,
aggregateId: 1,
version: 1,
createDate: ‘2018-01-01 13:23:34’,
payload: {
description: ‘new-description’
}
}
{
type: ‘TASK_SNAPSHOT,
aggregateId: 1,
version: 1,
createDate: ‘2018-01-01 14:23:34’,
payload: {
title: ‘some-title’,
description: ‘new-description’
}
}

Event source everything!

More Related Content

What's hot

Similar to Event source everything!

More from The Software House

Event source everything!