@kronos-ts/eventsourcing 0.1.0

package/dist/tag-resolver.d.ts

@@ -0,0 +1,30 @@
+import type { Tag } from "@kronos-ts/common";
+import type { EventMessage } from "@kronos-ts/messaging";
+/**
+ * Resolves tags from an event message. Tags are metadata markers attached
+ * to events for filtering, categorization, and criteria-based sourcing.
+ *
+ * By default, tags are derived from the event descriptor's `tags` function
+ * at event creation time. The TagResolver runs before storage and can enrich
+ * events with additional tags from metadata, context, etc.
+ */
+export interface TagResolver {
+    resolve(event: EventMessage): Tag[];
+}
+/**
+ * Default tag resolver — passes through tags already on the event.
+ *
+ * Events are created with descriptor-derived tags. This resolver simply
+ * returns those existing tags unchanged.
+ */
+export declare function descriptorBasedTagResolver(): TagResolver;
+/**
+ * Resolves additional tags from event metadata. For each configured key,
+ * if the metadata contains that key, a tag is created.
+ */
+export declare function metadataBasedTagResolver(...metadataKeys: string[]): TagResolver;
+/**
+ * Combines multiple tag resolvers. Tags from all resolvers are merged.
+ */
+export declare function multiTagResolver(...resolvers: TagResolver[]): TagResolver;
+//# sourceMappingURL=tag-resolver.d.ts.map

package/dist/tag-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-resolver.d.ts","sourceRoot":"","sources":["../src/tag-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAA;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,GAAG,EAAE,CAAA;CACpC;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,IAAI,WAAW,CAMxD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,YAAY,EAAE,MAAM,EAAE,GAAG,WAAW,CAa/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,SAAS,EAAE,WAAW,EAAE,GAAG,WAAW,CAUzE"}

package/dist/tag-resolver.js

@@ -0,0 +1,46 @@
+/**
+ * Default tag resolver — passes through tags already on the event.
+ *
+ * Events are created with descriptor-derived tags. This resolver simply
+ * returns those existing tags unchanged.
+ */
+export function descriptorBasedTagResolver() {
+    return {
+        resolve(event) {
+            return [...event.tags];
+        },
+    };
+}
+/**
+ * Resolves additional tags from event metadata. For each configured key,
+ * if the metadata contains that key, a tag is created.
+ */
+export function metadataBasedTagResolver(...metadataKeys) {
+    return {
+        resolve(event) {
+            const tags = [];
+            for (const key of metadataKeys) {
+                const value = event.metadata[key];
+                if (value != null) {
+                    tags.push({ key, value: String(value) });
+                }
+            }
+            return tags;
+        },
+    };
+}
+/**
+ * Combines multiple tag resolvers. Tags from all resolvers are merged.
+ */
+export function multiTagResolver(...resolvers) {
+    return {
+        resolve(event) {
+            const tags = [];
+            for (const resolver of resolvers) {
+                tags.push(...resolver.resolve(event));
+            }
+            return tags;
+        },
+    };
+}
+//# sourceMappingURL=tag-resolver.js.map

package/dist/tag-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-resolver.js","sourceRoot":"","sources":["../src/tag-resolver.ts"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B;IACxC,OAAO;QACL,OAAO,CAAC,KAAmB;YACzB,OAAO,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAA;QACxB,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,GAAG,YAAsB;IAChE,OAAO;QACL,OAAO,CAAC,KAAmB;YACzB,MAAM,IAAI,GAAU,EAAE,CAAA;YACtB,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;gBAC/B,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAA;gBACjC,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;oBAClB,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;gBAC1C,CAAC;YACH,CAAC;YACD,OAAO,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAG,SAAwB;IAC1D,OAAO;QACL,OAAO,CAAC,KAAmB;YACzB,MAAM,IAAI,GAAU,EAAE,CAAA;YACtB,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,IAAI,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAA;YACvC,CAAC;YACD,OAAO,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC"}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@kronos-ts/eventsourcing",
+  "version": "0.1.0",
+  "description": "Event sourcing for Kronos — dynamic-consistency-boundary event store with load/append.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "author": "Theo Emanuelsson",
+  "homepage": "https://github.com/KronosDB/kronos-ts/tree/main/packages/eventsourcing#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KronosDB/kronos-ts.git",
+    "directory": "packages/eventsourcing"
+  },
+  "bugs": {
+    "url": "https://github.com/KronosDB/kronos-ts/issues"
+  },
+  "keywords": [
+    "kronos",
+    "event-sourcing",
+    "cqrs",
+    "dcb",
+    "typescript"
+  ],
+  "sideEffects": false,
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.ts",
+    "!src/**/*.bench.ts"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  },
+  "publishConfig": {
+    "access": "public",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@kronos-ts/common": "workspace:*",
+    "@kronos-ts/messaging": "workspace:*",
+    "@kronos-ts/modelling": "workspace:*",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@kronos-ts/app": "workspace:*"
+  }
+}

package/src/append-condition.ts

@@ -0,0 +1,23 @@
+import type { EventCriteria } from "@kronos-ts/messaging"
+import type { ConsistencyMarker } from "./consistency-marker.js"
+
+/**
+ * Defines the consistency boundary for appending events.
+ *
+ * By default, the append condition matches the sourcing condition —
+ * guaranteeing that no conflicting events were appended since the state was loaded.
+ *
+ * Can be overridden per command handler for cases where less strict consistency
+ * is valid (e.g. a bank debit that doesn't conflict with credits).
+ */
+export interface AppendCondition {
+  readonly criteria: EventCriteria
+  readonly marker: ConsistencyMarker
+}
+
+/**
+ * Create an append condition from criteria and a consistency marker.
+ */
+export function appendCondition(criteria: EventCriteria, marker: ConsistencyMarker): AppendCondition {
+  return { criteria, marker }
+}

package/src/append.ts

@@ -0,0 +1,99 @@
+import {
+  resourceKey,
+  qualifiedNameToString,
+  generateIdentifier,
+  type Metadata,
+  type ResourceKey,
+} from "@kronos-ts/common"
+import {
+  getResource,
+  computeIfAbsent,
+  requireInvocationPhase,
+} from "@kronos-ts/messaging/processing-state"
+import type { z } from "zod"
+import type { EventDescriptor, EventMessage, EventCriteria } from "@kronos-ts/messaging"
+
+/** Append events to the active unit of work, buffered until commit. */
+export interface AppendFunction {
+  <P extends z.ZodType>(event: EventDescriptor<P>, payload: z.infer<P>): void
+  <P extends z.ZodType>(event: EventDescriptor<P>, payload: z.infer<P>, metadata: Metadata): void
+}
+
+// ---------------------------------------------------------------------------
+// Resource keys (owned by append — open-question #1 resolved: keys live with
+// the helper that writes them)
+// ---------------------------------------------------------------------------
+
+/** Buffered events waiting to be flushed at PREPARE_COMMIT. */
+export const BUFFERED_EVENTS_KEY: ResourceKey<EventMessage[]> = resourceKey("bufferedEvents")
+
+/** Sourcing info from load() calls, used to build append condition. */
+export const SOURCING_INFOS_KEY: ResourceKey<Array<{ criteria: EventCriteria; markerPosition: bigint }>> =
+  resourceKey("sourcingInfos")
+
+/** State cache: prevents duplicate load() calls within same UnitOfWork. */
+export const STATE_CACHE_KEY: ResourceKey<Map<string, Promise<unknown>>> = resourceKey("stateCache")
+
+/** State module references keyed by cache key, used to apply evolvers on append. */
+export const STATE_MODULES_KEY: ResourceKey<Map<string, { module: any; id: unknown }>> =
+  resourceKey("stateModules")
+
+/**
+ * Plan 04-01 (HDL-02 / D-42): module-level append.
+ *
+ * Throws NoActiveUnitOfWork outside a UoW (D-43 fail-fast on no-UoW).
+ * Throws WrongUoWPhase outside INVOCATION phase (D-43 mutator guard).
+ *
+ * Buffers events in BUFFERED_EVENTS_KEY; updates cached state via
+ * matching evolvers (same logic as command-handling-module.ts appendFn).
+ */
+export const append: AppendFunction = ((
+  eventDescriptor: EventDescriptor<any>,
+  eventPayload: unknown,
+  eventMetadata?: Metadata,
+) => {
+  const state = requireInvocationPhase() // D-43 mutator guard
+  const events = computeIfAbsent(BUFFERED_EVENTS_KEY, () => [])
+  const tags = eventDescriptor.tags ? eventDescriptor.tags(eventPayload) : []
+  const eventMessage: EventMessage = {
+    identifier: generateIdentifier(),
+    name: eventDescriptor.name,
+    version: eventDescriptor.version,
+    payload: eventPayload,
+    metadata: eventMetadata ?? state.metadata, // fallback to UoW metadata when caller omits
+    timestamp: Date.now(),
+    tags,
+  }
+  events.push(eventMessage)
+
+  // Update cached state by applying matching evolvers.
+  // Verbatim copy of command-handling-module.ts:101-123 logic — moved here so
+  // both command-handling-module (via delegation) and direct module-level callers
+  // get identical behaviour.
+  const cache = getResource(STATE_CACHE_KEY)
+  const modules = getResource(STATE_MODULES_KEY)
+  if (cache && modules) {
+    const eventType = qualifiedNameToString(eventDescriptor.name)
+    for (const [cacheKey, { module, id }] of modules) {
+      const cachedPromise = cache.get(cacheKey)
+      if (!cachedPromise) continue
+      const evolvers = (module as any).evolvers as ReadonlyArray<{
+        descriptor: { name: any }
+        evolve: (s: any, e: any, id: any) => any
+      }> | undefined
+      if (!evolvers) continue
+      for (const evolver of evolvers) {
+        if (qualifiedNameToString(evolver.descriptor.name) === eventType) {
+          cache.set(
+            cacheKey,
+            cachedPromise.then((result: any) => ({
+              ...result,
+              state: evolver.evolve(result.state, eventPayload, id),
+            })),
+          )
+          break
+        }
+      }
+    }
+  }
+}) as AppendFunction

package/src/consistency-marker.ts

@@ -0,0 +1,43 @@
+import { resourceKey, type ResourceKey } from "@kronos-ts/common"
+
+/**
+ * An opaque marker representing a position in the event store.
+ * Used by append conditions to guarantee consistency —
+ * "no conflicting events were appended since this marker."
+ */
+export interface ConsistencyMarker {
+  readonly position: bigint
+}
+
+/** Marker representing the origin (before any events). */
+export const ORIGIN: ConsistencyMarker = { position: -1n }
+
+/** Marker representing infinity (no consistency check needed). */
+export const INFINITY: ConsistencyMarker = { position: BigInt(Number.MAX_SAFE_INTEGER) }
+
+/** Resource key for storing a ConsistencyMarker in a ProcessingContext. */
+export const MARKER_RESOURCE_KEY: ResourceKey<ConsistencyMarker> = resourceKey("consistencyMarker")
+
+export function noMarker(): ConsistencyMarker {
+  return ORIGIN
+}
+
+export function markerAt(position: bigint): ConsistencyMarker {
+  return { position }
+}
+
+/**
+ * Returns the lower bound of two markers — the most restrictive position.
+ * When checking consistency across multiple sourcing operations,
+ * use the lower bound to ensure no events are missed.
+ */
+export function markerLowerBound(a: ConsistencyMarker, b: ConsistencyMarker): ConsistencyMarker {
+  return a.position < b.position ? a : b
+}
+
+/**
+ * Returns the upper bound of two markers — the least restrictive position.
+ */
+export function markerUpperBound(a: ConsistencyMarker, b: ConsistencyMarker): ConsistencyMarker {
+  return a.position > b.position ? a : b
+}

package/src/event-sourced-repository.ts

@@ -0,0 +1,141 @@
+import { qualifiedNameToString } from "@kronos-ts/common"
+import type { EventMessage } from "@kronos-ts/messaging"
+import type { StateModule, StateRepository, LoadResult } from "@kronos-ts/modelling"
+import type { EventStore } from "./event-store.js"
+import { sourcingCondition } from "./sourcing-condition.js"
+import type { SnapshotStore, Snapshot } from "./snapshot-store.js"
+import type { SnapshotPolicy, EvolutionResult } from "./snapshot-policy.js"
+
+export interface EventSourcedRepositoryOptions<Id, S> {
+  state: StateModule<Id, S>
+  eventStore: EventStore
+  snapshotStore?: SnapshotStore
+  snapshotPolicy?: SnapshotPolicy
+}
+
+/**
+ * Creates a repository for a state module sourced from events.
+ *
+ * When `load(id)` is called, the repository:
+ * 1. Checks the snapshot store for a cached state (if configured)
+ * 2. Resolves the sourcing criteria from the state module + id
+ * 3. Sources matching events from the event store (from snapshot position if available)
+ * 4. Starts from snapshot state (or `create()`) and folds events through matching evolvers
+ * 5. Optionally creates a new snapshot if the policy triggers
+ * 6. Returns the state AND sourcing info (criteria + marker)
+ */
+export function createEventSourcedRepository<Id, S>(
+  module: StateModule<Id, S>,
+  eventStore: EventStore,
+  snapshotStore?: SnapshotStore,
+  snapshotPolicy?: SnapshotPolicy,
+): StateRepository<Id, S> {
+  async function doLoad(id: Id): Promise<LoadResult<S>> {
+    const startTime = performance.now()
+    const criteria = module.criteria(id)
+
+    // Try to load snapshot
+    let state = module.create(id)
+    let startPosition: bigint | undefined
+    let snapshot: Snapshot | undefined
+
+    if (snapshotStore) {
+      try {
+        snapshot = await snapshotStore.load(module.name, id)
+        if (snapshot) {
+          state = snapshot.payload as S
+          // Source events AFTER the snapshot position
+          startPosition = snapshot.position + 1n
+        }
+      } catch (err) {
+        console.warn(`Failed to load snapshot for ${module.name}:${String(id)}, falling back to full replay:`, err)
+        // Fall back to full replay from the beginning
+      }
+    }
+
+    const condition = sourcingCondition(criteria, startPosition)
+    const { events, marker } = await eventStore.source(condition)
+
+    const lifecycle = module.lifecycle
+    let isFirstEvent = !snapshot // first event only if no snapshot
+    let wasDeleted = lifecycle?.isDeleted?.(state) ?? false
+
+    let eventsApplied = 0
+    for (const event of events) {
+      const previousState = state
+      state = await applyEvent(module, state, event, id)
+      eventsApplied++
+
+      // Lifecycle hooks
+      if (lifecycle && state !== previousState) {
+        // onCreate: first event transitions from initial state
+        if (isFirstEvent && eventsApplied === 1) {
+          await lifecycle.onCreate?.(state, id)
+        }
+
+        // onStateChange: after each evolving event
+        await lifecycle.onStateChange?.(previousState, state, event, id)
+
+        // onDelete: when isDeleted transitions from false to true
+        if (lifecycle.isDeleted) {
+          const nowDeleted = lifecycle.isDeleted(state)
+          if (nowDeleted && !wasDeleted) {
+            await lifecycle.onDelete?.(state, id)
+          }
+          wasDeleted = nowDeleted
+        }
+      }
+    }
+
+    const sourcingTimeMs = performance.now() - startTime
+
+    // Check if we should create a new snapshot (fire-and-forget)
+    if (snapshotStore && snapshotPolicy && eventsApplied > 0) {
+      const result: EvolutionResult = { eventsApplied, sourcingTimeMs }
+      if (snapshotPolicy.shouldSnapshot(result)) {
+        snapshotStore
+          .store(module.name, id, {
+            position: marker.position,
+            payload: state,
+            timestamp: Date.now(),
+            metadata: {},
+          })
+          .catch((err) => {
+            console.warn(`Failed to store snapshot for ${module.name}:${String(id)}:`, err)
+          })
+      }
+    }
+
+    return {
+      state,
+      sourcingInfo: {
+        criteria,
+        markerPosition: marker.position,
+      },
+    }
+  }
+
+  return {
+    stateName: module.name,
+    load: doLoad,
+    loadOrCreate: doLoad, // Same implementation — create() always provides initial state
+  }
+}
+
+async function applyEvent<Id, S>(
+  module: StateModule<Id, S>,
+  state: S,
+  event: EventMessage,
+  id: Id,
+): Promise<S> {
+  const eventType = qualifiedNameToString(event.name)
+
+  for (const evolver of module.evolvers) {
+    const evolverType = qualifiedNameToString(evolver.descriptor.name)
+    if (evolverType === eventType) {
+      return await evolver.evolve(state, event.payload, id)
+    }
+  }
+
+  return state
+}

package/src/event-storage-engine.ts

@@ -0,0 +1,69 @@
+import type { EventMessage, StreamableEventSource } from "@kronos-ts/messaging"
+import type { SourcingCondition } from "./sourcing-condition.js"
+import type { SourcingResult } from "./event-store.js"
+import type { AppendCondition } from "./append-condition.js"
+import type { ConsistencyMarker } from "./consistency-marker.js"
+
+/**
+ * A transactional handle for an append operation.
+ *
+ * The two-phase pattern allows the processing lifecycle to control when
+ * events become visible:
+ *
+ * 1. {@link appendEvents} stages events and returns an AppendTransaction
+ * 2. {@link commit} makes events visible to consumers
+ * 3. {@link afterCommit} returns the consistency marker
+ * 4. {@link rollback} discards staged events on failure
+ */
+export interface AppendTransaction {
+  /** Make appended events visible to consumers. */
+  commit(): Promise<void>
+  /** Get the consistency marker after a successful commit. */
+  afterCommit(): Promise<ConsistencyMarker>
+  /** Discard staged events. */
+  rollback(): void
+}
+
+/**
+ * Infrastructure-level abstraction for event persistence.
+ *
+ * This is the raw storage mechanism — append, source, and stream events.
+ * Database extensions (drizzle, knex, prisma, etc.) implement this interface
+ * to provide persistent event storage.
+ *
+ * Not intended for direct use by application code. The {@link EventStore}
+ * composes an EventStorageEngine with event distribution (EventSink) and
+ * tag resolution (TagResolver).
+ */
+export interface EventStorageEngine extends StreamableEventSource {
+  /**
+   * Source events matching the given condition (criteria-based, for state sourcing).
+   * Returns the matching events and a consistency marker.
+   */
+  source(condition: SourcingCondition): Promise<SourcingResult>
+
+  /**
+   * Append events to the store.
+   * If an append condition is provided, the engine verifies that no conflicting
+   * events were written since the marker before appending.
+   *
+   * Returns an {@link AppendTransaction} for two-phase commit control.
+   * For simple cases, use the convenience form that auto-commits:
+   * ```typescript
+   * const marker = await store.append(events, condition)
+   * ```
+   */
+  appendEvents(
+    events: ReadonlyArray<EventMessage>,
+    condition?: AppendCondition,
+  ): Promise<AppendTransaction>
+
+  /**
+   * Convenience method that appends events and auto-commits in one step.
+   * Equivalent to calling appendEvents() followed by commit() and afterCommit().
+   */
+  append(
+    events: ReadonlyArray<EventMessage>,
+    condition?: AppendCondition,
+  ): Promise<ConsistencyMarker>
+}

package/src/event-store-transaction.ts

@@ -0,0 +1,58 @@
+import type { EventMessage } from "@kronos-ts/messaging"
+
+/**
+ * A transaction scope for event store operations within a UnitOfWork.
+ *
+ * Events are buffered during the transaction and only persisted when
+ * the UnitOfWork commits. The `onAppend` hook enables state cache
+ * updates as events are buffered (before persistence).
+ */
+export interface EventStoreTransaction {
+  /**
+   * Buffer an event for append. The event is not yet persisted —
+   * it will be written to the store at PREPARE_COMMIT.
+   */
+  appendEvent(event: EventMessage): void
+
+  /**
+   * Register a callback invoked each time an event is buffered via `appendEvent`.
+   * Used by the state cache to apply events to cached state immediately,
+   * keeping the cache consistent within the same UnitOfWork.
+   */
+  onAppend(callback: (event: EventMessage) => void): void
+
+  /**
+   * Get all buffered events (not yet committed).
+   */
+  readonly bufferedEvents: ReadonlyArray<EventMessage>
+}
+
+/**
+ * Creates an EventStoreTransaction that buffers events and notifies
+ * registered callbacks.
+ */
+export function createEventStoreTransaction(): EventStoreTransaction {
+  const events: EventMessage[] = []
+  const appendCallbacks: Array<(event: EventMessage) => void> = []
+
+  return {
+    appendEvent(event: EventMessage): void {
+      events.push(event)
+      for (const callback of appendCallbacks) {
+        try {
+          callback(event)
+        } catch (e) {
+          console.warn("EventStoreTransaction: onAppend callback threw an exception:", e)
+        }
+      }
+    },
+
+    onAppend(callback: (event: EventMessage) => void): void {
+      appendCallbacks.push(callback)
+    },
+
+    get bufferedEvents(): ReadonlyArray<EventMessage> {
+      return events
+    },
+  }
+}

package/src/event-store.ts

@@ -0,0 +1,26 @@
+import type { EventMessage, EventBus } from "@kronos-ts/messaging"
+import type { EventStorageEngine } from "./event-storage-engine.js"
+import type { ConsistencyMarker } from "./consistency-marker.js"
+
+/**
+ * Result of sourcing events — the events plus a consistency marker
+ * representing the position up to which events were read.
+ */
+export interface SourcingResult {
+  readonly events: ReadonlyArray<EventMessage>
+  readonly marker: ConsistencyMarker
+}
+
+/**
+ * The event store — dual-role component that combines event storage
+ * with event distribution.
+ *
+ * Extends:
+ * - `EventStorageEngine` — raw storage (source, append, stream)
+ * - `EventBus` — event publication + push-based subscription
+ *
+ * In an event sourcing context, the EventStore persists events durably while
+ * simultaneously distributing them to subscribed event handlers, eliminating
+ * the need for a separate EventBus component.
+ */
+export interface EventStore extends EventStorageEngine, EventBus {}