@live-change/email-service 0.9.221 → 0.9.223

package/index.js

@@ -5,7 +5,7 @@ import definition from './definition.js'
 
 import './send.js'
 import './auth.js'
-import './notiifcations.js'
+import './notifications.js'
 
 import validator from './emailValidator.js'
 definition.validator('email', validator)

package/notificationEmailContent.js

@@ -0,0 +1,25 @@
+export function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+export function buildPlainEmailContent({ to, notificationType, title, message, notification }) {
+  const subject = title
+    ? String(title)
+    : `Notification: ${notificationType}`
+  const lines = [
+    message ? String(message) : `You have a new notification (${notificationType}).`,
+    '',
+    notification ? `Notification id: ${notification}` : null
+  ].filter(line => line != null)
+  const text = lines.join('\n')
+  const html = `<div style="font-family:sans-serif;line-height:1.4">
+  <h2 style="margin:0 0 12px">${escapeHtml(subject)}</h2>
+  <p>${escapeHtml(lines[0] || '')}</p>
+  ${notification ? `<p style="color:#666;font-size:12px">id: ${escapeHtml(String(notification))}</p>` : ''}
+</div>`
+  return { to, subject, text, html }
+}

package/notifications.js

@@ -0,0 +1,155 @@
+import definition from './definition.js'
+import { Email } from './auth.js'
+import { buildPlainEmailContent } from './notificationEmailContent.js'
+
+const CONTACT_TYPE = 'email_Email'
+const Notification = definition.foreignModel('notification', 'Notification')
+
+async function channelActive(trigger, {
+  userId,
+  contactId,
+  notificationType
+}) {
+  try {
+    return await trigger({ type: 'isNotificationChannelActive' }, {
+      userId,
+      contactType: CONTACT_TYPE,
+      contactId,
+      notificationType
+    })
+  } catch {
+    // Prefer fail-open for delivery when preference service is unavailable
+    return true
+  }
+}
+
+async function sendNotificationEmail(trigger, {
+  userId,
+  notificationId,
+  notificationType,
+  title,
+  message
+}) {
+  const emails = await Email.indexRangeGet('byUser', [userId], { limit: 32 }) ?? []
+  if (!emails.length) return { sent: 0, skipped: 0 }
+
+  let sent = 0
+  let skipped = 0
+
+  for (const row of emails) {
+    const contactId = row?.id ?? row?.to ?? row?.email
+    const address = row?.email || contactId
+    if (!contactId || !address) continue
+
+    const active = await channelActive(trigger, {
+      userId,
+      contactId: String(contactId),
+      notificationType
+    })
+    if (!active) {
+      skipped += 1
+      continue
+    }
+
+    const content = buildPlainEmailContent({
+      to: String(address),
+      notificationType,
+      title,
+      message,
+      notification: notificationId
+    })
+
+    await trigger({ type: 'sendEmailMessage' }, { email: content })
+    sent += 1
+  }
+
+  if (sent > 0 && notificationId) {
+    await trigger({ type: 'markNotificationsEmailed' }, {
+      user: userId,
+      notifications: [String(notificationId)]
+    }).catch(() => {})
+  } else if (notificationId && sent === 0 && emails.length) {
+    await trigger({ type: 'setNotificationChannelState' }, {
+      notification: String(notificationId),
+      emailState: 'pending'
+    }).catch(() => {})
+  }
+
+  return { sent, skipped }
+}
+
+definition.trigger({
+  name: 'notificationCreated',
+  properties: {
+    notification: { type: String },
+    sessionOrUserType: { type: String, validation: ['nonEmpty'] },
+    sessionOrUser: { type: String, validation: ['nonEmpty'] },
+    notificationType: { type: String, validation: ['nonEmpty'] },
+    title: { type: String },
+    message: { type: String },
+    time: { type: Date }
+  },
+  async execute(params, { trigger }) {
+    if (String(params.sessionOrUserType) !== 'user_User') return { skipped: true, reason: 'not_user' }
+    const userId = String(params.sessionOrUser)
+    const notificationId = params.notification != null
+      ? String(params.notification)
+      : null
+
+    if (notificationId) {
+      await trigger({ type: 'setNotificationChannelState' }, {
+        notification: notificationId,
+        emailState: 'pending'
+      }).catch(() => {})
+    }
+
+    return sendNotificationEmail(trigger, {
+      userId,
+      notificationId,
+      notificationType: String(params.notificationType),
+      title: params.title,
+      message: params.message
+    })
+  }
+})
+
+definition.trigger({
+  name: 'checkEmailNotificationState',
+  properties: {
+    sessionOrUserType: { type: String, validation: ['nonEmpty'] },
+    sessionOrUser: { type: String, validation: ['nonEmpty'] }
+  },
+  async execute({ sessionOrUserType, sessionOrUser }, { trigger }) {
+    if (String(sessionOrUserType) !== 'user_User') {
+      return { skipped: true, reason: 'not_user' }
+    }
+    const userId = String(sessionOrUser)
+    const rows = await Notification.indexRangeGet(
+      'bySessionOrUser',
+      ['user_User', userId],
+      { limit: 64, reverse: true }
+    ) ?? []
+
+    const pending = rows.filter(row => {
+      const state = String(row?.emailState ?? '')
+      return state !== 'sent'
+    })
+
+    const results = []
+    for (const row of pending) {
+      const notificationId = row?.id ?? row?.to
+      if (!notificationId) continue
+      const result = await sendNotificationEmail(trigger, {
+        userId,
+        notificationId: String(notificationId),
+        notificationType: String(row.notificationType ?? 'unknown'),
+        title: row.title,
+        message: row.message
+      })
+      results.push({ notification: notificationId, ...result })
+    }
+    return { count: results.length, results }
+  }
+})
+
+export { buildPlainEmailContent } from './notificationEmailContent.js'

package/notifications.test.mjs

@@ -0,0 +1,33 @@
+/**
+ * Unit tests for plain notification email content builder.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { buildPlainEmailContent, escapeHtml } from './notificationEmailContent.js'
+
+test('escapeHtml escapes markup', () => {
+  assert.equal(escapeHtml('<b>&"'), '&lt;b&gt;&amp;&quot;')
+})
+
+test('buildPlainEmailContent uses title and message', () => {
+  const content = buildPlainEmailContent({
+    to: 'a@test.com',
+    notificationType: 'ops_MaintenanceNeeded',
+    title: 'Maintenance needed',
+    message: 'Device offline',
+    notification: 'n1'
+  })
+  assert.equal(content.to, 'a@test.com')
+  assert.equal(content.subject, 'Maintenance needed')
+  assert.match(content.text, /Device offline/)
+  assert.match(content.html, /Maintenance needed/)
+  assert.match(content.html, /n1/)
+})
+
+test('buildPlainEmailContent falls back to notificationType subject', () => {
+  const content = buildPlainEmailContent({
+    to: 'a@test.com',
+    notificationType: 'example_TestNotification'
+  })
+  assert.equal(content.subject, 'Notification: example_TestNotification')
+})

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@live-change/email-service",
-  "version": "0.9.221",
+  "version": "0.9.223",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "NODE_ENV=test tape tests/*"
+    "test": "node --test notifications.test.mjs"
   },
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.9.221",
+    "@live-change/framework": "^0.9.223",
     "got": "^14.4.7",
     "html-to-text": "^9.0.5",
     "inline-css": "4.0.2",
@@ -32,6 +32,6 @@
     "postcss-calc": "10.1.1",
     "postcss-custom-properties": "14.0.4"
   },
-  "gitHead": "ae6d6ee6938d3aaf0c2eda15fe19660d9a3cf105",
+  "gitHead": "bbe8401443d2e2a238362a9e73cd2697ddf2e6e9",
   "type": "module"
 }

package/notiifcations.js

@@ -1,50 +0,0 @@
-import App from '@live-change/framework'
-const app = App.app()
-import definition from './definition.js'
-
-definition.trigger({
-  name: 'notificationCreated',
-  properties: {
-    notification: {
-      type: Object
-    },
-    sessionOrUserType: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    sessionOrUser: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    notificationType: {
-      type: String,
-      validation: ['nonEmpty']
-    }
-  },
-  async execute(params , { service }, emit) {
-    /// TODO: think if this mechanism along with grouping could be moved to notification service
-    /// TODO: check if user enabled email for this type of notification
-  }
-})
-
-definition.trigger({
-  name: 'checkEmailNotificationState',
-  properties: {
-    sessionOrUserType: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-    sessionOrUser: {
-      type: String,
-      validation: ['nonEmpty']
-    },
-  },
-  async execute(params , { service }, emit) {
-
-    /// TODO: 1. get notifications by user
-    /// TODO: 2. check if there are any notifications that are not emailed yed
-    /// TODO: 3. decide if notifications should be grouped, partition notifications to grouped and non-grouped
-    /// TODO: 4. send email for each group of notifications, and each non-grouped notification
-    /// TODO: 5. mark notifications as emailed
-  }
-})