TYPO3 Event Sourcing

TYPO3 Event Sourcing Oliver Hader 11/2016
Event Sourcing
… some new opportunities
November 5th, 2016

~basics
~bank account example 
~generic modelling
~opportunities

DDD ~basics

Domain-driven Design
• book by Eric Evans, 2003
• robust & maintainable software applications
• domain experts & ubiquitous language
• toolbox for domain architectures

Layered Architecture
User Interface Layer
Application Layer
Domain Layer
Infrastructure Layer
Orchestrates application
and domain layer
Encapsulates domain
and data access
Encapsulates
infrastructure concerns

Aggregates
Customer
Address
Invoice
Car
Wheel
Engine
Garage
CarRental
Survey
car aggregate
customer aggregate
aggregate root
aggregate root
concerns
repairs
interviews
car rental aggregate

Bounded Contexts
Customer
Car
Fuel
CarRental
car rental bounded context
Car
Wheel
Engine
Garage
garage bounded context
Mechanic
Damage
~DomainModelCarRental ~DomainModelGarage

Entities & Value Objects
• make the implicit explicit
• make validation part of your domain model
• example for bank account number
• $account-‐>setIban('CH1504842000000000002');

• $iban
=
new
Iban('CH1504842000000000002'); 
$account-‐>setIban($iban);

Events
• are messages
• are modelled in separate classes
• concerning something that really happened
• used to communicate between components
• handle with observer patterns (signal-slot)
• $event
=
new
ReplacedBrokenEngineEvent(…);

CQRS ~basics

CQS
• CQS - Command Query Separation
• actually deﬁned by Bertrand Mayer in 1997
• separate processing in domain model into
• write model - modify state with command
• read model - fetch & represent state with query

CQRS
• CQRS - Command Query Responsibility Segregation
• more speciﬁc & restrictive by Greg Young
• segregation between write store & read store
• changes trigger updates in read store
• visualization just uses data-transfer objects

Event Sourcing ~basics

Event Sourcing
• … CQRS continued & in more details
• aim to persist events instead of resulting state
• event stores provide read/write capabilities
• applying all events results to current state again
• events are projected into desired formats

Events & Event Store
• events are immutable
• cannot be modiﬁed
• cannot be deleted
• legacy events must be handled
• event store is consistent
• events are retrieved in correct order
• there are no gaps in the event history

Projections
• are observers & handle events
• interpret and persist events to
• MySQL database
• ﬁlesystem, e.g. HTML
• emit notiﬁcations, mails
• whatever required format

Materialized View
• persist information for accordant requirements
• forget about complex JOIN statements
• data is represented denormalized
• pre-process information for view
• read 40 ﬁeld values vs. just two are shown

Event Sourcing Overview
Command Handler
Command Bus
Repository
ServiceEventPublisher
EventHandler
Denormalizer
Thin Data Layer
Facade
Domain
DTOs
Commands
Aggregate
Events
Events
Events Events
SQL
ClientCommands Queries
External
Events
Internal
Events
some query
results

Why??? ~basics

TYPO3 Data Architecture
Repository &
Reconstitution
Routing
Controller
View
Model
Permission
Persistence
Infrastructure
Frontend Extbase Backend
EditDocumentController
FormEngine
<<TCA>>
FormDataProvider
BackendUserAuthentication
DataHandler
RelationHandler
TypoScriptFrontendController
ActionContoller
AbstractView
AbstractEntity & AbstractValueObject
Repository
Typo3DbBackend
Backend
PersistenceManager
DataMapper
StandaloneView <<custom>>
ConnectionPool
Connection
<<TCA>>
AbstractPlugin
ContentObjectRenderer
FrontendRequestHandler
BackendRouteDispatcher
BackendRequestHandler
MVCDispatcher
<<TypoScript>>
<<direct database operations>> <<direct database operations>>
x
x
x

Localization in TYPO3
DataHandlerController
DataHandler
RelationHandler
DatabaseConnection
translate
<<create>>
localize()
copyRecord()
<<create>>
DataHandler
process_datamap()
last_insert_id()
fetch record
record
[x]-processDBdata()
<<create>>
start()
fetch references
references
writeForeignField()
update references
insert record
new_record_id
new_record_id
new_record_id
references
new_record_id
multipleread&writeprocesses

Context & Overlays
is translation of
uid 13
sys_language_uid 0
:tt_content
l10n_parent 0
header Message
pid 100
t3ver_wsid 0
t3ver_state 0
t3ver_oid 0
uid 27
sys_language_uid 1
:tt_content
l10n_parent 13
header Nachricht
pid 100
t3ver_wsid 1
t3ver_state 1
t3ver_oid 0
uid 28
sys_language_uid 1
:tt_content
l10n_parent 13
header Nachricht
pid -1
t3ver_wsid 1
t3ver_state -1
t3ver_oid 27
uid 41
sys_language_uid 0
:tt_content
l10n_parent 0
header News
pid -1
t3ver_wsid 1
t3ver_state 0
t3ver_oid 13
is workspace
version of
is new
version
is default
version
is workspace
version of
is new
palceholder

Why…
• is persistence and relation handling different
• extbase cannot persist in workspace context
• only back-end has permission layer
• are context information persisted with each record
• are record overlays fetched & applied each time

bank account example

Regular approach
• using ExtensionBuilder to kick-start model
• AccountController - modify & read information
• AccountRepository - modify & read information
• Account modelled as aggregate root
• Transaction model bound to Aggregate (1:n)
• using lazy-loading for Transaction entities

Identify domain events
• event storming is a team process
• helps to combine knowledge concerning domain
• in style of reverse engineering
• working backwards
• identify events
• identify commands that lead to events
• identify rules that are applied to commands

Bank Account Example
debited
money
debit
money
account
not closed
balance
sufficient
account
created
deposit
money
account
not closed
deposited
money
create
account

Demo & Source Code
• https://github.com/TYPO3Incubator/
bank_account_example
• Conﬁguration
• CommandController & ManagementController
• Domain Commands & Domain Events
• EventRepositories & ProjectionRepositories
• Projections & Data-Transfer Objects

generic modelling

Generic Domain Model
• no real models for most core database tables
• generic models contain common aspects
• identity (”tt_content:123”)
• atomic, direct values
• relations to other entities
• ”generic“ is not domain-driven
• but this concept is very useful here

Generic Domain Events
• created, modiﬁed, deleted ~CRUD (without R)
• moved, duplicated
• hidden, shown ~visibility
• translated ~language context
• branched, merged ~workspace context
• attached, removed, ordered relation ~association

Interceptors
• DataHandler ~$tce->process_datamap();
• DatabaseConnection ~INSERT, UPDATE, DELETE
• translate actions into generic commands
• $GLOBALS['TCA'][…]['ctrl']['eventSourcing']=[ 

'listenEvents'
=>
true, 

'recordEvents'
=>
true, 

'projectEvents'
=>
true,

Command Upgrades
• tranlate generic to speciﬁc domain commands
• delegates domain control back to application
• back to bank account example
• does not need to implement generic commands
• action in back-end form result in real commands

Context & Local Storage
• Materialized View on database-level
• workspace and language deﬁne speciﬁc context
• each context uses an individual database
• information stored in SQLite locally
• projections update for each context
• it was named Local Storage

Local Storage
DEFAULT
MySQL
- _conn: DriverConnection
Connection
+ select(...arguments[])
+ insert(…arguments[])
+ update(…arguments[])
+ delete(…arguments[])
ORIGIN
MySQL
Connection
DefaultConnection
LocalStorage
workspace-0
SQLite
Connection
DefaultConnection
LocalStorage
workspace-1
SQLite
Connection
current state future state, context based
assigned
to
assigned to

Demo & Source Code
• https://github.com/TYPO3Incubator/data_handling
• Content Editing in back-end
• Event Store results
• Projections
• Command Translations

opportunities

Projections!
• separation between mutation & presentation
• events are the new & only true source
• everything else can be projected
• … and re-projected if it was wrong
• e.g. https://review.typo3.org/#/c/45320/
• trigger index update (Solr, Elasticsearc)

Questions?

Sources
• Figures
• “Layered Architecture“ - Buenosvinos, Carlos, Soronellas, Christian und Akbary, Keyvan. 2016. Domain-
Driven Design in PHP. Victoria : Leanpub, 2016. ISBN 9780994608413
• ”CQRS Overview“ - Betts, Dominic, et al. 2013. Exploring CQRS and Event Sourcing. Redmond : Microsoft
patterns & practices, 2013. ISBN 9781621140160
• ”Event Sourcing Overview“ - Nijhof, Mark. 2013. CQRS, The example. Victoria : Leanpub, 2013. ISBN
9781484102879
• GitHub source codes
• https://github.com/TYPO3Incubator/bank_account_example
• https://github.com/TYPO3Incubator/data_handling
• Master Thesis on Event Sourcing (German only)
• https://get.h4ck3r31.net/T3CRR16-HwWL498EvURCxnnittPoHyNrXkN3xi/
Hader_Oliver_TYPO3_EventSourcing.pdf

Thank you!
ohader 
@ohader 
Oliver_Hader
follow mehttps://h4ck3r31.net

TYPO3 Event Sourcing

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to TYPO3 Event Sourcing

Similar to TYPO3 Event Sourcing (20)

More from Oliver Hader

More from Oliver Hader (14)

Recently uploaded

Recently uploaded (20)

TYPO3 Event Sourcing