backend-manager 5.0.89 → 5.0.92

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

@@ -39,7 +39,7 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
 
   // Update stats if requested
   if (settings.update) {
-    const error = await updateStats(admin, assistant, Manager, data, settings.update);
+    const error = await updateStats(assistant, data, settings.update);
 
     if (error) {
       return assistant.respond(error.message, { code: 500 });
@@ -58,7 +58,9 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
   return assistant.respond(data);
 };
 
-async function updateStats(admin, assistant, Manager, existingData, update) {
+async function updateStats(assistant, existingData, update) {
+  const Manager = assistant.Manager;
+  const { admin } = Manager.libraries;
   const stats = admin.firestore().doc('meta/stats');
   const newData = {
     app: Manager.config?.app?.id || null,
@@ -70,7 +72,7 @@ async function updateStats(admin, assistant, Manager, existingData, update) {
 
   // Update notification stats
   if (update === true || update?.notifications) {
-    const count = await getAllNotifications(admin, assistant).catch((e) => e);
+    const count = await getAllNotifications(assistant).catch((e) => e);
 
     if (count instanceof Error) {
       error = new Error(`Failed getting notifications: ${count.message}`);
@@ -81,7 +83,7 @@ async function updateStats(admin, assistant, Manager, existingData, update) {
 
   // Update subscription stats
   if (!error && (update === true || update?.subscriptions)) {
-    const subscriptions = await getAllSubscriptions(admin, assistant).catch((e) => e);
+    const subscriptions = await getAllSubscriptions(assistant).catch((e) => e);
 
     if (subscriptions instanceof Error) {
       error = new Error(`Failed getting subscriptions: ${subscriptions.message}`);
@@ -92,7 +94,7 @@ async function updateStats(admin, assistant, Manager, existingData, update) {
 
   // Update user stats
   if (!error && (!existingData?.users?.total || update === true || update?.users)) {
-    const users = await getAllUsers(admin, assistant).catch((e) => e);
+    const users = await getAllUsers(assistant).catch((e) => e);
 
     if (users instanceof Error) {
       error = new Error(`Failed getting users: ${users.message}`);
@@ -103,7 +105,7 @@ async function updateStats(admin, assistant, Manager, existingData, update) {
 
   // Update online users
   if (!error && (update === true || update?.online)) {
-    const online = await countOnlineUsers(admin, assistant);
+    const online = await countOnlineUsers(assistant);
 
     _.set(newData, 'users.online', online);
   }
@@ -125,7 +127,9 @@ async function updateStats(admin, assistant, Manager, existingData, update) {
   return error;
 }
 
-async function getAllUsers(admin, assistant) {
+async function getAllUsers(assistant) {
+  const { admin } = assistant.Manager.libraries;
+
   assistant.log('getAllUsers(): Starting...');
 
   const users = [];
@@ -142,7 +146,9 @@ async function getAllUsers(admin, assistant) {
   return users;
 }
 
-async function getAllNotifications(admin, assistant) {
+async function getAllNotifications(assistant) {
+  const { admin } = assistant.Manager.libraries;
+
   assistant.log('getAllNotifications(): Starting...');
 
   const snap = await admin.firestore().collection('notifications').count().get();
@@ -153,7 +159,9 @@ async function getAllNotifications(admin, assistant) {
   return count;
 }
 
-async function getAllSubscriptions(admin, assistant) {
+async function getAllSubscriptions(assistant) {
+  const { admin } = assistant.Manager.libraries;
+
   assistant.log('getAllSubscriptions(): Starting...');
 
   const snapshot = await admin.firestore().collection('users')
@@ -195,7 +203,8 @@ async function getAllSubscriptions(admin, assistant) {
   return stats;
 }
 
-async function countOnlineUsers(admin, assistant) {
+async function countOnlineUsers(assistant) {
+  const { admin } = assistant.Manager.libraries;
   let online = 0;
 
   const paths = ['gatherings/online', 'sessions/app', 'sessions/online'];

package/src/manager/routes/general/email/post.js

@@ -4,10 +4,7 @@
  */
 const path = require('path');
 const { merge } = require('lodash');
-
-module.exports = async ({ assistant, Manager, settings, analytics }) => {
-  const fetch = Manager.require('wonderful-fetch');
-
+module.exports = async ({ assistant, Manager, settings }) => {
   // Validate required parameters
   if (!settings.id) {
     return assistant.respond('Parameter {id} is required.', { code: 400 });
@@ -22,10 +19,7 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
       email: 3,
     },
     delay: 1,
-    payload: {
-      backendManagerKey: process.env.BACKEND_MANAGER_KEY,
-      app: Manager.config.app.id,
-    },
+    payload: {},
   };
 
   // Load email template
@@ -75,25 +69,18 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
   assistant.log('Email payload:', emailPayload);
 
-  // Send the email via NEW admin/email API
-  const result = await fetch(`${Manager.project.apiUrl}/backend-manager/admin/email`, {
-    method: 'post',
-    response: 'json',
-    log: true,
-    headers: {
-      'Authorization': `Bearer ${process.env.BACKEND_MANAGER_KEY}`,
-    },
-    body: emailPayload.payload,
-  }).catch(e => e);
+  // Send email directly via library
+  const email = Manager.Email(assistant);
+  const result = await email.send(emailPayload.payload).catch(e => e);
 
   if (result instanceof Error) {
-    return assistant.respond(`Error sending email: ${result}`, { code: 500, sentry: true });
+    return assistant.respond(result.message, { code: result.code || 500, sentry: result.code !== 400 });
   }
 
-  assistant.log('Response:', result);
+  assistant.log('Response:', result.status);
 
   // Track analytics
-  analytics.event('general/email', { id: settings.id });
+  assistant.analytics.event('general/email', { id: settings.id });
 
   return assistant.respond({ success: true });
 };

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

@@ -9,9 +9,7 @@ const dns = require('dns').promises;
 // 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()));
-
-// Load OpenAI library
-const OpenAI = require(path.join(__dirname, '..', '..', '..', 'libraries', 'openai'));
+const { inferContact } = require(path.join(__dirname, '..', '..', '..', 'libraries', 'infer-contact.js'));
 
 module.exports = async ({ assistant, Manager, settings, analytics }) => {
 
@@ -100,7 +98,7 @@ module.exports = async ({ assistant, Manager, settings, analytics }) => {
   // 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;
   }
@@ -212,102 +210,6 @@ async function validateWithZeroBounce(email) {
   }
 }
 
-// Helper: Infer name from email
-async function inferName(email, assistant) {
-  if (process.env.OPENAI_API_KEY) {
-    const aiResult = await inferNameWithAI(email, assistant);
-    if (aiResult && (aiResult.firstName || aiResult.lastName)) {
-      return aiResult;
-    }
-  }
-
-  return inferNameFromEmail(email);
-}
-
-// Helper: Use AI to infer name
-async function inferNameWithAI(email, assistant) {
-  try {
-    const ai = new OpenAI(assistant);
-    const result = await ai.request({
-      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": "...",
-              "lastName": "...",
-              "company": "...",
-              "confidence": "..."
-            }
-
-            If you cannot determine a name, use empty strings.
-          </format>
-        `,
-      },
-      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;
-}
-
-// Helper: Regex-based name inference
-function inferNameFromEmail(email) {
-  const local = email.split('@')[0];
-  const cleaned = local.replace(/[0-9]+$/, '');
-  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',
-  };
-}
-
-// Helper: Capitalize string
-function capitalize(str) {
-  if (!str) {
-    return '';
-  }
-  return str
-    .split(' ')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-    .join(' ');
-}
-
 // Helper: Add contact to SendGrid
 async function addToSendGrid({ email, firstName, lastName, source, appId, brandName }) {
   try {

package/src/manager/routes/payments/intent/post.js

@@ -71,6 +71,10 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
 
   assistant.log(`Generated orderId=${orderId}`);
 
+  // Build redirect URLs
+  const confirmationUrl = buildConfirmationUrl(Manager.project.websiteUrl, { product, productId, productType, frequency, processor, trial, orderId });
+  const cancelUrl = buildCancelUrl(Manager.project.websiteUrl, { productId, frequency });
+
   // Load the processor module
   let processorModule;
   try {
@@ -89,8 +93,8 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
       productId,
       frequency,
       trial,
-      config: Manager.config,
-      Manager,
+      confirmationUrl,
+      cancelUrl,
       assistant,
     });
   } catch (e) {
@@ -132,3 +136,41 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     url: result.url,
   });
 };
+
+/**
+ * Build the confirmation/success redirect URL
+ */
+function buildConfirmationUrl(baseUrl, { product, productId, productType, frequency, processor, trial, orderId }) {
+  const amount = productType === 'subscription'
+    ? (product.prices?.[frequency]?.amount || 0)
+    : (product.prices?.once?.amount || 0);
+
+  const url = new URL('/payment/confirmation', baseUrl);
+  url.searchParams.set('productId', productId);
+  url.searchParams.set('productName', product.name || productId);
+  url.searchParams.set('amount', trial && product.trial?.days ? '0' : String(amount));
+  url.searchParams.set('currency', 'USD');
+  url.searchParams.set('frequency', frequency || 'once');
+  url.searchParams.set('paymentMethod', processor);
+  url.searchParams.set('trial', String(!!trial && !!product.trial?.days));
+  url.searchParams.set('orderId', orderId);
+  url.searchParams.set('track', 'true');
+
+  return url.toString();
+}
+
+/**
+ * Build the cancel/back redirect URL
+ */
+function buildCancelUrl(baseUrl, { productId, frequency }) {
+  const url = new URL('/payment/checkout', baseUrl);
+  url.searchParams.set('product', productId);
+
+  if (frequency) {
+    url.searchParams.set('frequency', frequency);
+  }
+
+  url.searchParams.set('payment', 'cancelled');
+
+  return url.toString();
+}

package/src/manager/routes/payments/intent/processors/stripe.js

@@ -1,3 +1,5 @@
+const resolvePriceId = require('../../../../libraries/payment-processors/resolve-price-id.js');
+
 /**
  * Stripe intent processor
  * Creates Stripe Checkout Sessions for subscription and one-time purchases
@@ -12,11 +14,11 @@ module.exports = {
    * @param {string} options.productId - Product ID from config (e.g., 'premium')
    * @param {string} options.frequency - 'monthly' or 'annually' (subscriptions only)
    * @param {boolean} options.trial - Whether to include a trial period (subscriptions only)
-   * @param {object} options.config - BEM config
-   * @param {object} options.Manager - Manager instance
+   * @param {string} options.confirmationUrl - Success redirect URL
+   * @param {string} options.cancelUrl - Cancel redirect URL
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant }) {
+  async createIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, cancelUrl, assistant }) {
     // Initialize Stripe SDK
     const StripeLib = require('../../../../libraries/payment-processors/stripe.js');
     const stripe = StripeLib.init();
@@ -24,50 +26,13 @@ module.exports = {
     const productType = product.type || 'subscription';
 
     // Resolve the Stripe price ID based on product type
-    let priceId;
-    if (productType === 'subscription') {
-      priceId = product.prices?.[frequency]?.stripe;
-      if (!priceId) {
-        throw new Error(`No Stripe price found for ${productId}/${frequency}`);
-      }
-    } else {
-      priceId = product.prices?.once?.stripe;
-      if (!priceId) {
-        throw new Error(`No Stripe price found for ${productId}/once`);
-      }
-    }
+    const priceId = resolvePriceId(product, productType, frequency);
 
     // Resolve or create Stripe customer (keyed by uid in metadata)
     const email = assistant?.getUser()?.auth?.email || null;
     const customer = await resolveCustomer(stripe, uid, email, assistant);
 
-    assistant?.log(`Stripe checkout: type=${productType}, priceId=${priceId}, uid=${uid}, customerId=${customer.id}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
-
-    // Build confirmation redirect URL
-    const baseUrl = Manager.project.websiteUrl;
-    const amount = productType === 'subscription'
-      ? (product.prices?.[frequency]?.amount || 0)
-      : (product.prices?.once?.amount || 0);
-
-    let confirmationUrl = new URL('/payment/confirmation', baseUrl);
-    confirmationUrl.searchParams.set('productId', productId);
-    confirmationUrl.searchParams.set('productName', product.name || productId);
-    confirmationUrl.searchParams.set('amount', trial && product.trial?.days ? '0' : String(amount));
-    confirmationUrl.searchParams.set('currency', 'USD');
-    confirmationUrl.searchParams.set('frequency', frequency || 'once');
-    confirmationUrl.searchParams.set('paymentMethod', 'stripe');
-    confirmationUrl.searchParams.set('trial', String(!!trial && !!product.trial?.days));
-    confirmationUrl.searchParams.set('orderId', orderId);
-    confirmationUrl.searchParams.set('track', 'true');
-    confirmationUrl = confirmationUrl.toString();
-
-    let cancelUrl = new URL('/payment/checkout', baseUrl);
-    cancelUrl.searchParams.set('product', productId);
-    if (frequency) {
-      cancelUrl.searchParams.set('frequency', frequency);
-    }
-    cancelUrl.searchParams.set('payment', 'cancelled');
-    cancelUrl = cancelUrl.toString();
+    assistant.log(`Stripe checkout: type=${productType}, priceId=${priceId}, uid=${uid}, customerId=${customer.id}, trial=${trial}, trialDays=${product.trial?.days || 'none'}`);
 
     // Build session params based on product type
     let sessionParams;
@@ -81,7 +46,7 @@ module.exports = {
     // Create the checkout session
     const session = await stripe.checkout.sessions.create(sessionParams);
 
-    assistant?.log(`Stripe session created: sessionId=${session.id}, mode=${sessionParams.mode}, url=${session.url}`);
+    assistant.log(`Stripe session created: sessionId=${session.id}, mode=${sessionParams.mode}, url=${session.url}`);
 
     return {
       id: session.id,
@@ -165,7 +130,7 @@ async function resolveCustomer(stripe, uid, email, assistant) {
 
   if (search.data.length > 0) {
     const existing = search.data[0];
-    assistant?.log(`Found existing Stripe customer: ${existing.id}`);
+    assistant.log(`Found existing Stripe customer: ${existing.id}`);
     return existing;
   }
 
@@ -179,6 +144,6 @@ async function resolveCustomer(stripe, uid, email, assistant) {
   }
 
   const customer = await stripe.customers.create(params);
-  assistant?.log(`Created new Stripe customer: ${customer.id}`);
+  assistant.log(`Created new Stripe customer: ${customer.id}`);
   return customer;
 }

package/src/manager/routes/payments/intent/processors/test.js

@@ -1,4 +1,5 @@
 const fetch = require('wonderful-fetch');
+const resolvePriceId = require('../../../../libraries/payment-processors/resolve-price-id.js');
 
 /**
  * Test intent processor
@@ -16,12 +17,12 @@ module.exports = {
    * @param {string} options.productId - Product ID from config
    * @param {string} options.frequency - 'monthly' or 'annually' (subscriptions only)
    * @param {boolean} options.trial - Whether to include a trial period (subscriptions only)
-   * @param {object} options.config - BEM config
-   * @param {object} options.Manager - Manager instance
+   * @param {string} options.confirmationUrl - Success redirect URL
+   * @param {string} options.cancelUrl - Cancel redirect URL
    * @param {object} options.assistant - Assistant instance
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant }) {
+  async createIntent({ uid, orderId, product, productId, frequency, trial, confirmationUrl, assistant }) {
     // Guard: test processor is not available in production
     if (assistant.isProduction()) {
       throw new Error('Test processor is not available in production');
@@ -30,10 +31,10 @@ module.exports = {
     const productType = product.type || 'subscription';
 
     if (productType === 'subscription') {
-      return createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant });
+      return createSubscriptionIntent({ uid, orderId, product, frequency, trial, confirmationUrl, assistant });
     }
 
-    return createOneTimeIntent({ uid, orderId, product, productId, config, Manager, assistant });
+    return createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, assistant });
   },
 };
 
@@ -41,12 +42,9 @@ module.exports = {
  * Create a test subscription intent
  * Generates Stripe-shaped subscription + customer.subscription.created event
  */
-async function createSubscriptionIntent({ uid, orderId, product, productId, frequency, trial, config, Manager, assistant }) {
+async function createSubscriptionIntent({ uid, orderId, product, frequency, trial, confirmationUrl, assistant }) {
   // Get the price ID for the requested frequency
-  const priceId = product.prices?.[frequency]?.stripe;
-  if (!priceId) {
-    throw new Error(`No Stripe price found for ${productId}/${frequency}`);
-  }
+  const priceId = resolvePriceId(product, 'subscription', frequency);
 
   // Generate IDs
   const timestamp = Date.now();
@@ -94,14 +92,14 @@ async function createSubscriptionIntent({ uid, orderId, product, productId, freq
     data: { object: subscription },
   };
 
-  assistant?.log(`Test subscription intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
+  assistant.log(`Test subscription intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
 
   // Auto-fire webhook
-  fireWebhook({ event, Manager, assistant });
+  fireWebhook({ event, assistant });
 
   return {
     id: sessionId,
-    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    url: confirmationUrl,
     raw: { id: sessionId, object: 'checkout.session', subscription: subscriptionId },
   };
 }
@@ -110,12 +108,9 @@ async function createSubscriptionIntent({ uid, orderId, product, productId, freq
  * Create a test one-time payment intent
  * Generates Stripe-shaped checkout session + checkout.session.completed event
  */
-async function createOneTimeIntent({ uid, orderId, product, productId, config, Manager, assistant }) {
-  // Get the price ID for one-time purchase
-  const priceId = product.prices?.once?.stripe;
-  if (!priceId) {
-    throw new Error(`No Stripe price found for ${productId}/once`);
-  }
+async function createOneTimeIntent({ uid, orderId, product, productId, confirmationUrl, assistant }) {
+  // Validate that a price exists (resolvePriceId throws if not found)
+  resolvePriceId(product, 'one-time', null);
 
   // Generate IDs
   const timestamp = Date.now();
@@ -141,14 +136,14 @@ async function createOneTimeIntent({ uid, orderId, product, productId, config, M
     data: { object: session },
   };
 
-  assistant?.log(`Test one-time intent: sessionId=${sessionId}, eventId=${eventId}, productId=${productId}`);
+  assistant.log(`Test one-time intent: sessionId=${sessionId}, eventId=${eventId}, productId=${productId}`);
 
   // Auto-fire webhook
-  fireWebhook({ event, Manager, assistant });
+  fireWebhook({ event, assistant });
 
   return {
     id: sessionId,
-    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    url: confirmationUrl,
     raw: { id: sessionId, object: 'checkout.session', mode: 'payment' },
   };
 }
@@ -156,14 +151,14 @@ async function createOneTimeIntent({ uid, orderId, product, productId, config, M
 /**
  * Fire-and-forget webhook to trigger the full pipeline
  */
-function fireWebhook({ event, Manager, assistant }) {
-  const webhookUrl = `${Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_KEY}`;
+function fireWebhook({ event, assistant }) {
+  const webhookUrl = `${assistant.Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_KEY}`;
   fetch(webhookUrl, {
     method: 'POST',
     response: 'json',
     body: event,
     timeout: 15000,
   }).catch((e) => {
-    assistant?.log(`Test processor auto-webhook failed: ${e.message}`);
+    assistant.log(`Test processor auto-webhook failed: ${e.message}`);
   });
 }

package/src/manager/routes/user/oauth2/_helpers.js

@@ -14,8 +14,9 @@ const STATE_KEY = process.env.BACKEND_MANAGER_KEY
  * Build context object with common OAuth2 data
  * Used by GET, POST, DELETE handlers
  */
-async function buildContext({ assistant, Manager, user, settings, libraries, requireProvider = true }) {
-  const { admin } = libraries;
+async function buildContext({ assistant, user, settings, requireProvider = true }) {
+  const Manager = assistant.Manager;
+  const { admin } = Manager.libraries;
 
   // Require authentication
   if (!user.authenticated) {

package/src/manager/routes/user/oauth2/delete.js

@@ -8,14 +8,14 @@ const {
  *
  * Revokes tokens with the provider (best effort) and removes the connection.
  */
-module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
-  const context = await buildContext({ assistant, Manager, user, settings, libraries });
+module.exports = async ({ assistant, user, settings }) => {
+  const context = await buildContext({ assistant, user, settings });
 
   if (context.error) {
     return assistant.respond(context.error.message, { code: context.error.code });
   }
 
-  const { admin, oauth2Provider, targetUid, targetUser, clientId, clientSecret } = context;
+  const { Manager, admin, oauth2Provider, targetUid, targetUser, clientId, clientSecret } = context;
 
   assistant.log('OAuth2 DELETE request', { provider: settings.provider });
 

package/src/manager/routes/user/oauth2/get.js

@@ -12,8 +12,8 @@ const {
  *   - authorize (default): Get authorization URL
  *   - status: Check connection status
  */
-module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
-  const context = await buildContext({ assistant, Manager, user, settings, libraries });
+module.exports = async ({ assistant, user, settings }) => {
+  const context = await buildContext({ assistant, user, settings });
 
   if (context.error) {
     return assistant.respond(context.error.message, { code: context.error.code });

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

@@ -14,18 +14,16 @@ const {
  *   - tokenize (default): Exchange authorization code for tokens
  *   - refresh: Refresh access token
  */
-module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
-  const { admin } = libraries;
-
+module.exports = async ({ assistant, user, settings }) => {
   assistant.log('OAuth2 POST request', { action: settings.action });
 
   switch (settings.action) {
     case 'refresh':
-      return processRefresh({ assistant, Manager, user, settings, libraries });
+      return processRefresh({ assistant, user, settings });
 
     case 'tokenize':
     default:
-      return processTokenize({ assistant, Manager, admin, settings });
+      return processTokenize({ assistant, settings });
   }
 };
 
@@ -33,7 +31,9 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
 // Handlers
 // ============================================================================
 
-async function processTokenize({ assistant, Manager, admin, settings }) {
+async function processTokenize({ assistant, settings }) {
+  const Manager = assistant.Manager;
+  const { admin } = Manager.libraries;
   assistant.log('processTokenize settings', {
     hasCode: !!settings.code,
     codeType: typeof settings.code,
@@ -167,14 +167,14 @@ async function processTokenize({ assistant, Manager, admin, settings }) {
   return assistant.respond({ success: true });
 }
 
-async function processRefresh({ assistant, Manager, user, settings, libraries }) {
-  const context = await buildContext({ assistant, Manager, user, settings, libraries });
+async function processRefresh({ assistant, user, settings }) {
+  const context = await buildContext({ assistant, user, settings });
 
   if (context.error) {
     return assistant.respond(context.error.message, { code: context.error.code });
   }
 
-  const { admin, oauth2Provider, targetUid, targetUser, clientId, clientSecret } = context;
+  const { Manager, admin, oauth2Provider, targetUid, targetUser, clientId, clientSecret } = context;
 
   const refreshToken = targetUser?.oauth2?.[settings.provider]?.token?.refresh_token;
 

package/src/manager/routes/user/sessions/delete.js

@@ -26,10 +26,10 @@ module.exports = async ({ assistant, user, settings, libraries }) => {
   let count = 0;
 
   // Sign out of main session
-  count += await signOutOfSession(admin, assistant, uid, sessionPath);
+  count += await signOutOfSession(assistant, uid, sessionPath);
 
   // Legacy for somiibo and old electron-manager
-  count += await signOutOfSession(admin, assistant, uid, 'gatherings/online');
+  count += await signOutOfSession(assistant, uid, 'gatherings/online');
 
   // Revoke Firebase refresh tokens
   try {
@@ -47,7 +47,8 @@ module.exports = async ({ assistant, user, settings, libraries }) => {
 /**
  * Sign out of a specific session path
  */
-async function signOutOfSession(admin, assistant, uid, sessionPath) {
+async function signOutOfSession(assistant, uid, sessionPath) {
+  const { admin } = assistant.Manager.libraries;
   let count = 0;
 
   const snapshot = await admin.database().ref(sessionPath)