@ossy/event-store 1.8.2 → 1.8.3

package/README.md

@@ -1,46 +1,59 @@
 # @ossy/event-store
 
-Event sourcing primitives for the Ossy platform. Provides `Aggregate` (stream interaction), `EventStore` (raw event I/O), and `AggregateRebuild` (startup snapshot rebuilding) on top of MongoDB.
+Event sourcing primitives for the Ossy platform. Provides `Aggregate` (ADR 0008 entity streams), `EventStore` (resource event I/O), `ProjectionRebuild` / `getProjection` (derived read models), `PushInvalidation` (SSE cache invalidation), and `AggregateRebuild` (startup snapshot rebuilding) on top of MongoDB.
+
+## Exports
+
+| Export | Module | Purpose |
+|--------|--------|---------|
+| `Mongo` | `mongodb.js` | Connect to MongoDB |
+| `Aggregate` | `aggregate.js` | Entity stream facade (delegates to `SchemaStream`) |
+| `SchemaStream` | `schema-stream.js` | Low-level ADR 0008 entity stream I/O |
+| `EventStore` | `event-store.js` | Append and query resource events |
+| `AggregateRebuild` | `aggregate-rebuild.js` | Startup snapshot rebuild for entities and resources |
+| `ProjectionRebuild` | `projection-rebuild.js` | Incremental and full projection rebuild |
+| `getProjection` | `projection-queries.js` | Read a projection snapshot by scope |
+| `PushInvalidation` | `push-invalidation.js` | Workspace-scoped SSE fan-out |
+| `buildInvalidationKeys`, `buildPushMessage` | `push-invalidation.js` | Derive client cache keys from events |
 
 ## Core concepts
 
 The event store keeps two MongoDB collections:
 
-- **`eventstore`** — every event ever appended. Immutable. Each document is one domain event with `aggregateId`, `aggregateType`, `aggregateVersion`, `type`, `payload`, `created`, and `createdBy`.
-- **`aggregates`** — denormalized state snapshots, rebuilt from the event stream. Used for fast queries. Rebuilt automatically at startup and kept up-to-date as new events arrive.
+- **`eventstore`** — every resource/entity event ever appended. Immutable. ADR 0008 documents use `type` (schema id), `resourceId`, `event` (lifecycle name), `version`, `payload`, `created`, and `createdBy`.
+- **`aggregates`** — denormalized state snapshots: entity/resource folds keyed by `id`, and projection snapshots keyed by `{ id: scopeId, type: projectionId, kind: 'projection' }`. Rebuilt at startup and updated on the changestream.
 
 ---
 
 ## `Aggregate`
 
-The main entry point for reading and writing event streams. All methods return Promises and are chainable with `.then()`.
+Facade over `SchemaStream` for entity aggregates that declare `static SchemaId`. All methods return Promises.
 
 ### Reading the current state
 
 ```js
 import { Aggregate } from '@ossy/event-store'
-import { Order } from '@acme/orders'
+import { User } from '@ossy/users/server'
 
-// Fold all events for `orderId` through Order.View() and return the result
-const state = await Aggregate.Of(Order, orderId).then(Aggregate.View())
+const state = await Aggregate.Of(User, userId).then(Aggregate.View())
 ```
 
-### Creating a new aggregate
+### Creating a new entity
 
-Pass an event object as the identifier. The event is appended and the new aggregate is returned.
+Pass a creation event as the identifier. The event is appended and the stream is returned.
 
 ```js
-const newOrderEvent = { type: 'OrderPlaced', createdBy: userId, payload: { ... } }
-const orderView = await Aggregate.Of(Order, newOrderEvent).then(Aggregate.View())
+const createdEvent = UsersEvents.Created({ email, firstName, lastName })
+const userView = await Aggregate.Of(User, createdEvent).then(Aggregate.View())
 ```
 
-An `aggregateId` inside the event is used as the aggregate's id; if absent, a `nanoid()` is generated.
+`resourceId` in the event is the entity id; if absent, the event factory generates one.
 
-### Appending an event to an existing aggregate
+### Appending to an existing entity
 
 ```js
-await Aggregate.Of(Order, orderId)
-  .then(Aggregate.Add({ type: 'OrderShipped', createdBy: userId, payload: { shippedAt: Date.now() } }))
+await Aggregate.Of(User, userId)
+  .then(Aggregate.Add(UsersEvents.NameUpdated({ firstName, lastName, createdBy: userId })))
   .then(Aggregate.Save())
 ```
 
@@ -48,117 +61,113 @@ await Aggregate.Of(Order, orderId)
 
 | Method | Signature | Description |
 |---|---|---|
-| `Aggregate.Of(Root, id)` | `(class, string) => Promise<Aggregate>` | Load an existing aggregate from the event store. |
-| `Aggregate.Of(Root, event)` | `(class, object) => Promise<Aggregate>` | Create a new aggregate by appending the first event. |
-| `Aggregate.Add(event)` | `(event) => (aggregate) => Promise<Aggregate>` | Append an event to the aggregate. Chainable. |
-| `Aggregate.Save()` | `() => (aggregate) => Promise<void>` | Persist the current state snapshot to the `aggregates` collection. |
-| `Aggregate.View(fn?)` | `(fn?) => (aggregate) => state` | Call the aggregate's `View(events, savedState)` and return the result. Pass a custom view function to override. |
-| `Aggregate.Validate(fn)` | `(fn) => (aggregate) => Promise<Aggregate>` | Run a validation function against `(events, savedState)`. Reject if the function throws. |
-| `Aggregate.Find(id)` | `(string) => Promise<object \| null>` | Low-level: find the snapshot document in `aggregates` by id. |
+| `Aggregate.Of(Root, id)` | `(class, string) => Promise<Stream>` | Load an entity stream by `resourceId`. |
+| `Aggregate.Of(Root, event)` | `(class, object) => Promise<Stream>` | Create a new entity by appending the first event. |
+| `Aggregate.Add(event)` | `(event) => (stream) => Promise<Stream>` | Append an event. Chainable. |
+| `Aggregate.Save()` | `() => (stream) => Promise<void>` | Persist the folded snapshot to `aggregates`. |
+| `Aggregate.View(fn?)` | `(fn?) => (stream) => state` | Fold events through the aggregate `View` reducer. |
+| `Aggregate.Validate(fn)` | `(fn) => (stream) => Promise<Stream>` | Run validation against `(events, savedState)`. |
+| `Aggregate.Find(id)` | `(string) => Promise<object \| null>` | Find a snapshot document in `aggregates` by id. |
 | `Aggregate.Collection` | `Collection` | Direct access to the MongoDB `aggregates` collection. |
 
+Entity aggregate classes require `static SchemaId` (ADR 0008). Resource documents use `@ossy/resources` `commitResource` / `mutateResource` instead.
+
 ---
 
-## Writing an aggregate class
+## `EventStore`
 
-An aggregate class is a pure reducer — no side effects, no I/O. It declares a `static AggregateType` string and a `static View(events, savedState)` function.
+Low-level access to the `eventstore` collection.
 
 ```js
-// src/order.aggregate.js  (inside an installable package)
-export class Order {
-  static AggregateType = 'Order'
-
-  /**
-   * Folds an array of events into the current state.
-   * @param {object[]} events    - Event documents in ascending version order.
-   * @param {object}   savedState - Last saved snapshot (can be empty object).
-   * @returns {object}
-   */
-  static View(events, savedState = {}) {
-    return events.reduce((state, event) => {
-      switch (event.type) {
-        case 'OrderPlaced':
-          return { ...state, id: event.aggregateId, status: 'pending', ...event.payload }
-        case 'OrderShipped':
-          return { ...state, status: 'shipped', shippedAt: event.created }
-        case 'OrderCancelled':
-          return { ...state, status: 'cancelled' }
-        default:
-          return state
-      }
-    }, savedState)
-  }
-}
-
-// Required exports for the *.aggregate.js primitive
-export { Order as Aggregate }
-export const id = 'Order'  // must equal Order.AggregateType
+import { EventStore } from '@ossy/event-store'
 ```
 
-> Aggregate files must be in an **installable package** (a `node_modules/` package with `"ossy": { "src": "./src" }` in `package.json`). The platform never loads aggregates from the local app's `src/` to avoid duplicates.
+| Method | Signature | Description |
+|---|---|---|
+| `EventStore.AppendResourceEvent(event)` | `(object) => Promise<object>` | Insert an ADR 0008 event document. |
+| `EventStore.GetResourceStream({ resourceId, fromVersion? })` | `=> Promise<object[]>` | Events for one `resourceId`, optionally after a version. |
+| `EventStore.GetResourceStreams()` | `=> Promise<{ resourceId, type }[]>` | All known `(resourceId, schemaId)` pairs. |
+| `EventStore.FindEvent(query)` | `(MongoQuery) => Promise<object>` | Find a single event. Rejects when not found. |
+| `EventStore.FindEvents(query)` | `(MongoQuery) => Promise<object[]>` | Find multiple events. Rejects when none found. |
+| `EventStore.Aggregate(pipeline)` | `(Pipeline) => Promise<object[]>` | Run a MongoDB aggregation pipeline. |
+| `EventStore.Collection` | `Collection` | Direct access to the `eventstore` collection. |
 
 ---
 
-## `EventStore`
+## Projections
 
-Low-level access to the `eventstore` collection. Prefer using `Aggregate` for most work.
+Projection aggregates (`kind: 'projection'`) fold resource events into scope-keyed read models (e.g. workspace booking list).
 
 ```js
-import { EventStore } from '@ossy/event-store'
+import { getProjection } from '@ossy/event-store'
+
+const list = await getProjection(workspaceId, '@ossy/booking/data/booking-list')
 ```
 
-| Method | Signature | Description |
-|---|---|---|
-| `EventStore.AppendEvent(event)` | `(object) => Promise<object>` | Insert an event document. Rejects on failure. |
-| `EventStore.GetEventStream({ aggregateId, fromVersion? })` | `=> Promise<object[]>` | Return all events for an aggregate id, optionally after a version. |
-| `EventStore.GetEventStreams()` | `=> Promise<{ aggregateId, aggregateType }[]>` | Return all known `(aggregateId, aggregateType)` pairs. |
-| `EventStore.FindEvent(query)` | `(MongoQuery) => Promise<object>` | Find a single event. Rejects when not found. |
-| `EventStore.FindEvents(query)` | `(MongoQuery) => Promise<object[]>` | Find multiple events. Rejects when none found. |
-| `EventStore.Aggregate(pipeline)` | `(Pipeline) => Promise<object[]>` | Run a MongoDB aggregation pipeline against the event store. |
-| `EventStore.Collection` | `Collection` | Direct access to the MongoDB `eventstore` collection. |
+| API | Description |
+|-----|-------------|
+| `ProjectionRebuild.registerProjection({ id, Aggregate })` | Register a projection class (also called via `AggregateRebuild.registerAggregate` when `kind === 'projection'`) |
+| `ProjectionRebuild.dispatch(event)` | Apply one changestream event to matching projections |
+| `ProjectionRebuild.rebuildAll()` | Replay source events at startup (called from `AggregateRebuild.BuildAndSaveAll()`) |
+
+Projection classes declare `static sources`, `static scopeFromEvent(event)`, `static Apply(event, state)`, and optionally `static cacheKeys(scopeId, event)`.
+
+---
+
+## Push invalidation (ADR 0008 §9)
+
+After changestream rebuild, `PushInvalidation.publish(event)` fans out SSE messages to workspace subscribers.
+
+- **Server:** `GET /events` (workspace-scoped via `workspaceId` header or user settings cookie)
+- **Client:** `sdk.subscribePush({ onMessage })` — `WorkspaceProvider` invalidates read-cache keys automatically
+- **Keys:** `resource:{id}`, `location:{path}`, `projection:{id}:{scopeId}`, `action:{actionId}`
+
+Use `buildInvalidationKeys(event)` to derive keys server-side; `buildPushMessage(event)` wraps them for SSE payloads. Projection aggregates may define `static cacheKeys(scopeId, event)` for bespoke list-action keys.
 
 ---
 
 ## `AggregateRebuild`
 
-Rebuilds state snapshots from scratch at startup. Called automatically by `@ossy/platform` — you rarely need to use this directly.
+Rebuilds entity/resource snapshots from scratch at startup. Called automatically by `@ossy/platform`.
 
 ```js
 import { AggregateRebuild } from '@ossy/event-store'
 
-// Register an aggregate class (done automatically by the platform)
-AggregateRebuild.registerAggregate({ id: 'Order', Aggregate: Order })
-
-// Rebuild and save every known aggregate of every registered type
+AggregateRebuild.registerAggregate({ id: 'User', Aggregate: User })
 await AggregateRebuild.BuildAndSaveAll()
-
-// Rebuild a single aggregate
-await AggregateRebuild.BuildAndSave('Order', orderId)
 ```
 
+`registerAggregate` routes projection modules (`Aggregate.kind === 'projection'`) to `ProjectionRebuild`. Entity classes are indexed by `Aggregate.SchemaId` for resource rebuilds.
+
 ---
 
 ## `*.aggregate.js` primitive
 
-The platform auto-discovers aggregate files from installed packages. See [PRIMITIVES.md](../platform/PRIMITIVES.md#aggregate) for the full specification.
+The platform auto-discovers aggregate files from installed packages. Entity aggregates export `{ id, Aggregate }` with `Aggregate.SchemaId`; projection aggregates set `Aggregate.kind = 'projection'`. See [PRIMITIVES.md](../platform/PRIMITIVES.md#aggregate).
 
 ---
 
 ## MongoDB setup
 
-Connect to MongoDB before using any `Aggregate` or `EventStore` methods:
-
 ```js
 import { Mongo } from '@ossy/event-store'
 
 await Mongo.connect(process.env.DB_URL)
 ```
 
-The platform server calls `Mongo.connect` automatically when `DB_URL` is present in the environment.
-
-Indexes recommended for the `eventstore` collection:
+Recommended indexes for `eventstore`:
 
 ```js
-{ aggregateId: 1, aggregateVersion: 1 }  // stream queries
-{ aggregateType: 1 }                      // type-level queries
+{ resourceId: 1, version: 1 }  // stream queries
+{ type: 1, event: 1 }          // projection replay / task triggers
+```
+
+---
+
+## Testing
+
+```bash
+npm test -w @ossy/event-store
 ```
+
+Runs unit tests for push invalidation key derivation (`push-invalidation.spec.js`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -19,16 +19,23 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "keywords": [],
+  "scripts": {
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --verbose"
+  },
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/observability": "^1.8.2",
+    "@ossy/fold": "^1.0.1",
+    "@ossy/observability": "^1.8.3",
     "mongodb": "^7.2.0",
     "nanoid": "^5.1.11"
   },
+  "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "jest": "^30.2.0"
+  },
   "files": [
     "src"
   ],
-  "gitHead": "2b8745d57fee8b6c08787e2755b4df489291a5cd"
+  "gitHead": "a0d89185a17f8de8ce328c3a648c108ff1d61d8f"
 }

package/src/aggregate-rebuild.js

@@ -1,65 +1,82 @@
-import { Aggregate } from './aggregate.js'
-import { EventStore } from './event-store.js'
+import { EventStore, getResourceStream } from './event-store.js'
+import { SchemaStream } from './schema-stream.js'
+import { ProjectionRebuild } from './projection-rebuild.js'
+import { withMongoReconnect } from './mongodb.js'
+import { createDefaultReducer } from '@ossy/fold'
 import { createLogger } from '@ossy/observability'
 
 const log = createLogger('event-store')
 
 export class AggregateRebuild {
 
-    /** @type {Record<string, Function>} */
-    static _aggregateMap = {}
+  /** @type {Record<string, Function>} */
+  static _aggregateMap = {}
 
-    /**
-     * Registers a pre-loaded aggregate module. Called by the platform server at
-     * startup for each aggregate entry in the manifest, following the same pattern
-     * as task and resource-template registration.
-     *
-     * @param {{ id: string, Aggregate: Function }} mod - The aggregate bundle module.
-     */
-    static registerAggregate(mod) {
-        const { id, Aggregate: AggregateClass } = mod
-        if (typeof AggregateClass !== 'function' || !id) {
-            log.warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
-            return
-        }
-        AggregateRebuild._aggregateMap[id] = AggregateClass
-        log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
+  /** @type {Record<string, Function>} */
+  static _schemaMap = {}
+
+  /**
+   * @param {{ id: string, Aggregate: Function }} mod
+   */
+  static registerAggregate (mod) {
+    const { id, Aggregate: AggregateClass } = mod
+    if (typeof AggregateClass !== 'function' || !id) {
+      log.warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
+      return
+    }
+    AggregateRebuild._aggregateMap[id] = AggregateClass
+    if (AggregateClass.SchemaId) {
+      AggregateRebuild._schemaMap[AggregateClass.SchemaId] = AggregateClass
+    }
+    if (AggregateClass.kind === 'projection') {
+      ProjectionRebuild.registerProjection(mod)
+      return
     }
+    log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
+  }
 
-    static async BuildAndSave(aggregateType, aggregateId) {
-        const AggregateRoot = AggregateRebuild._aggregateMap[aggregateType]
+  static async BuildAndSaveResource (resourceId, schemaId) {
+    const AggregateRoot = schemaId ? AggregateRebuild._schemaMap[schemaId] : null
+    const snapshot = await SchemaStream.Find(resourceId)
+    const events = await getResourceStream({ resourceId, fromVersion: 0 })
 
-        if (!AggregateRoot) {
-            log.debug(`[AggregateRebuild][BuildAndSave] Skipping unregistered aggregate type: ${aggregateType}`)
-            return
-        }
+    if (!events.length && !snapshot) return
 
-        return Aggregate.Of(AggregateRoot, aggregateId)
-            .then(Aggregate.Save())
-    }
+    const state = AggregateRoot
+      ? AggregateRoot.View(events, snapshot?.state)
+      : createDefaultReducer()(events, snapshot?.state)
 
-    static async BuildAndSaveAll() {
-        log.debug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
+    const type = schemaId ?? state.type ?? events[0]?.type
+    const version = events[events.length - 1]?.version ?? snapshot?.version ?? 0
 
-        const knownTypes = new Set(Object.keys(AggregateRebuild._aggregateMap))
+    return withMongoReconnect(() =>
+      SchemaStream.Collection.updateOne(
+        { id: resourceId },
+        { $set: { id: resourceId, version, type, state } },
+        { upsert: true },
+      ),
+    )
+  }
 
-        if (knownTypes.size === 0) {
-            log.warn('[AggregateRebuild][BuildAndSaveAll] No aggregates registered — skipping rebuild')
-            return
-        }
+  static async BuildAndSaveAll () {
+    log.debug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
 
-        return EventStore.GetEventStreams()
-            .then(streams => Promise.allSettled(
-                streams
-                    .filter(({ aggregateType }) => knownTypes.has(aggregateType))
-                    .map(({ aggregateType, aggregateId }) => AggregateRebuild.BuildAndSave(aggregateType, aggregateId))
-            ))
-            .then(results => {
-                const failed = results.filter(result => result.status === 'rejected')
-                const success = results.filter(result => result.status === 'fulfilled')
-                log.info('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
-                log.info(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
-                log.info(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
-            })
+    if (Object.keys(AggregateRebuild._schemaMap).length === 0) {
+      log.warn('[AggregateRebuild][BuildAndSaveAll] No schema aggregates registered — skipping rebuild')
+      return
     }
+
+    return EventStore.GetResourceStreams()
+      .then(streams => Promise.allSettled(
+        streams.map(({ resourceId, type }) => AggregateRebuild.BuildAndSaveResource(resourceId, type)),
+      ))
+      .then(async results => {
+        await ProjectionRebuild.rebuildAll()
+        const failed = results.filter(r => r.status === 'rejected')
+        const success = results.filter(r => r.status === 'fulfilled')
+        log.info('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
+        log.info(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
+        log.info(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
+      })
+  }
 }

package/src/aggregate-rebuild.task.js

@@ -1,13 +1,19 @@
-import { AggregateRebuild } from '@ossy/event-store'
+import { AggregateRebuild } from './aggregate-rebuild.js'
+
+/** Platform audit envelopes have no entity aggregate snapshot — handled inline on the changestream. */
+const PLATFORM_AUDIT_TYPES = [
+  '@ossy/platform/schema/task-run',
+  '@ossy/platform/schema/action-invocation',
+  '@ossy/platform/schema/meter-event',
+]
 
 export const metadata = {
-  id: 'aggregate-rebuild',
-  // Empty trigger matches all events. AggregateRebuild.BuildAndSave silently
-  // skips any aggregateType not registered in the manifest, so only events
-  // for known aggregate types result in a rebuild.
-  triggers: [{}]
+  id: '@ossy/event-store/tasks/aggregate-rebuild',
+  triggers: [{ excludeTypes: PLATFORM_AUDIT_TYPES }],
 }
 
 export async function run ({ event }) {
-  await AggregateRebuild.BuildAndSave(event.aggregateType, event.aggregateId)
+  if (!event?.resourceId) return
+
+  await AggregateRebuild.BuildAndSaveResource(event.resourceId, event.type)
 }

package/src/aggregate.js

@@ -1,157 +1,60 @@
 import { nanoid } from 'nanoid'
-import { Mongo, withMongoReconnect } from './mongodb.js'
-import { EventStore } from './event-store.js'
+import { SchemaStream } from './schema-stream.js'
 import { createLogger } from '@ossy/observability'
 
 const log = createLogger('event-store')
 
 /**
- * Utility class that helps interact with event streams.
- * Use this class if you want to create a new stream, add events to an existing stream or view streams.
- * @class
+ * ADR 0008 entity stream facade — all aggregates require `SchemaId`.
  */
 export class Aggregate {
 
-  static get Collection() {
-    return Mongo.db.collection('aggregates')
+  static get Collection () {
+    return SchemaStream.Collection
   }
 
-  /**
-   *  Start interacting with an event stream
-   *
-   * @param {Class} AggregateRoot - Root aggregate (class that aggregates the events)
-   * @param {string} id - Id of aggregate - aggregateId
-   * @return {Aggregate} - Instance of Aggregate
-   *
-   * @example
-   * Aggregate.Of(User, userId)
-   * Aggregate.Of(Workspace, workspaceId)
-   */
-  static Of(AggregateRoot, identifier) {
-
-    log.info(`[Aggregate][Of()][${AggregateRoot?.AggregateType}] Creating aggregate root`)
-
-    if (typeof identifier === 'string') {
-
-      return Aggregate.Find(identifier)
-        .then(aggregate => {
-          return EventStore.GetEventStream({ aggregateId: identifier, fromVersion: aggregate?.version })
-            .then(events => new Aggregate(AggregateRoot, identifier, events, aggregate))
-        })
+  static Of (AggregateRoot, identifier) {
+    if (!AggregateRoot?.SchemaId) {
+      return Promise.reject(new Error(
+        `[Aggregate] ${AggregateRoot?.AggregateType ?? 'Unknown'} missing SchemaId — use an ADR 0008 entity aggregate`,
+      ))
     }
 
-    if (typeof identifier === 'object') {
-      log.info('[Aggregate] Creating new aggregate event stream')
-      return Aggregate.Add(identifier)(new Aggregate(AggregateRoot, identifier.aggregateId || nanoid(), []))
+    if (typeof identifier === 'object' && identifier !== null) {
+      log.info(`[Aggregate][Of] Creating ${AggregateRoot.SchemaId}`)
+      const resourceId = identifier.resourceId ?? identifier.aggregateId ?? nanoid()
+      const event = {
+        ...identifier,
+        resourceId,
+        type: identifier.type ?? AggregateRoot.SchemaId,
+      }
+      return Promise.resolve(new SchemaStream(AggregateRoot, resourceId, [], null))
+        .then(SchemaStream.Add(event))
     }
 
-    log.error('[Aggregate] No recognizable identifier provided')
-    return Promise.reject()
+    log.info(`[Aggregate][Of] ${AggregateRoot.SchemaId}`)
+    return SchemaStream.Of(AggregateRoot, identifier)
   }
 
-  static Find(identifier) {
-    log.info(`[Aggregate][Find()] Fetching aggregate for ${identifier}`)
-    return withMongoReconnect(() => Aggregate.Collection.findOne({ id: identifier }))
-      .then(aggregate => {
-        if (!aggregate) {
-          log.debug(`[Aggregate][Find()] No aggregate found for ${identifier}`)
-        }
-        return aggregate
-      })
+  static Find (identifier) {
+    return SchemaStream.Find(identifier)
   }
 
-  static Add(event) {
-    return aggregate => {
-
-      return EventStore.AppendEvent({
-        ...event,
-        id: nanoid(),
-        created: Date.now(),
-        createdBy: event.createdBy,
-        aggregateType: aggregate.type,
-        aggregateId: aggregate.id,
-        aggregateVersion: aggregate.version + 1,
-      })
-      .then(savedEvent => {
-        aggregate.version = savedEvent.aggregateVersion,
-        aggregate.events = [...aggregate.events, savedEvent]
-        return aggregate
-      })
-    }
-
+  static Add (event) {
+    return stream => SchemaStream.Add(event)(stream)
   }
 
-  static Save() {
-    return aggregate => {
-      log.debug(`[Aggregate][Save] Saving state for ${aggregate.type} ${aggregate.id}`)
-
-      if (!aggregate.events || aggregate.events.length === 0) {
-        log.debug(`[Aggregate][Save] No events to save for ${aggregate.type} ${aggregate.id}`)
-        return Promise.resolve()
-      }
-
-      const latestEventVersion = [...aggregate.events].sort((a, b) => a.aggregateVersion - b.aggregateVersion).pop()?.aggregateVersion
-
-      if (latestEventVersion < aggregate.version) {
-        log.debug(`[Aggregate][Save] No new events to save for ${aggregate.type} ${aggregate.id}`)
-        return Promise.resolve()
-      }
-
-      const state = aggregate.View(aggregate.events, aggregate.state)
-
-      return withMongoReconnect(() =>
-        Aggregate.Collection.updateOne({ id: aggregate.id }, {
-          $set: {
-            id: aggregate.id,
-            version: latestEventVersion,
-            type: aggregate.type,
-            state: state
-          }
-        }, { upsert: true })
-      )
-        .catch(error => {
-          log.error(`[Aggregate][Save] Failed to save state for ${aggregate.type} ${aggregate.id}`, undefined, error)
-        })
-    }
-  }
-
-  static Validate(validator) {
-    return aggregate => Promise.resolve()
-      .then(() => validator(aggregate.events, aggregate.state))
-      .then(() => aggregate)
+  static Save () {
+    return stream => SchemaStream.Save()(stream)
   }
 
-  static View(view) {
-    return aggregate => {
-      log.debug(`[Aggregate][View] Building view for ${aggregate.type} ${aggregate.id}`)
-
-      if (typeof view === 'function') {
-        return view(aggregate.events, aggregate.state)
-      }
-
-      return aggregate.View(aggregate.events, aggregate.state)
-    }
-
+  static Validate (validator) {
+    return stream => Promise.resolve()
+      .then(() => validator(stream.events, stream.state))
+      .then(() => stream)
   }
 
-  /**
-   *  Use the Aggregate.Of(type, id) static method instead
-   *
-   * @param {string} id - Id of aggregate - aggregateId
-   * @param {string} root - root aggregate (class that aggregates the events)
-   * @param {Event[]} events - The events that make up the stream
-   * @param {Object} aggregate - The object representing the aggregate of all the events
-   */
-  constructor(AggregateRoot, id, events, aggregate) {
-    log.debug(`[Aggregate][Constructor] Assembling ${AggregateRoot.AggregateType} ${id}`)
-
-    this.id = id;
-    this.version = aggregate?.version || 0
-    this.type = AggregateRoot.AggregateType
-    this.events = events || []
-    this.state = aggregate?.state
-
-    this.View = AggregateRoot.View
+  static View (view) {
+    return stream => SchemaStream.View(view)(stream)
   }
-
 }

package/src/event-store.js

@@ -4,108 +4,101 @@ import { createLogger } from '@ossy/observability'
 const log = createLogger('event-store')
 
 /**
- * Database queries related to workspace events
+ * ADR 0008 resource event append.
+ *
+ * @param {object} event
+ * @returns {Promise<object>}
+ */
+export function appendResourceEvent (event) {
+  log.info('[EventStore] Appending resource event')
+  return withMongoReconnect(() => Mongo.db.collection('eventstore').insertOne(event))
+    .then(insertResult => (insertResult.acknowledged ? event : Promise.reject()))
+    .catch(error => {
+      log.error('[EventStore] Could not append resource event', undefined, error)
+      return Promise.reject(error)
+    })
+}
+
+/**
+ * @param {{ resourceId: string, fromVersion?: number }} opts
+ * @returns {Promise<object[]>}
+ */
+export function getResourceStream ({ resourceId, fromVersion = 0 }) {
+  const query = {
+    resourceId,
+    version: { $gt: fromVersion },
+  }
+  return withMongoReconnect(() =>
+    EventStore.Collection.find(query, { sort: { version: 1 } }).toArray(),
+  )
+}
+
+/**
+ * @returns {Promise<{ resourceId: string, type: string }[]>}
+ */
+export function getResourceStreams () {
+  return EventStore.Aggregate([
+    { $match: { resourceId: { $exists: true, $ne: null } } },
+    {
+      $group: {
+        _id: { resourceId: '$resourceId', type: '$type' },
+      },
+    },
+    {
+      $project: {
+        _id: 0,
+        resourceId: '$_id.resourceId',
+        type: '$_id.type',
+      },
+    },
+  ])
+}
+
+/**
  * @class
  */
 export class EventStore {
 
-  static get Collection() {
+  static get Collection () {
     return Mongo.db.collection('eventstore')
   }
 
-  static AppendEvent(event) {
-    log.info('[EventStore] Appending event')
-    log.debug('[EventStore] Event', { event })
+  static AppendResourceEvent (event) {
+    return appendResourceEvent(event)
+  }
 
-    return withMongoReconnect(() => EventStore.Collection.insertOne(event))
-      .then(insertResult => {
-        return insertResult.acknowledged
-          ? Promise.resolve(event)
-          : Promise.reject()
-      })
-      .catch(error => {
-        log.error('[EventStore] Could not append event', undefined, error)
-        return Promise.reject()
-      })
+  static GetResourceStream (opts) {
+    return getResourceStream(opts)
   }
 
-  static FindEvent(query) {
-    log.info('[EventStore] Searching for event')
-    log.debug('[EventStore] Query', { query })
+  static GetResourceStreams () {
+    return getResourceStreams()
+  }
 
+  static FindEvent (query) {
+    log.info('[EventStore] Searching for event')
     return withMongoReconnect(() => EventStore.Collection.findOne(query))
-      .then(event => !!event ? event : Promise.reject())
+      .then(event => (event ? event : Promise.reject()))
       .catch(error => {
         log.error('[EventStore] No event found', undefined, error)
-        return Promise.reject()
+        return Promise.reject(error)
       })
   }
 
-  static FindEvents(query) {
+  static FindEvents (query) {
     log.info('[EventStore] Searching for events')
-    log.debug('[EventStore] Query', { query })
-
     return withMongoReconnect(() =>
-      EventStore.Collection.find(query, { sort: { aggregateVersion: 1 } }).toArray()
+      EventStore.Collection.find(query, { sort: { version: 1, created: 1 } }).toArray(),
     )
-      .then(events => !!events?.length ? events : Promise.reject())
+      .then(events => (events?.length ? events : Promise.reject()))
       .catch(error => {
         log.error('[EventStore] No events found', undefined, error)
-        return Promise.reject()
-      })
-  }
-
-  static GetEventStream({
-    aggregateId,
-    fromVersion = 0
-  }) {
-    log.debug(`[EventStore][GetEventStream()] Fetching stream ${aggregateId} from version ${fromVersion}`)
-
-    const query = {
-      aggregateId: aggregateId,
-      aggregateVersion: { '$gt': fromVersion }
-    }
-
-    const options = {
-      sort: { aggregateVersion: 1 }
-    }
-
-    return withMongoReconnect(() => EventStore.Collection.find(query, options).toArray())
-      .then(events => {
-        log.debug(`[EventStore][GetEventStream()] Found ${events.length} events for ${aggregateId}`)
-        return events
-      })
-  }
-
-  static GetEventStreams() {
-    log.info('[EventStore][GetEventStreams()] Fetching event streams')
-
-    return EventStore.Aggregate([
-      {
-        '$group': {
-          '_id': {
-            'aggregateId': '$aggregateId',
-            'aggregateType': '$aggregateType'
-          }
-        }
-      },
-      {
-        '$project': {
-          '_id': 0,
-          'aggregateId': '$_id.aggregateId',
-          'aggregateType': '$_id.aggregateType'
-        }
-      }
-    ])
-      .then(result => {
-        log.debug(`[EventStore][GetEventStreams()] found ${result.length} streams`)
-        return result
+        return Promise.reject(error)
       })
   }
 
-  static Aggregate(pipeline) {
+  static Aggregate (pipeline) {
     log.info('[EventStore] Running aggregation pipeline')
-
     return withMongoReconnect(() => EventStore.Collection.aggregate(pipeline).toArray())
       .then(events => (Array.isArray(events) ? events : []))
       .catch(error => {
@@ -114,8 +107,7 @@ export class EventStore {
       })
   }
 
-  static CloseDbConnection() {
+  static CloseDbConnection () {
     return Mongo.closeConnection()
   }
-
 }

package/src/index.js

@@ -1,4 +1,8 @@
 export * from './mongodb.js'
 export * from './event-store.js'
 export * from './aggregate.js'
+export * from './schema-stream.js'
 export * from './aggregate-rebuild.js'
+export * from './projection-rebuild.js'
+export { getProjection } from './projection-queries.js'
+export { PushInvalidation, buildInvalidationKeys, buildPushMessage } from './push-invalidation.js'

package/src/projection-queries.js

@@ -0,0 +1,17 @@
+import { withMongoReconnect } from './mongodb.js'
+import { ProjectionRebuild } from './projection-rebuild.js'
+
+/**
+ * Load a projection snapshot by scope id and projection type id.
+ *
+ * @param {string} scopeId e.g. workspaceId
+ * @param {string} projectionId e.g. `@ossy/booking/data/booking-list`
+ * @returns {Promise<object | null>}
+ */
+export async function getProjection (scopeId, projectionId) {
+  if (!scopeId || !projectionId) return null
+  const doc = await withMongoReconnect(() =>
+    ProjectionRebuild.Collection.findOne({ id: scopeId, type: projectionId }),
+  )
+  return doc?.state ?? null
+}

package/src/projection-rebuild.js

@@ -0,0 +1,136 @@
+import { matchesSource } from '@ossy/fold'
+import { EventStore } from './event-store.js'
+import { Mongo, withMongoReconnect } from './mongodb.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('event-store')
+
+/**
+ * ADR 0008 projection aggregate rebuild — derived read models keyed by `scopeId`.
+ */
+export class ProjectionRebuild {
+
+  /** @type {Function[]} */
+  static _projections = []
+
+  /**
+   * @param {{ id: string, Aggregate: Function }} mod
+   */
+  static registerProjection (mod) {
+    const { Aggregate: ProjectionClass } = mod
+    if (ProjectionClass?.kind !== 'projection' || typeof ProjectionClass.Apply !== 'function') {
+      log.warn('[ProjectionRebuild] registerProjection: expected kind=projection with Apply()')
+      return
+    }
+    ProjectionRebuild._projections.push(ProjectionClass)
+    log.debug(`[ProjectionRebuild] Registered projection: ${mod.id ?? ProjectionClass.ProjectionId}`)
+  }
+
+  static get Collection () {
+    return Mongo.db.collection('aggregates')
+  }
+
+  static async dispatch (event) {
+    if (!event?.resourceId) return
+
+    for (const ProjectionClass of ProjectionRebuild._projections) {
+      const sources = ProjectionClass.sources ?? []
+      if (!sources.some(source => matchesSource(source, event))) continue
+
+      const scopeId = typeof ProjectionClass.scopeFromEvent === 'function'
+        ? ProjectionClass.scopeFromEvent(event)
+        : null
+      if (!scopeId) continue
+
+      try {
+        await ProjectionRebuild._applyOne(ProjectionClass, scopeId, event)
+      } catch (err) {
+        log.error(`[ProjectionRebuild] failed for ${ProjectionClass.ProjectionId}`, undefined, err)
+      }
+    }
+  }
+
+  /** Replay all matching events and rebuild projection snapshots (startup). */
+  static async rebuildAll () {
+    for (const ProjectionClass of ProjectionRebuild._projections) {
+      const sources = ProjectionClass.sources ?? []
+      if (!sources.length) continue
+
+      const orClauses = sources.map(s => {
+        const clause = { type: s.type, event: s.event }
+        return clause
+      })
+
+      const events = await EventStore.Collection.find({ $or: orClauses })
+        .sort({ created: 1, version: 1 })
+        .toArray()
+
+      const byScope = new Map()
+      for (const event of events) {
+        if (!sources.some(source => matchesSource(source, event))) continue
+        const scopeId = ProjectionClass.scopeFromEvent?.(event)
+        if (!scopeId) continue
+        if (!byScope.has(scopeId)) byScope.set(scopeId, [])
+        byScope.get(scopeId).push(event)
+      }
+
+      for (const [scopeId, scopeEvents] of byScope) {
+        let state = ProjectionClass.initialState?.(scopeId) ?? {}
+        for (const event of scopeEvents) {
+          state = ProjectionClass.Apply(event, state) ?? state
+        }
+        const version = scopeEvents.length
+        const last = scopeEvents[scopeEvents.length - 1]
+        const cursor = last ? { eventId: last.id, eventVersion: last.version } : null
+
+        await withMongoReconnect(() =>
+          ProjectionRebuild.Collection.updateOne(
+            { id: scopeId, type: ProjectionClass.ProjectionId },
+            {
+              $set: {
+                id: scopeId,
+                type: ProjectionClass.ProjectionId,
+                kind: 'projection',
+                version,
+                state: { ...state, version, cursor },
+              },
+            },
+            { upsert: true },
+          ),
+        )
+      }
+
+      log.info(`[ProjectionRebuild] Rebuilt ${ProjectionClass.ProjectionId} (${byScope.size} scopes)`)
+    }
+  }
+
+  static async _applyOne (ProjectionClass, scopeId, event) {
+    const projectionId = ProjectionClass.ProjectionId
+    const snapshot = await withMongoReconnect(() =>
+      ProjectionRebuild.Collection.findOne({ id: scopeId, type: projectionId }),
+    )
+
+    const state = snapshot?.state ?? ProjectionClass.initialState?.(scopeId) ?? {}
+    const next = ProjectionClass.Apply(event, state)
+    if (!next) return
+
+    const version = (snapshot?.version ?? 0) + 1
+    const cursor = { eventId: event.id, eventVersion: event.version }
+
+    await withMongoReconnect(() =>
+      ProjectionRebuild.Collection.updateOne(
+        { id: scopeId, type: projectionId },
+        {
+          $set: {
+            id: scopeId,
+            type: projectionId,
+            kind: 'projection',
+            version,
+            state: { ...next, version, cursor },
+          },
+        },
+        { upsert: true },
+      ),
+    )
+  }
+}

package/src/push-invalidation.js

@@ -0,0 +1,130 @@
+import { matchesSource } from '@ossy/fold'
+import { ProjectionRebuild } from './projection-rebuild.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('event-store')
+
+function normalizeLocation (loc) {
+  if (loc == null || loc === '') return '/'
+  const trimmed = String(loc).replace(/^\/+|\/+$/g, '')
+  return trimmed ? `/${trimmed}/` : '/'
+}
+
+/**
+ * ADR 0008 §9 — derive client cache keys from a resource event.
+ *
+ * @param {object} event eventstore document
+ * @returns {string[]}
+ */
+export function buildInvalidationKeys (event) {
+  if (!event?.resourceId) return []
+
+  const keys = new Set()
+  keys.add(`resource:${event.resourceId}`)
+
+  const location = event.payload?.location
+  if (typeof location === 'string' && location.length > 0) {
+    keys.add(`location:${normalizeLocation(location)}`)
+  }
+
+  const parentLocation = event.payload?.parentLocation
+  if (typeof parentLocation === 'string' && parentLocation.length > 0) {
+    keys.add(`location:${normalizeLocation(parentLocation)}`)
+  }
+
+  for (const ProjectionClass of ProjectionRebuild._projections) {
+    const sources = ProjectionClass.sources ?? []
+    if (!sources.some(source => matchesSource(source, event))) continue
+
+    const scopeId = ProjectionClass.scopeFromEvent?.(event)
+    if (!scopeId) continue
+
+    const projectionKeys = typeof ProjectionClass.cacheKeys === 'function'
+      ? ProjectionClass.cacheKeys(scopeId, event)
+      : [`projection:${ProjectionClass.ProjectionId}:${scopeId}`]
+
+    for (const key of projectionKeys) {
+      if (key) keys.add(key)
+    }
+  }
+
+  return [...keys]
+}
+
+/**
+ * @param {object} event eventstore document
+ * @returns {object | null}
+ */
+export function buildPushMessage (event) {
+  if (!event?.resourceId) return null
+
+  const workspaceId = event.payload?.belongsTo ?? null
+  const invalidate = buildInvalidationKeys(event)
+  if (!invalidate.length) return null
+
+  return {
+    kind: 'resource.updated',
+    type: event.type,
+    resourceId: event.resourceId,
+    event: event.event,
+    version: event.version,
+    eventId: event.id,
+    scope: workspaceId ? { workspaceId } : {},
+    invalidate,
+  }
+}
+
+/**
+ * Workspace-scoped SSE fan-out for cache invalidation (ADR 0008 §9).
+ */
+export class PushInvalidation {
+
+  /** @type {Map<string, Set<Function>>} */
+  static _subscribers = new Map()
+
+  /**
+   * @param {string} workspaceId
+   * @param {(message: object) => void} send
+   * @returns {() => void}
+   */
+  static subscribe (workspaceId, send) {
+    if (!workspaceId) return () => {}
+
+    if (!PushInvalidation._subscribers.has(workspaceId)) {
+      PushInvalidation._subscribers.set(workspaceId, new Set())
+    }
+    const listeners = PushInvalidation._subscribers.get(workspaceId)
+    listeners.add(send)
+
+    return () => {
+      listeners.delete(send)
+      if (listeners.size === 0) {
+        PushInvalidation._subscribers.delete(workspaceId)
+      }
+    }
+  }
+
+  /**
+   * Publish invalidation after changestream rebuild.
+   *
+   * @param {object} event eventstore document
+   */
+  static publish (event) {
+    const message = buildPushMessage(event)
+    if (!message) return
+
+    const workspaceId = message.scope?.workspaceId
+    if (!workspaceId) return
+
+    const listeners = PushInvalidation._subscribers.get(workspaceId)
+    if (!listeners?.size) return
+
+    for (const send of listeners) {
+      try {
+        send(message)
+      } catch (err) {
+        log.warn('[PushInvalidation] listener failed', undefined, err)
+      }
+    }
+  }
+}

package/src/push-invalidation.spec.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from '@jest/globals'
+import { buildInvalidationKeys, buildPushMessage } from './push-invalidation.js'
+import { ProjectionRebuild } from './projection-rebuild.js'
+
+describe('push-invalidation', () => {
+  it('builds resource and location keys', () => {
+    const keys = buildInvalidationKeys({
+      resourceId: 'res1',
+      type: '@ossy/platform/schema/file',
+      event: 'Created',
+      payload: { location: '/docs/', belongsTo: 'ws1' },
+    })
+
+    expect(keys).toContain('resource:res1')
+    expect(keys).toContain('location:/docs/')
+  })
+
+  it('includes projection cache keys when projection matches', () => {
+    class TestProjection {
+      static kind = 'projection'
+      static ProjectionId = '@ossy/test/data/list'
+      static sources = [{ type: '@ossy/test/schema/item', event: 'Created' }]
+      static scopeFromEvent (event) { return event.payload?.belongsTo }
+      static cacheKeys (scopeId) {
+        return [`projection:@ossy/test/data/list:${scopeId}`, 'action:@ossy/test/actions/list']
+      }
+      static Apply () { return {} }
+    }
+
+    ProjectionRebuild._projections.push(TestProjection)
+
+    const keys = buildInvalidationKeys({
+      resourceId: 'item1',
+      type: '@ossy/test/schema/item',
+      event: 'Created',
+      payload: { belongsTo: 'ws9' },
+    })
+
+    expect(keys).toContain('projection:@ossy/test/data/list:ws9')
+    expect(keys).toContain('action:@ossy/test/actions/list')
+
+    ProjectionRebuild._projections.pop()
+  })
+
+  it('builds push message scoped to workspace', () => {
+    const message = buildPushMessage({
+      id: 'evt1',
+      resourceId: 'res1',
+      type: '@ossy/booking/schema/booking',
+      event: 'Patched',
+      version: 3,
+      payload: { belongsTo: 'ws1', location: '/@ossy/booking/' },
+    })
+
+    expect(message).toEqual(expect.objectContaining({
+      kind: 'resource.updated',
+      resourceId: 'res1',
+      version: 3,
+      eventId: 'evt1',
+      scope: { workspaceId: 'ws1' },
+    }))
+    expect(message.invalidate).toContain('resource:res1')
+  })
+})

package/src/schema-stream.js

@@ -0,0 +1,104 @@
+import { nanoid } from 'nanoid'
+import { EventStore, getResourceStream } from './event-store.js'
+import { Mongo, withMongoReconnect } from './mongodb.js'
+import { createLogger } from '@ossy/observability'
+
+const log = createLogger('event-store')
+
+/**
+ * ADR 0008 schema-backed entity stream — keyed by `resourceId`.
+ */
+export class SchemaStream {
+
+  static get Collection () {
+    return Mongo.db.collection('aggregates')
+  }
+
+  /**
+   * @param {Function} AggregateRoot aggregate class with `SchemaId` and `View`
+   * @param {string | object} identifier resourceId or Created event partial
+   */
+  static Of (AggregateRoot, identifier) {
+    if (typeof identifier === 'object' && identifier !== null) {
+      const resourceId = identifier.resourceId ?? identifier.aggregateId ?? nanoid()
+      return Promise.resolve(new SchemaStream(AggregateRoot, resourceId, [], null))
+    }
+
+    return SchemaStream.Find(identifier)
+      .then(snapshot =>
+        getResourceStream({ resourceId: identifier, fromVersion: snapshot?.version ?? 0 })
+          .then(events => new SchemaStream(AggregateRoot, identifier, events, snapshot)),
+      )
+  }
+
+  static Find (resourceId) {
+    return withMongoReconnect(() => SchemaStream.Collection.findOne({ id: resourceId }))
+  }
+
+  static Add (event) {
+    return stream => {
+      const version = stream.version + 1
+      const schemaId = event.type ?? stream.events[0]?.type ?? stream.AggregateRoot?.SchemaId
+      const saved = {
+        ...event,
+        type: schemaId,
+        id: nanoid(),
+        created: Date.now(),
+        resourceId: stream.id,
+        version,
+      }
+      return EventStore.AppendResourceEvent(saved)
+        .then(() => {
+          stream.version = version
+          stream.events = [...stream.events, saved]
+          return stream
+        })
+    }
+  }
+
+  static Save () {
+    return stream => {
+      if (!stream.events?.length) return Promise.resolve()
+
+      const latestVersion = stream.events[stream.events.length - 1]?.version ?? stream.version
+      const state = stream.AggregateRoot.View(stream.events, stream.state)
+      const schemaId = state.type ?? stream.events[0]?.type ?? stream.AggregateRoot.SchemaId
+
+      return withMongoReconnect(() =>
+        SchemaStream.Collection.updateOne(
+          { id: stream.id },
+          {
+            $set: {
+              id: stream.id,
+              version: latestVersion,
+              type: schemaId,
+              state,
+            },
+          },
+          { upsert: true },
+        ),
+      )
+        .then(() => stream)
+        .catch(err => {
+          log.error(`[SchemaStream] save failed for ${stream.id}`, undefined, err)
+          return Promise.reject(err)
+        })
+    }
+  }
+
+  static View (view) {
+    return stream => {
+      if (typeof view === 'function') return view(stream.events, stream.state)
+      return stream.AggregateRoot.View(stream.events, stream.state)
+    }
+  }
+
+  constructor (AggregateRoot, id, events, snapshot) {
+    this.AggregateRoot = AggregateRoot
+    this.id = id
+    this.version = snapshot?.version ?? 0
+    this.state = snapshot?.state
+    this.events = events ?? []
+    this.View = AggregateRoot.View
+  }
+}