@ossy/event-store 1.8.2 → 3.0.1

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/ensure-indexes.js

@@ -0,0 +1,41 @@
+import { createLogger } from '@ossy/observability'
+import { Mongo, withMongoReconnect } from './mongodb.js'
+
+const log = createLogger('event-store')
+
+let ensured = false
+
+/**
+ * Ensure MongoDB indexes required for aggregate/event-stream reads.
+ * Without `{ resourceId, version }` on `eventstore`, every `getResourceStream`
+ * call scans the full collection — sign-up and changestream rebuilds deadlock under load.
+ */
+export async function ensureEventStoreIndexes () {
+  if (ensured) return
+
+  await withMongoReconnect(async () => {
+    const eventstore = Mongo.db.collection('eventstore')
+    await eventstore.createIndex(
+      { resourceId: 1, version: 1 },
+      { name: 'resourceId_version', background: true },
+    )
+
+    const aggregates = Mongo.db.collection('aggregates')
+    await aggregates.createIndex(
+      { id: 1 },
+      { name: 'aggregate_id', unique: true, background: true },
+    )
+    await aggregates.createIndex(
+      { type: 1, 'state.email': 1 },
+      { name: 'type_state_email', background: true, sparse: true },
+    )
+  })
+
+  ensured = true
+  log.info('[ensure-indexes] eventstore and aggregates indexes ready')
+}
+
+/** @internal test helper */
+export function resetEnsureIndexesForTests () {
+  ensured = false
+}

package/src/ensure-indexes.spec.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from '@jest/globals'
+import { ensureEventStoreIndexes, resetEnsureIndexesForTests } from './ensure-indexes.js'
+
+describe('ensureEventStoreIndexes', () => {
+  it('is exported and idempotent flag resets in tests', () => {
+    expect(typeof ensureEventStoreIndexes).toBe('function')
+    resetEnsureIndexesForTests()
+  })
+})

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,9 @@
 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'
+export { ensureEventStoreIndexes, resetEnsureIndexesForTests } from './ensure-indexes.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 },
+      ),
+    )
+  }
+}