Skip to content

InMemoryEventStore

API reference for InMemoryEventStore

@delta-base/toolkit


In-memory implementation of EventStore for testing and development

This implementation provides a complete event store that runs entirely in memory, making it perfect for unit tests, integration tests, and development scenarios where you don’t need persistence.

new InMemoryEventStore(): InMemoryEventStore

InMemoryEventStore

aggregateStream<State, EventType>(streamId, options): Promise<AggregateStreamResult<State>>

Aggregate events from a stream to rebuild state

State

EventType extends Readonly<{ data: EventData; metadata?: PlatformEventMetadata; type: string; }>

string

The stream identifier

AggregateStreamOptions<State, EventType>

Aggregation options including initial state and evolution function

Promise<AggregateStreamResult<State>>

Promise resolving to the aggregated state and stream metadata

EventStore.aggregateStream


appendToStream<EventType>(streamId, events, options?): Promise<AppendToStreamResult>

Append events to a stream

EventType extends Readonly<{ data: EventData; metadata?: PlatformEventMetadata; type: string; }> = Readonly<{ data: EventData; metadata?: PlatformEventMetadata; type: string; }>

string

The stream identifier

EventType[]

Events to append

AppendToStreamOptions

Append options including expected version

Promise<AppendToStreamResult>

Promise resolving to the append result

EventStore.appendToStream


clear(): void

Clear all data (utility method for testing)

void


getAllEvents(): object[]

Get all events across all streams (utility method for testing)

object[]

Array of all events ordered by global position


getAllStreamIds(): string[]

Get all stream IDs (utility method for testing)

string[]

Array of all stream identifiers


getTotalEventCount(): number

Get total event count across all streams (utility method for testing)

number

Total number of events stored


queryEvents<EventType>(options): Promise<QueryEventsResult<EventType>>

Query events across all streams with flexible filtering options

EventType extends Readonly<{ data: EventData; metadata?: PlatformEventMetadata; type: string; }>

QueryEventsOptions = {}

Query parameters for filtering events

Promise<QueryEventsResult<EventType>>

Promise resolving to the query result with events and pagination info

EventStore.queryEvents


readStream<EventType>(streamId, options?): Promise<ReadStreamResult<EventType>>

Read events from a stream with options

EventType extends Readonly<{ data: EventData; metadata?: PlatformEventMetadata; type: string; }>

string

The stream identifier

ReadStreamOptions

Read options for filtering and pagination

Promise<ReadStreamResult<EventType>>

Promise resolving to read result with events and metadata

EventStore.readStream


streamExists(streamId): Promise<boolean>

Check if a stream exists (utility method for testing)

string

The stream identifier

Promise<boolean>

Promise resolving to boolean indicating existence