@lazyapps/mqemitter 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/mqemitter
+
+In-process message queue with role-specific sub-modules. Provides lightweight inter-component communication for monolithic LazyApps deployments using MQEmitter.
+
+## Installation
+
+```bash
+pnpm add @lazyapps/mqemitter
+```
+
+## Part of LazyApps
+
+This package is part of the [LazyApps](https://github.com/oliversturm/lazyapps-libs) event-sourcing and CQRS framework.

package/commandProcessorEventBusMqEmitter.js

@@ -0,0 +1,32 @@
+import { getLogger } from '@lazyapps/logger';
+import { getSharedMqEmitter } from './mqEmitterRegistry.js';
+
+export const commandProcessorEventBusMqEmitter =
+  ({ mqName }) =>
+  () => {
+    const initLog = getLogger('CP/EB/MQE', 'INIT');
+
+    return Promise.resolve(getSharedMqEmitter('INIT', mqName))
+      .then((mq) => ({
+        publishEvent: (correlationId) => (event) => {
+          const log = getLogger('CP/EB/MQE', correlationId);
+          log.debug(`Publishing event timestamp ${event.timestamp}`);
+          event.correlationId = correlationId;
+          mq.emit({ topic: 'events', payload: event });
+          return event;
+        },
+        publishReplayState: (correlationId) => (state) => {
+          const log = getLogger('CP/EB/MQE', correlationId);
+          log.debug(`Publishing replay state ${state}`);
+          mq.emit({
+            topic: '__system',
+            payload: { type: 'SET_REPLAY_STATE', state, correlationId },
+          });
+          return state;
+        },
+      }))
+      .then((res) => {
+        initLog.debug('Event bus ready');
+        return res;
+      });
+  };

package/commandReceiverMqEmitter.js

@@ -0,0 +1,76 @@
+import { getLogger } from '@lazyapps/logger';
+import { getSharedMqEmitter } from './mqEmitterRegistry.js';
+import { nanoid } from 'nanoid';
+
+// The terminology is not optimal here. In the case of other
+// transports, for instance the project eventbus-rabbitmq,
+// there are "command-receiver" implementations which apply
+// to the command receiver component of the architecture in that
+// they allow that received to send events to the event bus.
+// For this mqemitter implementation, the command receiver
+// is the component that receives commands and handles them --
+// in the case of rabbit etc such an implementation does not
+// currently exist, so the inconsistency has existed for a while.
+// For mqemitter, the publishEvent stuff is in the
+// commandProcessorEventBusMqEmitter.js file.
+//
+export const commandReceiverMqEmitter =
+  ({ mqName }) =>
+  ({
+    aggregateStore,
+    eventStore,
+    eventBus,
+    aggregates,
+    handleCommand,
+    correlationConfig,
+  }) => {
+    const initLog = getLogger('CR/MQ', 'INIT');
+
+    return Promise.resolve(getSharedMqEmitter('INIT', mqName))
+      .then((mq) => {
+        mq.on('command', ({ payload: messagePayload }, cb) => {
+          let { correlationId } = messagePayload;
+          if (!correlationId) {
+            correlationId = `${
+              correlationConfig?.serviceId || 'UNK'
+            }-${nanoid()}`;
+          }
+
+          const log = getLogger('CR/MQ', correlationId);
+          log.debug(`Received command: ${JSON.stringify(messagePayload)}`);
+          const { command, aggregateName, aggregateId, payload } =
+            messagePayload;
+          const aggregate = aggregates[aggregateName];
+          const commandHandler =
+            aggregate?.commands && aggregate.commands[command];
+          // Minimal input tests here -- this receiver
+          // will be used in-process, not a public
+          // endpoint.
+          if (commandHandler) {
+            handleCommand(
+              aggregateStore,
+              eventStore,
+              eventBus,
+              command,
+              aggregateName,
+              aggregateId,
+              payload,
+              commandHandler,
+              undefined /* auth */,
+              undefined /* timestamp */,
+              correlationId,
+            ).catch((err) => {
+              log.error(`An error occurred handling command ${command} for aggregate ${aggregateName}(${aggregateId}) with payload:
+    
+    ${JSON.stringify(payload)}
+          
+    ${err}`);
+            });
+          }
+          cb();
+        });
+      })
+      .then(() => {
+        initLog.debug('Command receiver active');
+      });
+  };

package/commandSenderMqEmitter.js

@@ -0,0 +1,26 @@
+import { getLogger } from '@lazyapps/logger';
+import { getSharedMqEmitter } from './mqEmitterRegistry.js';
+
+export const commandSenderMqEmitter = ({ mqName }) => {
+  return {
+    sendCommand: (correlationId, cmd) => {
+      const log = getLogger('RM/CS', correlationId);
+      cmd.correlationId = correlationId;
+      return Promise.resolve(getSharedMqEmitter(correlationId, mqName))
+        .then((mq) =>
+          mq.emit({
+            topic: 'command',
+            payload: cmd,
+          }),
+        )
+        .then(() => {
+          log.debug(`Sending command ${JSON.stringify(cmd)}`);
+        })
+        .catch((e) => {
+          log.error(
+            `Error occurred sending command ${JSON.stringify(cmd)}: ${e}`,
+          );
+        });
+    },
+  };
+};

package/index.js

@@ -0,0 +1,10 @@
+export { commandProcessorEventBusMqEmitter } from './commandProcessorEventBusMqEmitter.js';
+export { commandReceiverMqEmitter } from './commandReceiverMqEmitter.js';
+export { commandSenderMqEmitter } from './commandSenderMqEmitter.js';
+export { readModelEventBusMqEmitter } from './readModelEventBusMqEmitter.js';
+export { readModelListenerMqEmitter } from './readModelListenerMqEmitter.js';
+export {
+  registerSharedMqEmitter,
+  getSharedMqEmitter,
+  getPublishedMqEmitter,
+} from './mqEmitterRegistry.js';

package/mqEmitterRegistry.js

@@ -0,0 +1,51 @@
+import { getLogger } from '@lazyapps/logger';
+import cs from 'mqemitter-cs';
+import net from 'node:net';
+
+// These emitters are process bounded and they must be shared
+// between different parts of the process. In the case of
+// the frontend processes that use vite (or whatever bundler)
+// this is not easily done by way of injection. I considered
+// using a bundler plugin to inject the emitters, but that
+// is quite specific to the bundler. After some research, it
+// also appears to be impossible to inject a specific object
+// reference into the vite process. It cleans up in such a strange
+// way that all imports in the vite context are separate from
+// those outside it. I created a registry of emitters so they
+// can be shared efficiently between the parts of the monolith
+// process that don't have a problem with it, and for other
+// parts there is a simple network server instead.
+
+const emitters = new Map();
+
+export const registerSharedMqEmitter = (name, emitter, port = undefined) => {
+  const log = getLogger('MQ/Reg', 'INIT');
+
+  log.debug(`Registering shared MQ emitter: ${name}`);
+  emitters.set(name, emitter);
+  if (port) {
+    log.debug(`Publishing shared MQ emitter ${name} on port ${port}`);
+    const server = net.createServer(cs.server(emitter));
+    server.on('listening', () => {
+      log.debug(`MQ emitter ${name} listening on port ${port}`);
+    });
+    server.listen(port);
+  }
+};
+
+export const getSharedMqEmitter = (correlationId, name) => {
+  const log = getLogger('MQ/Reg', correlationId);
+  if (!emitters.has(name)) {
+    throw new Error(
+      `[${correlationId}] No shared MQ emitter registered for name: ${name}`,
+    );
+  }
+  log.debug(`Getting shared MQ emitter: ${name}`);
+  return emitters.get(name);
+};
+
+export const getPublishedMqEmitter = (correlationId, port) => {
+  const log = getLogger('MQ/Reg', correlationId);
+  log.debug(`Getting published MQ emitter on port ${port}`);
+  return cs.client(net.connect(port));
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@lazyapps/mqemitter",
+  "version": "0.1.0",
+  "description": "In-process message queue with role-specific sub-modules for LazyApps",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "*.js"
+  ],
+  "keywords": [
+    "event-sourcing",
+    "cqrs",
+    "lazyapps",
+    "message-queue",
+    "mqemitter"
+  ],
+  "author": "Oliver Sturm",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oliversturm/lazyapps-libs.git",
+    "directory": "packages/mqemitter"
+  },
+  "bugs": {
+    "url": "https://github.com/oliversturm/lazyapps-libs/issues"
+  },
+  "homepage": "https://github.com/oliversturm/lazyapps-libs/tree/main/packages/mqemitter#readme",
+  "engines": {
+    "node": ">=18.20.3 || >=20.18.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.46.0",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "mqemitter-cs": "^1.0.1",
+    "nanoid": "^5.0.7",
+    "@lazyapps/logger": "^0.1.0"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "vitest"
+  }
+}

package/readModelEventBusMqEmitter.js

@@ -0,0 +1,44 @@
+import { getLogger } from '@lazyapps/logger';
+import { getSharedMqEmitter } from './mqEmitterRegistry.js';
+
+export const readModelEventBusMqEmitter =
+  ({ mqName }) =>
+  (context) => {
+    let inReplay = false;
+
+    const handleSysMessage = (msg) => {
+      switch (msg.type) {
+        case 'SET_REPLAY_STATE':
+          inReplay = msg.state;
+          break;
+      }
+    };
+
+    const initLog = getLogger('RM/EB', 'INIT');
+
+    return Promise.resolve(getSharedMqEmitter('INIT', mqName))
+      .then((mq) => {
+        mq.on('events', ({ payload }, cb) => {
+          const { correlationId } = payload;
+          const log = getLogger('RM/EB', correlationId);
+          log.debug(`Received event: ${JSON.stringify(payload)}`);
+          context.projectionHandler.projectEvent(correlationId)(
+            payload,
+            inReplay,
+          );
+
+          cb();
+        });
+        mq.on('__system', ({ payload }, cb) => {
+          const { correlationId, event } = payload;
+          const log = getLogger('RM/EB', correlationId);
+          log.debug(`Received '__system' event: ${JSON.stringify(event)}`);
+
+          handleSysMessage(event);
+          cb();
+        });
+      })
+      .then(() => {
+        initLog.debug(`Event bus receiving`);
+      });
+  };

package/readModelListenerMqEmitter.js

@@ -0,0 +1,74 @@
+import { getLogger } from '@lazyapps/logger';
+import { getSharedMqEmitter } from './mqEmitterRegistry.js';
+import { nanoid } from 'nanoid';
+
+export const readModelListenerMqEmitter =
+  ({ mqName }) =>
+  (context) => {
+    const initLog = getLogger('RM/LS', 'INIT');
+    return Promise.resolve(getSharedMqEmitter('INIT', mqName))
+      .then((mq) => {
+        mq.on('query', ({ payload }, cb) => {
+          const { readModelName, resolverName, args, replyTopic } = payload;
+          let { correlationId } = payload;
+          if (!correlationId) {
+            correlationId = `${
+              context.correlationConfig?.serviceId || 'UNK'
+            }-${nanoid()}`;
+          }
+
+          const log = getLogger('RM/LS', correlationId);
+          log.debug(
+            `Query received for ${readModelName}/${resolverName} (reply ${replyTopic}) with args ${JSON.stringify(
+              args,
+            )}`,
+          );
+          const readModel = context.readModels[readModelName];
+          if (!readModel) {
+            log.error(
+              `Read model ${readModelName} not found during query for ${readModelName}/${resolverName} (reply ${replyTopic}) with args ${JSON.stringify(
+                args,
+              )}`,
+            );
+            cb();
+            return;
+          }
+          const resolver = readModel.resolvers[resolverName];
+          if (!resolver) {
+            log.error(
+              `Resolver ${resolverName} not found in read model ${readModelName} during query for ${readModelName}/${resolverName} (reply ${replyTopic}) with args ${JSON.stringify(
+                args,
+              )}`,
+            );
+            cb();
+            return;
+          }
+          // Run the promise, then call cb and return
+          // The promise will send the reply
+          // asynchronously
+          Promise.resolve(
+            resolver(context.storage.perRequest(correlationId), args),
+          )
+            .then((result) => {
+              const payload = {
+                correlationId,
+                result,
+              };
+              mq.emit({ topic: replyTopic, payload });
+            })
+            .catch((err) => {
+              log.error(
+                `An error occurred handling query for ${readModelName}/${resolverName} (reply ${replyTopic}) with args ${JSON.stringify(
+                  args,
+                )}: ${err}`,
+              );
+            });
+
+          cb();
+        });
+      })
+      .then((res) => {
+        initLog.debug(`Read model listener active`);
+        return res;
+      });
+  };