backend-manager 5.0.72 → 5.0.74

package/src/manager/helpers/usage.js

@@ -1,11 +1,10 @@
 /**
  * Usage
  * Meant to check and update usage for a user
- * Uses the ITWCW apps/{app}/products/{product}/limits/{metric} to check limits
+ * Reads product limits from Manager.config.products
  * Stores usage in the user's firestore document OR in local/temp storage if no user
  */
 
-const fetch = require('wonderful-fetch');
 const moment = require('moment');
 const _ = require('lodash');
 const hcaptcha = require('hcaptcha');
@@ -16,14 +15,12 @@ function Usage(m) {
   self.Manager = m;
 
   self.user = null;
-  self.app = null;
   self.options = null;
   self.assistant = null;
   self.storage = null;
 
   self.paths = {
     user: '',
-    app: '',
   }
 
   self.initialized = false;
@@ -37,8 +34,6 @@ Usage.prototype.init = function (assistant, options) {
 
     // Set options
     options = options || {};
-    options.app = options.app || Manager.config.app.id;
-    options.refetch = typeof options.refetch === 'undefined' ? false : options.refetch;
     options.clear = typeof options.clear === 'undefined' ? false : options.clear;
     options.today = typeof options.today === 'undefined' ? undefined : options.today;
     options.key = typeof options.key === 'undefined' ? undefined : options.key;
@@ -60,7 +55,7 @@ Usage.prototype.init = function (assistant, options) {
     // Set assistant
     self.assistant = assistant;
 
-    // Setup storage
+    // Setup storage (used for unauthenticated local-mode usage tracking)
     self.storage = Manager.storage({name: 'usage', temporary: true, clear: options.clear, log: options.log});
 
     // Set local key
@@ -69,11 +64,6 @@ Usage.prototype.init = function (assistant, options) {
 
     // Set paths
     self.paths.user = `users.${self.key}`;
-    self.paths.app = `apps.${options.app}`;
-
-    // Get storage data
-    const appLastFetched = moment(self.storage.get(`${self.paths.app}.lastFetched`, 0).value());
-    const diff = moment().diff(appLastFetched, 'hours');
 
     // Authenticate user (user will be resolved as well)
     self.user = await assistant.authenticate();
@@ -100,31 +90,6 @@ Usage.prototype.init = function (assistant, options) {
     }
 
     // Log
-    self.log(`Usage.init(): Checking if usage data needs to be fetched (${diff} hours)...`);
-
-    // Get app data to get plan limits using cached data if possible
-    if (diff > 1 || options.refetch) {
-      await self.getApp(options.app)
-        .then((json) => {
-          // Write data and last fetched to storage
-          self.storage.set(`${self.paths.app}.data`, json).write();
-          self.storage.set(`${self.paths.app}.lastFetched`, new Date().toISOString()).write();
-        })
-        .catch(e => {
-          assistant.errorify(`Usage.init(): Error fetching app data: ${e}`, {code: 500, sentry: true});
-        });
-    }
-
-    // Get app data
-    self.app = self.storage.get(`${self.paths.app}.data`, {}).value();
-
-    // Check for app data
-    if (!self.app) {
-      return reject(new Error('Usage.init(): No app data found'));
-    }
-
-    // Log
-    self.log(`Usage.init(): Got app data`, self.app);
     self.log(`Usage.init(): Got user`, self.user);
 
     // Set initialized to true
@@ -146,7 +111,7 @@ Usage.prototype.validate = function (name, options) {
     options = options || {};
     options.useCaptchaResponse = typeof options.useCaptchaResponse === 'undefined' ? true : options.useCaptchaResponse;
     options.log = typeof options.log === 'undefined' ? true : options.log;
-    options.throw = typeof options.throw === 'undefined' ? false : options.throw;
+    options._forceReject = typeof options._forceReject === 'undefined' ? false : options._forceReject;
 
     // Check for required options
     const period = self.getUsage(name);
@@ -164,8 +129,8 @@ Usage.prototype.validate = function (name, options) {
       );
     }
 
-    // Dev mode throw
-    if (options.throw) {
+    // Force reject (for testing/debugging)
+    if (options._forceReject) {
       return _reject();
     }
 
@@ -283,20 +248,31 @@ Usage.prototype.getUsage = function (name) {
   }
 };
 
-Usage.prototype.getLimit = function (name) {
+Usage.prototype.getProduct = function (id) {
   const self = this;
   const Manager = self.Manager;
-  const assistant = self.assistant;
 
-  // Get key
-  const key = `products.${self.options.app}-${self.user.plan.id}.limits`;
+  const products = Manager.config.products || [];
+
+  // Look up by provided ID, or fall back to user's subscription product
+  id = id || self.user.subscription.product.id;
+
+  return products.find(p => p.id === id)
+    || products.find(p => p.id === 'basic')
+    || {};
+};
+
+Usage.prototype.getLimit = function (name) {
+  const self = this;
 
-  // Get limit
+  const limits = self.getProduct().limits || {};
+
+  // Return specific limit or all limits
   if (name) {
-    return _.get(self.app, `${key}.${name}`, 0);
-  } else {
-    return _.get(self.app, key, {});
+    return limits[name] || 0;
   }
+
+  return limits;
 };
 
 Usage.prototype.update = function () {
@@ -370,49 +346,4 @@ Usage.prototype.log = function () {
   }
 };
 
-Usage.prototype.getApp = function (id) {
-  const self = this;
-
-  // Shortcuts
-  const Manager = self.Manager;
-  const assistant = self.assistant;
-
-  return new Promise(function(resolve, reject) {
-    const { admin } = Manager.libraries;
-
-    try {
-      // If we're on ITW, we can read directly from Firestore
-      // If we don't do this, calling getApp on ITW will call getApp on ITW again and again
-      if (Manager.config.app.id === 'itw-creative-works') {
-        admin.firestore().doc(`apps/${id}`)
-          .get()
-          .then((r) => {
-            const data = r.data();
-
-            // Check for data
-            if (!data) {
-              return reject(new Error('No data found'));
-            }
-
-            // Resolve
-            return resolve(data);
-          })
-          .catch((e) => reject(e));
-      } else {
-        fetch('https://us-central1-itw-creative-works.cloudfunctions.net/getApp', {
-          method: 'post',
-          response: 'json',
-          body: {
-            id: id,
-          },
-        })
-        .then((json) => resolve(json))
-        .catch((e) => reject(e));
-      }
-    } catch (e) {
-      return reject(e);
-    }
-  });
-};
-
 module.exports = Usage;

package/src/manager/helpers/user.js

@@ -40,44 +40,52 @@ function User(Manager, settings, options) {
       email: settings?.auth?.email ?? null,
       temporary: getWithDefault(settings?.auth?.temporary, false, defaults),
     },
-    plan: {
-      id: getWithDefault(settings?.plan?.id, 'basic', defaults), // intro | basic | advanced | premium
-      status: getWithDefault(settings?.plan?.status, 'cancelled', defaults), // active | suspended | cancelled
+    subscription: {
+      product: {
+        id: getWithDefault(settings?.subscription?.product?.id, 'basic', defaults), // product ID from config (e.g., 'basic', 'premium', 'pro')
+        name: getWithDefault(settings?.subscription?.product?.name, 'Basic', defaults), // display name from config
+      },
+      status: getWithDefault(settings?.subscription?.status, 'active', defaults), // 'active' | 'suspended' | 'cancelled'
       expires: {
-        timestamp: getWithDefault(settings?.plan?.expires?.timestamp, oldDate, defaults),
-        timestampUNIX: getWithDefault(settings?.plan?.expires?.timestampUNIX, oldDateUNIX, defaults),
+        timestamp: getWithDefault(settings?.subscription?.expires?.timestamp, oldDate, defaults),
+        timestampUNIX: getWithDefault(settings?.subscription?.expires?.timestampUNIX, oldDateUNIX, defaults),
       },
       trial: {
-        activated: getWithDefault(settings?.plan?.trial?.activated, false, defaults),
+        activated: getWithDefault(settings?.subscription?.trial?.activated, false, defaults),
         expires: {
-          timestamp: getWithDefault(settings?.plan?.trial?.expires?.timestamp, oldDate, defaults),
-          timestampUNIX: getWithDefault(settings?.plan?.trial?.expires?.timestampUNIX, oldDateUNIX, defaults),
+          timestamp: getWithDefault(settings?.subscription?.trial?.expires?.timestamp, oldDate, defaults),
+          timestampUNIX: getWithDefault(settings?.subscription?.trial?.expires?.timestampUNIX, oldDateUNIX, defaults),
+        },
+      },
+      cancellation: {
+        pending: getWithDefault(settings?.subscription?.cancellation?.pending, false, defaults),
+        date: {
+          timestamp: getWithDefault(settings?.subscription?.cancellation?.date?.timestamp, oldDate, defaults),
+          timestampUNIX: getWithDefault(settings?.subscription?.cancellation?.date?.timestampUNIX, oldDateUNIX, defaults),
         },
       },
       limits: {
-        // devices: settings?.plan?.limits?.devices ?? null,
+        // devices: settings?.subscription?.limits?.devices ?? null,
       },
       payment: {
-        processor: settings?.plan?.payment?.processor ?? null, // paypal | stripe | chargebee, etc
-        orderId: settings?.plan?.payment?.orderId ?? null, // xxx-xxx-xxx
-        resourceId: settings?.plan?.payment?.resourceId ?? null, // x-xxxxxx
-        frequency: settings?.plan?.payment?.frequency ?? null, // monthly || annually
-        active: getWithDefault(settings?.plan?.payment?.active, false, defaults), // true | false
+        processor: settings?.subscription?.payment?.processor ?? null, // 'stripe' | 'paypal' | etc
+        resourceId: settings?.subscription?.payment?.resourceId ?? null, // subscription ID from provider (e.g., 'sub_xxx')
+        frequency: settings?.subscription?.payment?.frequency ?? null, // 'monthly' | 'annually'
         startDate: {
-          timestamp: getWithDefault(settings?.plan?.payment?.startDate?.timestamp, now, defaults), // x-xxxxxx
-          timestampUNIX: getWithDefault(settings?.plan?.payment?.startDate?.timestampUNIX, nowUNIX, defaults), // x-xxxxxx
+          timestamp: getWithDefault(settings?.subscription?.payment?.startDate?.timestamp, oldDate, defaults),
+          timestampUNIX: getWithDefault(settings?.subscription?.payment?.startDate?.timestampUNIX, oldDateUNIX, defaults),
         },
         updatedBy: {
           event: {
-            name: settings?.plan?.payment?.updatedBy?.event?.name ?? null, // x-xxxxxx
-            id: settings?.plan?.payment?.updatedBy?.event?.id ?? null, // x-xxxxxx
+            name: settings?.subscription?.payment?.updatedBy?.event?.name ?? null,
+            id: settings?.subscription?.payment?.updatedBy?.event?.id ?? null,
           },
           date: {
-            timestamp: getWithDefault(settings?.plan?.payment?.updatedBy?.date?.timestamp, now, defaults), // x-xxxxxx
-            timestampUNIX: getWithDefault(settings?.plan?.payment?.updatedBy?.date?.timestampUNIX, nowUNIX, defaults), // x-xxxxxx
+            timestamp: getWithDefault(settings?.subscription?.payment?.updatedBy?.date?.timestamp, oldDate, defaults),
+            timestampUNIX: getWithDefault(settings?.subscription?.payment?.updatedBy?.date?.timestampUNIX, oldDateUNIX, defaults),
           },
         },
-      }
+      },
     },
     roles: {
       admin: getWithDefault(settings?.roles?.admin, false, defaults),
@@ -172,23 +180,6 @@ function User(Manager, settings, options) {
     self.properties = pruneObject(self.properties);
   }
 
-  self.resolve = function (options) {
-    options = options || {};
-    options.defaultPlan = options.defaultPlan || 'basic';
-    const planId = self.properties?.plan?.id ?? options.defaultPlan;
-    const premiumExpire = self.properties?.plan?.expires?.timestamp ?? 0;
-
-    let difference = ((new Date(premiumExpire).getTime() - new Date().getTime())/(24*3600*1000));
-    // console.log('---difference', difference);
-    if (difference <= -1) {
-      _.set(self.properties, 'plan.id', options.defaultPlan);
-      // console.log('---REVERTED TO BASIC BECAUSE EXPIRED');
-    } else {
-      // console.log('---ITS FINE');
-    }
-    return self;
-  }
-
   self.merge = function (userObject) {
     self.properties = _.merge({}, self.properties, userObject)
     return self;

package/src/manager/index.js

@@ -391,7 +391,7 @@ Manager.prototype._preProcess = function (mod) {
   });
 };
 
-Manager.prototype._processMiddleware = function (req, res, routePath) {
+Manager.prototype._processMiddleware = function (req, res, routePath, options) {
   const self = this;
 
   // Set paths for BEM internal routes/schemas
@@ -399,11 +399,11 @@ Manager.prototype._processMiddleware = function (req, res, routePath) {
   const bemSchemasDir = path.resolve(__dirname, './schemas');
 
   // Route directly through middleware (no hooks for new system)
-  return self.Middleware(req, res).run(routePath, {
+  return self.Middleware(req, res).run(routePath, Object.assign({
     routesDir: bemRoutesDir,
     schemasDir: bemSchemasDir,
     schema: routePath,
-  });
+  }, options || {}));
 };
 
 // Manager.prototype.Assistant = function(ref, options) {
@@ -461,12 +461,6 @@ Manager.prototype.Roles = function () {
   return new self.libraries.Roles(self, ...arguments);
 };
 
-Manager.prototype.SubscriptionResolver = function () {
-  const self = this;
-  self.libraries.SubscriptionResolver = self.libraries.SubscriptionResolver || require('./helpers/subscription-resolver.js');
-  return new self.libraries.SubscriptionResolver(self, ...arguments);
-};
-
 Manager.prototype.Usage = function () {
   const self = this;
   self.libraries.Usage = self.libraries.Usage || require('./helpers/usage.js');
@@ -719,6 +713,17 @@ Manager.prototype.setupFunctions = function (exporter, options) {
     self.assistant.log('Setting up Firebase functions...');
   }
 
+  // Route-specific middleware overrides
+  // Routes listed here get custom middleware options (e.g., skip auth for webhooks)
+  const routeMiddlewareOverrides = {
+    'payments/webhook': {
+      authenticate: false,
+      setupUsage: false,
+      setupAnalytics: false,
+      includeNonSchemaSettings: true,
+    },
+  };
+
   // Setup functions
   exporter.bm_api =
   self.libraries.functions
@@ -731,7 +736,8 @@ Manager.prototype.setupFunctions = function (exporter, options) {
       return self._process((new (require(`${core}/actions/api.js`))()).init(self, { req, res }));
     } else {
       // New RESTful middleware system -> direct to middleware (no hooks)
-      return self._processMiddleware(req, res, route.routePath);
+      const overrides = routeMiddlewareOverrides[route.routePath];
+      return self._processMiddleware(req, res, route.routePath, overrides);
     }
   });
 
@@ -924,6 +930,12 @@ Manager.prototype.setupFunctions = function (exporter, options) {
   .firestore.document('notifications/{token}')
   .onWrite((change, context) => self.EventMiddleware({ change, context }).run(`${events}/firestore/notifications/on-write.js`));
 
+  exporter.bm_paymentsWebhookOnWrite =
+  self.libraries.functions
+  .runWith({memory: '256MB', timeoutSeconds: 60})
+  .firestore.document('payments-webhooks/{eventId}')
+  .onWrite((change, context) => self.EventMiddleware({ change, context }).run(`${events}/firestore/payments-webhooks/on-write.js`));
+
   // Setup cron jobs
   exporter.bm_cronDaily =
   self.libraries.functions

package/src/manager/libraries/stripe.js

@@ -0,0 +1,293 @@
+const powertools = require('node-powertools');
+
+// Lazy singleton Stripe SDK instance
+let stripeInstance = null;
+
+/**
+ * Stripe shared library
+ * Provides SDK initialization and unified subscription transformation
+ */
+const Stripe = {
+  /**
+   * Initialize or return the Stripe SDK instance
+   * @param {string} secretKey - Stripe secret key
+   * @returns {object} Stripe SDK instance
+   */
+  init() {
+    if (!stripeInstance) {
+      const secretKey = process.env.STRIPE_SECRET_KEY;
+
+      if (!secretKey) {
+        throw new Error('STRIPE_SECRET_KEY environment variable is required');
+      }
+
+      stripeInstance = require('stripe')(secretKey);
+    }
+
+    return stripeInstance;
+  },
+
+  /**
+   * Transform a raw Stripe subscription object into the unified subscription shape
+   * This produces the exact same object stored in users/{uid}.subscription
+   *
+   * @param {object} rawSubscription - Raw Stripe subscription object
+   * @param {object} options
+   * @param {object} options.config - BEM config (must contain products array)
+   * @param {string} options.eventName - Name of the webhook event (e.g., 'customer.subscription.updated')
+   * @param {string} options.eventId - ID of the webhook event (e.g., 'evt_xxx')
+   * @returns {object} Unified subscription object
+   */
+  toUnified(rawSubscription, options) {
+    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);
+
+    // Resolve cancellation
+    const cancellation = resolveCancellation(rawSubscription);
+
+    // Resolve trial
+    const trial = resolveTrial(rawSubscription);
+
+    // Resolve frequency
+    const frequency = resolveFrequency(rawSubscription);
+
+    // Resolve product from price
+    const product = resolveProduct(rawSubscription, config);
+
+    // Resolve expiration
+    const expires = resolveExpires(rawSubscription, oldDate, oldDateUNIX);
+
+    // Resolve start date
+    const startDate = resolveStartDate(rawSubscription, oldDate, oldDateUNIX);
+
+    // Build the unified subscription object
+    const now = powertools.timestamp(new Date(), { output: 'string' });
+    const nowUNIX = powertools.timestamp(now, { output: 'unix' });
+
+    return {
+      product: product,
+      status: status,
+      expires: expires,
+      trial: trial,
+      cancellation: cancellation,
+      limits: {},
+      payment: {
+        processor: 'stripe',
+        resourceId: rawSubscription.id || null,
+        frequency: frequency,
+        startDate: startDate,
+        updatedBy: {
+          event: {
+            name: options.eventName || null,
+            id: options.eventId || null,
+          },
+          date: {
+            timestamp: now,
+            timestampUNIX: nowUNIX,
+          },
+        },
+      },
+    };
+  },
+};
+
+/**
+ * Map Stripe subscription status to unified status
+ *
+ * | Stripe Status        | Unified Status |
+ * |----------------------|----------------|
+ * | active               | active         |
+ * | trialing             | active         |
+ * | past_due             | suspended      |
+ * | unpaid               | suspended      |
+ * | canceled             | cancelled      |
+ * | incomplete           | cancelled      |
+ * | incomplete_expired   | cancelled      |
+ */
+function resolveStatus(raw) {
+  const stripeStatus = raw.status;
+
+  if (stripeStatus === 'active' || stripeStatus === 'trialing') {
+    return 'active';
+  }
+
+  if (stripeStatus === 'past_due' || stripeStatus === 'unpaid') {
+    return 'suspended';
+  }
+
+  // canceled, incomplete, incomplete_expired, or anything else
+  return 'cancelled';
+}
+
+/**
+ * Resolve cancellation state from Stripe subscription
+ * 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 cancelAt = raw.cancel_at
+      ? powertools.timestamp(new Date(raw.cancel_at * 1000), { output: 'string' })
+      : powertools.timestamp(new Date((raw.current_period_end || 0) * 1000), { output: 'string' });
+
+    return {
+      pending: true,
+      date: {
+        timestamp: cancelAt,
+        timestampUNIX: powertools.timestamp(cancelAt, { output: 'unix' }),
+      },
+    };
+  }
+
+  // Already cancelled
+  if (raw.canceled_at) {
+    const cancelledDate = powertools.timestamp(new Date(raw.canceled_at * 1000), { output: 'string' });
+
+    return {
+      pending: false,
+      date: {
+        timestamp: cancelledDate,
+        timestampUNIX: powertools.timestamp(cancelledDate, { output: 'unix' }),
+      },
+    };
+  }
+
+  // No cancellation
+  return {
+    pending: false,
+    date: {
+      timestamp: oldDate,
+      timestampUNIX: oldDateUNIX,
+    },
+  };
+}
+
+/**
+ * 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 };
+  if (trialEnd) {
+    const trialEndDate = powertools.timestamp(new Date(trialEnd), { output: 'string' });
+    trialExpires = {
+      timestamp: trialEndDate,
+      timestampUNIX: powertools.timestamp(trialEndDate, { output: 'unix' }),
+    };
+  }
+
+  return {
+    activated: activated,
+    expires: trialExpires,
+  };
+}
+
+/**
+ * Resolve billing frequency from Stripe subscription
+ */
+function resolveFrequency(raw) {
+  // Stripe stores interval on the plan/price object
+  const interval = raw.plan?.interval
+    || 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;
+}
+
+/**
+ * Resolve product by matching the Stripe price ID against config products
+ * Returns { id, name } — falls back to basic if no match is found
+ */
+function resolveProduct(raw, config) {
+  // Get the price ID from the subscription
+  const priceId = raw.plan?.id
+    || raw.items?.data?.[0]?.price?.id
+    || null;
+
+  if (!priceId || !config.products) {
+    return { id: 'basic', name: 'Basic' };
+  }
+
+  // Search through products for a matching price ID
+  for (const product of config.products) {
+    if (!product.prices) {
+      continue;
+    }
+
+    for (const frequency of Object.keys(product.prices)) {
+      if (product.prices[frequency]?.stripe === priceId) {
+        return { id: product.id, name: product.name || product.id };
+      }
+    }
+  }
+
+  // No match found
+  return { id: 'basic', name: 'Basic' };
+}
+
+/**
+ * Resolve subscription expiration from Stripe data
+ */
+function resolveExpires(raw, oldDate, oldDateUNIX) {
+  // For active/trialing subscriptions, use current_period_end
+  const periodEnd = raw.current_period_end
+    ? powertools.timestamp(new Date(raw.current_period_end * 1000), { output: 'string' })
+    : oldDate;
+
+  return {
+    timestamp: periodEnd,
+    timestampUNIX: periodEnd !== oldDate
+      ? powertools.timestamp(periodEnd, { output: 'unix' })
+      : oldDateUNIX,
+  };
+}
+
+/**
+ * Resolve subscription start date from Stripe data
+ */
+function resolveStartDate(raw, oldDate, oldDateUNIX) {
+  const startDate = raw.start_date
+    ? powertools.timestamp(new Date(raw.start_date * 1000), { output: 'string' })
+    : oldDate;
+
+  return {
+    timestamp: startDate,
+    timestampUNIX: startDate !== oldDate
+      ? powertools.timestamp(startDate, { output: 'unix' })
+      : oldDateUNIX,
+  };
+}
+
+module.exports = Stripe;

package/src/manager/routes/admin/stats/get.js

@@ -157,7 +157,7 @@ async function getAllSubscriptions(admin, assistant) {
   assistant.log('getAllSubscriptions(): Starting...');
 
   const snapshot = await admin.firestore().collection('users')
-    .where('plan.expires.timestampUNIX', '>=', Date.now() / 1000)
+    .where('subscription.expires.timestampUNIX', '>=', Date.now() / 1000)
     .get();
 
   const stats = {
@@ -167,8 +167,8 @@ async function getAllSubscriptions(admin, assistant) {
 
   snapshot.forEach((doc) => {
     const data = doc.data();
-    const planId = data?.plan?.id || 'basic';
-    const frequency = data?.plan?.payment?.frequency || 'unknown';
+    const planId = data?.subscription?.product?.id || 'basic';
+    const frequency = data?.subscription?.payment?.frequency || 'unknown';
     const isAdmin = data?.roles?.admin || false;
     const isVip = data?.roles?.vip || false;
 

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

@@ -58,7 +58,7 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
     // Check rate limit via Usage API
     try {
-      await usage.validate('marketing-subscribe', { throw: true, useCaptchaResponse: false });
+      await usage.validate('marketing-subscribe', { useCaptchaResponse: false });
       usage.increment('marketing-subscribe');
       await usage.update();
     } catch (e) {