backend-manager 5.0.89 → 5.0.92

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: 'd-b7f8da3c98ad49a2ad1e187f3a67b546',
+    group: 25928,
+    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: 'd-b7f8da3c98ad49a2ad1e187f3a67b546',
+    group: 25928,
+    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: 'd-c1522214c67b47058669acc5a81ed663',
+    group: 25928,
+    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 },
+  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 },
   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/src/test/runner.js

@@ -1,3 +1,4 @@
+const os = require('os');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 const chalk = require('chalk');
@@ -52,6 +53,16 @@ class TestRunner {
    * Main run method
    */
   async run() {
+    // Abort if BEM is running from the user's home directory (e.g., accidental ~/node_modules install)
+    const homeDir = os.homedir();
+    if (__dirname.startsWith(path.join(homeDir, 'node_modules'))) {
+      console.error(chalk.red('\n  ERROR: BEM is running from ~/node_modules (home directory install).'));
+      console.error(chalk.red('  This is likely an accidental global install that shadows local project copies.'));
+      console.error(chalk.red(`  Fix: rm -rf ${path.join(homeDir, 'node_modules')} ${path.join(homeDir, 'package.json')} ${path.join(homeDir, 'package-lock.json')}`));
+      console.error(chalk.red(`  Running from: ${__dirname}\n`));
+      process.exit(1);
+    }
+
     // Set testing flag to skip external API calls (emails, SendGrid)
     process.env.BEM_TESTING = 'true';
 

package/src/test/test-accounts.js

@@ -175,6 +175,24 @@ const JOURNEY_ACCOUNTS = {
       subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
     },
   },
+  'journey-payments-plan-change': {
+    id: 'journey-payments-plan-change',
+    uid: '_test-journey-payments-plan-change',
+    email: '_test.journey-payments-plan-change@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
+    },
+  },
+  'journey-payments-one-time': {
+    id: 'journey-payments-one-time',
+    uid: '_test-journey-payments-one-time',
+    email: '_test.journey-payments-one-time@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' },
+    },
+  },
 };
 
 /**

package/templates/backend-manager-config.json

@@ -72,18 +72,37 @@
           },
         },
       },
-      // Example one-time product:
-      // {
-      //   id: 'credits-100',
-      //   name: '100 Credits',
-      //   type: 'one-time',
-      //   prices: {
-      //     once: {
-      //       amount: 9.99,
-      //       stripe: null,
-      //     },
-      //   },
-      // },
+      {
+        id: 'ultimate',
+        name: 'Ultimate',
+        type: 'subscription',
+        limits: {
+          requests: 10000,
+        },
+        prices: {
+          monthly: {
+            amount: 19.99,
+            stripe: null,
+            paypal: null,
+          },
+          annually: {
+            amount: 199.99,
+            stripe: null,
+            paypal: null,
+          },
+        },
+      },
+      {
+        id: 'credits-100',
+        name: '100 Credits',
+        type: 'one-time',
+        prices: {
+          once: {
+            amount: 9.99,
+            stripe: null,
+          },
+        },
+      },
       // Add more products/tiers here
     ],
   },

package/test/events/payments/journey-payments-one-time-failure.js

@@ -0,0 +1,105 @@
+/**
+ * Test: Payment Journey - One-Time Payment Failure
+ * Simulates: invoice.payment_failed for a non-subscription invoice → purchase-failed transition
+ *
+ * This verifies the webhook routing for one-time invoice failures:
+ * invoice.payment_failed with no subscription billing_reason → category: 'one-time'
+ *
+ * Uses the journey-payments-one-time account (one-time events don't modify subscription state)
+ */
+module.exports = {
+  description: 'Payment journey: one-time invoice.payment_failed → purchase-failed',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'resolve-one-time-product',
+      async run({ accounts, assert, state, config }) {
+        const uid = accounts['journey-payments-one-time'].uid;
+
+        // Resolve first one-time product from config
+        const oneTimeProduct = config.payment.products.find(p => p.type === 'one-time' && p.prices?.once);
+        assert.ok(oneTimeProduct, 'Config should have at least one one-time product');
+
+        state.uid = uid;
+        state.productId = oneTimeProduct.id;
+      },
+    },
+
+    {
+      name: 'send-one-time-payment-failed',
+      async run({ http, assert, state, config }) {
+        state.eventId = `_test-evt-journey-onetime-fail-${Date.now()}`;
+        state.invoiceId = `_test-inv-onetime-fail-${Date.now()}`;
+        state.orderId = `0000-0000-0000`; // Fake orderId for test
+
+        // Send invoice.payment_failed with a non-subscription billing reason
+        // This routes to category: 'one-time' in the webhook parser
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          id: state.eventId,
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              id: state.invoiceId,
+              object: 'invoice',
+              billing_reason: 'manual',
+              amount_due: 999,
+              amount_paid: 0,
+              status: 'open',
+              metadata: {
+                uid: state.uid,
+                orderId: state.orderId,
+                productId: state.productId,
+              },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'webhook-categorized-as-one-time',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.event?.category, 'one-time', 'Category should be one-time');
+        assert.equal(webhookDoc.event?.resourceType, 'invoice', 'Resource type should be invoice');
+        assert.equal(webhookDoc.transition, 'purchase-failed', 'Transition should be purchase-failed');
+      },
+    },
+
+    {
+      name: 'order-doc-created-with-failure',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'one-time', 'Type should be one-time');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.equal(orderDoc.processor, 'test', 'Processor should be test');
+      },
+    },
+
+    {
+      name: 'subscription-unchanged',
+      async run({ firestore, assert, state }) {
+        // One-time payment failures must NOT modify subscription state
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(
+          userDoc.subscription?.product?.id,
+          'basic',
+          'Subscription should remain basic after one-time failure',
+        );
+      },
+    },
+  ],
+};