Event Sourcing

// Klassisk state-baseret model
class Account {
    balance: number
    
    deposit(amount) {
        this.balance += amount  // gammel værdi tabt
        db.accounts.update(this.id, { balance: this.balance })
    }
}

// -----------------------------------------------------------
// Event Sourced model
// -----------------------------------------------------------

// Events er immutable facts om hvad der er sket
class AccountOpened { 
    constructor(accountId, owner, timestamp) { ... }
}
class MoneyDeposited { 
    constructor(accountId, amount, timestamp) { ... }
}
class MoneyWithdrawn { 
    constructor(accountId, amount, timestamp) { ... }
}

class AccountAggregate {
    private events: DomainEvent[] = []
    private balance = 0
    
    // Business-metoder producerer events, ændrer ikke state direkte
    open(accountId, owner) {
        this.apply(new AccountOpened(accountId, owner, new Date()))
    }
    
    deposit(amount) {
        if (amount <= 0) throw new Error('Amount must be positive')
        this.apply(new MoneyDeposited(this.id, amount, new Date()))
    }
    
    withdraw(amount) {
        if (amount > this.balance) throw new Error('Insufficient funds')
        this.apply(new MoneyWithdrawn(this.id, amount, new Date()))
    }
    
    // Apply anvender event på in-memory state og gemmer det
    private apply(event: DomainEvent) {
        this.when(event)
        this.events.push(event)
    }
    
    // When er ren state-transition — samme funktion bruges ved replay
    private when(event: DomainEvent) {
        if (event instanceof AccountOpened) {
            this.balance = 0
        } else if (event instanceof MoneyDeposited) {
            this.balance += event.amount
        } else if (event instanceof MoneyWithdrawn) {
            this.balance -= event.amount
        }
    }
    
    // Genopbyg fra event log
    static loadFrom(events: DomainEvent[]) {
        const acc = new AccountAggregate()
        for (const e of events) acc.when(e)
        return acc
    }
}

// Persistens = append events
class EventStore {
    async append(streamId, events) {
        await db.events.insert(events.map(e => ({
            stream_id: streamId,
            event_type: e.constructor.name,
            data: JSON.stringify(e),
            timestamp: e.timestamp,
            version: this.nextVersion(streamId)
        })))
    }
    
    async load(streamId): DomainEvent[] {
        const rows = await db.query(
            'SELECT * FROM events WHERE stream_id = $1 ORDER BY version',
            [streamId]
        )
        return rows.map(row => this.deserialize(row))
    }
}

// Tidsrejse — hvad var saldoen den 3. marts kl 14:22?
const events = await store.load(accountId)
const historical = events.filter(e => e.timestamp <= new Date('2026-03-03T14:22:00'))
const account = AccountAggregate.loadFrom(historical)
console.log('Saldo på tidspunktet:', account.balance)