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!

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Event source everything!

Similar to Event source everything! (20)

More from The Software House

More from The Software House (20)

Recently uploaded

Recently uploaded (20)

Event source everything!