npm - backend-manager - Versions diffs - 5.0.154 → 5.0.157 - Mend

backend-manager 5.0.154 → 5.0.157

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/CHANGELOG.md +41 -0
package/CLAUDE.md +2 -2
package/package.json +1 -1
package/src/cli/commands/setup-tests/firestore-indexes-required.js +1 -1
package/src/cli/commands/setup-tests/functions-package.js +3 -1
package/src/cli/commands/setup-tests/{required-indexes.js → helpers/required-indexes.js} +22 -0
package/src/cli/commands/setup-tests/helpers/seed-campaigns.js +132 -0
package/src/cli/commands/setup-tests/index.js +2 -0
package/src/cli/commands/setup-tests/marketing-campaigns-seeded.js +109 -0
package/src/manager/cron/daily/marketing-prune.js +140 -0
package/src/manager/cron/frequent/marketing-campaigns.js +158 -0
package/src/manager/events/auth/on-create.js +36 -1
package/src/manager/libraries/email/constants.js +46 -2
package/src/manager/libraries/email/index.js +13 -3
package/src/manager/libraries/email/marketing/index.js +205 -33
package/src/manager/libraries/email/providers/beehiiv.js +90 -0
package/src/manager/libraries/email/providers/sendgrid.js +179 -1
package/src/manager/libraries/email/transactional/index.js +17 -0
package/src/manager/libraries/email/utm.js +116 -0
package/src/manager/libraries/notification.js +223 -0
package/src/manager/routes/admin/notification/post.js +16 -241
package/src/manager/routes/marketing/campaign/delete.js +45 -0
package/src/manager/routes/marketing/campaign/get.js +69 -0
package/src/manager/routes/marketing/campaign/post.js +161 -0
package/src/manager/routes/marketing/campaign/put.js +122 -0
package/src/manager/routes/user/data-request/delete.js +3 -1
package/src/manager/routes/user/data-request/get.js +3 -1
package/src/manager/routes/user/data-request/post.js +3 -1
package/src/manager/routes/user/delete.js +4 -3
package/src/manager/routes/user/signup/post.js +10 -8
package/src/manager/schemas/marketing/campaign/delete.js +6 -0
package/src/manager/schemas/marketing/campaign/get.js +11 -0
package/src/manager/schemas/marketing/campaign/post.js +35 -0
package/src/manager/schemas/marketing/campaign/put.js +35 -0
package/templates/backend-manager-config.json +3 -0

package/src/manager/routes/admin/notification/post.js CHANGED Viewed

@@ -1,262 +1,37 @@
 /**
  * POST /admin/notification - Send FCM push notification
- * Admin-only endpoint to send push notifications
+ * Admin-only endpoint to send push notifications.
+ * Uses shared notification library (also used by marketing-campaigns cron).
  */
-const PATH_NOTIFICATIONS = 'notifications';
-const BAD_TOKEN_REASONS = [
-  'messaging/invalid-registration-token',
-  'messaging/registration-token-not-registered',
-];
-const BATCH_SIZE = 500;
+const notification = require('../../../libraries/notification.js');
 module.exports = async ({ assistant, user, settings, analytics }) => {
-  // Require authentication
   if (!user.authenticated) {
     return assistant.respond('Authentication required', { code: 401 });
   }
-  // Require admin
   if (!user.roles.admin) {
     return assistant.respond('Admin required.', { code: 403 });
   }
-  // Set up response tracking
-  const response = {
-    subscribers: 0,
-    batches: 0,
-    sent: 0,
-    deleted: 0,
-  };
-  // Validate required fields
   if (!settings.notification.title || !settings.notification.body) {
     return assistant.respond('Parameters <title> and <body> required', { code: 400 });
   }
-  // Build notification payload
-  const notification = {
+  const result = await notification.send(assistant, {
     title: settings.notification.title,
     body: settings.notification.body,
-    imageUrl: settings.notification.icon
-      || 'https://cdn.itwcreativeworks.com/assets/itw-creative-works/images/socials/itw-creative-works-brandmark-square-black-1024x1024.png',
-    click_action: settings.notification.clickAction
-      || settings.notification.click_action
-      || 'https://itwcreativeworks.com',
-  };
-  // Add cache buster to click_action URL
-  try {
-    const url = new URL(notification.click_action);
-    url.searchParams.set('cb', new Date().getTime());
-    notification.click_action = url.toString();
-  } catch (e) {
-    return assistant.respond(`Failed to add cb to URL: ${e}`, { code: 400 });
-  }
-  assistant.log('Resolved notification payload', notification);
-  // Build filter options
-  const filterOptions = {
-    tags: settings.filters.tags || false,
-    owner: settings.filters.owner || null,
-    token: settings.filters.token || null,
-    limit: settings.filters.limit || null,
-  };
-  // Process tokens and send notifications
-  await processTokens(assistant, notification, filterOptions, response);
-  // Track analytics
-  analytics.event('admin/notification', { sent: response.sent });
-  return assistant.respond(response);
-};
-// Helper: Process tokens and send notifications
-async function processTokens(assistant, notification, options, response) {
-  const Manager = assistant.Manager;
-  // If a specific token is provided, send directly to it (useful for testing)
-  if (options.token) {
-    assistant.log(`Sending to specific token: ${options.token}`);
-    try {
-      await sendBatch(assistant, [options.token], 0, notification, response);
-      assistant.log('Single token notification sent successfully.');
-    } catch (e) {
-      assistant.error('Error sending to specific token', e);
-    }
-    return;
-  }
-  // Build query conditions
-  const queryConditions = [];
-  // Filter by tags
-  if (options.tags) {
-    queryConditions.push({ field: 'tags', operator: 'array-contains-any', value: options.tags });
-  }
-  // Filter by owner UID
-  if (options.owner) {
-    queryConditions.push({ field: 'owner', operator: '==', value: options.owner });
-  }
-  // Calculate max batches based on limit
-  const maxBatches = options.limit
-    ? Math.ceil(options.limit / BATCH_SIZE)
-    : Infinity;
-  // Log filter options
-  assistant.log('Processing tokens with filters:', {
-    tags: options.tags,
-    owner: options.owner,
-    limit: options.limit,
-    maxBatches: maxBatches,
-  });
-  // Track tokens processed for limit
-  let tokensProcessed = 0;
-  // Batch processing logic
-  await Manager.Utilities().iterateCollection(
-    async (batch, index) => {
-      let batchTokens = [];
-      // Collect tokens from the current batch
-      for (const doc of batch.docs) {
-        // Stop if we've hit the limit
-        if (options.limit && tokensProcessed >= options.limit) {
-          break;
-        }
-        const data = doc.data();
-        batchTokens.push(data.token);
-        tokensProcessed++;
-      }
-      // Skip if no tokens to send
-      if (batchTokens.length === 0) {
-        return;
-      }
-      // Send the batch
-      try {
-        assistant.log(`Sending batch ${index} with ${batchTokens.length} tokens.`);
-        await sendBatch(assistant, batchTokens, index, notification, response);
-      } catch (e) {
-        assistant.error(`Error sending batch ${index}`, e);
-      }
+    icon: settings.notification.icon,
+    clickAction: settings.notification.clickAction
+      || settings.notification.click_action,
+    filters: {
+      tags: settings.filters.tags || false,
+      owner: settings.filters.owner || null,
+      token: settings.filters.token || null,
+      limit: settings.filters.limit || null,
     },
-    {
-      collection: PATH_NOTIFICATIONS,
-      where: queryConditions,
-      batchSize: BATCH_SIZE,
-      maxBatches: maxBatches,
-      log: true,
-    }
-  )
-    .then(() => {
-      assistant.log('All batches processed successfully.');
-    })
-    .catch(e => {
-      assistant.error(`Error during token processing: ${e}`);
-    });
-}
-// Helper: Send batch of notifications
-async function sendBatch(assistant, batch, id, notification, response) {
-  const { admin } = assistant.Manager.libraries;
-  try {
-    assistant.log(`Sending batch #${id}: tokens=${batch.length}...`, notification);
-    // Prepare messages
-    const messages = batch.map(token => ({
-      token: token,
-      notification: {
-        title: notification.title,
-        body: notification.body,
-        imageUrl: notification.imageUrl,
-      },
-      webpush: {
-        notification: {
-          title: notification.title,
-          body: notification.body,
-          icon: notification.imageUrl,
-          click_action: notification.click_action,
-        },
-        data: {
-          click_action: notification.click_action,
-        },
-        fcm_options: {
-          link: notification.click_action,
-        }
-      },
-      data: {
-        click_action: notification.click_action,
-      },
-    }));
-    // Send the batch
-    const result = await admin.messaging().sendEach(messages);
-    assistant.log(`Sent batch #${id}: tokens=${batch.length}, success=${result.successCount}, failures=${result.failureCount}`, JSON.stringify(result));
-    // Attach token to response
-    result.responses = result.responses.map((item, index) => {
-      item.token = batch[index];
-      return item;
-    });
-    // Clean bad tokens
-    if (result.failureCount > 0) {
-      await cleanTokens(assistant, batch, result.responses, id, response);
-    }
-    // Update response
-    response.sent += (batch.length - result.failureCount);
-  } catch (e) {
-    throw new Error(`Error sending batch ${id}: ${e}`);
-  }
-}
-// Helper: Clean bad tokens
-async function cleanTokens(assistant, batch, results, id, response) {
-  assistant.log(`Cleaning ${results.length} tokens of batch ID: ${id}`);
-  const cleanPromises = results
-    .map((item, index) => {
-      const shouldClean = BAD_TOKEN_REASONS.includes(item?.error?.code);
-      assistant.log(`Checking #${index}: success=${item.success}, error=${item?.error?.code || null}, clean=${shouldClean}`, item.error);
-      if (!item.error || !shouldClean) {
-        return null;
-      }
-      return deleteToken(assistant, item.token, item.error.code, response);
-    })
-    .filter(Boolean);
-  try {
-    await Promise.all(cleanPromises);
-    assistant.log(`Completed cleaning tokens for batch ID: ${id}`);
-  } catch (e) {
-    assistant.error(`Error cleaning tokens for batch ID: ${id}`, e);
-  }
-}
-// Helper: Delete bad token
-async function deleteToken(assistant, token, errorCode, response) {
-  const { admin } = assistant.Manager.libraries;
-  try {
-    await admin.firestore().doc(`${PATH_NOTIFICATIONS}/${token}`).delete();
+  });
-    assistant.log(`Deleted bad token: ${token} (Reason: ${errorCode})`);
+  analytics.event('admin/notification', { sent: result.sent });
-    response.deleted++;
-  } catch (error) {
-    assistant.error(`Failed to delete bad token: ${token} (Reason: ${errorCode})`, error);
-  }
-}
+  return assistant.respond(result);
+};

package/src/manager/routes/marketing/campaign/delete.js ADDED Viewed

@@ -0,0 +1,45 @@
+/**
+ * DELETE /marketing/campaign - Delete a marketing campaign
+ * Admin-only. Can only delete pending campaigns.
+ */
+module.exports = async ({ assistant, user, Manager, settings, analytics }) => {
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+  if (!user.roles.admin) {
+    return assistant.respond('Admin access required', { code: 403 });
+  }
+  const { admin } = Manager.libraries;
+  const campaignId = (settings.id || '').trim();
+  if (!campaignId) {
+    return assistant.respond('Campaign ID is required', { code: 400 });
+  }
+  const docRef = admin.firestore().doc(`marketing-campaigns/${campaignId}`);
+  const doc = await docRef.get();
+  if (!doc.exists) {
+    return assistant.respond('Campaign not found', { code: 404 });
+  }
+  const existing = doc.data();
+  // Can only delete pending campaigns (sent/failed are historical records)
+  if (existing.status !== 'pending') {
+    return assistant.respond(`Cannot delete campaign with status "${existing.status}"`, { code: 400 });
+  }
+  await docRef.delete();
+  assistant.log('marketing/campaign deleted:', { campaignId });
+  analytics.event('marketing/campaign', { action: 'delete' });
+  return assistant.respond({
+    success: true,
+    deleted: campaignId,
+  });
+};

package/src/manager/routes/marketing/campaign/get.js ADDED Viewed

@@ -0,0 +1,69 @@
+/**
+ * GET /marketing/campaign - List or get marketing campaigns
+ * Admin-only. Used by calendar frontend.
+ *
+ * Query params:
+ *   id       — Get a single campaign by ID
+ *   start    — Filter campaigns with sendAt >= start (unix timestamp)
+ *   end      — Filter campaigns with sendAt <= end (unix timestamp)
+ *   status   — Filter by status (pending, sent, failed)
+ *   type     — Filter by type (email, push)
+ *   limit    — Max results (default 100)
+ */
+module.exports = async ({ assistant, user, Manager, settings }) => {
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+  if (!user.roles.admin) {
+    return assistant.respond('Admin access required', { code: 403 });
+  }
+  const { admin } = Manager.libraries;
+  // Single campaign by ID
+  if (settings.id) {
+    const doc = await admin.firestore().doc(`marketing-campaigns/${settings.id}`).get();
+    if (!doc.exists) {
+      return assistant.respond('Campaign not found', { code: 404 });
+    }
+    return assistant.respond({
+      success: true,
+      campaign: { id: doc.id, ...doc.data() },
+    });
+  }
+  // List campaigns with filters
+  let query = admin.firestore().collection('marketing-campaigns');
+  if (settings.status) {
+    query = query.where('status', '==', settings.status);
+  }
+  if (settings.type) {
+    query = query.where('type', '==', settings.type);
+  }
+  if (settings.start) {
+    query = query.where('sendAt', '>=', parseInt(settings.start, 10));
+  }
+  if (settings.end) {
+    query = query.where('sendAt', '<=', parseInt(settings.end, 10));
+  }
+  query = query.orderBy('sendAt', 'asc');
+  query = query.limit(parseInt(settings.limit, 10) || 100);
+  const snapshot = await query.get();
+  const campaigns = snapshot.docs.map(doc => ({
+    id: doc.id,
+    ...doc.data(),
+  }));
+  return assistant.respond({
+    success: true,
+    campaigns,
+    count: campaigns.length,
+  });
+};

package/src/manager/routes/marketing/campaign/post.js ADDED Viewed

@@ -0,0 +1,161 @@
+/**
+ * POST /marketing/campaign - Create a marketing campaign
+ * Admin-only. Saves to marketing-campaigns collection.
+ *
+ * - sendAt defaults to 'now' (immediate send)
+ * - Future sendAt → saved as 'pending' for cron pickup
+ * - Past/now sendAt → fires immediately, saved as 'sent'/'failed'
+ * - Supports type: 'email' (default) or 'push' (future)
+ *
+ * Content is markdown — converted to HTML at send time per provider.
+ */
+const _ = require('lodash');
+const moment = require('moment');
+const pushid = require('pushid');
+module.exports = async ({ assistant, user, Manager, settings, analytics }) => {
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+  if (!user.roles.admin) {
+    return assistant.respond('Admin access required', { code: 403 });
+  }
+  const { admin } = Manager.libraries;
+  const campaignId = settings.id || pushid();
+  const now = moment();
+  // Normalize sendAt → unix timestamp
+  const sendAt = normalizeSendAt(settings.sendAt, now);
+  // Build the campaign document (settings nested, like emails-queue)
+  const campaignSettings = {};
+  // Required
+  campaignSettings.name = settings.name;
+  campaignSettings.subject = settings.subject;
+  // Content
+  if (settings.preheader) { campaignSettings.preheader = settings.preheader; }
+  if (settings.template && settings.template !== 'default') { campaignSettings.template = settings.template; }
+  if (settings.content) { campaignSettings.content = settings.content; }
+  if (settings.data && Object.keys(settings.data).length) { campaignSettings.data = settings.data; }
+  // Targeting
+  if (settings.lists && settings.lists.length) { campaignSettings.lists = settings.lists; }
+  if (settings.segments && settings.segments.length) { campaignSettings.segments = settings.segments; }
+  if (settings.excludeSegments && settings.excludeSegments.length) { campaignSettings.excludeSegments = settings.excludeSegments; }
+  if (settings.all) { campaignSettings.all = true; }
+  // UTM
+  if (settings.utm && Object.keys(settings.utm).length) { campaignSettings.utm = settings.utm; }
+  // Config
+  if (settings.sender) { campaignSettings.sender = settings.sender; }
+  if (settings.providers && settings.providers.length) { campaignSettings.providers = settings.providers; }
+  if (settings.group) { campaignSettings.group = settings.group; }
+  if (settings.categories && settings.categories.length) { campaignSettings.categories = settings.categories; }
+  // Clone and clean undefined values for Firestore
+  const settingsCloned = _.cloneDeepWith(campaignSettings, (value) => {
+    if (typeof value === 'undefined') {
+      return null;
+    }
+  });
+  const isFuture = sendAt > now.unix();
+  const type = settings.type || 'email';
+  const doc = {
+    settings: settingsCloned,
+    sendAt,
+    status: 'pending',
+    type,
+    ...(settings.recurrence ? { recurrence: settings.recurrence } : {}),
+    metadata: {
+      created: {
+        timestamp: now.toISOString(),
+        timestampUNIX: now.unix(),
+      },
+      updated: {
+        timestamp: now.toISOString(),
+        timestampUNIX: now.unix(),
+      },
+    },
+  };
+  // Save to Firestore
+  await admin.firestore().doc(`marketing-campaigns/${campaignId}`).set(doc);
+  assistant.log('marketing/campaign created:', { campaignId, sendAt, isFuture, type });
+  // If sendAt is now/past, fire immediately
+  let results = null;
+  if (!isFuture && type === 'email') {
+    const mailer = Manager.Email(assistant);
+    results = await mailer.sendCampaign({ ...campaignSettings, sendAt: 'now' });
+    // Update status
+    const status = Object.values(results).some(r => r.success) ? 'sent' : 'failed';
+    await admin.firestore().doc(`marketing-campaigns/${campaignId}`).set({
+      status,
+      results,
+      metadata: {
+        updated: {
+          timestamp: new Date().toISOString(),
+          timestampUNIX: Math.round(Date.now() / 1000),
+        },
+      },
+    }, { merge: true });
+    assistant.log('marketing/campaign sent:', { campaignId, status, results });
+  }
+  // Analytics
+  analytics.event('marketing/campaign', {
+    action: isFuture ? 'schedule' : 'send',
+    type,
+  });
+  return assistant.respond({
+    success: true,
+    id: campaignId,
+    status: isFuture ? 'pending' : (results ? 'sent' : 'pending'),
+    sendAt,
+    providers: results,
+  });
+};
+/**
+ * Normalize sendAt to unix timestamp.
+ * Accepts: 'now', ISO string, unix timestamp (number or string), undefined/empty.
+ * Defaults to now.
+ */
+function normalizeSendAt(sendAt, now) {
+  if (!sendAt || sendAt === 'now') {
+    return now.unix();
+  }
+  // Unix timestamp (number)
+  if (typeof sendAt === 'number') {
+    return sendAt;
+  }
+  // Unix timestamp as string (all digits)
+  if (/^\d+$/.test(sendAt)) {
+    return parseInt(sendAt, 10);
+  }
+  // ISO string or other parseable date
+  const parsed = moment(sendAt);
+  if (parsed.isValid()) {
+    return parsed.unix();
+  }
+  // Fallback to now
+  return now.unix();
+}

package/src/manager/routes/marketing/campaign/put.js ADDED Viewed

@@ -0,0 +1,122 @@
+/**
+ * PUT /marketing/campaign - Update a marketing campaign
+ * Admin-only. Used by calendar frontend for edits and rescheduling.
+ *
+ * Accepts any field from the POST schema. Only provided fields are updated.
+ * Changing sendAt reschedules the campaign (if still pending).
+ */
+const _ = require('lodash');
+const moment = require('moment');
+module.exports = async ({ assistant, user, Manager, settings, analytics }) => {
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+  if (!user.roles.admin) {
+    return assistant.respond('Admin access required', { code: 403 });
+  }
+  const { admin } = Manager.libraries;
+  const campaignId = (settings.id || '').trim();
+  if (!campaignId) {
+    return assistant.respond('Campaign ID is required', { code: 400 });
+  }
+  // Fetch existing
+  const docRef = admin.firestore().doc(`marketing-campaigns/${campaignId}`);
+  const doc = await docRef.get();
+  if (!doc.exists) {
+    return assistant.respond('Campaign not found', { code: 404 });
+  }
+  const existing = doc.data();
+  // Can only edit pending campaigns
+  if (existing.status !== 'pending') {
+    return assistant.respond(`Cannot edit campaign with status "${existing.status}"`, { code: 400 });
+  }
+  // Build update — merge provided fields into existing settings
+  const update = {
+    metadata: {
+      updated: {
+        timestamp: new Date().toISOString(),
+        timestampUNIX: Math.round(Date.now() / 1000),
+      },
+    },
+  };
+  // Update sendAt if provided
+  if (settings.sendAt !== undefined && settings.sendAt !== '') {
+    update.sendAt = normalizeSendAt(settings.sendAt);
+  }
+  // Update type if provided
+  if (settings.type) {
+    update.type = settings.type;
+  }
+  // Update recurrence if provided
+  if (settings.recurrence !== undefined) {
+    update.recurrence = settings.recurrence;
+  }
+  // Update settings fields — only merge what's provided
+  const settingsUpdate = {};
+  const settingsFields = [
+    'name', 'subject', 'preheader', 'template', 'content', 'data',
+    'lists', 'segments', 'excludeSegments', 'all',
+    'utm', 'sender', 'providers', 'group', 'categories',
+  ];
+  for (const field of settingsFields) {
+    if (settings[field] !== undefined && settings[field] !== '') {
+      settingsUpdate[field] = settings[field];
+    }
+  }
+  if (Object.keys(settingsUpdate).length) {
+    // Clean undefined values for Firestore
+    const cleaned = _.cloneDeepWith(settingsUpdate, (value) => {
+      if (typeof value === 'undefined') {
+        return null;
+      }
+    });
+    update.settings = { ...existing.settings, ...cleaned };
+  }
+  await docRef.set(update, { merge: true });
+  assistant.log('marketing/campaign updated:', { campaignId, update });
+  analytics.event('marketing/campaign', { action: 'update' });
+  // Fetch updated doc
+  const updated = await docRef.get();
+  return assistant.respond({
+    success: true,
+    campaign: { id: campaignId, ...updated.data() },
+  });
+};
+function normalizeSendAt(sendAt) {
+  if (!sendAt || sendAt === 'now') {
+    return Math.round(Date.now() / 1000);
+  }
+  if (typeof sendAt === 'number') {
+    return sendAt;
+  }
+  if (/^\d+$/.test(sendAt)) {
+    return parseInt(sendAt, 10);
+  }
+  const parsed = moment(sendAt);
+  return parsed.isValid() ? parsed.unix() : Math.round(Date.now() / 1000);
+}

package/src/manager/routes/user/data-request/delete.js CHANGED Viewed

@@ -48,6 +48,8 @@ function sendCancellationEmail(assistant, user, requestId) {
   const Manager = assistant.Manager;
   const mailer = Manager.Email(assistant);
   const uid = user.auth.uid;
+  const firstName = user.personal?.name?.first;
+  const greeting = firstName ? `Hey ${firstName}, your` : 'Your';
   mailer.send({
     to: user,
@@ -62,7 +64,7 @@ function sendCancellationEmail(assistant, user, requestId) {
       },
       body: {
         title: 'Data Request Cancelled',
-        message: `Your data export request has been cancelled as requested.
+        message: `${greeting} data export request has been cancelled as requested.
 - **Request reference:** #${requestId}
 - **Account UID:** ${uid}