@infuro/cms-core 1.0.45 → 1.0.46

package/dist/chunk-GUSHM5HN.js

@@ -0,0 +1,862 @@
+import { renderLayout } from './chunk-CRYKVJTO.js';
+import { notificationTriggerEmitter } from './chunk-HCIRL37O.js';
+import { queueEmail } from './chunk-L3525VXI.js';
+import { mergeEmailLayoutCompanyDetails } from './chunk-2KUCQVAQ.js';
+import { applyTemplateVars } from './chunk-CRFV5WJK.js';
+import { __name } from './chunk-SHUYVCID.js';
+
+// src/lib/event-order-template-context.ts
+function resolvePublicSiteUrl() {
+  if (typeof process !== "undefined") {
+    const u = (process.env.CMS_PUBLIC_URL || process.env.NEXT_PUBLIC_SITE_URL || "").trim();
+    if (u) return u.replace(/\/+$/, "");
+    const v = (process.env.VERCEL_URL || "").trim();
+    if (v) return v.startsWith("http") ? v.replace(/\/+$/, "") : `https://${v.replace(/\/+$/, "")}`;
+  }
+  return "";
+}
+__name(resolvePublicSiteUrl, "resolvePublicSiteUrl");
+function buildOrderTrackUrl(qrToken, siteUrl) {
+  const token = qrToken?.trim();
+  if (!token) return "";
+  const base = (siteUrl ?? resolvePublicSiteUrl()).replace(/\/+$/, "");
+  if (!base) return `/track/${token}`;
+  return `${base}/track/${token}`;
+}
+__name(buildOrderTrackUrl, "buildOrderTrackUrl");
+function buildOrderQrImageUrl(trackUrl, size = 200) {
+  if (!trackUrl.trim()) return "";
+  return `https://api.qrserver.com/v1/create-qr-code/?size=${size}x${size}&data=${encodeURIComponent(trackUrl)}`;
+}
+__name(buildOrderQrImageUrl, "buildOrderQrImageUrl");
+function formatOrderDetailsText(input) {
+  const { orderNumber, total, currency, lines } = input;
+  const header = `Order: ${orderNumber}
+Total: ${total} ${currency}`;
+  if (!lines.length) return header;
+  const items = lines.map((line) => `- ${line.name} \xD7 ${line.quantity} (${line.total} ${line.currency})`).join("\n");
+  return `${header}
+
+Items:
+${items}`;
+}
+__name(formatOrderDetailsText, "formatOrderDetailsText");
+function formatOrderDetailsHtml(input) {
+  const text = formatOrderDetailsText(input);
+  const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return `<pre style="font-family:inherit;white-space:pre-wrap;margin:0">${escaped}</pre>`;
+}
+__name(formatOrderDetailsHtml, "formatOrderDetailsHtml");
+function buildEventOrderTemplateVariables(input) {
+  const { event, order, contact, productNames, orderLines = [], siteUrl } = input;
+  const trackUrl = buildOrderTrackUrl(order.qrToken, siteUrl);
+  const qrImageUrl = buildOrderQrImageUrl(trackUrl);
+  const orderDetailsPayload = {
+    orderNumber: String(order.orderNumber ?? ""),
+    total: String(order.total ?? ""),
+    currency: String(order.currency ?? "INR"),
+    lines: orderLines
+  };
+  return {
+    eventName: event.name ?? "",
+    eventSlug: event.slug ?? "",
+    venue: event.venue ?? "",
+    startDate: formatEventDate(event.startDate),
+    orderNumber: String(order.orderNumber ?? ""),
+    orderTotal: String(order.total ?? ""),
+    currency: String(order.currency ?? "INR"),
+    customerName: contact.name?.trim() || contact.email?.split("@")[0] || "Guest",
+    customerEmail: contact.email?.trim() || "",
+    customerPhone: contact.phone?.trim() || "",
+    productNames,
+    trackUrl,
+    qrImageUrl,
+    orderDetails: formatOrderDetailsText(orderDetailsPayload),
+    orderDetailsHtml: formatOrderDetailsHtml(orderDetailsPayload)
+  };
+}
+__name(buildEventOrderTemplateVariables, "buildEventOrderTemplateVariables");
+function formatEventDate(d) {
+  if (!d) return "";
+  try {
+    return new Date(d).toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    });
+  } catch {
+    return String(d);
+  }
+}
+__name(formatEventDate, "formatEventDate");
+
+// src/lib/order-notification-context.ts
+async function loadOrderLines(dataSource, entityMap, orderId, currency) {
+  if (!entityMap.order_items) return [];
+  const itemRows = await dataSource.getRepository(entityMap.order_items).find({
+    where: {
+      orderId
+    },
+    relations: [
+      "product"
+    ],
+    order: {
+      id: "ASC"
+    }
+  });
+  return itemRows.map((item) => {
+    const row = item;
+    const name = row.product?.name || row.product?.title || `Product #${row.productId}`;
+    return {
+      name: String(name),
+      quantity: Number(row.quantity) || 1,
+      total: row.total,
+      currency
+    };
+  });
+}
+__name(loadOrderLines, "loadOrderLines");
+async function loadPrimaryEvent(dataSource, entityMap, itemRows) {
+  if (!entityMap.event_products || !entityMap.events) {
+    return {
+      productNames: []
+    };
+  }
+  const epRepo = dataSource.getRepository(entityMap.event_products);
+  const eventRepo = dataSource.getRepository(entityMap.events);
+  const eventMap = /* @__PURE__ */ new Map();
+  for (const item of itemRows) {
+    const productId = item.productId;
+    const productName = item.product?.name || item.product?.title || `Product #${productId}`;
+    const eps = await epRepo.find({
+      where: {
+        productId,
+        isActive: true
+      }
+    });
+    for (const ep of eps) {
+      const eventId = ep.eventId;
+      const existing = eventMap.get(eventId);
+      if (existing) {
+        if (!existing.productNames.includes(String(productName))) {
+          existing.productNames.push(String(productName));
+        }
+      } else {
+        const event = await eventRepo.findOne({
+          where: {
+            id: eventId,
+            deleted: false
+          }
+        });
+        if (event) {
+          eventMap.set(eventId, {
+            event,
+            productNames: [
+              String(productName)
+            ]
+          });
+        }
+      }
+    }
+  }
+  const first = eventMap.values().next().value;
+  if (!first) return {
+    productNames: []
+  };
+  return {
+    event: first.event,
+    productNames: first.productNames
+  };
+}
+__name(loadPrimaryEvent, "loadPrimaryEvent");
+async function loadOrderNotificationContexts(orderId, deps) {
+  if (!deps.entityMap.orders) return null;
+  const order = await deps.dataSource.getRepository(deps.entityMap.orders).findOne({
+    where: {
+      id: orderId,
+      deleted: false
+    },
+    relations: [
+      "contact"
+    ]
+  });
+  if (!order) return null;
+  const o = order;
+  const contact = o.contact ?? {};
+  const currency = String(o.currency ?? "INR");
+  const siteUrl = resolvePublicSiteUrl();
+  const itemRows = await deps.dataSource.getRepository(deps.entityMap.order_items).find({
+    where: {
+      orderId
+    },
+    relations: [
+      "product"
+    ],
+    order: {
+      id: "ASC"
+    }
+  });
+  const orderLines = await loadOrderLines(deps.dataSource, deps.entityMap, orderId, currency);
+  const { event, productNames: eventProductNames } = await loadPrimaryEvent(deps.dataSource, deps.entityMap, itemRows);
+  const allProductNames = orderLines.map((line) => line.name);
+  const productNames = eventProductNames.length > 0 ? eventProductNames.join(", ") : allProductNames.join(", ");
+  const variables = event ? buildEventOrderTemplateVariables({
+    event,
+    order: {
+      orderNumber: o.orderNumber,
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    productNames,
+    orderLines,
+    siteUrl
+  }) : buildEventOrderTemplateVariables({
+    event: {
+      name: productNames || "Your order",
+      slug: "",
+      venue: "",
+      startDate: null
+    },
+    order: {
+      orderNumber: o.orderNumber,
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    productNames,
+    orderLines,
+    siteUrl
+  });
+  return {
+    order: {
+      id: o.id,
+      orderNumber: String(o.orderNumber ?? ""),
+      total: o.total,
+      currency,
+      qrToken: o.qrToken
+    },
+    contact,
+    orderLines,
+    productNames,
+    event,
+    variables
+  };
+}
+__name(loadOrderNotificationContexts, "loadOrderNotificationContexts");
+
+// src/plugins/whatsapp/whatsapp-queue.ts
+var WHATSAPP_QUEUE_NAME = "whatsapp";
+function maskPhone(raw) {
+  const digits = raw.replace(/\D/g, "");
+  if (digits.length <= 4) return "****";
+  return `${"*".repeat(Math.max(0, digits.length - 4))}${digits.slice(-4)}`;
+}
+__name(maskPhone, "maskPhone");
+function registerWhatsAppQueueProcessor(cms) {
+  const queue = cms.getPlugin("queue");
+  const whatsapp = cms.getPlugin("whatsapp");
+  if (!queue) {
+    console.warn("[whatsapp] queue processor not registered: queue plugin missing");
+    return;
+  }
+  if (!whatsapp || typeof whatsapp.send !== "function") {
+    console.warn("[whatsapp] queue processor not registered: whatsapp plugin missing or not configured");
+    return;
+  }
+  queue.registerProcessor(WHATSAPP_QUEUE_NAME, async (data) => {
+    const payload = data;
+    if (!payload.to) {
+      console.warn("[whatsapp] queue job skipped: missing recipient");
+      return;
+    }
+    console.log("[whatsapp] queue job processing", {
+      to: maskPhone(payload.to),
+      templateKey: payload.templateKey ?? null,
+      externalTemplateRef: payload.externalTemplateRef ?? null
+    });
+    try {
+      const ok = await whatsapp.send(payload);
+      if (ok) {
+        console.log("[whatsapp] queue job completed", {
+          to: maskPhone(payload.to),
+          sent: true
+        });
+      } else {
+        console.warn("[whatsapp] queue job completed without delivery", {
+          to: maskPhone(payload.to),
+          sent: false
+        });
+      }
+    } catch (err) {
+      console.error("[whatsapp] queue job failed", {
+        to: maskPhone(payload.to),
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  });
+  console.log("[whatsapp] queue processor registered", {
+    queue: WHATSAPP_QUEUE_NAME
+  });
+}
+__name(registerWhatsAppQueueProcessor, "registerWhatsAppQueueProcessor");
+async function queueWhatsApp(cms, payload) {
+  const queue = cms.getPlugin("queue");
+  if (queue) {
+    console.log("[whatsapp] enqueue", {
+      to: maskPhone(payload.to),
+      templateKey: payload.templateKey ?? null,
+      externalTemplateRef: payload.externalTemplateRef ?? null
+    });
+    await queue.add(WHATSAPP_QUEUE_NAME, payload);
+    return true;
+  }
+  const whatsapp = cms.getPlugin("whatsapp");
+  if (whatsapp && typeof whatsapp.send === "function") {
+    console.log("[whatsapp] no queue plugin \u2014 sending immediately", {
+      to: maskPhone(payload.to)
+    });
+    return whatsapp.send(payload);
+  }
+  console.warn("[whatsapp] send skipped: neither queue nor whatsapp plugin available", {
+    to: maskPhone(payload.to)
+  });
+  return false;
+}
+__name(queueWhatsApp, "queueWhatsApp");
+
+// src/plugins/whatsapp/whatsapp-service.ts
+function norm(v) {
+  const t = v?.trim();
+  return t || void 0;
+}
+__name(norm, "norm");
+function pick(plugin, db, env, ...keys) {
+  for (const key of keys) {
+    const pk = key;
+    if (pk in plugin && plugin[pk] !== void 0 && String(plugin[pk]).trim() !== "") {
+      const v = norm(String(plugin[pk]));
+      if (v) return v;
+    }
+    if (norm(db[key])) return norm(db[key]);
+    if (norm(env[key])) return norm(env[key]);
+  }
+  return void 0;
+}
+__name(pick, "pick");
+function mergeWhatsAppConfigLayers(env, db, plugin) {
+  return {
+    accessToken: pick(plugin, db, env, "accessToken", "WHATSAPP_ACCESS_TOKEN"),
+    phoneNumberId: pick(plugin, db, env, "phoneNumberId", "WHATSAPP_PHONE_NUMBER_ID"),
+    apiVersion: pick(plugin, db, env, "apiVersion", "WHATSAPP_API_VERSION") ?? "v21.0"
+  };
+}
+__name(mergeWhatsAppConfigLayers, "mergeWhatsAppConfigLayers");
+function isWhatsAppPluginEnabled(db) {
+  const v = (db.enabled ?? "true").toLowerCase();
+  return v !== "false" && v !== "0";
+}
+__name(isWhatsAppPluginEnabled, "isWhatsAppPluginEnabled");
+function whatsAppConfigured(config) {
+  return Boolean(config.accessToken?.trim() && config.phoneNumberId?.trim());
+}
+__name(whatsAppConfigured, "whatsAppConfigured");
+function normalizeWhatsAppRecipient(to) {
+  const digits = to.replace(/\D/g, "");
+  return digits;
+}
+__name(normalizeWhatsAppRecipient, "normalizeWhatsAppRecipient");
+function resolveMetaWhatsAppTemplateName(opts) {
+  const ref = opts.externalTemplateRef?.trim();
+  const rowName = opts.name?.trim();
+  if (ref && !/^\d+$/.test(ref)) return ref;
+  if (rowName) return rowName;
+  return ref || void 0;
+}
+__name(resolveMetaWhatsAppTemplateName, "resolveMetaWhatsAppTemplateName");
+function maskPhone2(digits) {
+  if (digits.length <= 4) return "****";
+  return `${"*".repeat(Math.max(0, digits.length - 4))}${digits.slice(-4)}`;
+}
+__name(maskPhone2, "maskPhone");
+function logWhatsApp(level, message, extra) {
+  const line = extra ? `${message} ${JSON.stringify(extra)}` : message;
+  if (level === "info") console.log(`[whatsapp] ${line}`);
+  else if (level === "warn") console.warn(`[whatsapp] ${line}`);
+  else console.error(`[whatsapp] ${line}`);
+}
+__name(logWhatsApp, "logWhatsApp");
+var WhatsAppService = class {
+  static {
+    __name(this, "WhatsAppService");
+  }
+  getWhatsAppSettings;
+  config;
+  getMessageTemplateRow;
+  constructor(env, plugin = {}, getWhatsAppSettings, getMessageTemplateRow) {
+    this.getWhatsAppSettings = getWhatsAppSettings;
+    this.getMessageTemplateRow = getMessageTemplateRow;
+    this.config = mergeWhatsAppConfigLayers(env, {}, plugin);
+  }
+  async mergedConfig() {
+    let db = {};
+    try {
+      db = await this.getWhatsAppSettings?.() ?? {};
+    } catch {
+    }
+    return mergeWhatsAppConfigLayers((typeof process !== "undefined" ? process.env : {}) ?? {}, db, this.config);
+  }
+  async send(opts) {
+    const cfg = await this.mergedConfig();
+    if (!whatsAppConfigured(cfg)) {
+      logWhatsApp("warn", "send skipped: not configured (Plugins \u2192 WhatsApp or WHATSAPP_ACCESS_TOKEN + WHATSAPP_PHONE_NUMBER_ID)");
+      return false;
+    }
+    const to = normalizeWhatsAppRecipient(opts.to);
+    if (!to) {
+      logWhatsApp("warn", "send skipped: invalid recipient", {
+        rawTo: opts.to
+      });
+      return false;
+    }
+    logWhatsApp("info", "send started", {
+      to: maskPhone2(to),
+      templateKey: opts.templateKey ?? null,
+      externalTemplateRef: opts.externalTemplateRef ?? null,
+      phoneNumberId: cfg.phoneNumberId
+    });
+    let templateName = resolveMetaWhatsAppTemplateName({
+      externalTemplateRef: opts.externalTemplateRef
+    });
+    let templateLanguage = opts.templateLanguage?.trim();
+    let body = opts.body?.trim() ?? "";
+    const variables = opts.variables ?? {};
+    if (opts.templateKey?.trim() && this.getMessageTemplateRow) {
+      const { resolveEventOrderTemplate, EVENT_ORDER_TEMPLATE_KEY } = await import('./event-order-defaults-SDRNAZHC.js');
+      if (opts.templateKey.trim() === EVENT_ORDER_TEMPLATE_KEY) {
+        const resolved = await resolveEventOrderTemplate("whatsapp", async (ch, key) => {
+          const row = await this.getMessageTemplateRow(ch, key);
+          if (!row) return null;
+          return {
+            subject: null,
+            body: row.body,
+            externalTemplateRef: row.externalTemplateRef,
+            enabled: row.enabled
+          };
+        });
+        if (resolved && !resolved.enabled) {
+          logWhatsApp("warn", "send skipped: template disabled in message_templates", {
+            templateKey: opts.templateKey
+          });
+          return false;
+        }
+        if (resolved) {
+          body = resolved.body;
+          if (resolved.externalTemplateRef) templateName = resolved.externalTemplateRef;
+        }
+      }
+    }
+    const { applyTemplateVars: applyTemplateVars2 } = await import('./interpolate-WDUWDF3I.js');
+    if (body) body = applyTemplateVars2(body, variables);
+    if (templateName) {
+      const paramValues = opts.templateParamOrder?.length ? opts.templateParamOrder.map((key) => String(variables[key] ?? "").slice(0, 1024)) : Object.keys(variables).length ? Object.values(variables) : body ? [
+        body
+      ] : [];
+      logWhatsApp("info", "sending template message", {
+        to: maskPhone2(to),
+        templateName,
+        paramCount: paramValues.length,
+        paramOrder: opts.templateParamOrder ?? null
+      });
+      return this.sendTemplateMessage(cfg, to, templateName, paramValues, templateLanguage);
+    }
+    if (!body) {
+      logWhatsApp("warn", "send skipped: no template name and empty body", {
+        to: maskPhone2(to)
+      });
+      return false;
+    }
+    logWhatsApp("info", "sending text message", {
+      to: maskPhone2(to),
+      bodyLength: body.length
+    });
+    return this.sendTextMessage(cfg, to, body);
+  }
+  async sendTextMessage(cfg, to, body) {
+    const url = `https://graph.facebook.com/${cfg.apiVersion}/${cfg.phoneNumberId}/messages`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${cfg.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        messaging_product: "whatsapp",
+        to,
+        type: "text",
+        text: {
+          body
+        }
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      logWhatsApp("error", "text send failed", {
+        status: res.status,
+        to: maskPhone2(to),
+        error: errText
+      });
+      return false;
+    }
+    const data = await res.json().catch(() => ({}));
+    logWhatsApp("info", "text send succeeded", {
+      to: maskPhone2(to),
+      messageId: data.messages?.[0]?.id ?? null
+    });
+    return true;
+  }
+  async sendTemplateMessage(cfg, to, templateName, paramValues, templateLanguage) {
+    const components = paramValues.length > 0 ? [
+      {
+        type: "body",
+        parameters: paramValues.map((text) => ({
+          type: "text",
+          text: String(text).slice(0, 1024)
+        }))
+      }
+    ] : void 0;
+    const url = `https://graph.facebook.com/${cfg.apiVersion}/${cfg.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      to,
+      type: "template",
+      template: {
+        name: templateName,
+        language: {
+          code: templateLanguage?.trim() || "en"
+        },
+        ...components ? {
+          components
+        } : {}
+      }
+    };
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${cfg.accessToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      logWhatsApp("error", "template send failed", {
+        status: res.status,
+        to: maskPhone2(to),
+        templateName,
+        paramCount: paramValues.length,
+        error: errText
+      });
+      return false;
+    }
+    const data = await res.json().catch(() => ({}));
+    logWhatsApp("info", "template send succeeded", {
+      to: maskPhone2(to),
+      templateName,
+      messageId: data.messages?.[0]?.id ?? null
+    });
+    return true;
+  }
+};
+
+// src/lib/order-notification-dispatcher.ts
+var initialized = false;
+function maskPhone3(raw) {
+  const digits = String(raw ?? "").replace(/\D/g, "");
+  if (digits.length <= 4) return "(none)";
+  return `***${digits.slice(-4)}`;
+}
+__name(maskPhone3, "maskPhone");
+async function getSettingsGroup(dataSource, entityMap, group) {
+  if (!entityMap.configs) return {};
+  const rows = await dataSource.getRepository(entityMap.configs).find({
+    where: {
+      settings: group,
+      deleted: false
+    }
+  });
+  return Object.fromEntries(rows.map((r) => [
+    r.key,
+    r.value
+  ]));
+}
+__name(getSettingsGroup, "getSettingsGroup");
+async function isOrderNotificationsEnabled(dataSource, entityMap) {
+  const settings = await getSettingsGroup(dataSource, entityMap, "event_notifications");
+  return settings.enabled !== "false" && settings.enabled !== "0";
+}
+__name(isOrderNotificationsEnabled, "isOrderNotificationsEnabled");
+async function isTriggerCatalogEnabled(triggerKey, dataSource, entityMap) {
+  if (!entityMap.order_notification_triggers) {
+    console.warn("[order-notifications] order_notification_triggers missing \u2014 run migration 1781230000000-AddOrderNotificationTriggers");
+    return false;
+  }
+  try {
+    const row = await dataSource.getRepository(entityMap.order_notification_triggers).findOne({
+      where: {
+        triggerKey,
+        enabled: true
+      }
+    });
+    if (!row) {
+      console.warn("[order-notifications] trigger disabled or not in DB", {
+        triggerKey
+      });
+    }
+    return Boolean(row);
+  } catch (err) {
+    console.error("[order-notifications] failed to load trigger catalog", {
+      triggerKey,
+      err
+    });
+    return false;
+  }
+}
+__name(isTriggerCatalogEnabled, "isTriggerCatalogEnabled");
+async function loadBoundTemplate(triggerKey, channel, dataSource, entityMap) {
+  if (!entityMap.order_notification_bindings || !entityMap.message_templates) {
+    console.warn("[order-notifications] order_notification_bindings or message_templates missing from entityMap");
+    return null;
+  }
+  const binding = await dataSource.getRepository(entityMap.order_notification_bindings).findOne({
+    where: {
+      triggerKey,
+      channel,
+      enabled: true
+    }
+  });
+  if (!binding) {
+    console.warn("[order-notifications] no order_notification_bindings row", {
+      triggerKey,
+      channel
+    });
+    return null;
+  }
+  const templateId = binding.messageTemplateId;
+  if (templateId == null) {
+    console.warn("[order-notifications] binding exists but no template selected", {
+      triggerKey,
+      channel
+    });
+    return null;
+  }
+  const template = await dataSource.getRepository(entityMap.message_templates).findOne({
+    where: {
+      id: templateId,
+      channel,
+      deleted: false,
+      enabled: true
+    }
+  });
+  if (!template) {
+    console.warn("[order-notifications] bound template not found or disabled", {
+      triggerKey,
+      channel,
+      templateId
+    });
+    return null;
+  }
+  return template;
+}
+__name(loadBoundTemplate, "loadBoundTemplate");
+function mergeTriggerVariables(payload, rich) {
+  const basic = {
+    orderId: String(payload.orderId ?? ""),
+    orderNumber: payload.orderNumber,
+    customerName: payload.customerName,
+    customerPhone: payload.customerPhone ?? "",
+    total: String(payload.total),
+    orderTotal: String(payload.total),
+    currency: payload.currency,
+    vendorId: String(payload.vendorId ?? ""),
+    ...payload.refundAmount != null ? {
+      refundAmount: String(payload.refundAmount)
+    } : {}
+  };
+  return {
+    ...basic,
+    ...rich ?? {}
+  };
+}
+__name(mergeTriggerVariables, "mergeTriggerVariables");
+async function sendEmailForTrigger(triggerKey, orderId, variables, contactEmail, dataSource, entityMap, getCms) {
+  const template = await loadBoundTemplate(triggerKey, "email", dataSource, entityMap);
+  if (!template) return;
+  const [branding, emailSettings] = await Promise.all([
+    getSettingsGroup(dataSource, entityMap, "branding"),
+    getSettingsGroup(dataSource, entityMap, "email")
+  ]);
+  const companyDetails = mergeEmailLayoutCompanyDetails(branding, emailSettings);
+  const subject = applyTemplateVars(template.subject ?? "Order update", variables);
+  const bodyHtml = applyTemplateVars(template.body, variables);
+  const html = renderLayout({
+    bodyHtml,
+    companyDetails
+  });
+  const cms = await getCms();
+  await queueEmail(cms, {
+    to: contactEmail,
+    subject,
+    html,
+    text: bodyHtml.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()
+  });
+  console.log("[order-notifications] email queued", {
+    triggerKey,
+    orderId,
+    to: contactEmail
+  });
+}
+__name(sendEmailForTrigger, "sendEmailForTrigger");
+async function sendWhatsAppForTrigger(triggerKey, orderId, phone, variables, dataSource, entityMap, getCms) {
+  const template = await loadBoundTemplate(triggerKey, "whatsapp", dataSource, entityMap);
+  if (!template) return;
+  const paramOrder = template.providerMeta?.paramOrder ?? [];
+  if (paramOrder.length === 0) {
+    console.warn("[order-notifications] WhatsApp template has no paramOrder set \u2014 variables may send blank/wrong", {
+      triggerKey
+    });
+  }
+  const cms = await getCms();
+  const metaTemplateName = resolveMetaWhatsAppTemplateName({
+    externalTemplateRef: template.externalTemplateRef,
+    name: template.name
+  });
+  if (!metaTemplateName) {
+    console.warn("[order-notifications] bound WhatsApp template has no Meta template name", {
+      triggerKey,
+      templateId: template.id
+    });
+    return;
+  }
+  const sent = await queueWhatsApp(cms, {
+    to: phone.trim(),
+    templateKey: triggerKey,
+    externalTemplateRef: metaTemplateName,
+    templateLanguage: template.providerMeta?.language ?? void 0,
+    body: template.body,
+    variables,
+    templateParamOrder: paramOrder
+  });
+  if (!sent) {
+    console.warn("[order-notifications] WhatsApp send failed", {
+      triggerKey,
+      orderId,
+      hint: "Register whatsappPlugin() + queuePlugin() in getCms(), or set WHATSAPP_ACCESS_TOKEN and WHATSAPP_PHONE_NUMBER_ID"
+    });
+  } else {
+    console.log("[order-notifications] WhatsApp queued/sent", {
+      triggerKey,
+      orderId,
+      phone: maskPhone3(phone)
+    });
+  }
+}
+__name(sendWhatsAppForTrigger, "sendWhatsAppForTrigger");
+async function handleTrigger(triggerKey, payload, dataSource, entityMap, getCms) {
+  console.log("[order-notifications] received", {
+    triggerKey,
+    orderId: payload.orderId,
+    phone: maskPhone3(payload.customerPhone)
+  });
+  const pluginEnabled = await isOrderNotificationsEnabled(dataSource, entityMap);
+  if (!pluginEnabled) {
+    console.warn("[order-notifications] skip: Plugins \u2192 Order notifications disabled");
+    return;
+  }
+  const triggerEnabled = await isTriggerCatalogEnabled(triggerKey, dataSource, entityMap);
+  if (!triggerEnabled) return;
+  const context = await loadOrderNotificationContexts(payload.orderId, {
+    dataSource,
+    entityMap
+  });
+  const variables = mergeTriggerVariables(payload, context?.variables);
+  const contactEmail = context?.contact.email?.trim() || "";
+  const contactPhone = context?.contact.phone?.trim() || payload.customerPhone?.trim() || "";
+  if (contactEmail) {
+    await sendEmailForTrigger(triggerKey, payload.orderId, variables, contactEmail, dataSource, entityMap, getCms);
+  } else {
+    console.warn("[order-notifications] skip email: no customer email", {
+      triggerKey,
+      orderId: payload.orderId
+    });
+  }
+  if (contactPhone) {
+    await sendWhatsAppForTrigger(triggerKey, payload.orderId, contactPhone, variables, dataSource, entityMap, getCms);
+  } else {
+    console.warn("[order-notifications] skip WhatsApp: no customer phone", {
+      triggerKey,
+      orderId: payload.orderId
+    });
+  }
+}
+__name(handleTrigger, "handleTrigger");
+function initWhatsappTriggerDispatcher(deps) {
+  if (initialized) return;
+  initialized = true;
+  const { dataSource, entityMap, getCms } = deps;
+  notificationTriggerEmitter.onAnyTrigger((triggerKey, payload) => {
+    void handleTrigger(triggerKey, payload, dataSource, entityMap, getCms).catch((err) => {
+      console.error("[order-notifications]", triggerKey, err);
+    });
+  });
+  console.log("[order-notifications] dispatcher initialized (email + WhatsApp, unified via order_notification_bindings)");
+}
+__name(initWhatsappTriggerDispatcher, "initWhatsappTriggerDispatcher");
+async function resendOrderNotification(triggerKey, orderId, deps) {
+  if (!deps.entityMap.orders) return {
+    ok: false,
+    error: "orders entity missing"
+  };
+  const pluginEnabled = await isOrderNotificationsEnabled(deps.dataSource, deps.entityMap);
+  if (!pluginEnabled) return {
+    ok: false,
+    error: "Order notifications plugin is disabled"
+  };
+  const triggerEnabled = await isTriggerCatalogEnabled(triggerKey, deps.dataSource, deps.entityMap);
+  if (!triggerEnabled) {
+    return {
+      ok: false,
+      error: `Trigger "${triggerKey}" is disabled or migration 1781230000000 not applied`
+    };
+  }
+  const order = await deps.dataSource.getRepository(deps.entityMap.orders).findOne({
+    where: {
+      id: orderId,
+      deleted: false
+    },
+    relations: [
+      "contact"
+    ]
+  });
+  if (!order) return {
+    ok: false,
+    error: "Order not found"
+  };
+  const o = order;
+  await handleTrigger(triggerKey, {
+    orderId,
+    orderNumber: String(o.orderNumber ?? ""),
+    customerName: o.contact?.name ?? "",
+    customerPhone: o.contact?.phone ?? null,
+    total: o.total ?? 0,
+    currency: String(o.currency ?? "INR"),
+    vendorId: o.vendorId ?? null
+  }, deps.dataSource, deps.entityMap, deps.getCms);
+  return {
+    ok: true
+  };
+}
+__name(resendOrderNotification, "resendOrderNotification");
+
+export { WhatsAppService, buildEventOrderTemplateVariables, initWhatsappTriggerDispatcher, isWhatsAppPluginEnabled, mergeWhatsAppConfigLayers, queueWhatsApp, registerWhatsAppQueueProcessor, resendOrderNotification, whatsAppConfigured };