@ossy/event-store 3.7.0 → 3.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "3.7.0",
+  "version": "3.11.0",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -37,5 +37,5 @@
   "files": [
     "src"
   ],
-  "gitHead": "622d97535abad08415963405ace2f5aaaecd7ca4"
+  "gitHead": "53ff8456920e09151c9d88df4a6c3ee958d811eb"
 }

package/src/mongodb.js

@@ -13,6 +13,7 @@ if (!globalThis.require) {
 const log = createLogger('event-store')
 
 const DEFAULT_MONGO_URL = 'mongodb://mongodb:27017/'
+const DEFAULT_MAX_POOL_SIZE = 50
 
 /**
  * Resolve MongoDB URL at call time so dotenv can load before the first connection.
@@ -29,12 +30,30 @@ export function resolveMongoUrl(url = process.env.DB_URL) {
   return resolved
 }
 
+/** Driver default maxPoolSize is 100; we cap lower. See MONGO_MAX_POOL_SIZE / MONGO_MAX_IDLE_TIME_MS. */
+export function resolveMongoClientOptions(env = process.env) {
+  const maxPoolSize = parsePositiveInt(env.MONGO_MAX_POOL_SIZE, DEFAULT_MAX_POOL_SIZE)
+  /** @type {import('mongodb').MongoClientOptions} */
+  const options = {
+    serverSelectionTimeoutMS: 30_000,
+    maxPoolSize,
+  }
+  const maxIdleTimeMS = parsePositiveInt(env.MONGO_MAX_IDLE_TIME_MS, 0)
+  if (maxIdleTimeMS > 0) {
+    options.maxIdleTimeMS = maxIdleTimeMS
+  }
+  return options
+}
+
+function parsePositiveInt(value, fallback) {
+  const n = Number.parseInt(value ?? '', 10)
+  return Number.isFinite(n) && n > 0 ? n : fallback
+}
+
 let mongoClient = null
 
 function createClient() {
-  return new MongoClient(resolveMongoUrl(), {
-    serverSelectionTimeoutMS: 30_000,
-  })
+  return new MongoClient(resolveMongoUrl(), resolveMongoClientOptions())
 }
 
 export function isMongoTopologyClosedError(error) {

package/src/mongodb.spec.js

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, it } from '@jest/globals'
+import {
+  Mongo,
+  resolveMongoClientOptions,
+  resolveMongoUrl,
+} from './mongodb.js'
+
+describe('resolveMongoUrl', () => {
+  it('adds directConnection for localhost URLs', () => {
+    expect(resolveMongoUrl('mongodb://127.0.0.1:27017/')).toContain('directConnection=true')
+    expect(resolveMongoUrl('mongodb://localhost:27017/test')).toContain('directConnection=true')
+  })
+
+  it('leaves mongodb+srv URLs unchanged', () => {
+    const url = 'mongodb+srv://user:pass@cluster.example.net/'
+    expect(resolveMongoUrl(url)).toBe(url)
+  })
+})
+
+describe('resolveMongoClientOptions', () => {
+  it('defaults to a bounded pool that still leaves headroom for concurrent API work', () => {
+    expect(resolveMongoClientOptions({})).toEqual({
+      serverSelectionTimeoutMS: 30_000,
+      maxPoolSize: 50,
+    })
+  })
+
+  it('reads MONGO_MAX_POOL_SIZE and optional MONGO_MAX_IDLE_TIME_MS', () => {
+    expect(resolveMongoClientOptions({
+      MONGO_MAX_POOL_SIZE: '5',
+      MONGO_MAX_IDLE_TIME_MS: '15000',
+    })).toEqual({
+      serverSelectionTimeoutMS: 30_000,
+      maxPoolSize: 5,
+      maxIdleTimeMS: 15_000,
+    })
+  })
+
+  it('omits maxIdleTimeMS unless env is a positive int', () => {
+    expect(resolveMongoClientOptions({
+      MONGO_MAX_POOL_SIZE: '40',
+      MONGO_MAX_IDLE_TIME_MS: '0',
+    })).toEqual({
+      serverSelectionTimeoutMS: 30_000,
+      maxPoolSize: 40,
+    })
+  })
+
+  it('falls back when env values are invalid', () => {
+    expect(resolveMongoClientOptions({
+      MONGO_MAX_POOL_SIZE: '0',
+      MONGO_MAX_IDLE_TIME_MS: 'nope',
+    })).toEqual({
+      serverSelectionTimeoutMS: 30_000,
+      maxPoolSize: 50,
+    })
+  })
+})
+
+describe('Mongo singleton', () => {
+  afterEach(async () => {
+    await Mongo.closeConnection()
+  })
+
+  it('reuses one client across getters', () => {
+    const a = Mongo.Client
+    const b = Mongo.Client
+    expect(a).toBe(b)
+    expect(a.options.maxPoolSize).toBe(50)
+  })
+
+  it('resetClient replaces the singleton', async () => {
+    const first = Mongo.Client
+    Mongo.resetClient()
+    const second = Mongo.Client
+    expect(second).not.toBe(first)
+    expect(second.options.maxPoolSize).toBe(50)
+  })
+})

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'])
+  })
+})