@lazyapps/readmodelstorage-mongodb 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Oliver Sturm
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# @lazyapps/readmodelstorage-mongodb
+
+MongoDB-backed read model storage. Provides persistence for projected read model data with standard CRUD operations.
+
+## Installation
+
+```bash
+pnpm add @lazyapps/readmodelstorage-mongodb
+```
+
+## Part of LazyApps
+
+This package is part of the [LazyApps](https://github.com/oliversturm/lazyapps-libs) event-sourcing and CQRS framework.

package/index.js

@@ -0,0 +1,126 @@
+import { MongoClient } from 'mongodb';
+import pRetry from 'p-retry';
+
+import { getLogger } from '@lazyapps/logger';
+
+const wrapCalls = (correlationId, dbContext, names) => {
+  const log = getLogger('RM/MongoAPI', correlationId);
+  return names.reduce(
+    (r, v) => ({
+      ...r,
+      [v]: (collection, ...args) => {
+        log.debug(`Calling ${v}(${JSON.stringify(args)}) on ${collection}`);
+        return dbContext.db.collection(collection)[v](...args);
+      },
+    }),
+    {},
+  );
+};
+
+export const mongodb =
+  ({ url, user, pwd, scheme, host, urlPath, database = 'readmodel' } = {}) =>
+  () => {
+    const connectUrl = url
+      ? url
+      : user && pwd && scheme && host
+        ? (url = `${scheme}://${user}:${pwd}@${host}/${urlPath}`)
+        : 'mongodb://127.0.0.1:27017';
+
+    // This is meant to be a logging-safe URL, but obviously we don't do
+    // anything about a URL that may already include sensitive details.
+    // Not perfect.
+    const logLocation = user ? host : connectUrl;
+
+    const initLog = getLogger('RM/Mongo', 'INIT');
+
+    return pRetry(
+      () =>
+        MongoClient.connect(connectUrl, {
+          useNewUrlParser: true,
+          useUnifiedTopology: true,
+        }),
+      {
+        onFailedAttempt: (error) => {
+          initLog.error(
+            `Attempt ${error.attemptNumber} failed connecting to MongoDB at ${logLocation}: '${error}'. Will retry another ${error.retriesLeft} times.`,
+          );
+        },
+        retries: 10,
+      },
+    )
+      .catch((err) => {
+        initLog.error(`Can't connect to MongoDB at ${logLocation}: ${err}`);
+      })
+      .then((client) => ({ client, db: client.db(database) }))
+      .then((dbcontext) => {
+        initLog.info(
+          `MongoDB connected to url=${logLocation} and database=${database}`,
+        );
+        return dbcontext;
+      })
+      .then((dbContext) => ({
+        perRequest: (correlationId) => ({
+          ...wrapCalls(correlationId, dbContext, [
+            'insertOne',
+            'insertMany',
+            'updateOne',
+            'updateMany',
+            'deleteOne',
+            'deleteMany',
+            'findOneAndUpdate',
+            'findOneAndDelete',
+            'findOneAndReplace',
+            'bulkWrite',
+            'find',
+            'countDocuments',
+          ]),
+        }),
+        close: () => dbContext.client.close(),
+        updateLastProjectedEventTimestamps: (
+          correlationId,
+          rmNames,
+          timestamp,
+        ) =>
+          rmNames.length
+            ? dbContext.db
+                .collection('readmodel.state')
+                // Can't use updateMany here, because it only ever upserts
+                // one document even if multiple are matched using e.g. $in
+                .bulkWrite(
+                  rmNames.map((rmName) => ({
+                    updateOne: {
+                      filter: { name: rmName },
+                      update: {
+                        $set: { lastProjectedEventTimestamp: timestamp },
+                      },
+                      upsert: true,
+                    },
+                  })),
+                )
+                .then((r) => {
+                  const log = getLogger('RM/Mongo', correlationId);
+                  log.debug(
+                    `Updated last projected event timestamps for ${JSON.stringify(
+                      rmNames,
+                    )}. Matched ${r.matchedCount}, upserted ${
+                      r.upsertedCount
+                    }.`,
+                  );
+                })
+            : Promise.resolve(),
+        readLastProjectedEventTimestamps: (readModels) =>
+          Promise.all(
+            Object.keys(readModels).map((rmName) =>
+              dbContext.db
+                .collection('readmodel.state')
+                .find({ name: rmName }, { lastProjectedEventTimestamp: 1 })
+                .toArray()
+                .then((result) => {
+                  if (result && result.length === 1)
+                    readModels[rmName].lastProjectedEventTimestamp =
+                      result[0].lastProjectedEventTimestamp;
+                }),
+            ),
+          ),
+      }));
+  };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@lazyapps/readmodelstorage-mongodb",
+  "version": "0.1.0",
+  "description": "MongoDB-backed read model storage for LazyApps",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "event-sourcing",
+    "cqrs",
+    "lazyapps",
+    "read-models",
+    "mongodb"
+  ],
+  "author": "Oliver Sturm",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oliversturm/lazyapps-libs.git",
+    "directory": "packages/readmodelstorage-mongodb"
+  },
+  "bugs": {
+    "url": "https://github.com/oliversturm/lazyapps-libs/issues"
+  },
+  "homepage": "https://github.com/oliversturm/lazyapps-libs/tree/main/packages/readmodelstorage-mongodb#readme",
+  "engines": {
+    "node": ">=18.20.3 || >=20.18.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.46.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "mongodb": "^5.7.0",
+    "p-retry": "^6.1.0",
+    "@lazyapps/logger": "^0.1.0"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "vitest"
+  }
+}