@faustt/event-store

Easy to use event store library with TypeScript support

Introduction

Event sourcing is a powerful technique that has a lot of data analysis benefits. One drawback of event sourcing is that it is oftentimes tiresome to setup, let alone implement. This package tries to address this issue by providing a robust library that works both on the server (Memory) and browser (Memory or IndexedDB).

Example Usage

See the Examples Folder for more concrete examples.

import { EventStore, Aggregator, Event } from "@faustt/event-store";

// Declare some events.
// They are automatically made available to the event store.
declare global {
    namespace Faustt.EventStore {
        interface Events {
            "Transaction:Saved": {
                id: string;
                description: string;
                amount: number;
            };
            "Transaction:Deleted": {
                id: string;
            };
            "TransactionGroup:Saved": {
                id: string;
                name: string;
            };
            "TransactionGroup:Deleted": {
                id: string;
            };
        }
    }
}

interface Transaction {
    id: string;
    description: string;
    amount: number;
}

// Aggregators derive data from an event stream.
class Transactions implements Aggregator {
    public result: Transaction[] = [];

    public async process(event: Event): Promise<void> {
        switch (event.type) {
            case "Transaction:Saved":
                this.transactions.set(event.payload.id, event.payload);
                break;

            case "Transaction:Deleted":
                this.transactions.delete(event.payload.id);
                break;
        }
    }

    public async after(): Promise<void> {
        this.result = [...this.transactions.values()];
    }

    private transactions = new Map<string, Transaction>();
}

// Basic mapping function that computes the balance after a list of transactions.
function computeBalance(transactions: Transaction[]): number {
    return transactions.reduce((a, b) => a + b.amount, 0);
}

export async function main(args: string[]): Promise<void> {
    const store = new EventStore();

    // Events are automatically timestamped and kept in order.

    await store.emit("Transaction:Saved", {
        id: "test-1",
        description: "Test",
        amount: 10,
    });

    await store.emit("Transaction:Saved", {
        id: "test-2",
        description: "Test",
        amount: 50,
    });

    await store.emit("Transaction:Deleted", {
        id: "test-1",
    });

    await store.emit("Transaction:Saved", {
        id: "test-3",
        description: "Test",
        amount: 13,
    });

    // Log the balance after the aggregated transactions.

    await store
        .aggregate(Transactions)
        .then(computeBalance)
        .then((balance) => console.log(balance));
}

Maintainer

Tobias Faust