@ossy/event-store 1.0.1 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/event-store",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Ossy Event Store — Aggregate, EventStore, and MongoDB client",
   "repository": {
     "type": "git",
@@ -23,11 +23,12 @@
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "license": "MIT",
   "dependencies": {
+    "@ossy/observability": "^1.2.0",
     "mongodb": "^7.2.0",
     "nanoid": "^5.1.11"
   },
   "files": [
     "src"
   ],
-  "gitHead": "b8cbdc545a659e96af8948aa08a89316a2c2d193"
+  "gitHead": "46cdd391ec01ea9210543ee7b14661f77079a7e7"
 }

package/src/aggregate-rebuild.js

@@ -1,14 +1,8 @@
 import { Aggregate } from './aggregate.js'
 import { EventStore } from './event-store.js'
+import { createLogger } from '@ossy/observability'
 
-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)
-}
+const log = createLogger('event-store')
 
 export class AggregateRebuild {
 
@@ -25,18 +19,18 @@ export class AggregateRebuild {
     static registerAggregate(mod) {
         const { id, Aggregate: AggregateClass } = mod
         if (typeof AggregateClass !== 'function' || !id) {
-            _warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
+            log.warn('[AggregateRebuild] registerAggregate: invalid module — expected { id, Aggregate }')
             return
         }
         AggregateRebuild._aggregateMap[id] = AggregateClass
-        _logDebug(`[AggregateRebuild] Registered aggregate: ${id}`)
+        log.debug(`[AggregateRebuild] Registered aggregate: ${id}`)
     }
 
     static async BuildAndSave(aggregateType, aggregateId) {
         const AggregateRoot = AggregateRebuild._aggregateMap[aggregateType]
 
         if (!AggregateRoot) {
-            _logDebug(`[AggregateRebuild][BuildAndSave] Skipping unregistered aggregate type: ${aggregateType}`)
+            log.debug(`[AggregateRebuild][BuildAndSave] Skipping unregistered aggregate type: ${aggregateType}`)
             return
         }
 
@@ -45,12 +39,12 @@ export class AggregateRebuild {
     }
 
     static async BuildAndSaveAll() {
-        _logDebug('[AggregateRebuild][BuildAndSaveAll] Starting building aggregates')
+        log.debug('[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')
+            log.warn('[AggregateRebuild][BuildAndSaveAll] No aggregates registered — skipping rebuild')
             return
         }
 
@@ -63,9 +57,9 @@ export class AggregateRebuild {
             .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}`)
+                log.info('[AggregateRebuild][BuildAndSaveAll] Finished building aggregates')
+                log.info(`[AggregateRebuild][BuildAndSaveAll] Failed: ${failed.length}`)
+                log.info(`[AggregateRebuild][BuildAndSaveAll] Success: ${success.length}`)
             })
     }
 }

package/src/aggregate.js

@@ -1,15 +1,9 @@
 import { nanoid } from 'nanoid'
 import { Mongo, withMongoReconnect } from './mongodb.js'
 import { EventStore } from './event-store.js'
+import { createLogger } from '@ossy/observability'
 
-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)
-}
+const log = createLogger('event-store')
 
 /**
  * Utility class that helps interact with event streams.
@@ -35,7 +29,7 @@ export class Aggregate {
    */
   static Of(AggregateRoot, identifier) {
 
-    _log(`[Aggregate][Of()][${AggregateRoot?.AggregateType}] Creating aggregate root`)
+    log.info(`[Aggregate][Of()][${AggregateRoot?.AggregateType}] Creating aggregate root`)
 
     if (typeof identifier === 'string') {
 
@@ -47,20 +41,20 @@ export class Aggregate {
     }
 
     if (typeof identifier === 'object') {
-      _log('[Aggregate] Creating new aggregate event stream')
+      log.info('[Aggregate] Creating new aggregate event stream')
       return Aggregate.Add(identifier)(new Aggregate(AggregateRoot, identifier.aggregateId || nanoid(), []))
     }
 
-    _logError('[Aggregate] No recognizable identifier provided')
+    log.error('[Aggregate] No recognizable identifier provided')
     return Promise.reject()
   }
 
   static Find(identifier) {
-    _log(`[Aggregate][Find()] Fetching aggregate for ${identifier}`)
+    log.info(`[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}`)
+          log.debug(`[Aggregate][Find()] No aggregate found for ${identifier}`)
         }
         return aggregate
       })
@@ -89,17 +83,17 @@ export class Aggregate {
 
   static Save() {
     return aggregate => {
-      _logDebug(`[Aggregate][Save] Saving state for ${aggregate.type} ${aggregate.id}`)
+      log.debug(`[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}`)
+        log.debug(`[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}`)
+        log.debug(`[Aggregate][Save] No new events to save for ${aggregate.type} ${aggregate.id}`)
         return Promise.resolve()
       }
 
@@ -116,8 +110,7 @@ export class Aggregate {
         }, { upsert: true })
       )
         .catch(error => {
-          _logError(`[Aggregate][Save] Failed to save state for ${aggregate.type} ${aggregate.id}`)
-          console.error(error)
+          log.error(`[Aggregate][Save] Failed to save state for ${aggregate.type} ${aggregate.id}`, undefined, error)
         })
     }
   }
@@ -130,7 +123,7 @@ export class Aggregate {
 
   static View(view) {
     return aggregate => {
-      _logDebug(`[Aggregate][View] Building view for ${aggregate.type} ${aggregate.id}`)
+      log.debug(`[Aggregate][View] Building view for ${aggregate.type} ${aggregate.id}`)
 
       if (typeof view === 'function') {
         return view(aggregate.events, aggregate.state)
@@ -150,7 +143,7 @@ export class Aggregate {
    * @param {Object} aggregate - The object representing the aggregate of all the events
    */
   constructor(AggregateRoot, id, events, aggregate) {
-    _logDebug(`[Aggregate][Constructor] Assembling ${AggregateRoot.AggregateType} ${id}`)
+    log.debug(`[Aggregate][Constructor] Assembling ${AggregateRoot.AggregateType} ${id}`)
 
     this.id = id;
     this.version = aggregate?.version || 0

package/src/event-store.js

@@ -1,17 +1,7 @@
 import { Mongo, withMongoReconnect } from './mongodb.js'
+import { createLogger } from '@ossy/observability'
 
-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)
-}
+const log = createLogger('event-store')
 
 /**
  * Database queries related to workspace events
@@ -24,8 +14,8 @@ export class EventStore {
   }
 
   static AppendEvent(event) {
-    _log('[EventStore] Appending event')
-    _logDebug('[EventStore] Event', event)
+    log.info('[EventStore] Appending event')
+    log.debug('[EventStore] Event', { event })
 
     return withMongoReconnect(() => EventStore.Collection.insertOne(event))
       .then(insertResult => {
@@ -34,33 +24,33 @@ export class EventStore {
           : Promise.reject()
       })
       .catch(error => {
-        _logError('[EventStore] Could not append event', error)
+        log.error('[EventStore] Could not append event', undefined, error)
         return Promise.reject()
       })
   }
 
   static FindEvent(query) {
-    _log('[EventStore] Searching for event')
-    _logDebug('[EventStore] Query', query)
+    log.info('[EventStore] Searching for event')
+    log.debug('[EventStore] Query', { query })
 
     return withMongoReconnect(() => EventStore.Collection.findOne(query))
       .then(event => !!event ? event : Promise.reject())
       .catch(error => {
-        _logError('[EventStore] No event found', error)
+        log.error('[EventStore] No event found', undefined, error)
         return Promise.reject()
       })
   }
 
   static FindEvents(query) {
-    _log('[EventStore] Searching for events')
-    _logDebug('[EventStore] Query', query)
+    log.info('[EventStore] Searching for events')
+    log.debug('[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)
+        log.error('[EventStore] No events found', undefined, error)
         return Promise.reject()
       })
   }
@@ -69,7 +59,7 @@ export class EventStore {
     aggregateId,
     fromVersion = 0
   }) {
-    _logDebug(`[EventStore][GetEventStream()] Fetching stream ${aggregateId} from version ${fromVersion}`)
+    log.debug(`[EventStore][GetEventStream()] Fetching stream ${aggregateId} from version ${fromVersion}`)
 
     const query = {
       aggregateId: aggregateId,
@@ -82,13 +72,13 @@ export class EventStore {
 
     return withMongoReconnect(() => EventStore.Collection.find(query, options).toArray())
       .then(events => {
-        _logDebug(`[EventStore][GetEventStream()] Found ${events.length} events for ${aggregateId}`)
+        log.debug(`[EventStore][GetEventStream()] Found ${events.length} events for ${aggregateId}`)
         return events
       })
   }
 
   static GetEventStreams() {
-    _log('[EventStore][GetEventStreams()] Fetching event streams')
+    log.info('[EventStore][GetEventStreams()] Fetching event streams')
 
     return EventStore.Aggregate([
       {
@@ -108,18 +98,18 @@ export class EventStore {
       }
     ])
       .then(result => {
-        _logDebug(`[EventStore][GetEventStreams()] found ${result.length} streams`)
+        log.debug(`[EventStore][GetEventStreams()] found ${result.length} streams`)
         return result
       })
   }
 
   static Aggregate(pipeline) {
-    _log('[EventStore] Running aggregation pipeline')
+    log.info('[EventStore] Running aggregation pipeline')
 
     return withMongoReconnect(() => EventStore.Collection.aggregate(pipeline).toArray())
       .then(events => (Array.isArray(events) ? events : []))
       .catch(error => {
-        _logError('[EventStore] Aggregation failed', error)
+        log.error('[EventStore] Aggregation failed', undefined, error)
         return Promise.reject(error)
       })
   }

package/src/mongodb.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'module'
 import { MongoClient } from 'mongodb'
+import { createLogger } from '@ossy/observability'
 
 // When bundled as ESM by @ossy/app (Rollup + @rollup/plugin-commonjs), the
 // MongoDB driver's resolveRuntimeAdapters references `require` as a free
@@ -9,6 +10,8 @@ if (!globalThis.require) {
   globalThis.require = createRequire(import.meta.url)
 }
 
+const log = createLogger('event-store')
+
 const MONGO_URL = process.env.DB_URL || 'mongodb://mongodb:27017/'
 const DB_NAME = process.env.DB_NAME || 'test'
 
@@ -33,7 +36,7 @@ export function isMongoTopologyClosedError(error) {
 export function withMongoReconnect(run) {
   return run().catch((err) => {
     if (isMongoTopologyClosedError(err)) {
-      console.log('[Mongo] Topology closed — resetting client and retrying once')
+      log.info('[Mongo] Topology closed — resetting client and retrying once')
       Mongo.resetClient()
       return run()
     }
@@ -59,7 +62,7 @@ export class Mongo {
     if (prev) {
       prev.close().catch(() => {})
     }
-    console.log('[Mongo] New MongoClient instance created')
+    log.info('[Mongo] New MongoClient instance created')
   }
 
   /** Used by tests / graceful shutdown; resets singleton so a later operation opens a new client. */