backend-manager 5.0.91 → 5.0.93

package/src/manager/routes/user/signup/post.js

@@ -1,3 +1,7 @@
+const fetch = require('wonderful-fetch');
+const moment = require('moment');
+const { inferContact } = require('../../../libraries/infer-contact.js');
+
 const MAX_POLL_TIME_MS = 30000;
 const POLL_INTERVAL_MS = 500;
 const MAX_ACCOUNT_AGE_MS = 5 * 60 * 1000; // 5 minutes
@@ -7,11 +11,13 @@ const MAX_ACCOUNT_AGE_MS = 5 * 60 * 1000; // 5 minutes
  *
  * Called by client after account creation to:
  * 1. Poll for user doc to exist (waits for onCreate to complete)
- * 2. Check if user has already signed up (prevents duplicate calls)
- * 3. Update user with client details (geolocation, browser info)
- * 4. Process affiliate code and update referrer
+ * 2. Validate (already processed, account age)
+ * 3. Gather all data (client details, inferred contact)
+ * 4. Write everything to user doc in one merge
+ * 5. Process affiliate referral (writes to referrer's doc)
+ * 6. Send welcome emails + add to marketing lists (non-blocking)
  */
-module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
+module.exports = async ({ assistant, user, settings, libraries }) => {
   const { admin } = libraries;
 
   // Require authentication
@@ -30,7 +36,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
   assistant.log(`signup(): Starting for ${uid}`, settings);
 
   // 1. Poll for user doc to exist (wait for onCreate to complete)
-  const userDoc = await pollForUserDoc(admin, assistant, uid);
+  const userDoc = await pollForUserDoc(assistant, uid);
 
   if (!userDoc) {
     return assistant.respond('User document not found after waiting. Please try again.', { code: 500 });
@@ -56,52 +62,24 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     return assistant.respond('Account is too old to process signup', { code: 400 });
   }
 
-  // 4. Normalize data - support both legacy and new formats
-  const attribution = settings.attribution;
-
-  // Legacy support: if affiliateCode exists, normalize to new format
-  if (settings.affiliateCode && !attribution.affiliate?.code) {
-    attribution.affiliate = { code: settings.affiliateCode };
-  }
-
-  const affiliateCode = attribution.affiliate?.code || null;
-
-  // 5. Build update record with client details
-  const userRecord = {
-    flags: {
-      signupProcessed: true,
-    },
-    activity: {
-      ...settings.context,
-      geolocation: {
-        ...(settings.context?.geolocation || {}),
-        ...assistant.request.geolocation,
-      },
-      client: {
-        ...(settings.context?.client || {}),
-        ...assistant.request.client,
-      },
-    },
-    attribution: attribution || {},
-    metadata: Manager.Metadata().set({ tag: 'user/signup' }),
-  };
+  // 4. Gather all data, then write once
+  const email = user.auth.email;
+  const inferred = await inferUserContact(assistant, email);
+  const userRecord = buildUserRecord(assistant, settings, inferred);
 
-  assistant.log(`signup(): Updating user record for ${uid}`, userRecord);
+  assistant.log(`signup(): Writing user record for ${uid}`, userRecord);
 
-  // Update user doc with client details
   await admin.firestore().doc(`users/${uid}`)
     .set(userRecord, { merge: true })
     .catch((e) => {
       assistant.error(`signup(): Failed to update user record:`, e);
     });
 
-  // 6. Update referrer if affiliate code provided
-  if (affiliateCode) {
-    await updateReferral(admin, assistant, uid, affiliateCode)
-      .catch((e) => {
-        assistant.error(`signup(): Failed to update referral:`, e);
-      });
-  }
+  // 5. Process affiliate referral (writes to referrer's doc, not this user's)
+  await processAffiliate(assistant, uid, settings);
+
+  // 6. Send emails + marketing (non-blocking, fire-and-forget)
+  sendEmailsAndMarketing(assistant, uid, email, inferred);
 
   return assistant.respond({ signedUp: true });
 };
@@ -109,7 +87,8 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
 /**
  * Poll for user doc to exist (wait for onCreate to complete)
  */
-async function pollForUserDoc(admin, assistant, uid) {
+async function pollForUserDoc(assistant, uid) {
+  const { admin } = assistant.Manager.libraries;
   const startTime = Date.now();
 
   while (Date.now() - startTime < MAX_POLL_TIME_MS) {
@@ -133,25 +112,99 @@ async function pollForUserDoc(admin, assistant, uid) {
 }
 
 /**
- * Update referrer's referrals array when a new user signs up with an affiliate code
+ * Build the full user record: client details, attribution, and inferred contact
+ */
+function buildUserRecord(assistant, settings, inferred) {
+  const Manager = assistant.Manager;
+  const attribution = settings.attribution;
+
+  // Legacy support: if affiliateCode exists, normalize to new format
+  if (settings.affiliateCode && !attribution.affiliate?.code) {
+    attribution.affiliate = { code: settings.affiliateCode };
+  }
+
+  const record = {
+    flags: {
+      signupProcessed: true,
+    },
+    activity: {
+      ...settings.context,
+      geolocation: {
+        ...(settings.context?.geolocation || {}),
+        ...assistant.request.geolocation,
+      },
+      client: {
+        ...(settings.context?.client || {}),
+        ...assistant.request.client,
+      },
+    },
+    attribution: attribution || {},
+    metadata: Manager.Metadata().set({ tag: 'user/signup' }),
+  };
+
+  // Add inferred name/company if available
+  if (inferred) {
+    record.personal = {
+      ...(inferred.firstName || inferred.lastName ? {
+        name: {
+          ...(inferred.firstName ? { first: inferred.firstName } : {}),
+          ...(inferred.lastName ? { last: inferred.lastName } : {}),
+        },
+      } : {}),
+      ...(inferred.company ? { company: { name: inferred.company } } : {}),
+    };
+  }
+
+  return record;
+}
+
+/**
+ * Infer name/company from email using AI (or regex fallback)
+ * Returns the inferred contact info, or null on failure
+ */
+async function inferUserContact(assistant, email) {
+  try {
+    const inferred = await inferContact(email, assistant);
+
+    if (!inferred?.firstName && !inferred?.lastName && !inferred?.company) {
+      return null;
+    }
+
+    assistant.log(`signup(): Inferred contact: ${inferred.firstName || ''} ${inferred.lastName || ''}, company=${inferred.company || ''} (method=${inferred.method})`);
+
+    return inferred;
+  } catch (e) {
+    assistant.error('signup(): Name inference failed:', e);
+    return null;
+  }
+}
+
+/**
+ * Process affiliate referral if affiliate code provided
+ * Writes to the referrer's doc (not the current user's)
  */
-async function updateReferral(admin, assistant, newUserUid, affiliateCode) {
+async function processAffiliate(assistant, uid, settings) {
+  const { admin } = assistant.Manager.libraries;
+  const affiliateCode = settings.attribution?.affiliate?.code
+    || settings.affiliateCode
+    || null;
+
   if (!affiliateCode) {
     return;
   }
 
-  assistant.log(`updateReferral(): Looking for referrer with code ${affiliateCode}`);
+  assistant.log(`processAffiliate(): Looking for referrer with code ${affiliateCode}`);
 
   const snapshot = await admin.firestore().collection('users')
     .where('affiliate.code', '==', affiliateCode)
     .get()
     .catch((e) => {
-      assistant.error(`updateReferral(): Failed to find referrer:`, e);
+      assistant.error(`processAffiliate(): Failed to find referrer:`, e);
       throw e;
     });
 
   if (snapshot.empty) {
-    assistant.log(`updateReferral(): No referrer found with code ${affiliateCode}`);
+    assistant.log(`processAffiliate(): No referrer found with code ${affiliateCode}`);
     return;
   }
 
@@ -162,13 +215,12 @@ async function updateReferral(admin, assistant, newUserUid, affiliateCode) {
   let referrals = referrerData?.affiliate?.referrals || [];
   referrals = Array.isArray(referrals) ? referrals : [];
 
-  // Add new referral
   referrals.push({
-    uid: newUserUid,
+    uid: uid,
     timestamp: assistant.meta.startTime.timestamp,
   });
 
-  assistant.log(`updateReferral(): Appending referral to ${referrerDoc.id}`, referrals);
+  assistant.log(`processAffiliate(): Appending referral to ${referrerDoc.id}`, referrals);
 
   await admin.firestore().doc(`users/${referrerDoc.id}`)
     .set({
@@ -177,9 +229,157 @@ async function updateReferral(admin, assistant, newUserUid, affiliateCode) {
       },
     }, { merge: true })
     .then(() => {
-      assistant.log(`updateReferral(): Success`);
+      assistant.log(`processAffiliate(): Success`);
     })
     .catch((e) => {
-      assistant.error(`updateReferral(): Failed to update referrer:`, e);
+      assistant.error(`processAffiliate(): Failed to update referrer:`, e);
+    });
+}
+
+/**
+ * Send welcome emails and add to marketing lists (non-blocking, fire-and-forget)
+ */
+function sendEmailsAndMarketing(assistant, uid, email, inferred) {
+  const Manager = assistant.Manager;
+  const shouldSend = !assistant.isTesting() || process.env.TEST_EXTENDED_MODE;
+
+  if (!shouldSend) {
+    assistant.log(`signup(): Skipping emails/marketing (BEM_TESTING=true, TEST_EXTENDED_MODE not set)`);
+    return;
+  }
+
+  assistant.log(`signup(): Sending emails/adding to marketing for ${uid}`);
+
+  // Add to marketing lists (SendGrid + Beehiiv) via centralized endpoint
+  fetch(`${Manager.project.apiUrl}/backend-manager/marketing/contact`, {
+    method: 'POST',
+    response: 'json',
+    body: {
+      backendManagerKey: process.env.BACKEND_MANAGER_KEY,
+      email: email,
+      firstName: inferred?.firstName || '',
+      lastName: inferred?.lastName || '',
+      source: 'user:signup',
+    },
+  }).catch(e => assistant.error('signup(): marketing-contact failed:', e));
+
+  // Send welcome emails (non-blocking, don't fail on error)
+  sendWelcomeEmail(assistant, email).catch(e => assistant.error('signup(): sendWelcomeEmail failed:', e));
+  sendCheckupEmail(assistant, email).catch(e => assistant.error('signup(): sendCheckupEmail failed:', e));
+  sendFeedbackEmail(assistant, email).catch(e => assistant.error('signup(): sendFeedbackEmail failed:', e));
+}
+
+/**
+ * Send welcome email (immediate)
+ */
+function sendWelcomeEmail(assistant, email) {
+  const Manager = assistant.Manager;
+  const mailer = Manager.Email(assistant);
+
+  return mailer.send({
+    to: email,
+    categories: ['account/welcome'],
+    subject: `Welcome to ${Manager.config.brand.name}!`,
+    template: 'default',
+    group: 'account',
+    copy: false,
+    data: {
+      email: {
+        preview: `Welcome aboard! I'm Ian, the CEO and founder of ${Manager.config.brand.name}. I'm here to ensure your journey with us gets off to a great start.`,
+      },
+      body: {
+        title: `Welcome to ${Manager.config.brand.name}!`,
+        message: `
+          Welcome aboard!
+          <br><br>
+          I'm Ian, the founder and CEO of <strong>${Manager.config.brand.name}</strong>, and I'm thrilled to have you with us.
+          Your journey begins today, and we are committed to supporting you every step of the way.
+          <br><br>
+          We are dedicated to ensuring your experience is exceptional.
+          Feel free to reply directly to this email with any questions you may have.
+          <br><br>
+          Thank you for choosing <strong>${Manager.config.brand.name}</strong>. Here's to new beginnings!
+        `,
+      },
+      signoff: {
+        type: 'personal',
+        name: 'Ian Wiedenman, CEO',
+        url: `https://ianwiedenman.com?utm_source=welcome-email&utm_medium=email&utm_campaign=${Manager.config.app.id}`,
+        urlText: '@ianwieds',
+      },
+    },
+  })
+    .then((result) => {
+      assistant.log('sendWelcomeEmail(): Success', result.status);
+      return result;
+    });
+}
+
+/**
+ * Send checkup email (7 days after signup)
+ */
+function sendCheckupEmail(assistant, email) {
+  const Manager = assistant.Manager;
+  const mailer = Manager.Email(assistant);
+
+  return mailer.send({
+    to: email,
+    categories: ['account/checkup'],
+    subject: `How's your experience with ${Manager.config.brand.name}?`,
+    template: 'default',
+    group: 'account',
+    copy: false,
+    sendAt: moment().add(7, 'days').unix(),
+    data: {
+      email: {
+        preview: `Checking in from ${Manager.config.brand.name} to see how things are going. Let us know if you have any questions or feedback!`,
+      },
+      body: {
+        title: `How's everything going?`,
+        message: `
+          Hi there,
+          <br><br>
+          It's Ian again from <strong>${Manager.config.brand.name}</strong>. Just checking in to see how things are going for you.
+          <br><br>
+          Have you had a chance to explore all our features? Any questions or feedback for us?
+          <br><br>
+          We're always here to help, so don't hesitate to reach out. Just reply to this email and we'll get back to you as soon as possible.
+          <br><br>
+          Thank you for choosing <strong>${Manager.config.brand.name}</strong>. Here's to new beginnings!
+        `,
+      },
+      signoff: {
+        type: 'personal',
+        name: 'Ian Wiedenman, CEO',
+        url: `https://ianwiedenman.com?utm_source=checkup-email&utm_medium=email&utm_campaign=${Manager.config.app.id}`,
+        urlText: '@ianwieds',
+      },
+    },
+  })
+    .then((result) => {
+      assistant.log('sendCheckupEmail(): Success', result.status);
+      return result;
+    });
+}
+
+/**
+ * Send feedback email (14 days after signup)
+ */
+function sendFeedbackEmail(assistant, email) {
+  const Manager = assistant.Manager;
+  const mailer = Manager.Email(assistant);
+
+  return mailer.send({
+    to: email,
+    categories: ['engagement/feedback'],
+    subject: `Want to share your feedback about ${Manager.config.brand.name}?`,
+    template: 'main/engagement/feedback',
+    group: 'account',
+    copy: false,
+    sendAt: moment().add(14, 'days').unix(),
+  })
+    .then((result) => {
+      assistant.log('sendFeedbackEmail(): Success', result.status);
+      return result;
     });
 }

package/src/manager/schemas/admin/email/post.js

@@ -1,20 +1,25 @@
 /**
  * Schema for POST /admin/email
+ *
+ * Recipients (to, cc, bcc) accept flexible formats:
+ * - String email: "user@example.com"
+ * - UID string: "uid:abc123" (auto-resolves from Firestore)
+ * - Object: { email: "user@example.com", name: "John" }
+ * - Array of any of the above
  */
 module.exports = () => ({
-  to: { types: ['array'], default: [] },
-  cc: { types: ['array'], default: [] },
-  bcc: { types: ['array'], default: [] },
+  to: { types: ['array', 'string', 'object'], default: [] },
+  cc: { types: ['array', 'string', 'object'], default: [] },
+  bcc: { types: ['array', 'string', 'object'], default: [] },
   from: { types: ['object'], default: undefined },
   replyTo: { types: ['string'], default: undefined },
   subject: { types: ['string'], default: undefined },
-  template: { types: ['string'], default: 'd-b7f8da3c98ad49a2ad1e187f3a67b546' },
-  group: { types: ['number'], default: 24077 },
-  sendAt: { types: ['number'], default: undefined },
+  template: { types: ['string'], default: undefined },
+  group: { types: ['number'], default: undefined },
+  sendAt: { types: ['number', 'string'], default: undefined },
   user: { types: ['object'], default: {} },
   data: { types: ['object'], default: {} },
   categories: { types: ['array'], default: [] },
-  copy: { types: ['boolean'], default: true },
-  ensureUnique: { types: ['boolean'], default: true },
+  copy: { types: ['boolean'], default: undefined },
   html: { types: ['string'], default: undefined },
 });

package/src/test/run-tests.js

@@ -2,7 +2,7 @@
 
 /**
  * BEM Test Runner Entry Point
- * This script is executed by the CLI test command inside firebase emulators:exec
+ * This script is executed by the CLI test command inside the Firebase emulator
  * It reads configuration from BEM_TEST_CONFIG environment variable and runs the test suite
  */
 

package/test/functions/admin/send-email.js

@@ -8,7 +8,6 @@
  *
  * Possible status values:
  * - 'sent': Email sent via SendGrid
- * - 'non-unique': Duplicate email detected (when ensureUnique: true)
  * - 'queued': Scheduled beyond 71 hours, saved to queue for later
  */
 module.exports = {
@@ -26,7 +25,6 @@ module.exports = {
         const response = await http.command('admin:send-email', {
           to: [{ email: `_test-receiver@${config.domain}` }],
           copy: false,
-          ensureUnique: false,
         });
 
         assert.isError(response, 400, 'Missing subject should return 400');
@@ -44,7 +42,6 @@ module.exports = {
           subject: 'BEM Test Email - Status Sent',
           to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
           copy: false,
-          ensureUnique: false,
           data: {
             email: {
               subject: 'BEM Test Email - Status Sent',
@@ -55,7 +52,7 @@ module.exports = {
 
         assert.isSuccess(response, 'Admin should be able to send email');
         assert.hasProperty(response, 'data.status', 'Response should have status');
-        assert.equal(response.data.status, 'sent', 'Status should be sent when ensureUnique is false');
+        assert.equal(response.data.status, 'sent', 'Status should be sent');
       },
     },
 
@@ -73,7 +70,6 @@ module.exports = {
           subject: 'BEM Test Email - Status Queued',
           to: [{ email: `_test-receiver@${config.domain}`, name: 'Test Receiver' }],
           copy: false,
-          ensureUnique: false,
           sendAt: sendAt,
           data: {
             email: {
@@ -89,89 +85,6 @@ module.exports = {
       },
     },
 
-    // Test 6: Status 'non-unique' - Duplicate email detected
-    // This test sends two identical emails with ensureUnique: true
-    // The second one should return 'non-unique' status
-    {
-      name: 'status-non-unique',
-      auth: 'admin',
-      timeout: 120000, // Long timeout because ensureUnique waits ~45 seconds
-
-      async run({ http, assert, config }) {
-        const uniqueSubject = `BEM Test Email - Unique Check ${Date.now()}`;
-
-        // Send first email with ensureUnique: true
-        const response1Promise = http.command('admin:send-email', {
-          subject: uniqueSubject,
-          to: [{ email: `_test-receiver@${config.domain}` }],
-          copy: false,
-          ensureUnique: true,
-          categories: ['bem-test-unique'],
-          data: {
-            email: {
-              subject: uniqueSubject,
-              body: 'Testing ensureUnique feature.',
-            },
-          },
-        });
-
-        // Send second identical email immediately (same subject, to, categories = same hash)
-        const response2Promise = http.command('admin:send-email', {
-          subject: uniqueSubject,
-          to: [{ email: `_test-receiver@${config.domain}` }],
-          copy: false,
-          ensureUnique: true,
-          categories: ['bem-test-unique'],
-          data: {
-            email: {
-              subject: uniqueSubject,
-              body: 'Testing ensureUnique feature.',
-            },
-          },
-        });
-
-        // Wait for both
-        const [response1, response2] = await Promise.all([response1Promise, response2Promise]);
-
-        // Both should succeed
-        assert.isSuccess(response1, 'First email should succeed');
-        assert.isSuccess(response2, 'Second email should succeed');
-
-        // One should be 'sent', the other 'non-unique'
-        const statuses = [response1.data.status, response2.data.status].sort();
-        assert.equal(statuses[0], 'non-unique', 'One email should have status non-unique');
-        assert.equal(statuses[1], 'sent', 'One email should have status sent');
-      },
-    },
-
-    // Test 7: Unauthorized sender domain rejected by SendGrid
-    // TODO: SendGrid accepts emails from unauthorized domains at API level
-    // (they may fail at delivery). Consider adding BEM-level validation.
-    // {
-    //   name: 'unauthorized-from-domain-rejected',
-    //   auth: 'admin',
-    //   timeout: 30000,
-    //
-    //   async run({ http, assert, config }) {
-    //     const response = await http.command('admin:send-email', {
-    //       subject: 'BEM Test Email - Unauthorized Sender',
-    //       to: [{ email: `_test-receiver@${config.domain}` }],
-    //       from: { email: 'fake-sender@example.com', name: 'Fake Sender' },
-    //       copy: false,
-    //       ensureUnique: false,
-    //       data: {
-    //         email: {
-    //           subject: 'BEM Test Email - Unauthorized Sender',
-    //           body: 'This email should fail because the sender domain is not authorized.',
-    //         },
-    //       },
-    //     });
-    //
-    //     // SendGrid rejects emails from unauthorized sender domains with 403
-    //     assert.isError(response, 500, 'Sending from unauthorized domain should fail');
-    //   },
-    // },
-
     // --- Auth rejection tests (at end per convention) ---
     {
       name: 'unauthenticated-rejected',