backend-manager 5.1.4 → 5.2.1

package/src/manager/routes/marketing/email-preferences/post.js

@@ -1,24 +1,118 @@
 /**
- * POST /marketing/email-preferences - Update email preferences
- * Public endpoint — no authentication required
+ * POST /marketing/email-preferences - Update marketing email consent
  *
- * Supports two actions:
- * - "unsubscribe": Adds email to SendGrid ASM suppression group
- * - "resubscribe": Removes email from SendGrid ASM suppression group
+ * Two supported modes:
+ *
+ * 1) Authenticated (account-page toggle):
+ *    - User must be logged in.
+ *    - settings.action = 'opt-in' | 'opt-out'.
+ *    - Writes canonical consent.marketing to user doc.
+ *    - Hits BOTH SendGrid + Beehiiv via the email library (one source of truth).
+ *
+ * 2) Anonymous (HMAC unsubscribe link from email footer):
+ *    - No login. settings.email + settings.asmId + settings.sig + settings.action.
+ *    - HMAC validates the link was generated by us.
+ *    - Hits SendGrid ASM directly (legacy behavior — preserves existing one-click unsub).
+ *    - Also writes canonical consent.marketing to user doc when email maps to a user.
  */
 const fetch = require('wonderful-fetch');
 const crypto = require('crypto');
 
 const RATE_LIMIT = 5;
 
-module.exports = async ({ assistant, Manager, settings, analytics }) => {
+module.exports = async ({ assistant, Manager, user, settings, analytics }) => {
+
+  // --- AUTHENTICATED MODE ---
+  if (user.authenticated) {
+    return handleAuthenticated({ assistant, Manager, user, settings, analytics });
+  }
+
+  // --- ANONYMOUS HMAC MODE ---
+  return handleAnonymous({ assistant, Manager, settings, analytics });
+};
+
+/**
+ * Authenticated user toggling marketing on/off from the account page.
+ */
+async function handleAuthenticated({ assistant, Manager, user, settings, analytics }) {
+  const { admin } = Manager.libraries;
+  const action = settings.action;
+
+  if (action !== 'subscribe' && action !== 'unsubscribe') {
+    return assistant.respond('Invalid action — must be "subscribe" or "unsubscribe"', { code: 400 });
+  }
+
+  // Rate-limit per-user (defense against accidental toggling spam)
+  const usage = await Manager.Usage().init(assistant);
+  const currentUsage = usage.getUsage('email-preferences');
+  if (currentUsage >= RATE_LIMIT) {
+    return assistant.respond('Rate limit exceeded', { code: 429 });
+  }
+  usage.increment('email-preferences');
+  await usage.update();
+
+  const uid = user.auth.uid;
+  const email = user.auth.email;
+  const ip = assistant.request.geolocation?.ip || null;
+  const timestamp = assistant.meta.startTime.timestamp;
+  const timestampUNIX = assistant.meta.startTime.timestampUNIX;
+
+  // Build the consent.marketing mutation
+  const marketingPatch = action === 'subscribe'
+    ? {
+      status: 'granted',
+      grantedAt: { timestamp, timestampUNIX, source: 'account', ip, text: null },
+      // Leave revokedAt untouched — informational record of most recent revoke
+    }
+    : {
+      status: 'revoked',
+      revokedAt: { timestamp, timestampUNIX, source: 'account', ip, text: null },
+      // Leave grantedAt untouched — informational record of original grant
+    };
+
+  await admin.firestore().doc(`users/${uid}`).set({
+    consent: { marketing: marketingPatch },
+    metadata: Manager.Metadata().set({ tag: 'marketing/email-preferences' }),
+  }, { merge: true });
+
+  assistant.log(`email-preferences (auth): ${uid} → ${action}`);
+
+  // Skip provider calls in test mode unless extended mode is on
+  const shouldCallExternalAPIs = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
+
+  if (shouldCallExternalAPIs) {
+    const mailer = Manager.Email(assistant);
+
+    try {
+      if (action === 'unsubscribe') {
+        await mailer.remove(email);
+      } else {
+        await mailer.sync(uid);
+      }
+    } catch (e) {
+      assistant.error(`email-preferences (auth) provider sync failed:`, e);
+      // Doc is already updated — provider sync is best-effort. Don't fail the request.
+    }
+  } else {
+    assistant.log('email-preferences (auth): Skipping provider calls (BEM_TESTING=true)');
+  }
+
+  analytics.event('marketing/email-preferences', { action, mode: 'authenticated' });
+
+  return assistant.respond({ success: true, action });
+}
+
+/**
+ * Anonymous HMAC unsubscribe link (preserves existing email-footer one-click flow).
+ */
+async function handleAnonymous({ assistant, Manager, settings, analytics }) {
+  const { admin } = Manager.libraries;
 
-  // Extract parameters
   const email = (settings.email || '').trim().toLowerCase();
   const asmId = parseInt(settings.asmId, 10);
   const action = settings.action || 'unsubscribe';
 
-  // Validate email
+  // Validate inputs
   if (!email) {
     return assistant.respond('Email is required', { code: 400 });
   }
@@ -28,29 +122,25 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
     return assistant.respond('Invalid email format', { code: 400 });
   }
 
-  // Validate ASM group ID
   if (!asmId || isNaN(asmId)) {
     return assistant.respond('ASM group ID is required', { code: 400 });
   }
 
-  // Validate action
-  if (action !== 'unsubscribe' && action !== 'resubscribe') {
+  if (action !== 'subscribe' && action !== 'unsubscribe') {
     return assistant.respond('Invalid action', { code: 400 });
   }
 
-  // Verify HMAC signature (proves the link was generated by our server)
+  // HMAC validation (proves we generated this link)
   const expectedSig = crypto.createHmac('sha256', process.env.UNSUBSCRIBE_HMAC_KEY).update(email).digest('hex');
   if (settings.sig !== expectedSig) {
     return assistant.respond('Invalid signature', { code: 403 });
   }
 
-  // Initialize Usage for rate limiting (key: IP forces unauthenticated storage always)
+  // IP rate limiting (anonymous flow — unauthenticated firestore storage)
   const usage = await Manager.Usage().init(assistant, {
     unauthenticatedMode: 'firestore',
     key: assistant.request.geolocation.ip,
   });
-
-  // Rate limiting (manual check since email-preferences isn't in product limits)
   const currentUsage = usage.getUsage('email-preferences');
   if (currentUsage >= RATE_LIMIT) {
     return assistant.respond('Rate limit exceeded', { code: 429 });
@@ -58,37 +148,34 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
   usage.increment('email-preferences');
   await usage.update();
 
-  // Skip external API calls in test mode unless TEST_EXTENDED_MODE is set
+  // Mirror to the user doc if this email maps to a user (best-effort, silent on miss)
+  await mirrorAnonymousToUserDoc({ assistant, Manager, email, action });
+
+  // Call SendGrid ASM (legacy behavior)
   const shouldCallExternalAPIs = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
 
   if (!shouldCallExternalAPIs) {
-    assistant.log('marketing/email-preferences: Skipping SendGrid (BEM_TESTING=true, TEST_EXTENDED_MODE not set)');
+    assistant.log('email-preferences (anon): Skipping SendGrid (BEM_TESTING=true)');
     return assistant.respond({ success: true });
   }
 
-  // Call SendGrid ASM API
   try {
     if (action === 'unsubscribe') {
-      // Add email to suppression group
+      // POST returns JSON ({recipient_emails: [...]}) on success
       await fetch(`https://api.sendgrid.com/v3/asm/groups/${asmId}/suppressions`, {
         method: 'POST',
         response: 'json',
-        headers: {
-          'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
-        },
+        headers: { 'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}` },
         timeout: 10000,
-        body: {
-          recipient_emails: [email],
-        },
+        body: { recipient_emails: [email] },
       });
     } else {
-      // Remove email from suppression group
+      // DELETE returns 204 with empty body — must NOT request response: 'json'
+      // or wonderful-fetch throws SyntaxError on the empty body.
       await fetch(`https://api.sendgrid.com/v3/asm/groups/${asmId}/suppressions/${encodeURIComponent(email)}`, {
         method: 'DELETE',
-        response: 'json',
-        headers: {
-          'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
-        },
+        response: 'text',
+        headers: { 'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}` },
         timeout: 10000,
       });
     }
@@ -97,12 +184,53 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
     return assistant.respond('Failed to process your request', { code: 500 });
   }
 
-  // Log result
-  assistant.log('marketing/email-preferences result:', { email, asmId, action });
-
-  // Track analytics
-  analytics.event('marketing/email-preferences', { action });
+  assistant.log('email-preferences (anon) result:', { email, asmId, action });
+  analytics.event('marketing/email-preferences', { action, mode: 'anonymous' });
 
-  // Generic success (no sensitive info leakage)
   return assistant.respond({ success: true });
-};
+}
+
+/**
+ * Anonymous HMAC unsub also writes to the user doc (if found) so consent stays in sync.
+ * Silent if the email doesn't map to a user. Source is recorded as 'sendgrid' since the
+ * HMAC link only fires from SendGrid email footers.
+ */
+async function mirrorAnonymousToUserDoc({ assistant, Manager, email, action }) {
+  const { admin } = Manager.libraries;
+
+  const snapshot = await admin.firestore().collection('users')
+    .where('auth.email', '==', email)
+    .limit(1)
+    .get()
+    .catch((e) => {
+      assistant.error('email-preferences (anon): Failed to look up user by email:', e);
+      return null;
+    });
+
+  if (!snapshot || snapshot.empty) {
+    return; // Silent — email may not map to a current user
+  }
+
+  const userDoc = snapshot.docs[0];
+  const uid = userDoc.id;
+  const timestamp = assistant.meta.startTime.timestamp;
+  const timestampUNIX = assistant.meta.startTime.timestampUNIX;
+
+  const marketingPatch = action === 'unsubscribe'
+    ? {
+      status: 'revoked',
+      revokedAt: { timestamp, timestampUNIX, source: 'sendgrid', ip: null, text: null },
+    }
+    : {
+      status: 'granted',
+      grantedAt: { timestamp, timestampUNIX, source: 'sendgrid', ip: null, text: null },
+    };
+
+  await admin.firestore().doc(`users/${uid}`).set({
+    consent: { marketing: marketingPatch },
+    metadata: Manager.Metadata().set({ tag: 'marketing/email-preferences' }),
+  }, { merge: true })
+    .catch((e) => {
+      assistant.error(`email-preferences (anon): Failed to mirror to user doc ${uid}:`, e);
+    });
+}

package/src/manager/routes/marketing/webhook/forward/post.js

@@ -0,0 +1,168 @@
+/**
+ * POST /marketing/webhook/forward?provider=sendgrid|beehiiv&key=<BACKEND_MANAGER_WEBHOOK_KEY>
+ *
+ * Parent-only forwarder. SendGrid and Beehiiv send webhooks to this single URL
+ * on the parent BEM. The parent reads its `brands` collection and re-POSTs the
+ * raw body to every child's /marketing/webhook?provider=X. Each child then
+ * processes the event against its own Firestore and providers.
+ *
+ * Gating:
+ *   - Only enabled when Manager.config.parent === 'self'. Any other value (a URL
+ *     pointing TO the parent, the typical setup for child BEMs) returns 404.
+ *   - Same BACKEND_MANAGER_WEBHOOK_KEY is shared across all brands, so the
+ *     parent forwards the key it received (already validated) when calling
+ *     each child.
+ *
+ * Brand URL derivation:
+ *   - Each brand doc in the `brands` collection has `brand.url` (e.g. 'https://somiibo.com').
+ *   - API URL is derived by inserting 'api.' subdomain: 'https://api.somiibo.com'.
+ *   - Child receivers live at `/backend-manager/marketing/webhook` on that host.
+ *
+ * Self-inclusion:
+ *   - The parent's own brand IS included in the fan-out. The parent BEM has
+ *     its own user base (e.g. itwcreativeworks.com users) and needs the same
+ *     consent updates as any other brand. Self-fan-out goes via HTTP like
+ *     every other child — no special inline path.
+ *
+ * Failure isolation:
+ *   - Each child POST is awaited via Promise.allSettled so one slow/down child
+ *     doesn't block the others. Failures are logged but the overall request
+ *     still returns 200 so the provider doesn't retry the parent indefinitely.
+ *     Children themselves track idempotency, so provider retries are safe.
+ */
+const fetch = require('wonderful-fetch');
+
+const CHILD_TIMEOUT_MS = 10000;
+
+module.exports = async ({ assistant, Manager, libraries }) => {
+  const { admin } = libraries;
+  const query = assistant.request.query;
+
+  // Gate: only the parent BEM exposes this route. Any brand whose config.parent
+  // points to a URL (the normal case) returns 404 — pretend the route doesn't exist.
+  if (!Manager.isParent()) {
+    return assistant.respond('Not found', { code: 404 });
+  }
+
+  const provider = query.provider;
+  const key = query.key;
+
+  if (!provider) {
+    return assistant.respond('Missing provider parameter', { code: 400 });
+  }
+
+  // Same key used for the receiver — parent validates incoming, then re-uses
+  // it for outbound calls to children (all brands share this env value).
+  if (!key || key !== process.env.BACKEND_MANAGER_WEBHOOK_KEY) {
+    return assistant.respond('Invalid key', { code: 401 });
+  }
+
+  // Read the brands collection. This lives in the PARENT's Firestore.
+  const snapshot = await admin.firestore().collection('brands').get()
+    .catch((e) => {
+      assistant.error('marketing webhook forward: failed to read brands collection:', e);
+      return null;
+    });
+
+  if (!snapshot) {
+    return assistant.respond('Failed to load brands', { code: 500 });
+  }
+
+  // Collect brand URLs from the docs
+  const brands = [];
+  snapshot.forEach((doc) => {
+    const data = doc.data() || {};
+    const brandUrl = data.brand?.url || null;
+    const brandId = data.brand?.id || doc.id;
+
+    if (!brandUrl) {
+      assistant.log(`marketing webhook forward: brand ${brandId} has no brand.url, skipping`);
+      return;
+    }
+
+    brands.push({ brandId, brandUrl });
+  });
+
+  if (brands.length === 0) {
+    assistant.log('marketing webhook forward: no brands to forward to');
+    return assistant.respond({ received: true, forwarded: 0 });
+  }
+
+  assistant.log(`marketing webhook forward: fanning out ${provider} event to ${brands.length} brand(s)`);
+
+  // Forward the raw body to every child. assistant.ref.req.body holds the body
+  // as we received it from the provider. We re-POST it without modification.
+  const rawBody = assistant.ref.req?.body;
+
+  const results = await Promise.allSettled(
+    brands.map(({ brandId, brandUrl }) => forwardToChild({
+      assistant,
+      brandId,
+      brandUrl,
+      provider,
+      key,
+      body: rawBody,
+    }))
+  );
+
+  let succeeded = 0;
+  let failed = 0;
+  const failures = [];
+  for (let i = 0; i < results.length; i += 1) {
+    const r = results[i];
+    const brand = brands[i];
+    if (r.status === 'fulfilled' && r.value?.ok) {
+      succeeded += 1;
+    } else {
+      failed += 1;
+      const reason = r.status === 'rejected' ? r.reason?.message : (r.value?.error || 'unknown');
+      failures.push({ brandId: brand.brandId, reason });
+      assistant.error(`marketing webhook forward: ${brand.brandId} failed:`, reason);
+    }
+  }
+
+  assistant.log(`marketing webhook forward: ${provider} complete — succeeded=${succeeded}, failed=${failed}`);
+
+  // Always return 200 — child failures shouldn't make the provider retry the
+  // parent. Each child tracks its own idempotency so safe to re-fan on retry.
+  return assistant.respond({
+    received: true,
+    forwarded: brands.length,
+    succeeded,
+    failed,
+    failures: failures.length > 0 ? failures : undefined,
+  });
+};
+
+/**
+ * POST the raw body to one child BEM's /marketing/webhook receiver.
+ * Returns { ok: true } on success, { ok: false, error } on failure.
+ */
+async function forwardToChild({ assistant, brandId, brandUrl, provider, key, body }) {
+  // Derive API URL: brandUrl 'https://somiibo.com' → 'https://api.somiibo.com'.
+  // Use URL parsing so we tolerate trailing slashes and unusual hosts.
+  let apiUrl;
+  try {
+    const url = new URL(brandUrl);
+    url.hostname = `api.${url.hostname}`;
+    url.pathname = '/backend-manager/marketing/webhook';
+    url.search = `?provider=${encodeURIComponent(provider)}&key=${encodeURIComponent(key)}`;
+    apiUrl = url.toString();
+  } catch (e) {
+    return { ok: false, error: `Invalid brand URL "${brandUrl}": ${e.message}` };
+  }
+
+  try {
+    const result = await fetch(apiUrl, {
+      method: 'POST',
+      response: 'json',
+      timeout: CHILD_TIMEOUT_MS,
+      headers: { 'Content-Type': 'application/json' },
+      body,
+    });
+    assistant.log(`marketing webhook forward: ${brandId} OK — ${JSON.stringify(result)}`);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e?.message || String(e) };
+  }
+}

package/src/manager/routes/marketing/webhook/post.js

@@ -0,0 +1,180 @@
+/**
+ * POST /marketing/webhook?provider=sendgrid|beehiiv&key=<BACKEND_MANAGER_WEBHOOK_KEY>
+ *
+ * Receives cross-provider unsubscribe webhooks (SendGrid + Beehiiv) and:
+ *   1. Authenticates via ?key= query param (BACKEND_MANAGER_WEBHOOK_KEY env)
+ *   2. Optionally rejects mismatched brand via ?brand= filter
+ *   3. Loads the matching processor module from ./processors/{provider}.js
+ *   4. Parses the webhook payload into one or more normalized events
+ *   5. For each event: idempotency check via marketing-webhooks/{eventId}, then dispatch
+ *   6. Returns 200 immediately so the provider doesn't retry
+ *
+ * Each processor module defines:
+ *   - parseWebhook(req)   — returns Array<{ eventId, eventType, email, timestamp, raw, ... }>
+ *   - isSupported(type)   — returns true if this event should be processed
+ *   - handleEvent(ctx)    — does the work for one event (user doc + cross-provider sync)
+ *
+ * Mirrors the existing payments-webhook pattern. Processes events inline rather than
+ * via a Firestore trigger — marketing webhooks are lower volume and lighter work than
+ * payments, so the extra async layer isn't justified.
+ */
+const path = require('path');
+const powertools = require('node-powertools');
+
+module.exports = async ({ assistant, Manager, libraries }) => {
+  const { admin } = libraries;
+  const query = assistant.request.query;
+
+  const provider = query.provider;
+  const key = query.key;
+
+  // Validate provider
+  if (!provider) {
+    return assistant.respond('Missing provider parameter', { code: 400 });
+  }
+
+  // Validate key against BACKEND_MANAGER_WEBHOOK_KEY (separate from BACKEND_MANAGER_KEY
+  // so it can be rotated independently and scoped narrowly)
+  if (!key || key !== process.env.BACKEND_MANAGER_WEBHOOK_KEY) {
+    return assistant.respond('Invalid key', { code: 401 });
+  }
+
+  // Brand filter (defensive — mirror payments webhook pattern). If a brand is
+  // specified and doesn't match ours, silently ignore. This lets one webhook
+  // URL be shared across brands while each brand only processes its own events.
+  const brand = query.brand;
+  const ourBrand = Manager.config.brand?.id;
+  if (brand && ourBrand && brand !== ourBrand) {
+    assistant.log(`marketing webhook: brand mismatch (received=${brand}, expected=${ourBrand}), ignoring`);
+    return assistant.respond({ received: true, ignored: true });
+  }
+
+  // Load the processor module
+  let processorModule;
+  try {
+    processorModule = require(path.resolve(__dirname, `processors/${provider}.js`));
+  } catch (e) {
+    assistant.error(`marketing webhook: failed to load processor "${provider}":`, e);
+    return assistant.respond(`Unknown provider: ${provider}`, { code: 400 });
+  }
+
+  // Parse the webhook body into events
+  let events;
+  try {
+    events = processorModule.parseWebhook(assistant.ref.req);
+  } catch (e) {
+    assistant.error(`marketing webhook: parse failed for ${provider}:`, e);
+    return assistant.respond(`Failed to parse webhook: ${e.message}`, { code: 400 });
+  }
+
+  if (!Array.isArray(events) || events.length === 0) {
+    assistant.log(`marketing webhook: ${provider} returned no events`);
+    return assistant.respond({ received: true, processed: 0 });
+  }
+
+  assistant.log(`marketing webhook: ${provider} delivered ${events.length} event(s)`);
+
+  // Process each event independently — one failure shouldn't block the others.
+  // Use Promise.allSettled so we return success only after all events have been
+  // attempted.
+  const results = await Promise.allSettled(
+    events.map((event) => processOneEvent({ Manager, assistant, admin, provider, event, processorModule }))
+  );
+
+  let processed = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const r of results) {
+    if (r.status === 'fulfilled') {
+      if (r.value?.processed) processed++;
+      else skipped++;
+    } else {
+      failed++;
+      assistant.error('marketing webhook: event processing rejected:', r.reason);
+    }
+  }
+
+  assistant.log(`marketing webhook: ${provider} complete — processed=${processed}, skipped=${skipped}, failed=${failed}`);
+
+  return assistant.respond({ received: true, processed, skipped, failed });
+};
+
+/**
+ * Process a single event end-to-end: idempotency check, support check, dispatch to handler.
+ * Returns { processed: bool, skipped?: string, error?: any }.
+ */
+async function processOneEvent({ Manager, assistant, admin, provider, event, processorModule }) {
+  const { eventId, eventType } = event;
+
+  // No eventId means we can't dedupe — skip rather than risk double-processing
+  if (!eventId) {
+    assistant.log(`marketing webhook: ${provider} event missing eventId (type=${eventType}), skipping`);
+    return { processed: false, skipped: 'missing-event-id' };
+  }
+
+  // Filter by supported event types
+  if (processorModule.isSupported && !processorModule.isSupported(eventType)) {
+    return { processed: false, skipped: 'unsupported-event-type' };
+  }
+
+  // Idempotency: skip if we've already processed this event
+  const idempotencyRef = admin.firestore().doc(`marketing-webhooks/${eventId}`);
+  const existingDoc = await idempotencyRef.get();
+
+  if (existingDoc.exists) {
+    const existingStatus = existingDoc.data()?.status;
+    if (existingStatus !== 'failed') {
+      assistant.log(`marketing webhook: ${provider} duplicate event ${eventId} (status=${existingStatus}), skipping`);
+      return { processed: false, skipped: 'duplicate' };
+    }
+    assistant.log(`marketing webhook: ${provider} retrying previously failed event ${eventId}`);
+  }
+
+  // Build the audit doc
+  const now = powertools.timestamp(new Date(), { output: 'string' });
+  const nowUNIX = powertools.timestamp(now, { output: 'unix' });
+
+  // Write 'pending' state before dispatching so concurrent deliveries see the lock
+  await idempotencyRef.set({
+    id: eventId,
+    provider,
+    status: 'pending',
+    raw: event.raw || null,
+    event: {
+      type: eventType,
+      email: event.email || null,
+      timestamp: event.timestamp || null,
+    },
+    error: null,
+    metadata: {
+      created: { timestamp: now, timestampUNIX: nowUNIX },
+      completed: { timestamp: null, timestampUNIX: null },
+    },
+  });
+
+  // Dispatch to the processor's event handler
+  let handlerResult;
+  try {
+    handlerResult = await processorModule.handleEvent({ Manager, assistant, parsed: event });
+
+    // Mark completed
+    await idempotencyRef.set({
+      status: 'completed',
+      result: handlerResult || null,
+      metadata: {
+        completed: { timestamp: powertools.timestamp(new Date(), { output: 'string' }), timestampUNIX: powertools.timestamp(new Date(), { output: 'unix' }) },
+      },
+    }, { merge: true });
+
+    return { processed: true };
+  } catch (e) {
+    assistant.error(`marketing webhook: handler failed for ${provider} event ${eventId}:`, e);
+
+    await idempotencyRef.set({
+      status: 'failed',
+      error: { message: e.message || String(e), stack: e.stack || null },
+    }, { merge: true }).catch(() => {});
+
+    return { processed: false, error: e };
+  }
+}