backend-manager 5.0.89 → 5.0.92

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/payment-failed.js

@@ -1,15 +1,25 @@
 /**
  * Transition: payment-failed
  * Triggered when a subscription payment fails (active → suspended)
- *
- * Use cases:
- * - Send payment failure notification email
- * - Include link to update payment method
- * - Fire analytics event for churn risk
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant }) {
   assistant.log(`Transition [subscription/payment-failed]: uid=${uid}, product=${after.product.id}, previousStatus=${before?.status}`);
 
-  // TODO: Send payment failure email with update-payment link
-  // TODO: Fire analytics event
+  sendOrderEmail({
+    template: 'd-e56af0ac62364bfb9e50af02854e2cd3',
+    subject: 'Your payment failed',
+    categories: ['order/payment-failed'],
+    uid,
+    assistant,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/payment-recovered.js

@@ -1,14 +1,25 @@
 /**
  * Transition: payment-recovered
  * Triggered when a suspended subscription is recovered (suspended → active)
- *
- * Use cases:
- * - Send payment recovered confirmation email
- * - Fire analytics event for recovered subscriber
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant }) {
   assistant.log(`Transition [subscription/payment-recovered]: uid=${uid}, product=${after.product.id}`);
 
-  // TODO: Send payment recovered email
-  // TODO: Fire analytics event
+  sendOrderEmail({
+    template: 'd-d6dbd17a260a4755b34a852ba09c2454',
+    subject: 'Your payment was successful',
+    categories: ['order/payment-recovered'],
+    uid,
+    assistant,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/plan-changed.js

@@ -1,16 +1,34 @@
 /**
  * Transition: plan-changed
  * Triggered when a user upgrades or downgrades their plan (product A → product B, both active + paid)
- *
- * Use cases:
- * - Send plan change confirmation email
- * - Include new plan details and what changed
- * - Fire analytics event for upgrade/downgrade
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant }) {
   const direction = after.product.id > before.product.id ? 'upgrade' : 'downgrade';
   assistant.log(`Transition [subscription/plan-changed]: uid=${uid}, ${before.product.id} → ${after.product.id} (${direction})`);
 
-  // TODO: Send plan change email with new plan details
-  // TODO: Fire analytics event
+  sendOrderEmail({
+    template: 'd-399086311bbb48b4b77bc90b20fb9d0a',
+    subject: 'Your subscription plan has been updated',
+    categories: ['order/plan-changed'],
+    uid,
+    assistant,
+    data: {
+      order: {
+        ...order,
+        // Inject previous plan info into the unified object for the template
+        unified: {
+          ...order.unified,
+          previous: {
+            product: before.product,
+            price: before.payment?.price || 0,
+          },
+        },
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+        },
+      },
+    },
+  });
 };

package/src/manager/events/firestore/payments-webhooks/transitions/subscription/subscription-cancelled.js

@@ -1,16 +1,31 @@
 /**
  * Transition: subscription-cancelled
  * Triggered when a subscription is fully cancelled (any non-cancelled → cancelled)
- *
- * Use cases:
- * - Send final cancellation email
- * - Include reactivation link or win-back offer
- * - Fire analytics event for churned subscriber
- * - Clean up any subscription-specific resources
  */
-module.exports = async function ({ before, after, uid, userDoc, admin, assistant, Manager, eventType, eventId }) {
+const { sendOrderEmail, formatDate } = require('../send-email.js');
+
+module.exports = async function ({ before, after, order, uid, assistant }) {
   assistant.log(`Transition [subscription/subscription-cancelled]: uid=${uid}, previousProduct=${before?.product?.id}, previousStatus=${before?.status}`);
 
-  // TODO: Send cancellation email with reactivation link
-  // TODO: Fire analytics event
+  // Check if subscription has a future expiry (e.g., cancelled at period end)
+  const hasFutureExpiry = after.expires?.timestamp && new Date(after.expires.timestamp) > new Date();
+
+  sendOrderEmail({
+    template: 'd-39041132e6b24e5ebf0e95bce2d94dba',
+    subject: 'Your subscription has been cancelled',
+    categories: ['order/cancelled'],
+    uid,
+    assistant,
+    data: {
+      order: {
+        ...order,
+        _computed: {
+          date: formatDate(new Date().toISOString()),
+          ...(hasFutureExpiry && {
+            expiresDate: formatDate(after.expires.timestamp),
+          }),
+        },
+      },
+    },
+  });
 };

package/src/manager/functions/core/actions/api/admin/send-email.js

@@ -51,18 +51,6 @@ Module.prototype.main = function () {
       return reject(assistant.errorify(email.message, { code: 400 }));
     }
 
-    // Check for duplicate emails being sent
-    const uniqueResult = await self.ensureFirstInstance(email);
-
-    // If not unique, return early
-    if (!uniqueResult) {
-      return resolve({
-        data: {
-          status: 'non-unique',
-        },
-      });
-    }
-
     // If scheduled beyond SendGrid's limit, queue it
     if (email.sendAt && email.sendAt >= moment().add(SEND_AT_LIMIT, 'hours').unix()) {
       await self.saveToEmailQueue(email).catch(e => e);
@@ -151,7 +139,6 @@ Module.prototype.defaultize = function () {
 
     // Set defaults
     options.copy = typeof options.copy === 'undefined' ? true : options.copy;
-    options.ensureUnique = typeof options.ensureUnique === 'undefined' ? true : options.ensureUnique;
     options.categories = powertools.arrayify(options.categories || []);
 
     email.to = powertools.arrayify(options.to || []);
@@ -262,38 +249,6 @@ Module.prototype.defaultize = function () {
     email.cc = email.cc.filter(obj => !email.to.some(obj2 => obj.email === obj2.email));
     email.bcc = email.bcc.filter(obj => !email.to.some(obj2 => obj.email === obj2.email));
 
-    // Try to get contact name from SendGrid
-    await fetch(`https://api.sendgrid.com/v3/marketing/contacts/search/emails`, {
-      method: 'post',
-      response: 'json',
-      timeout: 60000,
-      headers: {
-        'Authorization': `Bearer ${process.env.SENDGRID_API_KEY}`,
-        'Content-Type': 'application/json',
-      },
-      body: {
-        emails: email.to.map(obj => obj.email),
-      },
-    })
-      .then((json) => {
-        assistant.log('Got contact names', json);
-
-        // Update names from contacts
-        email.to.forEach((to) => {
-          const match = json.result[to.email];
-          if (match) {
-            email.to[0].name = match.contact.first_name || email.dynamicTemplateData.user.personal.name.first;
-          }
-        });
-      })
-      .catch((e) => {
-        if (e.status === 404) {
-          assistant.log('Contact does not exist in database');
-        } else {
-          assistant.error('Failed to get contact names', e);
-        }
-      });
-
     // Log resolved email
     assistant.log('Resolved email.to', email.to);
 
@@ -331,7 +286,6 @@ Module.prototype.defaultize = function () {
     email.dynamicTemplateData.email.unsubscribeUrl = `https://itwcreativeworks.com/portal/account/email-preferences?email=${encode(email.to[0].email)}&asmId=${encode(email.asm.groupId)}&templateId=${encode(email.templateId)}&appName=${email.dynamicTemplateData.app.name}&appUrl=${email.dynamicTemplateData.app.url}`;
     email.dynamicTemplateData.email.categories = email.categories;
     email.dynamicTemplateData.email.carbonCopy = options.copy;
-    email.dynamicTemplateData.email.ensureUnique = options.ensureUnique;
 
     // Handle raw HTML content (overrides template)
     if (options.html) {
@@ -350,16 +304,6 @@ Module.prototype.defaultize = function () {
       'List-Unsubscribe': `<${email.dynamicTemplateData.email.unsubscribeUrl}>`,
     };
 
-    // Generate email hash for deduplication
-    email.hash = crypto.createHash('sha256');
-    email.hash.update(
-      email.to.map(obj => obj.email).join(',')
-      + email.from.email
-      + email.subject
-      + options.categories.join(',')
-    );
-    email.hash = email.hash.digest('hex');
-
     // Clone and clean data for stringified version
     const emailClonedData = _.cloneDeep(email.dynamicTemplateData);
     emailClonedData.app.sponsorships = {};
@@ -400,81 +344,6 @@ Module.prototype.saveToEmailQueue = function (email) {
   });
 };
 
-Module.prototype.ensureFirstInstance = function (email) {
-  const self = this;
-  const Manager = self.Manager;
-  const assistant = self.assistant;
-  const payload = self.payload;
-
-  return new Promise(async function(resolve, reject) {
-    const timeout = assistant.isDevelopment() ? 3000 : 45000;
-    const { admin } = self.libraries;
-
-    const hash = email.hash;
-    const id = email.dynamicTemplateData.email.id;
-    const options = payload.data.payload;
-
-    assistant.log(`ensureFirstInstance(): Checking for unique email hash=${hash}, id=${id}`);
-
-    // Skip uniqueness check if disabled
-    if (!options.ensureUnique) {
-      assistant.log(`ensureFirstInstance(): Skipping unique email check`);
-      return resolve(true);
-    }
-
-    // Save email to temporary storage
-    await admin.firestore().doc(`temporary/email-queue`).set({
-      [hash]: {
-        [id]: assistant.meta.startTime.timestampUNIX,
-      },
-    }, { merge: true })
-      .then((doc) => {
-        assistant.log(`ensureFirstInstance(): Saved email to temporary storage`, hash);
-      })
-      .catch((e) => {
-        assistant.error(`ensureFirstInstance(): Failed to save email to temporary storage`, hash, e);
-      });
-
-    // Wait for timeout to allow duplicates to register
-    assistant.log(`ensureFirstInstance(): Waiting for ${timeout / 1000} sec`);
-    await powertools.poll(async (index) => {
-      return false;
-    }, { interval: 1000, timeout: timeout })
-      .catch((e) => {
-        assistant.log(`ensureFirstInstance(): Timeout reached`);
-      });
-
-    // Check if this is the first instance
-    const result = await admin.firestore().doc(`temporary/email-queue`).get()
-      .then((doc) => doc.data()?.[hash] || {})
-      .catch((e) => ({}));
-
-    const length = Object.keys(result).length;
-    const isFirstInstance = length === 1 || result[id] === Math.min(...Object.values(result));
-
-    assistant.log(`ensureFirstInstance(): Result`, result);
-    assistant.log(`ensureFirstInstance(): Result isFirstInstance`, length, isFirstInstance);
-
-    if (isFirstInstance) {
-      // Delete email from temporary storage
-      await admin.firestore().doc(`temporary/email-queue`).set({
-        [hash]: FieldValue.delete(),
-      }, { merge: true })
-        .then((doc) => {
-          assistant.log(`ensureFirstInstance(): Deleted email from temporary storage`, hash);
-        })
-        .catch((e) => {
-          assistant.error(`ensureFirstInstance(): Failed to delete email from temporary storage`, hash, e);
-        });
-
-      return resolve(true);
-    } else {
-      assistant.warn(`ensureFirstInstance(): Email is not unique`, hash, length, result);
-      return resolve(false);
-    }
-  });
-};
-
 // Helper to URL-encode base64
 function encode(s) {
   return encodeURIComponent(Buffer.from(String(s)).toString('base64'));

package/src/manager/functions/core/actions/api/general/add-marketing-contact.js

@@ -1,11 +1,11 @@
 const fetch = require('wonderful-fetch');
 const path = require('path');
 const dns = require('dns').promises;
-const OpenAI = require(path.join(__dirname, '..', '..', '..', '..', '..', 'libraries', 'openai'));
 
 // Load disposable domains list
 const DISPOSABLE_DOMAINS = require(path.join(__dirname, '..', '..', '..', '..', '..', 'libraries', 'disposable-domains.json'));
 const DISPOSABLE_SET = new Set(DISPOSABLE_DOMAINS.map(d => d.toLowerCase()));
+const { inferContact } = require(path.join(__dirname, '..', '..', '..', '..', '..', 'libraries', 'infer-contact.js'));
 
 function Module() {}
 
@@ -108,7 +108,7 @@ Module.prototype.main = function () {
     // Infer name if not provided
     let nameInferred = null;
     if (!firstName && !lastName) {
-      nameInferred = await inferName(email, assistant);
+      nameInferred = await inferContact(email, assistant);
       firstName = nameInferred.firstName;
       lastName = nameInferred.lastName;
     }
@@ -248,141 +248,6 @@ async function checkMxRecord(domain) {
   }
 }
 
-/**
- * Infer first/last name from email address
- * Uses ChatGPT if OPENAI_API_KEY exists, otherwise regex parsing
- */
-async function inferName(email, assistant) {
-  // Try ChatGPT first if available
-  if (process.env.OPENAI_API_KEY) {
-    const aiResult = await inferNameWithAI(email, assistant);
-    if (aiResult && (aiResult.firstName || aiResult.lastName)) {
-      return aiResult;
-    }
-  }
-
-  // Fallback to regex parsing
-  return inferNameFromEmail(email);
-}
-
-/**
- * Use ChatGPT to infer name from email
- */
-async function inferNameWithAI(email, assistant) {
-  try {
-    const ai = new OpenAI(assistant);
-    const result = await ai.request({
-      // model: 'gpt-4.1-nano',
-      model: 'gpt-5-mini',
-      timeout: 30000,
-      maxTokens: 1024,
-      moderate: false,
-      response: 'json',
-      prompt: {
-        content: `
-          <identity>
-            You extract names and company from email addresses.
-          </identity>
-
-          <format>
-            Return ONLY valid JSON like so:
-            {
-              "firstName": "...", // First name <string>, capitalized
-              "lastName": "...", // Last name <string>, capitalized
-              "company": "...", // Company name <string>, capitalized
-              "confidence": "..." // Confidence level <number>, 0-1 scale
-            }
-
-            If you cannot determine a name, use empty strings.
-          </format>
-
-          <examples>
-            <example>
-              <input>john.smith@acme.com</input>
-              <output>{"firstName": "John", "lastName": "Smith", "company": "Acme", "confidence": 0.9}</output>
-            </example>
-            <example>
-              <input>jsmith123@gmail.com</input>
-              <output>{"firstName": "J", "lastName": "Smith", "company": "", "confidence": 0.4}</output>
-            </example>
-            <example>
-              <input>support@bigcorp.io</input>
-              <output>{"firstName": "", "lastName": "", "company": "Bigcorp", "confidence": 0.7}</output>
-            </example>
-            <example>
-              <input>mary_jane_watson@stark-industries.com</input>
-              <output>{"firstName": "Mary", "lastName": "Watson", "company": "Stark Industries", "confidence": 0.85}</output>
-            </example>
-            <example>
-              <input>info@company.org</input>
-              <output>{"firstName": "", "lastName": "", "company": "Company", "confidence": 0.6}</output>
-            </example>
-          </examples>
-        `,
-      },
-      message: {
-        content: `Email: ${email}`,
-      },
-    });
-
-    if (result?.firstName !== undefined) {
-      return {
-        firstName: capitalize(result.firstName || ''),
-        lastName: capitalize(result.lastName || ''),
-        company: capitalize(result.company || ''),
-        confidence: typeof result.confidence === 'number' ? result.confidence : 0.5,
-        method: 'ai',
-      };
-    }
-  } catch (e) {
-    console.error('AI name inference error:', e);
-  }
-
-  return null;
-}
-
-/**
- * Regex-based name inference from email
- */
-function inferNameFromEmail(email) {
-  const local = email.split('@')[0];
-
-  // Remove trailing numbers
-  const cleaned = local.replace(/[0-9]+$/, '');
-
-  // Split on common separators
-  const parts = cleaned.split(/[._-]/);
-
-  if (parts.length >= 2) {
-    return {
-      firstName: capitalize(parts[0]),
-      lastName: capitalize(parts.slice(1).join(' ')),
-      confidence: 0.5,
-      method: 'regex',
-    };
-  }
-
-  return {
-    firstName: capitalize(cleaned),
-    lastName: '',
-    confidence: 0.25,
-    method: 'regex',
-  };
-}
-
-/**
- * Capitalize first letter of each word
- */
-function capitalize(str) {
-  if (!str) {
-    return '';
-  }
-  return str
-    .split(' ')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join(' ');
-}
-
 /**
  * Add contact to SendGrid Marketing Contacts
  */

package/src/manager/functions/core/actions/api/user/sign-up.js

@@ -112,7 +112,7 @@ Module.prototype.main = function () {
           });
       }
 
-      // Note: SendGrid list and welcome emails are now handled by auth:on-create
+      // Note: SendGrid list, welcome emails, and name inference are handled by user/signup route
 
       return resolve({
         data: {

package/src/manager/helpers/user.js

@@ -41,6 +41,7 @@ const SCHEMA = {
       orderId: { type: 'string', default: null, nullable: true },
       resourceId: { type: 'string', default: null, nullable: true },
       frequency: { type: 'string', default: null, nullable: true },
+      price: { type: 'number', default: 0 },
       startDate: '$timestamp',
       updatedBy: {
         event: {

package/src/manager/index.js

@@ -507,6 +507,18 @@ Manager.prototype.Metadata = function () {
   return new self.libraries.Metadata(self, ...arguments);
 };
 
+Manager.prototype.Email = function (assistant) {
+  const self = this;
+  self.libraries.Email = self.libraries.Email || require('./libraries/email.js');
+  return new self.libraries.Email(assistant);
+};
+
+Manager.prototype.AI = function (assistant, key) {
+  const self = this;
+  self.libraries.AI = self.libraries.AI || require('./libraries/openai.js');
+  return new self.libraries.AI(assistant, key);
+};
+
 // For importing API libraries
 Manager.prototype.Api = function () {
   const self = this;