@ossy/event-store 1.8.2 → 3.0.1

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
+  }
+}