@web-ts-toolkit/message-service 0.6.0

package/index.mjs

@@ -0,0 +1,742 @@
+// src/schemas/base.ts
+import mongoose from "mongoose";
+var MESSAGE_MODEL_NAME = "Message";
+var MESSAGE_ARCHIVE_MODEL_NAME = "MessageArchive";
+var MessageContentSchema = new mongoose.Schema(
+  {
+    title: { type: String, default: "" },
+    long: { type: String, default: "" },
+    short: { type: String, default: "" }
+  },
+  { _id: false }
+);
+function defaultMessageContent() {
+  return { title: "", long: "", short: "" };
+}
+var BaseMessageFields = {
+  templateCd: { type: String, default: "" },
+  type: { type: String, default: "notification" },
+  fromUser: { type: mongoose.Schema.Types.ObjectId, default: null },
+  toUser: { type: mongoose.Schema.Types.ObjectId, default: null },
+  toRoles: { type: [String], default: [] },
+  senderContent: { type: MessageContentSchema, default: defaultMessageContent },
+  receiverContent: { type: MessageContentSchema, default: defaultMessageContent },
+  documents: { type: [mongoose.Schema.Types.ObjectId], default: [] },
+  paymentSession: { type: String, default: null },
+  paymentCd: { type: String, default: "" },
+  payload: { type: mongoose.Schema.Types.Mixed, default: {} },
+  display: { type: mongoose.Schema.Types.Mixed, default: {} },
+  clientRequestId: { type: String, default: null }
+};
+
+// src/schemas/message.ts
+import mongoose2 from "mongoose";
+
+// src/template-registry.ts
+var TemplateRegistry = class {
+  constructor() {
+    this.templates = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a template. Overwrites if templateCd already exists.
+   */
+  register(template) {
+    this.templates.set(template.templateCd, template);
+  }
+  /**
+   * Register multiple templates at once.
+   */
+  registerAll(templates) {
+    for (const t of templates) {
+      this.register(t);
+    }
+  }
+  /**
+   * Find a template by its templateCd.
+   */
+  find(templateCd) {
+    return this.templates.get(templateCd);
+  }
+  /**
+   * Check if a template exists.
+   */
+  has(templateCd) {
+    return this.templates.has(templateCd);
+  }
+  /**
+   * Get all registered template codes.
+   */
+  getTemplateCodes() {
+    return Array.from(this.templates.keys());
+  }
+  /**
+   * Get all registered templates.
+   */
+  getAll() {
+    return Array.from(this.templates.values());
+  }
+  /**
+   * Remove a template by templateCd.
+   */
+  unregister(templateCd) {
+    return this.templates.delete(templateCd);
+  }
+  /**
+   * Clear all templates.
+   */
+  clear() {
+    this.templates.clear();
+  }
+};
+var defaultRegistry = new TemplateRegistry();
+function includesAction(templateCd, actionCd, registry) {
+  const template = registry.find(templateCd);
+  if (!template) return false;
+  return template.actions.some((a) => a.actionCd === actionCd);
+}
+
+// src/schemas/methods.ts
+function isSender(user) {
+  return String(this.fromUser) === String(user.id || user._id);
+}
+function isReceiver(user) {
+  const id = String(user.id || user._id);
+  return String(this.toUser) === id || this.toRoles.some((r) => user.roles?.includes(r));
+}
+
+// src/schemas/message.ts
+function createArchiveMethod(ctx) {
+  return function archive(actionCd, archivedBy, registry) {
+    if (!includesAction(this.templateCd, actionCd, registry) || !archivedBy) {
+      return Promise.resolve();
+    }
+    const MessageArchive = mongoose2.model(ctx.archiveModelName);
+    const data = this.toObject();
+    return MessageArchive.create({
+      ...data,
+      actionCd,
+      archivedBy
+    }).then(async () => {
+      await this.deleteOne();
+    });
+  };
+}
+function createPreSaveHook(ctx) {
+  return async function sendNotificationEmail() {
+    if (!this.toUser || !this.receiverContent?.title) {
+      return;
+    }
+    const title = this.receiverContent.title.trim();
+    if (ctx.emailNotificationExclusions.includes(title.toLowerCase())) {
+      return;
+    }
+    try {
+      const User = mongoose2.model(ctx.userModelName);
+      const user = await User.findById(this.toUser).select("email").lean();
+      if (!user?.email) {
+        return;
+      }
+      const long = this.receiverContent.long || "";
+      const short = this.receiverContent.short || "";
+      const body = long.length > short.length ? long : short;
+      await ctx.emailNotifier(user.email, title, body);
+    } catch {
+    }
+  };
+}
+function assertModelRegistered(name, role) {
+  if (!mongoose2.modelNames().includes(name)) {
+    throw new Error(
+      `message-service: cannot configure schema \u2014 ${role} model "${name}" is not registered with Mongoose. Call mongoose.model("${name}", ...) before buildMessageSchema().`
+    );
+  }
+}
+function resolveConfig(config) {
+  return {
+    emailNotifier: config?.emailNotifier ?? null,
+    emailNotificationExclusions: (config?.emailNotificationExclusions ?? []).map((e) => e.toLowerCase()),
+    userModelName: config?.userModelName ?? "User",
+    archiveModelName: config?.archiveModelName ?? MESSAGE_ARCHIVE_MODEL_NAME
+  };
+}
+function buildMessageSchema(config) {
+  const resolved = resolveConfig(config);
+  if (resolved.emailNotifier) {
+    assertModelRegistered(resolved.userModelName, "user");
+  }
+  const schema = new mongoose2.Schema(BaseMessageFields, {
+    timestamps: true
+  });
+  schema.index({ createdAt: 1 });
+  schema.index({ clientRequestId: 1 }, { sparse: true });
+  schema.methods.isSender = isSender;
+  schema.methods.isReceiver = isReceiver;
+  schema.methods.archive = createArchiveMethod({ archiveModelName: resolved.archiveModelName });
+  if (resolved.emailNotifier) {
+    schema.pre(
+      "save",
+      createPreSaveHook({
+        emailNotifier: resolved.emailNotifier,
+        emailNotificationExclusions: resolved.emailNotificationExclusions,
+        userModelName: resolved.userModelName
+      })
+    );
+  }
+  return schema;
+}
+var MessageSchema = buildMessageSchema();
+
+// src/schemas/message-archive.ts
+import mongoose3 from "mongoose";
+function buildMessageArchiveSchema() {
+  const schema = new mongoose3.Schema(
+    {
+      ...BaseMessageFields,
+      actionCd: { type: String, default: "" },
+      archivedBy: { type: mongoose3.Schema.Types.ObjectId, default: null, index: true },
+      archivedAt: { type: Date, default: Date.now }
+    },
+    {
+      timestamps: true
+    }
+  );
+  schema.index({ createdAt: 1 });
+  schema.methods.isSender = isSender;
+  schema.methods.isReceiver = isReceiver;
+  return schema;
+}
+var MessageArchiveSchema = buildMessageArchiveSchema();
+
+// src/template-engine.ts
+import Handlebars from "handlebars";
+var compiledTemplates = /* @__PURE__ */ new Map();
+function compile(template, data) {
+  let compiled = compiledTemplates.get(template);
+  if (!compiled) {
+    compiled = Handlebars.compile(template, { noEscape: true });
+    compiledTemplates.set(template, compiled);
+  }
+  return compiled(data);
+}
+function filterActions(actions, usertype, options = {}) {
+  const { permissions = {}, message = {}, data = {} } = options;
+  return actions.filter((action) => {
+    if (!action[usertype]) return false;
+    if (action.permission && !permissions[action.permission]) return false;
+    if (action.condition && !action.condition(message)) return false;
+    return true;
+  }).map((action) => {
+    const { confirmation } = action;
+    return {
+      actionCd: action.actionCd,
+      isDefault: action.isDefault,
+      name: compile(action.name, data),
+      variant: action.variant,
+      confirmation: confirmation ? {
+        title: compile(confirmation.title, data),
+        message: compile(confirmation.message, data),
+        ...confirmation.notesLabel ? { notesLabel: compile(confirmation.notesLabel, data) } : {},
+        ...confirmation.requireNotes !== void 0 ? { requireNotes: confirmation.requireNotes } : {},
+        ...confirmation.documents !== void 0 ? { documents: confirmation.documents } : {}
+      } : void 0,
+      payload: action.payload
+    };
+  });
+}
+function isActionAllowed(action, user, message, options = {}) {
+  const isReceiver2 = action.receiver && message.isReceiver(user);
+  const isSender2 = action.sender && message.isSender(user);
+  if (!isReceiver2 && !isSender2) return false;
+  if (action.permission && !(options.permissions || {})[action.permission]) return false;
+  if (action.condition && !action.condition(message)) return false;
+  return true;
+}
+function interpolateTemplate(template, data, usertype, options = {}) {
+  const { permissions = {}, message = {} } = options;
+  const { senderContent, receiverContent, actions, uiTemplate } = template;
+  return {
+    senderContent: {
+      title: compile(senderContent?.title || "", data),
+      long: compile(senderContent?.long || "", data),
+      short: compile(senderContent?.short || "", data)
+    },
+    receiverContent: {
+      title: compile(receiverContent?.title || "", data),
+      long: compile(receiverContent?.long || "", data),
+      short: compile(receiverContent?.short || "", data)
+    },
+    uiTemplate: resolveUiTemplate(uiTemplate, usertype),
+    actions: filterActions(actions, usertype, { permissions, message, data })
+  };
+}
+function resolveUiTemplate(uiTemplate, usertype) {
+  if (typeof uiTemplate === "string") return uiTemplate;
+  return uiTemplate[usertype] || uiTemplate.sender || uiTemplate.receiver || "";
+}
+
+// src/providers/email.ts
+var NoopEmailProvider = class {
+  async sendNotification(_to, _title, _body) {
+  }
+};
+
+// src/providers/payment.ts
+var NoopPaymentProvider = class {
+  async createSession(_user, _code, _priceArgs) {
+    return null;
+  }
+  async expireSession(_sessionId) {
+  }
+  async refundPayment(_sessionId) {
+  }
+};
+
+// src/message-service.ts
+import { isString } from "@web-ts-toolkit/utils";
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 100;
+var GENERIC_NOTIFICATION_TEMPLATE_CD = "__generic-notification__";
+var MessageNotFoundError = class extends Error {
+  constructor(messageId) {
+    super(`message "${messageId}" not found`);
+    this.name = "MessageNotFoundError";
+  }
+};
+var MessageArchivedError = class extends Error {
+  constructor(messageId) {
+    super(`message "${messageId}" is archived`);
+    this.name = "MessageArchivedError";
+  }
+};
+var TemplateNotFoundError = class extends Error {
+  constructor(templateCd) {
+    super(`template "${templateCd}" not found`);
+    this.name = "TemplateNotFoundError";
+  }
+};
+var ActionNotFoundError = class extends Error {
+  constructor(templateCd, actionCd) {
+    super(`action "${actionCd}" not found in template "${templateCd}"`);
+    this.name = "ActionNotFoundError";
+  }
+};
+var ActionNotAllowedError = class extends Error {
+  constructor() {
+    super("not allowed");
+    this.name = "ActionNotAllowedError";
+  }
+};
+var MessageService = class {
+  constructor(options) {
+    this.getModel = options.getModel;
+    this.paymentProvider = options.paymentProvider ?? null;
+    this.expirePaymentSession = this.paymentProvider?.expireSession.bind(this.paymentProvider);
+    this.refundPaymentSession = this.paymentProvider?.refundPayment.bind(this.paymentProvider);
+    this.adminRoles = options.adminRoles ?? [];
+    this.registry = options.registry ?? defaultRegistry;
+    this.defaultListLimit = options.defaultListLimit ?? DEFAULT_LIST_LIMIT;
+    this.maxListLimit = options.maxListLimit ?? MAX_LIST_LIMIT;
+  }
+  // -------------------------------------------------------------------------
+  // Message lookup
+  // -------------------------------------------------------------------------
+  /**
+   * Find a message by id, falling back to the archive. Returns null if
+   * the message does not exist in either collection.
+   */
+  async findMessage(messageId, options = {}) {
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    const MessageArchive = this.getModel(MESSAGE_ARCHIVE_MODEL_NAME);
+    const message = await this.findByIdWithOptions(Message, messageId, options);
+    if (message) return message;
+    return await this.findByIdWithOptions(
+      MessageArchive,
+      messageId,
+      options
+    );
+  }
+  async findMessageOrThrow(messageId, options = {}) {
+    const message = await this.findMessage(messageId, options);
+    if (!message) {
+      throw new MessageNotFoundError(messageId);
+    }
+    return message;
+  }
+  // -------------------------------------------------------------------------
+  // Create message from template
+  // -------------------------------------------------------------------------
+  async createMessage(params) {
+    const {
+      templateCd,
+      user,
+      roles = [],
+      identity = {},
+      permissions = {},
+      payload = {},
+      payerUser,
+      req,
+      clientRequestId
+    } = params;
+    if (clientRequestId) {
+      const existing = await this.findByClientRequestId(clientRequestId);
+      if (existing) return existing;
+    }
+    const template = this.registry.find(templateCd);
+    if (!template) throw new TemplateNotFoundError(templateCd);
+    const messageData = await template.prepareMessage({
+      user,
+      roles,
+      identity,
+      permissions,
+      payload,
+      getModel: this.getModel,
+      req
+    });
+    if (!messageData) return [];
+    const ctx = { user, roles, identity, permissions, payload, payerUser, req };
+    const items = Array.isArray(messageData) ? messageData : [messageData];
+    const results = [];
+    for (const m of items) {
+      results.push(await this.persistItem(template, m, ctx, clientRequestId));
+    }
+    return results;
+  }
+  // -------------------------------------------------------------------------
+  // Create generic notification (no template, no actions)
+  // -------------------------------------------------------------------------
+  async createNotification(params) {
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    return Message.create({
+      type: "notification",
+      templateCd: GENERIC_NOTIFICATION_TEMPLATE_CD,
+      fromUser: params.fromUser ?? null,
+      toUser: params.toUser ?? null,
+      toRoles: params.toRoles,
+      senderContent: params.senderContent,
+      receiverContent: params.receiverContent,
+      documents: params.documents || []
+    });
+  }
+  // -------------------------------------------------------------------------
+  // List messages
+  // -------------------------------------------------------------------------
+  /**
+   * Build a Mongoose filter for messages visible to the given user.
+   * Exposed so callers can use the same visibility rules for custom
+   * queries (e.g. with `populate`).
+   */
+  buildVisibilityFilter(user) {
+    const userId = user.id || String(user._id);
+    return {
+      $or: [{ fromUser: userId }, { toUser: userId }, { toRoles: { $in: user.roles ?? [] } }]
+    };
+  }
+  /**
+   * List active (non-archived) messages visible to a user.
+   * Returns messages where the user is the sender, the receiver,
+   * or matches one of the recipient's roles.
+   */
+  async listMessages(params) {
+    const { user, limit: rawLimit, skip: rawSkip, populate } = params;
+    const limit = Math.min(Math.max(rawLimit ?? this.defaultListLimit, 1), this.maxListLimit);
+    const skip = Math.max(rawSkip ?? 0, 0);
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    const query = this.applyPopulate(
+      Message.find(this.buildVisibilityFilter(user)).sort({ createdAt: -1 }).skip(skip).limit(limit),
+      populate
+    );
+    return query;
+  }
+  /**
+   * Count active (non-archived) messages visible to a user.
+   * Useful for badge indicators ("3 new messages").
+   */
+  async countMessages(user) {
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    return Message.countDocuments(this.buildVisibilityFilter(user));
+  }
+  // -------------------------------------------------------------------------
+  // Get actions for a message
+  // -------------------------------------------------------------------------
+  async getActions(messageId, usertype, options = {}) {
+    const message = options.message ?? await this.findMessage(messageId, { populate: options.populate });
+    if (!message) return null;
+    if (!options.isAdmin && options.user) {
+      const isAllowedUsertype = usertype === "sender" ? message.isSender(options.user) : message.isReceiver(options.user);
+      if (!isAllowedUsertype) {
+        return null;
+      }
+    }
+    if (message.templateCd === GENERIC_NOTIFICATION_TEMPLATE_CD) {
+      return { uiTemplate: "notification", actions: [] };
+    }
+    const template = this.registry.find(message.templateCd);
+    if (!template) return null;
+    const data = message.payload ?? {};
+    const interpolated = interpolateTemplate(template, data, usertype, {
+      permissions: options.permissions,
+      message
+    });
+    if (options.isAdmin) {
+      return { uiTemplate: interpolated.uiTemplate, actions: [] };
+    }
+    return { uiTemplate: interpolated.uiTemplate, actions: interpolated.actions };
+  }
+  // -------------------------------------------------------------------------
+  // Handle an action on a message
+  // -------------------------------------------------------------------------
+  async handleAction(templateCd, actionCd, data) {
+    if (this.isArchivedMessage(data.message)) {
+      throw new MessageArchivedError(String(data.message._id));
+    }
+    const template = this.registry.find(templateCd);
+    if (!template) throw new TemplateNotFoundError(templateCd);
+    const action = template.actions.find((a) => a.actionCd === actionCd);
+    if (!action) throw new ActionNotFoundError(templateCd, actionCd);
+    if (!isActionAllowed(action, data.user, data.message, { permissions: data.permissions })) {
+      throw new ActionNotAllowedError();
+    }
+    const ctx = this.buildActionContext(data);
+    const result = await action.runHandler(ctx);
+    await data.message.archive(actionCd, data.user._id, this.registry);
+    await this.runSenderNotification(action, ctx, data.message);
+    return result;
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  async persistItem(template, m, ctx, clientRequestId) {
+    const toUser = m.toUser ?? null;
+    const toRoles = (m.toRoles && m.toRoles.length > 0 ? m.toRoles : this.adminRoles).slice();
+    const type = m.type || template.type || "notification";
+    const paymentCd = m.paymentCd || template.paymentCd || "";
+    let paymentSession = null;
+    if (paymentCd && this.paymentProvider && (toUser || toRoles.length > 0)) {
+      paymentSession = await this.paymentProvider.createSession(
+        (ctx.payerUser || ctx.user)._id,
+        paymentCd,
+        m.priceArgs
+      );
+      if (!paymentSession) throw new Error("payment session creation failed");
+    }
+    const interpolated = interpolateTemplate(template, m.templateData || {}, "receiver");
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    return Message.create({
+      type,
+      templateCd: template.templateCd,
+      fromUser: m.fromUser || ctx.user._id,
+      toUser,
+      toRoles,
+      senderContent: interpolated.senderContent,
+      receiverContent: interpolated.receiverContent,
+      documents: ctx.payload.documents || [],
+      paymentSession,
+      paymentCd,
+      payload: m.payload || ctx.payload,
+      display: m.display,
+      clientRequestId: clientRequestId ?? null
+    });
+  }
+  buildActionContext(data) {
+    return {
+      message: data.message,
+      user: data.user,
+      getModel: this.getModel,
+      expireSession: this.expirePaymentSession,
+      refundPayment: this.refundPaymentSession,
+      req: data.req
+    };
+  }
+  async runSenderNotification(action, ctx, message) {
+    if (!action.senderNotification) return;
+    let content;
+    if (typeof action.senderNotification === "function") {
+      content = await action.senderNotification(ctx);
+    } else {
+      content = action.senderNotification;
+    }
+    const senderTitle = message.senderContent?.title ?? "";
+    const senderNotificationContent = isString(content) ? { title: senderTitle, long: content, short: content } : {
+      title: content.title || senderTitle,
+      long: content.long,
+      short: content.short || content.long
+    };
+    const documents = !isString(content) ? content.documents || [] : [];
+    if (message.fromUser) {
+      await this.createNotification({
+        toUser: message.fromUser,
+        receiverContent: senderNotificationContent,
+        documents
+      });
+    }
+  }
+  async findByClientRequestId(clientRequestId) {
+    const Message = this.getModel(MESSAGE_MODEL_NAME);
+    const docs = await Message.find({ clientRequestId }).sort({ createdAt: 1, _id: 1 }).limit(Number.MAX_SAFE_INTEGER);
+    return docs.length > 0 ? docs : null;
+  }
+  isArchivedMessage(message) {
+    return "archivedAt" in message;
+  }
+  applyPopulate(query, populate) {
+    if (!populate) {
+      return query;
+    }
+    const items = Array.isArray(populate) ? populate : [populate];
+    let current = query;
+    for (const item of items) {
+      current = current.populate(item);
+    }
+    return current;
+  }
+  async findByIdWithOptions(model, id, options) {
+    const baseQuery = model.findById(id);
+    const selectedQuery = options.select === void 0 ? baseQuery : baseQuery.select(options.select);
+    const query = this.applyPopulate(selectedQuery, options.populate);
+    return query;
+  }
+};
+
+// src/route-factory.ts
+import JsonRouter from "@web-ts-toolkit/express-json-router";
+var ACTION_CD_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function assertValidActionCd(actionCd) {
+  if (typeof actionCd !== "string" || !ACTION_CD_PATTERN.test(actionCd)) {
+    throw new JsonRouter.clientErrors.BadRequestError(
+      "actionCd must be a string of letters, digits, underscores, and hyphens"
+    );
+  }
+}
+function assertValidUsertype(usertype) {
+  if (usertype !== "sender" && usertype !== "receiver") {
+    throw new JsonRouter.clientErrors.BadRequestError('usertype must be "sender" or "receiver"');
+  }
+}
+function mapServiceError(error) {
+  if (error instanceof MessageNotFoundError) {
+    throw new JsonRouter.clientErrors.NotFoundError("message not found");
+  }
+  if (error instanceof TemplateNotFoundError) {
+    throw new JsonRouter.clientErrors.NotFoundError(error.message);
+  }
+  if (error instanceof ActionNotFoundError) {
+    throw new JsonRouter.clientErrors.NotFoundError(error.message);
+  }
+  if (error instanceof ActionNotAllowedError) {
+    throw new JsonRouter.clientErrors.ForbiddenError(error.message);
+  }
+  if (error instanceof MessageArchivedError) {
+    throw new JsonRouter.clientErrors.GoneError(error.message);
+  }
+  throw error;
+}
+function createMessageRoutes(options) {
+  const {
+    getModel,
+    paymentProvider = null,
+    adminRoles,
+    registry,
+    authMiddleware = [],
+    getUser = defaultGetUser,
+    getPermissions = defaultGetPermissions,
+    getIdentity = defaultGetIdentity,
+    adminPermissionKey = "is.admin"
+  } = options;
+  const service = new MessageService({ getModel, paymentProvider, adminRoles, registry });
+  const router = new JsonRouter("", authMiddleware);
+  router.post("/new/:templateCd", async (req) => {
+    const templateCd = req.params.templateCd;
+    const user = getUser(req) || { _id: "" };
+    const roles = user.roles || [];
+    const identity = getIdentity(req);
+    const permissions = getPermissions(req);
+    const body = req.body || {};
+    const { clientRequestId, ...payload } = body;
+    const clientRequestIdStr = typeof clientRequestId === "string" ? clientRequestId : void 0;
+    try {
+      return await service.createMessage({
+        templateCd,
+        user,
+        roles,
+        identity,
+        permissions,
+        payload,
+        payerUser: user,
+        req,
+        clientRequestId: clientRequestIdStr
+      });
+    } catch (error) {
+      mapServiceError(error);
+    }
+  });
+  router.get("/:id/actions/:usertype", async (req) => {
+    const id = req.params.id;
+    const usertype = req.params.usertype;
+    assertValidUsertype(usertype);
+    const permissions = getPermissions(req);
+    const isAdmin = !!permissions[adminPermissionKey];
+    const user = getUser(req) || { _id: "" };
+    const result = await service.getActions(id, usertype, { permissions, user, isAdmin });
+    if (!result) {
+      throw new JsonRouter.clientErrors.NotFoundError("message not found");
+    }
+    return result;
+  });
+  async function handleAction(req) {
+    const id = req.params.id;
+    const actionCd = req.params.actionCd;
+    assertValidActionCd(actionCd);
+    let message;
+    try {
+      message = await service.findMessageOrThrow(id);
+    } catch (error) {
+      mapServiceError(error);
+    }
+    const user = getUser(req) || { _id: "" };
+    const permissions = getPermissions(req);
+    try {
+      return await service.handleAction(message.templateCd, actionCd, { message, user, permissions, req });
+    } catch (error) {
+      mapServiceError(error);
+    }
+  }
+  router.get("/:id/action/:actionCd", handleAction);
+  router.post("/:id/action/:actionCd", handleAction);
+  return { router, service };
+}
+function defaultGetUser(req) {
+  const raw = req._user || req.user;
+  return raw;
+}
+function defaultGetPermissions(req) {
+  return req._permissions || {};
+}
+function defaultGetIdentity(req) {
+  return req._identity || {};
+}
+export {
+  ActionNotAllowedError,
+  ActionNotFoundError,
+  BaseMessageFields,
+  GENERIC_NOTIFICATION_TEMPLATE_CD,
+  MESSAGE_ARCHIVE_MODEL_NAME,
+  MESSAGE_MODEL_NAME,
+  MessageArchiveSchema,
+  MessageArchivedError,
+  MessageContentSchema,
+  MessageNotFoundError,
+  MessageSchema,
+  MessageService,
+  NoopEmailProvider,
+  NoopPaymentProvider,
+  TemplateNotFoundError,
+  TemplateRegistry,
+  buildMessageArchiveSchema,
+  buildMessageSchema,
+  createMessageRoutes,
+  defaultRegistry,
+  filterActions,
+  includesAction,
+  interpolateTemplate,
+  isActionAllowed
+};