@ossy/event-store 1.0.1

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ossy/event-store",
+  "version": "1.0.1",
+  "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ossy-se/packages.git"
+  },
+  "type": "module",
+  "ossy": {
+    "src": "./src"
+  },
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [],
+  "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
+  "license": "MIT",
+  "dependencies": {
+    "mongodb": "^7.2.0",
+    "nanoid": "^5.1.11"
+  },
+  "files": [
+    "src"
+  ],
+  "gitHead": "b8cbdc545a659e96af8948aa08a89316a2c2d193"
+}

package/src/aggregate-rebuild.js

@@ -0,0 +1,71 @@
+import { Aggregate } from './aggregate.js'
+import { EventStore } from './event-store.js'
+
+const _debug = Boolean(process.env.DEBUG)
+
+function _log(message) { console.log(message) }
+function _warn(message) { console.warn(message) }
+function _logDebug(message) {
+  if (!_debug) return
+  console.log(message)
+}
+
+export class AggregateRebuild {
+
+    /** @type {Record<string, Function>} */
+    static _aggregateMap = {}
+
+    /**
+     * Registers a pre-loaded aggregate module. Called by the platform server at
+     * startup for each aggregate entry in the manifest, following the same pattern
+     * as task and resource-template registration.
+     *
+     * @param {{ id: string, Aggregate: Function }} mod - The aggregate bundle module.
+     */
+    static registerAggregate(mod) {
+        const { id, Aggregate: AggregateClass } = mod
+        if (typeof AggregateClass !== 'function' || !id) {
+            _warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
+            return
+        }
+        AggregateRebuild._aggregateMap[id] = AggregateClass
+        _logDebug(`[AggregateRebuild] Registered aggregate: ${id}`)
+    }
+
+    static async BuildAndSave(aggregateType, aggregateId) {
+        const AggregateRoot = AggregateRebuild._aggregateMap[aggregateType]
+
+        if (!AggregateRoot) {
+            _logDebug(`[AggregateRebuild][BuildAndSave] Skipping unregistered aggregate type: ${aggregateType}`)
+            return
+        }
+
+        return Aggregate.Of(AggregateRoot, aggregateId)
+            .then(Aggregate.Save())
+    }
+
+    static async BuildAndSaveAll() {
+        _logDebug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
+
+        const knownTypes = new Set(Object.keys(AggregateRebuild._aggregateMap))
+
+        if (knownTypes.size === 0) {
+            _warn('[AggregateRebuild][BuildAndSaveAll] No aggregates registered — skipping rebuild')
+            return
+        }
+
+        return EventStore.GetEventStreams()
+            .then(streams => Promise.allSettled(
+                streams
+                    .filter(({ aggregateType }) => knownTypes.has(aggregateType))
+                    .map(({ aggregateType, aggregateId }) => AggregateRebuild.BuildAndSave(aggregateType, aggregateId))
+            ))
+            .then(results => {
+                const failed = results.filter(result => result.status === 'rejected')
+                const success = results.filter(result => result.status === 'fulfilled')
+                _log('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
+                _log(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
+                _log(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
+            })
+    }
+}

package/src/aggregate.js

@@ -0,0 +1,164 @@
+import { nanoid } from 'nanoid'
+import { Mongo, withMongoReconnect } from './mongodb.js'
+import { EventStore } from './event-store.js'
+
+const _debug = Boolean(process.env.DEBUG)
+
+function _log(message) { console.log(message) }
+function _logError(message) { console.error(message) }
+function _logDebug(message) {
+  if (!_debug) return
+  console.log(message)
+}
+
+/**
+ * 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
+ */
+export class Aggregate {
+
+  static get Collection() {
+    return Mongo.db.collection('aggregates')
+  }
+
+  /**
+   *  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(`[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))
+        })
+    }
+
+    if (typeof identifier === 'object') {
+      _log('[Aggregate] Creating new aggregate event stream')
+      return Aggregate.Add(identifier)(new Aggregate(AggregateRoot, identifier.aggregateId || nanoid(), []))
+    }
+
+    _logError('[Aggregate] No recognizable identifier provided')
+    return Promise.reject()
+  }
+
+  static Find(identifier) {
+    _log(`[Aggregate][Find()] Fetching aggregate for ${identifier}`)
+    return withMongoReconnect(() => Aggregate.Collection.findOne({ id: identifier }))
+      .then(aggregate => {
+        if (!aggregate) {
+          _logDebug(`[Aggregate][Find()] No aggregate found for ${identifier}`)
+        }
+        return aggregate
+      })
+  }
+
+  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 Save() {
+    return aggregate => {
+      _logDebug(`[Aggregate][Save] Saving state for ${aggregate.type} ${aggregate.id}`)
+
+      if (!aggregate.events || aggregate.events.length === 0) {
+        _logDebug(`[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) {
+        _logDebug(`[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 => {
+          _logError(`[Aggregate][Save] Failed to save state for ${aggregate.type} ${aggregate.id}`)
+          console.error(error)
+        })
+    }
+  }
+
+  static Validate(validator) {
+    return aggregate => Promise.resolve()
+      .then(() => validator(aggregate.events, aggregate.state))
+      .then(() => aggregate)
+  }
+
+  static View(view) {
+    return aggregate => {
+      _logDebug(`[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)
+    }
+
+  }
+
+  /**
+   *  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) {
+    _logDebug(`[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
+  }
+
+}

package/src/event-store.js

@@ -0,0 +1,131 @@
+import { Mongo, withMongoReconnect } from './mongodb.js'
+
+const _debug = Boolean(process.env.DEBUG)
+
+function _log(message) { console.log(message) }
+function _logError(message, error) {
+  console.error(message)
+  if (error) console.error('[Reason]:', error)
+}
+function _logDebug(message, data) {
+  if (!_debug) return
+  console.log(message)
+  if (data !== undefined) console.log('[DEBUG DATA]:', data)
+}
+
+/**
+ * Database queries related to workspace events
+ * @class
+ */
+export class EventStore {
+
+  static get Collection() {
+    return Mongo.db.collection('eventstore')
+  }
+
+  static AppendEvent(event) {
+    _log('[EventStore] Appending event')
+    _logDebug('[EventStore] Event', event)
+
+    return withMongoReconnect(() => EventStore.Collection.insertOne(event))
+      .then(insertResult => {
+        return insertResult.acknowledged
+          ? Promise.resolve(event)
+          : Promise.reject()
+      })
+      .catch(error => {
+        _logError('[EventStore] Could not append event', error)
+        return Promise.reject()
+      })
+  }
+
+  static FindEvent(query) {
+    _log('[EventStore] Searching for event')
+    _logDebug('[EventStore] Query', query)
+
+    return withMongoReconnect(() => EventStore.Collection.findOne(query))
+      .then(event => !!event ? event : Promise.reject())
+      .catch(error => {
+        _logError('[EventStore] No event found', error)
+        return Promise.reject()
+      })
+  }
+
+  static FindEvents(query) {
+    _log('[EventStore] Searching for events')
+    _logDebug('[EventStore] Query', query)
+
+    return withMongoReconnect(() =>
+      EventStore.Collection.find(query, { sort: { aggregateVersion: 1 } }).toArray()
+    )
+      .then(events => !!events?.length ? events : Promise.reject())
+      .catch(error => {
+        _logError('[EventStore] No events found', error)
+        return Promise.reject()
+      })
+  }
+
+  static GetEventStream({
+    aggregateId,
+    fromVersion = 0
+  }) {
+    _logDebug(`[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 => {
+        _logDebug(`[EventStore][GetEventStream()] Found ${events.length} events for ${aggregateId}`)
+        return events
+      })
+  }
+
+  static GetEventStreams() {
+    _log('[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 => {
+        _logDebug(`[EventStore][GetEventStreams()] found ${result.length} streams`)
+        return result
+      })
+  }
+
+  static Aggregate(pipeline) {
+    _log('[EventStore] Running aggregation pipeline')
+
+    return withMongoReconnect(() => EventStore.Collection.aggregate(pipeline).toArray())
+      .then(events => (Array.isArray(events) ? events : []))
+      .catch(error => {
+        _logError('[EventStore] Aggregation failed', error)
+        return Promise.reject(error)
+      })
+  }
+
+  static CloseDbConnection() {
+    return Mongo.closeConnection()
+  }
+
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export * from './mongodb.js'
+export * from './event-store.js'
+export * from './aggregate.js'
+export * from './aggregate-rebuild.js'

package/src/mongodb.js

@@ -0,0 +1,72 @@
+import { createRequire } from 'module'
+import { MongoClient } from 'mongodb'
+
+// When bundled as ESM by @ossy/app (Rollup + @rollup/plugin-commonjs), the
+// MongoDB driver's resolveRuntimeAdapters references `require` as a free
+// variable to detect the Node.js runtime. Provide it on globalThis so the
+// bundled CJS code can find it without changing the build configuration.
+if (!globalThis.require) {
+  globalThis.require = createRequire(import.meta.url)
+}
+
+const MONGO_URL = process.env.DB_URL || 'mongodb://mongodb:27017/'
+const DB_NAME = process.env.DB_NAME || 'test'
+
+let mongoClient = null
+
+function createClient() {
+  return new MongoClient(MONGO_URL, {
+    serverSelectionTimeoutMS: 30_000,
+  })
+}
+
+export function isMongoTopologyClosedError(error) {
+  if (!error || typeof error !== 'object') return false
+  if (error.name === 'MongoTopologyClosedError') return true
+  if (typeof error.message === 'string' && error.message.includes('Topology is closed')) return true
+  return false
+}
+
+/**
+ * Run a DB operation; if the driver closed the topology after a prior failure, reset the client and retry once.
+ */
+export function withMongoReconnect(run) {
+  return run().catch((err) => {
+    if (isMongoTopologyClosedError(err)) {
+      console.log('[Mongo] Topology closed — resetting client and retrying once')
+      Mongo.resetClient()
+      return run()
+    }
+    return Promise.reject(err)
+  })
+}
+
+export class Mongo {
+  static get Client() {
+    if (!mongoClient) {
+      mongoClient = createClient()
+    }
+    return mongoClient
+  }
+
+  static get db() {
+    return Mongo.Client.db(DB_NAME)
+  }
+
+  static resetClient() {
+    const prev = mongoClient
+    mongoClient = createClient()
+    if (prev) {
+      prev.close().catch(() => {})
+    }
+    console.log('[Mongo] New MongoClient instance created')
+  }
+
+  /** Used by tests / graceful shutdown; resets singleton so a later operation opens a new client. */
+  static closeConnection() {
+    if (!mongoClient) return Promise.resolve()
+    const c = mongoClient
+    mongoClient = null
+    return c.close().catch(() => {})
+  }
+}