@ossy/event-store 1.8.3 → 3.0.2

package/README.md

@@ -119,7 +119,7 @@ Projection classes declare `static sources`, `static scopeFromEvent(event)`, `st
 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
+- **Client:** `sdk.subscribePush({ onMessage })` — opt in via `PushInvalidationSubscriber` or `enablePushInvalidation` in app config (off by default; see [@ossy/sdk-react README](../sdk-react/README.md#push-invalidation))
 - **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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "1.8.3",
+  "version": "3.0.2",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -25,8 +25,8 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
-    "@ossy/fold": "^1.0.1",
-    "@ossy/observability": "^1.8.3",
+    "@ossy/fold": "^3.0.2",
+    "@ossy/observability": "^3.0.2",
     "mongodb": "^7.2.0",
     "nanoid": "^5.1.11"
   },
@@ -37,5 +37,5 @@
   "files": [
     "src"
   ],
-  "gitHead": "a0d89185a17f8de8ce328c3a648c108ff1d61d8f"
+  "gitHead": "f0a8af3c370bbaffe4f7388c14f9345a5c6c56e5"
 }

package/src/aggregate-rebuild.js

@@ -35,19 +35,33 @@ export class AggregateRebuild {
     log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
   }
 
-  static async BuildAndSaveResource (resourceId, schemaId) {
+  /**
+   * Incrementally update an entity snapshot — same semantics as `SchemaStream.Of` + `Save`.
+   *
+   * @param {string} resourceId
+   * @param {string} [schemaId]
+   * @param {{ event?: object }} [options] changestream trigger event (avoids re-query when next in sequence)
+   */
+  static async BuildAndSaveResource (resourceId, schemaId, options = {}) {
+    const { event: triggerEvent } = options
     const AggregateRoot = schemaId ? AggregateRebuild._schemaMap[schemaId] : null
     const snapshot = await SchemaStream.Find(resourceId)
-    const events = await getResourceStream({ resourceId, fromVersion: 0 })
+    const fromVersion = snapshot?.version ?? 0
+
+    const events = await AggregateRebuild._loadTailEvents({
+      resourceId,
+      fromVersion,
+      triggerEvent,
+    })
 
-    if (!events.length && !snapshot) return
+    if (!events.length) return
 
     const state = AggregateRoot
       ? AggregateRoot.View(events, snapshot?.state)
       : createDefaultReducer()(events, snapshot?.state)
 
-    const type = schemaId ?? state.type ?? events[0]?.type
-    const version = events[events.length - 1]?.version ?? snapshot?.version ?? 0
+    const type = schemaId ?? state?.type ?? events[0]?.type ?? snapshot?.type
+    const version = events[events.length - 1].version
 
     return withMongoReconnect(() =>
       SchemaStream.Collection.updateOne(
@@ -58,6 +72,21 @@ export class AggregateRebuild {
     )
   }
 
+  /**
+   * @param {{ resourceId: string, fromVersion: number, triggerEvent?: object }} opts
+   * @returns {Promise<object[]>}
+   */
+  static async _loadTailEvents ({ resourceId, fromVersion, triggerEvent }) {
+    if (
+      triggerEvent?.resourceId === resourceId &&
+      triggerEvent.version === fromVersion + 1
+    ) {
+      return [triggerEvent]
+    }
+
+    return getResourceStream({ resourceId, fromVersion })
+  }
+
   static async BuildAndSaveAll () {
     log.debug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
 
@@ -80,3 +109,19 @@ export class AggregateRebuild {
       })
   }
 }
+
+/**
+ * Pure helper — pick tail events for incremental rebuild (exported for tests).
+ *
+ * @param {{ fromVersion: number, triggerEvent?: object, resourceId: string, fetchedTail: object[] }} opts
+ * @returns {object[]}
+ */
+export function selectTailEventsForRebuild ({ resourceId, fromVersion, triggerEvent, fetchedTail }) {
+  if (
+    triggerEvent?.resourceId === resourceId &&
+    triggerEvent.version === fromVersion + 1
+  ) {
+    return [triggerEvent]
+  }
+  return fetchedTail
+}

package/src/aggregate-rebuild.spec.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from '@jest/globals'
+import { selectTailEventsForRebuild } from './aggregate-rebuild.js'
+
+describe('selectTailEventsForRebuild', () => {
+  const resourceId = 'res_1'
+
+  it('uses the changestream trigger event when it is the next version', () => {
+    const triggerEvent = { resourceId, version: 3, event: 'Updated' }
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 2,
+      triggerEvent,
+      fetchedTail: [{ resourceId, version: 3 }],
+    })
+    expect(result).toEqual([triggerEvent])
+  })
+
+  it('uses fetched tail when trigger is not the immediate next version', () => {
+    const fetchedTail = [
+      { resourceId, version: 3 },
+      { resourceId, version: 4 },
+    ]
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 2,
+      triggerEvent: { resourceId, version: 4, event: 'Updated' },
+      fetchedTail,
+    })
+    expect(result).toEqual(fetchedTail)
+  })
+
+  it('uses fetched tail when no trigger event is provided', () => {
+    const fetchedTail = [{ resourceId, version: 1 }]
+    const result = selectTailEventsForRebuild({
+      resourceId,
+      fromVersion: 0,
+      fetchedTail,
+    })
+    expect(result).toEqual(fetchedTail)
+  })
+})
+
+describe('incremental rebuild semantics', () => {
+  it('folds only tail events onto snapshot state', () => {
+    const View = (events, state = {}) =>
+      events.reduce((acc, e) => ({ ...acc, count: (acc.count ?? 0) + 1, last: e.event }), state)
+
+    const snapshot = { version: 2, state: { count: 2, last: 'Created' } }
+    const tail = [{ version: 3, event: 'Updated' }]
+    const next = View(tail, snapshot.state)
+
+    expect(next).toEqual({ count: 3, last: 'Updated' })
+  })
+})

package/src/aggregate-rebuild.task.js

@@ -15,5 +15,5 @@ export const metadata = {
 export async function run ({ event }) {
   if (!event?.resourceId) return
 
-  await AggregateRebuild.BuildAndSaveResource(event.resourceId, event.type)
+  await AggregateRebuild.BuildAndSaveResource(event.resourceId, event.type, { event })
 }

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/index.js

@@ -6,3 +6,4 @@ 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'