abmp-npm 2.0.72 → 2.0.74

package/.claude/worktrees/fix-save-button-disable/backend/daily-pull/utils.js

@@ -0,0 +1,151 @@
+const { LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
+const { updateWixMemberLoginEmail } = require('../members-area-methods');
+const { extractUrlCounter } = require('../utils');
+
+const { MEMBER_ACTIONS } = require('./consts');
+
+const isUpdatedMember = member => member.action !== MEMBER_ACTIONS.NONE;
+const isSiteAssociatedMember = (member, siteAssociation) =>
+  member.memberships.some(membership => membership.association === siteAssociation);
+
+/**
+ * Attempts to change Wix login emails for the given members and returns one structured
+ * outcome per member (see updateWixMemberLoginEmail). Never throws for an individual member.
+ * @param {Array} toChangeWixMembersEmails
+ * @returns {Promise<Array>} outcomes
+ */
+const changeWixMembersEmails = async toChangeWixMembersEmails => {
+  console.log(
+    `[loginEmailSync] changing login emails for ${toChangeWixMembersEmails.length} members with ids: [${toChangeWixMembersEmails.map(member => member.memberId).join(', ')}]`
+  );
+  const outcomes = await Promise.all(
+    toChangeWixMembersEmails.map(member => updateWixMemberLoginEmail(member))
+  );
+  const summary = outcomes.reduce((acc, outcome) => {
+    acc[outcome.status] = (acc[outcome.status] || 0) + 1;
+    return acc;
+  }, {});
+  console.log(`[loginEmailSync] results summary: ${JSON.stringify(summary)}`);
+  return outcomes;
+};
+
+/**
+ * Summarizes login-email sync outcomes for manual handling via the task result.
+ * Pure function so it can be unit-tested without Wix.
+ * @param {Array} outcomes - from updateWixMemberLoginEmail / changeWixMembersEmails
+ * @returns {{ failedMemberIds: Set, failures: Array }} set of failed memberIds (whose CMS login
+ *   email must be left unchanged) and the failure records to surface in the task result
+ */
+const summarizeLoginEmailOutcomes = (outcomes = []) => {
+  const failedMemberIds = new Set();
+  const failures = [];
+  outcomes.forEach(outcome => {
+    if (outcome.status === LOGIN_EMAIL_SYNC_STATUS.FAILED) {
+      failedMemberIds.add(outcome.memberId);
+      failures.push({
+        memberId: outcome.memberId,
+        wixMemberId: outcome.wixMemberId,
+        desiredEmail: outcome.desiredEmail,
+        error: outcome.error || 'unknown error',
+      });
+    }
+  });
+  return { failedMemberIds, failures };
+};
+
+const extractBaseUrl = url => {
+  if (!url) return url;
+  const lastCounter = extractUrlCounter(url);
+  if (lastCounter > 0) {
+    // Remove the numeric counter to get the base URL
+    return url.split('-').slice(0, -1).join('-');
+  }
+  // No counter found, return the URL as-is
+  return url;
+};
+const incrementUrlCounter = (existingUrl, baseUrl) => {
+  if (!existingUrl || !baseUrl) {
+    return baseUrl;
+  }
+  // Normalize for comparison (case-insensitive)
+  const normalizedExisting = existingUrl.toLowerCase();
+  const normalizedBase = baseUrl.toLowerCase();
+
+  if (
+    normalizedExisting === normalizedBase ||
+    normalizedExisting.startsWith(`${normalizedBase}-`)
+  ) {
+    console.log(
+      `Found member with same url ${existingUrl} for baseUrl ${baseUrl}, increasing counter by 1`
+    );
+    const lastCounter = Math.max(0, extractUrlCounter(existingUrl));
+    return `${baseUrl}-${lastCounter + 1}`;
+  }
+
+  // No conflict, return baseUrl with counter 1 to be safe
+  return `${baseUrl}-1`;
+};
+/**
+ * Validates core member data requirements
+ * @param {Object} inputMemberData - Raw member data from API to validate
+ * @returns {boolean} - True if all required fields are valid, false otherwise
+ */
+const validateCoreMemberData = inputMemberData => {
+  // Check memberid
+  if (!inputMemberData?.memberid) {
+    console.warn('validateCoreMemberData: Missing required field - memberid is mandatory');
+    return false;
+  }
+
+  // Check email
+  if (
+    !inputMemberData?.email ||
+    typeof inputMemberData.email !== 'string' ||
+    !inputMemberData.email.trim()
+  ) {
+    console.warn(
+      'validateCoreMemberData: Missing required field - email (valid string) is mandatory'
+    );
+    return false;
+  }
+
+  // Check memberships
+  if (
+    !inputMemberData?.memberships ||
+    !Array.isArray(inputMemberData.memberships) ||
+    inputMemberData.memberships.length === 0
+  ) {
+    console.warn(
+      'validateCoreMemberData: Missing required field - memberships (non-empty array) is mandatory'
+    );
+    return false;
+  }
+
+  return true;
+};
+
+const containsNonEnglish = str => /[^a-zA-Z0-9-]/.test(str); // if it contains any non-english characters or invalid URL chars, test1 is allowed, hyphens are allowed
+
+/**
+ * Creates a full name from first and last name components
+ * @param {string} firstName - First name
+ * @param {string} lastName - Last name
+ * @returns {string} - Combined full name
+ */
+const createFullName = (firstName, lastName) => {
+  const trimmedFirst = firstName?.trim() || '';
+  const trimmedLast = lastName?.trim() || '';
+  return `${trimmedFirst} ${trimmedLast}`.trim();
+};
+
+module.exports = {
+  isUpdatedMember,
+  isSiteAssociatedMember,
+  changeWixMembersEmails,
+  summarizeLoginEmailOutcomes,
+  validateCoreMemberData,
+  containsNonEnglish,
+  createFullName,
+  incrementUrlCounter,
+  extractBaseUrl,
+};

package/.claude/worktrees/fix-save-button-disable/backend/data-hooks.js

@@ -0,0 +1,29 @@
+const { taskManager, TASK_TYPE } = require('psdev-task-manager');
+
+const { COMPILED_FILTERS_FIELDS } = require('./consts');
+const { TASKS_NAMES } = require('./tasks/consts');
+
+const scheduleCompileFiltersTask = field =>
+  taskManager().schedule({
+    name: TASKS_NAMES.CompileFiltersOptions,
+    data: { field },
+    type: TASK_TYPE.SCHEDULED,
+  });
+
+function scheduleCompileInterestsTask() {
+  return scheduleCompileFiltersTask(COMPILED_FILTERS_FIELDS.COMPILED_AREAS_OF_PRACTICES);
+}
+
+function scheduleCompileStatesTask() {
+  return scheduleCompileFiltersTask(COMPILED_FILTERS_FIELDS.COMPILED_STATE_LIST);
+}
+
+function scheduleCompileCitiesTask() {
+  return scheduleCompileFiltersTask(COMPILED_FILTERS_FIELDS.COMPILED_STATE_CITY_MAP);
+}
+
+module.exports = {
+  scheduleCompileInterestsTask,
+  scheduleCompileStatesTask,
+  scheduleCompileCitiesTask,
+};

package/.claude/worktrees/fix-save-button-disable/backend/dev-only-methods.js

@@ -0,0 +1,58 @@
+const { COLLECTIONS } = require('../public/consts');
+
+const { ensureUniqueUrlsInBatch } = require('./daily-pull/bulk-process-methods');
+const { ensureUniqueUrl } = require('./daily-pull/process-member-methods');
+const { wixData } = require('./elevated-modules');
+const { bulkSaveMembers } = require('./members-data-methods');
+const { queryAllItems } = require('./utils');
+
+async function deduplicateURls(collectionName, duplicateUrlsList) {
+  const query = await wixData.query(collectionName).hasSome('url', duplicateUrlsList).limit(1000);
+  const membersWithSameUrl = await queryAllItems(query);
+
+  console.log({ membersWithSameUrl });
+  const membersWithUniqueUrls = await ensureUniqueUrlsInBatch(membersWithSameUrl);
+  console.log({ membersWithUniqueUrls });
+  const deduplicatedUrls = membersWithUniqueUrls.map(m => m.url);
+  console.log({ deduplicatedUrls });
+  return await bulkSaveMembers(membersWithUniqueUrls, collectionName);
+}
+
+async function copyContactIdToWixMemberId() {
+  const query = wixData.query(COLLECTIONS.MEMBERS_DATA).isNotEmpty('contactId');
+  const members = await queryAllItems(query);
+  const updatedMembers = members.map(member => ({
+    ...member,
+    wixMemberId: member.contactId,
+  }));
+  return await bulkSaveMembers(updatedMembers, COLLECTIONS.MEMBERS_DATA);
+}
+
+async function createMissingUrls() {
+  const query = wixData.query(COLLECTIONS.MEMBERS_DATA).isEmpty('url');
+  const members = await queryAllItems(query);
+  console.log(
+    'membersWithoutUrls info',
+    JSON.stringify({
+      count: members.length,
+      membersIds: members.map(m => m.memberId),
+    })
+  );
+
+  const membersWithGeneratedUrlsPromises = members.map(async member => ({
+    ...member,
+    url: await ensureUniqueUrl({
+      url: member.url,
+      memberId: member.memberId,
+      fullName: member.fullName,
+    }),
+  }));
+  const membersWithGeneratedUrls = await Promise.all(membersWithGeneratedUrlsPromises);
+  //recheck urls in same batch to avoid duplicates
+  const uniqueUrlsUpdatedMembers = await ensureUniqueUrlsInBatch(membersWithGeneratedUrls);
+  const urls = uniqueUrlsUpdatedMembers.map(m => m.url).filter(Boolean);
+  console.log('unique urls', [...new Set(urls)]);
+  return await bulkSaveMembers(uniqueUrlsUpdatedMembers, COLLECTIONS.MEMBERS_DATA);
+}
+
+module.exports = { deduplicateURls, copyContactIdToWixMemberId, createMissingUrls };

package/.claude/worktrees/fix-save-button-disable/backend/elevated-modules.js

@@ -0,0 +1,18 @@
+const { items } = require('@wix/data');
+const { auth } = require('@wix/essentials');
+
+// @wix/data does not support suppressAuth currently, so we need to elevate it
+const wixData = {
+  insert: auth.elevate(items.insert),
+  update: auth.elevate(items.update),
+  bulkInsert: auth.elevate(items.bulkInsert),
+  query: auth.elevate(items.query),
+  save: auth.elevate(items.save),
+  remove: auth.elevate(items.remove),
+  get: auth.elevate(items.get),
+  truncate: auth.elevate(items.truncate),
+  bulkSave: auth.elevate(items.bulkSave),
+  search: auth.elevate(items.search),
+  //TODO: add other methods here as needed
+};
+module.exports = { wixData };

package/.claude/worktrees/fix-save-button-disable/backend/forms-methods.js

@@ -0,0 +1,52 @@
+const { COLLECTIONS } = require('../public/consts');
+
+const { triggerAutomation } = require('./automations-methods');
+const { CONFIG_KEYS } = require('./consts');
+const { wixData } = require('./elevated-modules');
+const { findMemberByWixDataId, createContactAndMemberIfNew } = require('./members-data-methods');
+const { getSiteConfigs } = require('./utils');
+
+const contactSubmission = async (data, memberDataId) => {
+  const { firstName, lastName, email, phone, message } = data;
+  const [memberData, automationEmailTriggerId] = await Promise.all([
+    findMemberByWixDataId(memberDataId),
+    getSiteConfigs(CONFIG_KEYS.AUTOMATION_EMAIL_TRIGGER_ID),
+  ]);
+  if (!memberData.showContactForm) {
+    console.log('Member contact form is not enabled for user, skipping contact submission!');
+    return;
+  }
+  let memberContactId = memberData.wixContactId;
+  if (!memberContactId) {
+    /**
+     * Create a member contact here since some members may have never logged in
+     * and therefore don’t have a contact ID. However, these members can still
+     * appear in the directory, and site visitors can reach out to them if they’ve
+     * enabled their contact form. To handle this, we ensure a contact is created for
+     * them during this flow if it doesn’t already exist.
+     */
+    console.info('Member contact id not found for user, creating new contact!');
+    const member = await createContactAndMemberIfNew(memberData);
+    memberContactId = member.wixContactId;
+  }
+  console.log('memberContactId', memberContactId);
+  const emailTriggered = await triggerAutomation(automationEmailTriggerId, {
+    contactId: memberContactId,
+    name: `${firstName} ${lastName}`,
+    email: email,
+    phone: phone,
+    message: message,
+  });
+  data = {
+    ...data,
+    phone: Number(data.phone),
+    memberContactId,
+    memberEmail: memberData.contactFormEmail,
+  };
+  await wixData.insert(COLLECTIONS.CONTACT_US_SUBMISSIONS, data);
+  return emailTriggered;
+};
+
+module.exports = {
+  contactSubmission,
+};

package/.claude/worktrees/fix-save-button-disable/backend/http-functions/httpFunctions.js

@@ -0,0 +1,86 @@
+const { COLLECTIONS } = require('../../public/consts');
+const { clearCollection } = require('../cms-data-methods');
+const { CONFIG_KEYS } = require('../consts');
+const { getSecret, getSiteConfigs } = require('../utils');
+
+const { migrateInterests } = require('./interests');
+
+const createHTTPFunctionsHelpers = wixHTTPFunctionsMethods => {
+  const { created, serverError, forbidden, ok, badRequest } = wixHTTPFunctionsMethods;
+  const responseOptions = {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  };
+
+  const isRequestAuthenticated = async request => {
+    const AUTH_TOKEN = await getSecret('migrate-api-key');
+    return request.headers.authorization === 'Bearer ' + AUTH_TOKEN;
+  };
+
+  const withAuth = handler => async request => {
+    if (!(await isRequestAuthenticated(request))) {
+      return forbidden({
+        ...responseOptions,
+        body: { error: 'Unauthorized' },
+      });
+    }
+    return handler(request);
+  };
+
+  const migrateInterestsHandler = async _request => {
+    try {
+      const result = await migrateInterests();
+      return created({
+        ...responseOptions,
+        body: {
+          result,
+        },
+      });
+    } catch (error) {
+      console.error('Error migrating interests:', error);
+      return serverError(error);
+    }
+  };
+
+  const clearCollectionHandler = async request => {
+    try {
+      const collectionName = request.query.collectionName;
+      if (!collectionName || !Object.values(COLLECTIONS).includes(collectionName)) {
+        return badRequest({
+          ...responseOptions,
+          body: { error: 'Invalid collection name' },
+        });
+      }
+      const result = await clearCollection(collectionName);
+      return ok({
+        ...responseOptions,
+        body: {
+          result,
+        },
+      });
+    } catch (error) {
+      return serverError(error);
+    }
+  };
+  const getSiteAssociationHandler = async _request => {
+    try {
+      const siteAssociation = await getSiteConfigs(CONFIG_KEYS.SITE_ASSOCIATION);
+      return ok({
+        ...responseOptions,
+        body: { siteAssociation },
+      });
+    } catch (error) {
+      console.error('Error getting site association:', error);
+      return serverError(error);
+    }
+  };
+
+  return {
+    post_migrateInterests: withAuth(migrateInterestsHandler),
+    delete_clearCollection: withAuth(clearCollectionHandler),
+    get_getSiteAssociation: withAuth(getSiteAssociationHandler),
+  };
+};
+
+module.exports = { createHTTPFunctionsHelpers };

package/.claude/worktrees/fix-save-button-disable/backend/http-functions/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('./httpFunctions'),
+};

package/.claude/worktrees/fix-save-button-disable/backend/http-functions/interests.js

@@ -0,0 +1,35 @@
+const axios = require('axios');
+
+const { COLLECTIONS } = require('../../public/consts');
+const { clearCollection } = require('../cms-data-methods');
+const { CONFIG_KEYS } = require('../consts');
+const { wixData } = require('../elevated-modules');
+const { getHeaders } = require('../pac-api-methods');
+const { getSiteConfigs } = require('../utils');
+
+const getInterests = async () => {
+  const [url, headers] = await Promise.all([
+    getSiteConfigs(CONFIG_KEYS.INTERESTS_API_URL),
+    getHeaders(),
+  ]);
+  try {
+    const response = await axios.get(url, { headers });
+    return response.data;
+  } catch (e) {
+    console.error('Error getting interests:', e);
+    throw e;
+  }
+};
+
+async function migrateInterests() {
+  const [interests, _] = await Promise.all([
+    getInterests(),
+    clearCollection(COLLECTIONS.INTERESTS),
+  ]);
+  const interestData = interests.map(val => ({ title: val.interest }));
+  return await wixData.bulkInsert(COLLECTIONS.INTERESTS, interestData);
+}
+
+module.exports = {
+  migrateInterests,
+};

package/.claude/worktrees/fix-save-button-disable/backend/index.js

@@ -0,0 +1,19 @@
+module.exports = {
+  ...require('./forms-methods'),
+  ...require('./search-filters-methods'),
+  ...require('./jobs'),
+  ...require('./consts'), //TODO: remove it once we finish NPM movement
+  ...require('./utils'), //TODO: remove it once we finish NPM movement
+  ...require('./daily-pull'), //TODO: remove it once we finish NPM movement
+  ...require('./pac-api-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./members-area-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./members-data-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./cms-data-methods'), //TODO: remove it once we finish NPM movement
+  ...require('./routers'),
+  ...require('./login'),
+  ...require('./data-hooks'),
+  ...require('./http-functions'),
+  ...require('./dev-only-methods'),
+  ...require('./tasks/migration-methods'),
+  ...require('./tasks/url-migration-methods'),
+};

package/.claude/worktrees/fix-save-button-disable/backend/jobs.js

@@ -0,0 +1,158 @@
+const { taskManager } = require('psdev-task-manager');
+
+const { scheduleDailyPullTasks } = require('./daily-pull/schedule-methods');
+const { TASKS_NAMES } = require('./tasks/consts');
+const { dailyPullExecutionCheck } = require('./tasks/daily-pull-check-methods');
+const { TASKS } = require('./tasks/tasks-configs');
+
+async function runScheduledTasks() {
+  try {
+    console.log('runScheduledTasks started');
+    return await taskManager().runScheduledTasks(TASKS);
+  } catch (error) {
+    console.error(`Failed to runScheduledTasks: ${error.message}`);
+    throw new Error(`Failed to runScheduledTasks: ${error.message}`);
+  }
+}
+
+/**
+ * Schedule daily pull tasks for all member actions.
+ * @param {string|Object} [options] - Optional. Either a backup date (YYYY-MM-DD) or options.
+ * @param {string} [options.backupDate] - Optional backup date to pull.
+ * @param {boolean} [options.isTestEnvironment=false] - Whether to use test environment.
+ * @param {boolean} [options.includeNone=false] - Whether to include NONE action.
+ * @returns {Promise<void>}
+ */
+async function scheduleDailyPullTask(options = null) {
+  try {
+    console.log('scheduleDailyPullTask started!');
+    const hasOptions = options && typeof options === 'object' && !Array.isArray(options);
+    const backupDate = hasOptions ? options.backupDate : options;
+    const isTestEnvironment = hasOptions ? Boolean(options.isTestEnvironment) : false;
+    const includeNone = hasOptions ? Boolean(options.includeNone) : false;
+    console.log(`backupDate: ${backupDate}`);
+    console.log(`isTestEnvironment: ${isTestEnvironment}`);
+    console.log(`includeNone: ${includeNone}`);
+
+    return await scheduleDailyPullTasks({ backupDate, isTestEnvironment, includeNone });
+  } catch (error) {
+    console.error(`Failed to scheduleDailyPullTask: ${error.message}`);
+    throw new Error(`Failed to scheduleDailyPullTask: ${error.message}`);
+  }
+}
+
+async function scheduleCreateContactsFromMembersTask() {
+  try {
+    console.log('scheduleCreateContactsFromMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleCreateContactsFromMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleCreateContactsFromMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleCreateContactsFromMembers: ${error.message}`);
+  }
+}
+
+async function scheduleFixPrimaryAddressForMembersTask() {
+  try {
+    console.log('scheduleFixPrimaryAddressForMembers started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixPrimaryAddressForMembers,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+    throw new Error(`Failed to scheduleFixPrimaryAddressForMembers: ${error.message}`);
+  }
+}
+
+async function scheduleFixUrlsWithSpacesTask() {
+  try {
+    console.log('scheduleFixUrlsWithSpaces started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleFixUrlsWithSpaces,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleFixUrlsWithSpaces: ${error.message}`);
+    throw new Error(`Failed to scheduleFixUrlsWithSpaces: ${error.message}`);
+  }
+}
+
+async function scheduleNormalizeMemberEmailsTask() {
+  try {
+    console.log('scheduleNormalizeMemberEmails started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleNormalizeMemberEmails,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleNormalizeMemberEmails: ${error.message}`);
+    throw new Error(`Failed to scheduleNormalizeMemberEmails: ${error.message}`);
+  }
+}
+
+/**
+ * Schedules setting ALL addresses for ALL members that have any address to STATE_CITY_ZIP
+ * (show city/state/zip, hide the street). Manually triggered one-off maintenance task.
+ */
+async function scheduleSetAddressesToCityStateTask() {
+  try {
+    console.log('scheduleSetAddressesToCityState started!');
+    return await taskManager().schedule({
+      name: TASKS_NAMES.scheduleSetAddressesToCityState,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    console.error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+    throw new Error(`Failed to scheduleSetAddressesToCityState: ${error.message}`);
+  }
+}
+
+/**
+ * Runs the daily pull execution check (watchdog).
+ * @param {Object} [options]
+ * @param {number} [options.hoursBack=4] - Lookback window in hours
+ * @param {boolean} [options.isTestEnvironment=false] - Pull from the test PAC API if the fallback fires
+ * @param {boolean} [options.includeNone=false] - Include the NONE action if the fallback fires
+ * @returns {Promise<Object>} - Check result
+ */
+async function runDailyPullExecutionCheck(options = {}) {
+  try {
+    console.log('runDailyPullExecutionCheck started!');
+    return await dailyPullExecutionCheck(options || {});
+  } catch (error) {
+    console.error(`Failed to runDailyPullExecutionCheck: ${error.message}`);
+    throw new Error(`Failed to runDailyPullExecutionCheck: ${error.message}`);
+  }
+}
+
+async function updateSiteMapS3() {
+  try {
+    return await taskManager().schedule({
+      name: TASKS_NAMES.updateSiteMapS3,
+      data: {},
+      type: 'scheduled',
+    });
+  } catch (error) {
+    throw new Error(`Failed to updateSiteMapS3: ${error.message}`);
+  }
+}
+
+module.exports = {
+  runScheduledTasks,
+  scheduleDailyPullTask,
+  updateSiteMapS3,
+  scheduleCreateContactsFromMembersTask,
+  scheduleFixPrimaryAddressForMembersTask,
+  scheduleFixUrlsWithSpacesTask,
+  scheduleNormalizeMemberEmailsTask,
+  scheduleSetAddressesToCityStateTask,
+  runDailyPullExecutionCheck,
+};

package/.claude/worktrees/fix-save-button-disable/backend/login/generate-member-session-token.js

@@ -0,0 +1,27 @@
+const { auth } = require('@wix/essentials');
+const { authentication } = require('@wix/identity');
+
+const elevatedSignOn = auth.elevate(authentication.signOn);
+
+/**
+ * Creates a Wix member session token for SSO / QA login using @wix/identity signOn (elevated).
+ * @param {string} email - Member login email
+ * @returns {Promise<string>} Session token for authentication.applySessionToken on the client
+ */
+async function generateMemberSessionToken(email) {
+  const trimmedEmail = (email || '').trim();
+  if (!trimmedEmail) {
+    throw new Error('Email is required to generate a session token');
+  }
+
+  const response = await elevatedSignOn({ email: trimmedEmail });
+  const sessionToken = response?.sessionToken;
+  if (!sessionToken) {
+    throw new Error('Failed to generate session token: empty response from signOn');
+  }
+  return sessionToken;
+}
+
+module.exports = {
+  generateMemberSessionToken,
+};

package/.claude/worktrees/fix-save-button-disable/backend/login/index.js

@@ -0,0 +1,8 @@
+const { loginQAMember } = require('./qa-login-methods');
+const { validateMemberToken, authenticateSSOToken } = require('./sso-methods');
+
+module.exports = {
+  loginQAMember,
+  validateMemberToken,
+  authenticateSSOToken,
+};