@ossy/event-store 3.6.2 → 3.8.0

package/README.md

@@ -155,13 +155,20 @@ import { Mongo } from '@ossy/event-store'
 await Mongo.connect(process.env.DB_URL)
 ```
 
-Recommended indexes for `eventstore`:
+Recommended indexes (created at startup by `ensureEventStoreIndexes`):
 
 ```js
+// eventstore
 { resourceId: 1, version: 1 }  // stream queries
-{ type: 1, event: 1 }          // projection replay / task triggers
+
+// aggregates
+{ id: 1 }                                      // snapshot get-by-id
+{ type: 1, 'state.email': 1 }                  // user lookup (sparse)
+{ 'state.belongsTo': 1, 'state.location': 1 }  // folder list/search (sparse)
 ```
 
+`{ type: 1, event: 1 }` on `eventstore` is still useful for projection replay / task triggers but is not created automatically.
+
 ---
 
 ## Testing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "3.6.2",
+  "version": "3.8.0",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -37,5 +37,5 @@
   "files": [
     "src"
   ],
-  "gitHead": "d81b840c5421995e8ac7550e5b37ae1145abcba9"
+  "gitHead": "14548dfc2019e7258e8c75db527acbf66fe829bd"
 }

package/src/ensure-indexes.js

@@ -9,6 +9,8 @@ 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.
+ * Without `{ state.belongsTo, state.location }` on `aggregates`, folder list/search
+ * examines the whole collection, including audit snapshots that are not in any folder.
  */
 export async function ensureEventStoreIndexes () {
   if (ensured) return
@@ -29,6 +31,10 @@ export async function ensureEventStoreIndexes () {
       { type: 1, 'state.email': 1 },
       { name: 'type_state_email', background: true, sparse: true },
     )
+    await aggregates.createIndex(
+      { 'state.belongsTo': 1, 'state.location': 1 },
+      { name: 'state_belongsTo_location', background: true, sparse: true },
+    )
   })
 
   ensured = true

package/src/projection-rebuild.js

@@ -5,6 +5,50 @@ import { createLogger } from '@ossy/observability'
 
 const log = createLogger('event-store')
 
+/**
+ * Workspace (or other) scope for a projection event.
+ * When `scopeByResource` is passed, later events on the same resourceId inherit
+ * the scope from an earlier event (Started → Completed without repeating belongsTo).
+ *
+ * @param {{ scopeFromEvent?: (event: object) => string | null }} ProjectionClass
+ * @param {object} event
+ * @param {Map<string, string> | null} [scopeByResource]
+ * @returns {string | null}
+ */
+export function resolveProjectionScope (ProjectionClass, event, scopeByResource = null) {
+  let scopeId = typeof ProjectionClass.scopeFromEvent === 'function'
+    ? ProjectionClass.scopeFromEvent(event)
+    : null
+  if (!scopeId && event?.resourceId) {
+    scopeId = scopeByResource?.get(event.resourceId) ?? null
+  }
+  if (scopeId && event?.resourceId && scopeByResource) {
+    scopeByResource.set(event.resourceId, scopeId)
+  }
+  return scopeId || null
+}
+
+/**
+ * Group matching events by projection scope, inheriting scope along a resource stream.
+ *
+ * @param {{ sources?: object[], scopeFromEvent?: Function }} ProjectionClass
+ * @param {object[]} events
+ * @returns {Map<string, object[]>}
+ */
+export function groupEventsByScope (ProjectionClass, events) {
+  const sources = ProjectionClass.sources ?? []
+  const byScope = new Map()
+  const scopeByResource = new Map()
+  for (const event of events) {
+    if (!sources.some(source => matchesSource(source, event))) continue
+    const scopeId = resolveProjectionScope(ProjectionClass, event, scopeByResource)
+    if (!scopeId) continue
+    if (!byScope.has(scopeId)) byScope.set(scopeId, [])
+    byScope.get(scopeId).push(event)
+  }
+  return byScope
+}
+
 /**
  * Document id for projection snapshots — must not collide with entity resourceIds
  * (aggregates collection has a unique index on `id`).
@@ -49,9 +93,7 @@ export class ProjectionRebuild {
       const sources = ProjectionClass.sources ?? []
       if (!sources.some(source => matchesSource(source, event))) continue
 
-      const scopeId = typeof ProjectionClass.scopeFromEvent === 'function'
-        ? ProjectionClass.scopeFromEvent(event)
-        : null
+      const scopeId = resolveProjectionScope(ProjectionClass, event)
       if (!scopeId) continue
 
       try {
@@ -77,14 +119,7 @@ export class ProjectionRebuild {
         .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)
-      }
+      const byScope = groupEventsByScope(ProjectionClass, events)
 
       for (const [scopeId, scopeEvents] of byScope) {
         let state = ProjectionClass.initialState?.(scopeId) ?? {}

package/src/projection-rebuild.spec.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from '@jest/globals'
+import { groupEventsByScope, resolveProjectionScope } from './projection-rebuild.js'
+
+const TaskRunList = {
+  sources: [
+    { type: '@ossy/platform/schema/task-run', event: 'Started' },
+    { type: '@ossy/platform/schema/task-run', event: 'Completed' },
+    { type: '@ossy/platform/schema/task-run', event: 'Failed' },
+  ],
+  scopeFromEvent (event) {
+    return event.payload?.belongsTo ?? null
+  },
+}
+
+describe('resolveProjectionScope', () => {
+  it('uses payload.belongsTo when present', () => {
+    expect(resolveProjectionScope(TaskRunList, {
+      resourceId: 'run1',
+      payload: { belongsTo: 'ws1' },
+    })).toBe('ws1')
+  })
+
+  it('skips events with no scope (live Completed without belongsTo)', () => {
+    expect(resolveProjectionScope(TaskRunList, {
+      resourceId: 'run1',
+      payload: { durationMs: 12 },
+    })).toBeNull()
+  })
+
+  it('inherits scope from an earlier event on the same resource', () => {
+    const scopeByResource = new Map()
+    expect(resolveProjectionScope(TaskRunList, {
+      resourceId: 'run1',
+      payload: { belongsTo: 'ws1' },
+    }, scopeByResource)).toBe('ws1')
+
+    expect(resolveProjectionScope(TaskRunList, {
+      resourceId: 'run1',
+      payload: { durationMs: 12 },
+    }, scopeByResource)).toBe('ws1')
+  })
+})
+
+describe('groupEventsByScope', () => {
+  it('keeps Completed with the workspace of Started when belongsTo is omitted', () => {
+    const byScope = groupEventsByScope(TaskRunList, [
+      {
+        resourceId: 'run1',
+        type: '@ossy/platform/schema/task-run',
+        event: 'Started',
+        payload: { belongsTo: 'ws1', taskId: 't1' },
+      },
+      {
+        resourceId: 'run1',
+        type: '@ossy/platform/schema/task-run',
+        event: 'Completed',
+        payload: { durationMs: 40 },
+      },
+    ])
+
+    expect([...byScope.keys()]).toEqual(['ws1'])
+    expect(byScope.get('ws1')).toHaveLength(2)
+    expect(byScope.get('ws1').map(e => e.event)).toEqual(['Started', 'Completed'])
+  })
+})