backend-manager 5.0.89 → 5.0.92

package/src/manager/libraries/payment-processors/stripe.js

@@ -3,6 +3,13 @@ const powertools = require('node-powertools');
 // Lazy singleton Stripe SDK instance
 let stripeInstance = null;
 
+// Epoch zero timestamps (used as default/empty dates)
+const EPOCH_ZERO = powertools.timestamp(new Date(0), { output: 'string' });
+const EPOCH_ZERO_UNIX = powertools.timestamp(EPOCH_ZERO, { output: 'unix' });
+
+// Stripe interval → unified frequency map
+const INTERVAL_TO_FREQUENCY = { year: 'annually', month: 'monthly', week: 'weekly', day: 'daily' };
+
 /**
  * Stripe shared library
  * Provides SDK initialization, resource fetching, and unified transformations
@@ -79,9 +86,6 @@ const Stripe = {
     options = options || {};
     const config = options.config || {};
 
-    const oldDate = powertools.timestamp(new Date(0), { output: 'string' });
-    const oldDateUNIX = powertools.timestamp(oldDate, { output: 'unix' });
-
     // Resolve status
     const status = resolveStatus(rawSubscription);
 
@@ -98,10 +102,13 @@ const Stripe = {
     const product = resolveProduct(rawSubscription, config);
 
     // Resolve expiration
-    const expires = resolveExpires(rawSubscription, oldDate, oldDateUNIX);
+    const expires = resolveExpires(rawSubscription);
 
     // Resolve start date
-    const startDate = resolveStartDate(rawSubscription, oldDate, oldDateUNIX);
+    const startDate = resolveStartDate(rawSubscription);
+
+    // Resolve price from config
+    const price = resolvePrice(product.id, frequency, config);
 
     // Build the unified subscription object
     const now = powertools.timestamp(new Date(), { output: 'string' });
@@ -118,6 +125,7 @@ const Stripe = {
         orderId: rawSubscription.metadata?.orderId || null,
         resourceId: rawSubscription.id || null,
         frequency: frequency,
+        price: price,
         startDate: startDate,
         updatedBy: {
           event: {
@@ -135,7 +143,7 @@ const Stripe = {
 
   /**
    * Transform a raw Stripe one-time payment resource into a unified shape
-   * Stub for now — will be fully implemented when one-time purchases are built out
+   * Mirrors subscription structure: { product, status, payment: { ... } }
    *
    * @param {object} rawResource - Raw Stripe resource (session, invoice, etc.)
    * @param {object} options
@@ -143,20 +151,33 @@ const Stripe = {
    */
   toUnifiedOneTime(rawResource, options) {
     options = options || {};
+    const config = options.config || {};
 
     const now = powertools.timestamp(new Date(), { output: 'string' });
     const nowUNIX = powertools.timestamp(now, { output: 'unix' });
 
+    // Resolve product + price from config
+    const productId = rawResource.metadata?.productId;
+    const product = resolveProductOneTime(productId, config);
+    const price = resolvePrice(productId, 'once', config);
+
     return {
-      id: rawResource.id || null,
-      processor: 'stripe',
-      orderId: rawResource.metadata?.orderId || null,
+      product: product,
       status: rawResource.status || 'unknown',
-      raw: rawResource,
-      metadata: {
-        created: {
-          timestamp: now,
-          timestampUNIX: nowUNIX,
+      payment: {
+        processor: 'stripe',
+        orderId: rawResource.metadata?.orderId || null,
+        resourceId: rawResource.id || null,
+        price: price,
+        updatedBy: {
+          event: {
+            name: options.eventName || null,
+            id: options.eventId || null,
+          },
+          date: {
+            timestamp: now,
+            timestampUNIX: nowUNIX,
+          },
         },
       },
     };
@@ -196,9 +217,6 @@ function resolveStatus(raw) {
  * Handles cancel_at_period_end for pending cancellations
  */
 function resolveCancellation(raw) {
-  const oldDate = powertools.timestamp(new Date(0), { output: 'string' });
-  const oldDateUNIX = powertools.timestamp(oldDate, { output: 'unix' });
-
   // Pending cancellation: active but set to cancel at period end
   if (raw.cancel_at_period_end) {
     const periodEnd = raw.current_period_end || raw.items?.data?.[0]?.current_period_end || 0;
@@ -232,8 +250,8 @@ function resolveCancellation(raw) {
   return {
     pending: false,
     date: {
-      timestamp: oldDate,
-      timestampUNIX: oldDateUNIX,
+      timestamp: EPOCH_ZERO,
+      timestampUNIX: EPOCH_ZERO_UNIX,
     },
   };
 }
@@ -242,15 +260,12 @@ function resolveCancellation(raw) {
  * Resolve trial state from Stripe subscription
  */
 function resolveTrial(raw) {
-  const oldDate = powertools.timestamp(new Date(0), { output: 'string' });
-  const oldDateUNIX = powertools.timestamp(oldDate, { output: 'unix' });
-
   const trialStart = raw.trial_start ? raw.trial_start * 1000 : 0;
   const trialEnd = raw.trial_end ? raw.trial_end * 1000 : 0;
   const activated = !!(trialStart && trialEnd);
 
   // Build trial expiration
-  let trialExpires = { timestamp: oldDate, timestampUNIX: oldDateUNIX };
+  let trialExpires = { timestamp: EPOCH_ZERO, timestampUNIX: EPOCH_ZERO_UNIX };
   if (trialEnd) {
     const trialEndDate = powertools.timestamp(new Date(trialEnd), { output: 'string' });
     trialExpires = {
@@ -274,23 +289,7 @@ function resolveFrequency(raw) {
     || raw.items?.data?.[0]?.price?.recurring?.interval
     || null;
 
-  if (interval === 'year') {
-    return 'annually';
-  }
-
-  if (interval === 'month') {
-    return 'monthly';
-  }
-
-  if (interval === 'week') {
-    return 'weekly';
-  }
-
-  if (interval === 'day') {
-    return 'daily';
-  }
-
-  return null;
+  return INTERVAL_TO_FREQUENCY[interval] || null;
 }
 
 /**
@@ -324,10 +323,28 @@ function resolveProduct(raw, config) {
   return { id: 'basic', name: 'Basic' };
 }
 
+/**
+ * Resolve product for one-time payments by matching productId from metadata
+ * Returns { id, name } — falls back to 'unknown' if no match is found
+ */
+function resolveProductOneTime(productId, config) {
+  if (!productId || !config.payment?.products) {
+    return { id: productId || 'unknown', name: 'Unknown' };
+  }
+
+  const product = config.payment.products.find(p => p.id === productId);
+
+  if (!product) {
+    return { id: productId, name: productId };
+  }
+
+  return { id: product.id, name: product.name || product.id };
+}
+
 /**
  * Resolve subscription expiration from Stripe data
  */
-function resolveExpires(raw, oldDate, oldDateUNIX) {
+function resolveExpires(raw) {
   // Stripe API 2025+ moves period dates to items.data[0]
   const periodEndRaw = raw.current_period_end
     || raw.items?.data?.[0]?.current_period_end
@@ -335,30 +352,52 @@ function resolveExpires(raw, oldDate, oldDateUNIX) {
 
   const periodEnd = periodEndRaw
     ? powertools.timestamp(new Date(periodEndRaw * 1000), { output: 'string' })
-    : oldDate;
+    : EPOCH_ZERO;
 
   return {
     timestamp: periodEnd,
-    timestampUNIX: periodEnd !== oldDate
+    timestampUNIX: periodEnd !== EPOCH_ZERO
       ? powertools.timestamp(periodEnd, { output: 'unix' })
-      : oldDateUNIX,
+      : EPOCH_ZERO_UNIX,
   };
 }
 
 /**
  * Resolve subscription start date from Stripe data
  */
-function resolveStartDate(raw, oldDate, oldDateUNIX) {
+function resolveStartDate(raw) {
   const startDate = raw.start_date
     ? powertools.timestamp(new Date(raw.start_date * 1000), { output: 'string' })
-    : oldDate;
+    : EPOCH_ZERO;
 
   return {
     timestamp: startDate,
-    timestampUNIX: startDate !== oldDate
+    timestampUNIX: startDate !== EPOCH_ZERO
       ? powertools.timestamp(startDate, { output: 'unix' })
-      : oldDateUNIX,
+      : EPOCH_ZERO_UNIX,
   };
 }
 
+/**
+ * Resolve the display price for a product/frequency from config
+ *
+ * @param {string} productId - Product ID (e.g., 'premium')
+ * @param {string} frequency - 'monthly', 'annually', or 'once'
+ * @param {object} config - App config
+ * @returns {number} Price amount (e.g., 4.99) or 0
+ */
+function resolvePrice(productId, frequency, config) {
+  const product = config.payment?.products?.find(p => p.id === productId);
+
+  if (!product) {
+    return 0;
+  }
+
+  if (frequency === 'once') {
+    return product.prices?.once?.amount || 0;
+  }
+
+  return product.prices?.[frequency]?.amount || 0;
+}
+
 module.exports = Stripe;

package/src/manager/libraries/payment-processors/test.js

@@ -37,10 +37,10 @@ const Test = {
 
       if (!snapshot.empty) {
         const data = snapshot.docs[0].data();
-        // payments-orders stores the unified subscription inside .subscription
+        // payments-orders stores the unified subscription inside .unified
         // Reconstruct a Stripe-shaped object from the unified data for toUnifiedSubscription()
-        if (resourceType === 'subscription' && data.subscription) {
-          return buildStripeSubscriptionFromUnified(data.subscription, resourceId, context?.eventType, context?.config);
+        if (resourceType === 'subscription' && data.unified) {
+          return buildStripeSubscriptionFromUnified(data.unified, resourceId, context?.eventType, context?.config);
         }
       }
     }
@@ -65,7 +65,7 @@ const Test = {
    */
   toUnifiedOneTime(rawResource, options) {
     const unified = Stripe.toUnifiedOneTime(rawResource, options);
-    unified.processor = 'test';
+    unified.payment.processor = 'test';
     return unified;
   },
 };

package/src/manager/libraries/prompts/infer-contact.md

@@ -0,0 +1,43 @@
+<identity>
+You extract names and company from email addresses.
+</identity>
+
+<format>
+Return ONLY valid JSON like so:
+{
+  "firstName": "...",
+  "lastName": "...",
+  "company": "...",
+  "confidence": "..."
+}
+
+- 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>

package/src/manager/routes/admin/backup/post.js

@@ -43,7 +43,7 @@ module.exports = async ({ assistant, Manager, user, settings, analytics, librari
     outputUriPrefix: bucketAddress,
     collectionIds: [],
   }).catch(async (e) => {
-    await setMetaStats(assistant, admin, e);
+    await setMetaStats(assistant, e);
     return e;
   });
 
@@ -55,7 +55,7 @@ module.exports = async ({ assistant, Manager, user, settings, analytics, librari
 
   assistant.log('Saved backup successfully:', response.metadata.outputUriPrefix);
 
-  await setMetaStats(assistant, admin, null);
+  await setMetaStats(assistant, null);
 
   // Track analytics
   analytics.event('admin/backup', { status: 'success' });
@@ -64,7 +64,8 @@ module.exports = async ({ assistant, Manager, user, settings, analytics, librari
 };
 
 // Helper: Set meta stats
-async function setMetaStats(assistant, admin, error) {
+async function setMetaStats(assistant, error) {
+  const { admin } = assistant.Manager.libraries;
   const isError = error instanceof Error;
 
   await admin.firestore().doc('meta/stats')