backend-manager 5.0.96 → 5.0.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.96",
+  "version": "5.0.98",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -67,6 +67,7 @@
     "lodash": "^4.17.23",
     "lowdb": "^1.0.0",
     "mailchimp-api-v3": "^1.15.0",
+    "markdown-it": "^14.1.1",
     "mime-types": "^2.1.35",
     "mocha": "^11.7.5",
     "moment": "^2.30.1",

package/src/cli/commands/setup-tests/firestore-indexes-required.js

@@ -0,0 +1,105 @@
+const BaseTest = require('./base-test');
+const jetpack = require('fs-jetpack');
+const _ = require('lodash');
+const chalk = require('chalk');
+const requiredIndexes = require('./required-indexes');
+
+class FirestoreIndexesRequiredTest extends BaseTest {
+  getName() {
+    return 'firestore indexes have required BEM indexes';
+  }
+
+  async run() {
+    const filePath = `${this.self.firebaseProjectPath}/firestore.indexes.json`;
+
+    if (!jetpack.exists(filePath)) {
+      return false;
+    }
+
+    const indexesFile = JSON.parse(jetpack.read(filePath));
+    const existingIndexes = indexesFile.indexes || [];
+
+    // Check that the first N indexes match the required indexes (must be at the top)
+    const topIsCorrect = requiredIndexes.every((required, i) => {
+      return this._indexMatches(existingIndexes[i], required);
+    });
+
+    // Check no duplicates exist (each required index should appear exactly once)
+    const noDuplicates = requiredIndexes.every(required => {
+      const count = existingIndexes.filter(existing => this._indexMatches(existing, required)).length;
+      return count === 1;
+    });
+
+    return topIsCorrect && noDuplicates;
+  }
+
+  async fix() {
+    const filePath = `${this.self.firebaseProjectPath}/firestore.indexes.json`;
+    let indexesFile;
+
+    if (jetpack.exists(filePath)) {
+      indexesFile = JSON.parse(jetpack.read(filePath));
+    } else {
+      indexesFile = { indexes: [], fieldOverrides: [] };
+    }
+
+    indexesFile.indexes = indexesFile.indexes || [];
+
+    // Remove any existing copies of required indexes
+    for (const required of requiredIndexes) {
+      indexesFile.indexes = indexesFile.indexes.filter(existing => !this._indexMatches(existing, required));
+    }
+
+    // Add all required indexes to the top (in reverse so they end up in correct order)
+    for (let i = requiredIndexes.length - 1; i >= 0; i--) {
+      indexesFile.indexes.unshift(requiredIndexes[i]);
+    }
+
+    jetpack.write(filePath, JSON.stringify(indexesFile, null, 2));
+
+    console.log(chalk.green(`  + Ensured ${requiredIndexes.length} required indexes at top of indexes array`));
+    console.log(chalk.yellow(`  Remember to deploy indexes: ${chalk.bold('firebase deploy --only firestore:indexes')}`));
+  }
+
+  /**
+   * Check if an existing index matches a required index definition
+   */
+  _indexMatches(existing, required) {
+    if (!existing) {
+      return false;
+    }
+
+    // Must match collectionGroup
+    if (existing.collectionGroup !== required.collectionGroup) {
+      return false;
+    }
+
+    // Must match queryScope (default COLLECTION)
+    if ((existing.queryScope || 'COLLECTION') !== (required.queryScope || 'COLLECTION')) {
+      return false;
+    }
+
+    // Must have same number of fields
+    if (!existing.fields || existing.fields.length !== required.fields.length) {
+      return false;
+    }
+
+    // Each field must match
+    return required.fields.every((reqField, i) => {
+      const exField = existing.fields[i];
+
+      if (exField.fieldPath !== reqField.fieldPath) {
+        return false;
+      }
+
+      // Match order or arrayConfig
+      if (reqField.arrayConfig) {
+        return exField.arrayConfig === reqField.arrayConfig;
+      }
+
+      return exField.order === reqField.order;
+    });
+  }
+}
+
+module.exports = FirestoreIndexesRequiredTest;

package/src/cli/commands/setup-tests/firestore-indexes-synced.js

@@ -3,6 +3,7 @@ const jetpack = require('fs-jetpack');
 const chalk = require('chalk');
 const _ = require('lodash');
 const inquirer = require('inquirer');
+const powertools = require('node-powertools');
 
 class FirestoreIndexesSyncedTest extends BaseTest {
   getName() {
@@ -26,13 +27,6 @@ class FirestoreIndexesSyncedTest extends BaseTest {
     }
     const equal = _.isEqual(liveIndexes, localIndexes);
 
-    if (localIndexes_exists && !equal) {
-      console.log(chalk.red(`To fix this...`));
-      console.log(chalk.red(`  - ${chalk.bold('npx bm indexes:get')} to overwrite Firestore's local indexes with the live indexes`));
-      console.log(chalk.red('  OR'));
-      console.log(chalk.red(`  - ${chalk.bold('firebase deploy --only firestore:indexes')} to replace the live indexes.`));
-    }
-
     jetpack.remove(`${self.firebaseProjectPath}/${tempPath}`);
 
     return !localIndexes_exists || equal;
@@ -41,28 +35,44 @@ class FirestoreIndexesSyncedTest extends BaseTest {
   async fix() {
     const self = this.self;
 
-    return new Promise((resolve, reject) => {
-      inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'replace',
-          message: 'Would you like to replace the local indexes?',
-          default: true,
-        }
-      ])
-      .then(async (answer) => {
-        if (answer.replace) {
-          const commands = require('../index');
-          const IndexesCommand = commands.IndexesCommand;
-          const indexesCmd = new IndexesCommand(self);
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'direction',
+        message: 'Firestore indexes are out of sync. Which direction?',
+        choices: [
+          {
+            name: `Live → Local   (replace ${chalk.bold('local')} indexes with ${chalk.bold('live')})`,
+            value: 'live-to-local',
+          },
+          {
+            name: `Local → Live   (replace ${chalk.bold('live')} indexes with ${chalk.bold('local')})`,
+            value: 'local-to-live',
+          },
+          {
+            name: 'Skip',
+            value: 'skip',
+          },
+        ],
+      },
+    ]);
+
+    if (answer.direction === 'live-to-local') {
+      const commands = require('../index');
+      const IndexesCommand = commands.IndexesCommand;
+      const indexesCmd = new IndexesCommand(self);
 
-          await indexesCmd.get(undefined, true);
-          return resolve();
-        } else {
-          return reject();
-        }
+      await indexesCmd.get(undefined, true);
+    } else if (answer.direction === 'local-to-live') {
+      console.log(chalk.yellow(`  Deploying local indexes to live...`));
+
+      await powertools.execute('firebase deploy --only firestore:indexes', {
+        log: true,
+        cwd: self.firebaseProjectPath,
       });
-    });
+
+      console.log(chalk.green(`  ✓ Live indexes updated from local`));
+    }
   }
 }
 

package/src/cli/commands/setup-tests/index.js

@@ -35,6 +35,7 @@ const StorageRulesFileTest = require('./storage-rules-file');
 const RemoteconfigTemplateFileTest = require('./remoteconfig-template-file');
 const HostingFolderTest = require('./hosting-folder');
 const PublicHtmlFilesTest = require('./public-html-files');
+const FirestoreIndexesRequiredTest = require('./firestore-indexes-required');
 const LegacyTestsCleanupTest = require('./legacy-tests-cleanup');
 
 /**
@@ -66,10 +67,11 @@ function getTests(context) {
     new RemoteconfigTemplateInJsonTest(context),
     new EmulatorConfigTest(context),
     new HostingRewritesTest(context),
-    new FirestoreIndexesSyncedTest(context),
     new StorageLifecyclePolicyTest(context),
     new FirestoreRulesFileTest(context),
     new FirestoreIndexesFileTest(context),
+    new FirestoreIndexesRequiredTest(context),
+    new FirestoreIndexesSyncedTest(context),
     new RealtimeRulesFileTest(context),
     new StorageRulesFileTest(context),
     new RemoteconfigTemplateFileTest(context),

package/src/cli/commands/setup-tests/required-indexes.js

@@ -0,0 +1,38 @@
+/**
+ * Required Firestore compound indexes for BEM routes
+ * These are automatically added to firestore.indexes.json during `npx bm setup`
+ */
+module.exports = [
+  // All /user/data-request routes — most recent request by created date
+  // Serves: .where('owner', '==', uid).orderBy('metadata.created.timestampUNIX', 'desc')
+  {
+    collectionGroup: 'data-requests',
+    queryScope: 'COLLECTION',
+    fields: [
+      { fieldPath: 'owner', order: 'ASCENDING' },
+      { fieldPath: 'metadata.created.timestampUNIX', order: 'DESCENDING' },
+    ],
+  },
+
+  // POST /payments/intent — trial eligibility check
+  // Query: .where('owner', '==', uid).where('type', '==', 'subscription')
+  {
+    collectionGroup: 'payments-orders',
+    queryScope: 'COLLECTION',
+    fields: [
+      { fieldPath: 'owner', order: 'ASCENDING' },
+      { fieldPath: 'type', order: 'ASCENDING' },
+    ],
+  },
+
+  // POST /admin/notification — send to filtered users
+  // Query: .where('tags', 'array-contains-any', tags).where('owner', '==', owner)
+  {
+    collectionGroup: 'notifications',
+    queryScope: 'COLLECTION',
+    fields: [
+      { fieldPath: 'tags', arrayConfig: 'CONTAINS' },
+      { fieldPath: 'owner', order: 'ASCENDING' },
+    ],
+  },
+];

package/src/manager/events/firestore/payments-webhooks/transitions/one-time/purchase-completed.js

@@ -5,11 +5,14 @@
 const { sendOrderEmail, formatDate } = require('../send-email.js');
 
 module.exports = async function ({ before, after, order, uid, userDoc, assistant }) {
+  const brandName = assistant.Manager.config.brand?.name || '';
+  const productName = after.product?.name || '';
+
   assistant.log(`Transition [one-time/purchase-completed]: uid=${uid}, resourceId=${after.payment?.resourceId}`);
 
   sendOrderEmail({
     template: 'main/order/confirmation',
-    subject: `Your order is confirmed! #${order?.id || ''}`,
+    subject: `Your ${brandName} ${productName} order #${order?.id || ''}`,
     categories: ['order/confirmation'],
     userDoc,
     assistant,

package/src/manager/events/firestore/payments-webhooks/transitions/send-email.js

@@ -27,12 +27,22 @@ function sendOrderEmail({ template, subject, categories, data, userDoc, assistan
     return;
   }
 
+  // Strip sensitive fields before passing to email template
+  const safeUser = { ...userDoc };
+  delete safeUser.api;
+  delete safeUser.oauth2;
+  delete safeUser.activity;
+  delete safeUser.affiliate;
+  delete safeUser.attribution;
+  delete safeUser.flags;
+
   const settings = {
     to: { email: userEmail, ...(userName && { name: userName }) },
     subject,
     template,
     categories,
     copy: true,
+    user: safeUser,
     data,
   };
 

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

@@ -9,7 +9,7 @@ module.exports = async function ({ before, after, order, uid, userDoc, assistant
 
   sendOrderEmail({
     template: 'main/order/cancellation-requested',
-    subject: `Your subscription cancellation is confirmed #${order?.id || ''}`,
+    subject: `Your cancellation is confirmed #${order?.id || ''}`,
     categories: ['order/cancellation-requested'],
     userDoc,
     assistant,

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

@@ -8,12 +8,13 @@ const { sendOrderEmail, formatDate } = require('../send-email.js');
 module.exports = async function ({ before, after, order, uid, userDoc, assistant }) {
   const isTrial = after.trial?.claimed === true;
   const brandName = assistant.Manager.config.brand?.name || '';
+  const planName = after.product?.name || '';
 
   assistant.log(`Transition [subscription/new-subscription]: uid=${uid}, product=${after.product?.id}, frequency=${after.payment?.frequency}, trial=${isTrial}`);
 
   sendOrderEmail({
     template: 'main/order/confirmation',
-    subject: `Your order from ${brandName} #${order?.id || ''}`,
+    subject: `Your ${brandName} ${planName} order #${order?.id || ''}`,
     categories: ['order/confirmation'],
     userDoc,
     assistant,

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

@@ -9,7 +9,7 @@ module.exports = async function ({ before, after, order, uid, userDoc, assistant
 
   sendOrderEmail({
     template: 'main/order/payment-failed',
-    subject: `Your payment failed #${order?.id || ''}`,
+    subject: `Payment failed for order #${order?.id || ''}`,
     categories: ['order/payment-failed'],
     userDoc,
     assistant,

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

@@ -9,7 +9,7 @@ module.exports = async function ({ before, after, order, uid, userDoc, assistant
 
   sendOrderEmail({
     template: 'main/order/payment-recovered',
-    subject: `Your payment was successful #${order?.id || ''}`,
+    subject: `Payment received for order #${order?.id || ''}`,
     categories: ['order/payment-recovered'],
     userDoc,
     assistant,

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

@@ -10,7 +10,7 @@ module.exports = async function ({ before, after, order, uid, userDoc, assistant
 
   sendOrderEmail({
     template: 'main/order/plan-changed',
-    subject: `Your subscription plan has been updated #${order?.id || ''}`,
+    subject: `Your plan has been updated #${order?.id || ''}`,
     categories: ['order/plan-changed'],
     userDoc,
     assistant,

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

@@ -8,7 +8,9 @@ module.exports = async function ({ before, after, order, uid, userDoc, assistant
   assistant.log(`Transition [subscription/subscription-cancelled]: uid=${uid}, previousProduct=${before?.product?.id}, previousStatus=${before?.status}`);
 
   // 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();
+  // Trials don't get future access — cancelling a trial revokes access immediately
+  const isTrial = after.trial?.claimed;
+  const hasFutureExpiry = !isTrial && after.expires?.timestamp && new Date(after.expires.timestamp) > new Date();
 
   sendOrderEmail({
     template: 'main/order/cancelled',

package/src/manager/libraries/email.js

@@ -13,6 +13,12 @@
  */
 const _ = require('lodash');
 const moment = require('moment');
+const MarkdownIt = require('markdown-it');
+const md = new MarkdownIt({
+  html: true,
+  breaks: true,
+  linkify: true,
+});
 
 // SendGrid limit for scheduled emails (72 hours, but use 71 for buffer)
 const SEND_AT_LIMIT = 71;
@@ -91,15 +97,10 @@ Email.prototype.build = async function (settings) {
     throw errorWithCode('Missing brand configuration in backend-manager-config.json', 400);
   }
 
-  const app = {
-    id: brand.id,
-    name: brand.name,
-    url: brand.url,
-    email: brand.contact?.email,
-    images: sanitizeImagesForEmail(brand.images || {}),
-  };
+  const brandData = _.cloneDeep(brand);
+  brandData.images = sanitizeImagesForEmail(brandData.images || {});
 
-  if (!app.email) {
+  if (!brandData.contact?.email) {
     throw errorWithCode('Missing brand.contact.email in backend-manager-config.json', 400);
   }
 
@@ -108,8 +109,8 @@ Email.prototype.build = async function (settings) {
   // Add carbon copy recipients
   if (copy) {
     cc.push({
-      email: app.email,
-      name: app.name,
+      email: brandData.contact.email,
+      name: brandData.name,
     });
     bcc.push(
       {
@@ -152,7 +153,7 @@ Email.prototype.build = async function (settings) {
   // Build categories
   const categories = _.uniq([
     'transactional',
-    app.id,
+    brandData.id,
     ...powertools.arrayify(settings.categories),
   ]);
 
@@ -160,7 +161,7 @@ Email.prototype.build = async function (settings) {
   const sendAt = normalizeSendAt(settings.sendAt);
 
   // Build unsubscribe URL
-  const unsubscribeUrl = `${Manager.project.websiteUrl}/portal/account/email-preferences?email=${encode(to[0].email)}&asmId=${encode(groupId)}&templateId=${encode(templateId)}&appName=${app.name}&appUrl=${app.url}`;
+  const unsubscribeUrl = `${Manager.project.websiteUrl}/portal/account/email-preferences?email=${encode(to[0].email)}&asmId=${encode(groupId)}&templateId=${encode(templateId)}&appName=${brandData.name}&appUrl=${brandData.url}`;
 
   // Build signoff
   const signoff = settings?.data?.signoff || {};
@@ -174,6 +175,14 @@ Email.prototype.build = async function (settings) {
     signoff.urlText = signoff.urlText || '@ianwieds';
   }
 
+  // Process markdown in body fields
+  if (settings?.data?.body?.message) {
+    settings.data.body.message = md.render(settings.data.body.message);
+  }
+  if (settings?.data?.email?.body) {
+    settings.data.email.body = md.render(settings.data.email.body);
+  }
+
   // Build dynamic template data
   const dynamicTemplateData = {
     email: {
@@ -194,7 +203,7 @@ Email.prototype.build = async function (settings) {
       ...settings?.data?.personalization,
     },
     signoff,
-    app,
+    brand: brandData,
     user: userProperties,
     data: settings.data || {},
   };
@@ -204,8 +213,8 @@ Email.prototype.build = async function (settings) {
     to,
     cc,
     bcc,
-    from: settings.from || { email: app.email, name: app.name },
-    replyTo: settings.replyTo || app.email,
+    from: settings.from || { email: brandData.contact.email, name: brandData.name },
+    replyTo: settings.replyTo || brandData.contact.email,
     subject,
     templateId,
     asm: { groupId },
@@ -230,7 +239,7 @@ Email.prototype.build = async function (settings) {
 
   // Build stringified version for template rendering
   const clonedData = _.cloneDeep(dynamicTemplateData);
-  clonedData.app.sponsorships = {};
+  clonedData.brand.sponsorships = {};
   email.dynamicTemplateData._stringified = JSON.stringify(clonedData, null, 2);
 
   return email;

package/src/manager/routes/forms/delete.js

@@ -0,0 +1,37 @@
+/**
+ * DELETE /forms - Delete a form
+ * Requires authentication and ownership.
+ */
+module.exports = async ({ assistant, user, settings, analytics, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  if (!settings.id) {
+    return assistant.respond('Missing required parameter: id', { code: 400 });
+  }
+
+  const uid = user.auth.uid;
+  const formRef = admin.firestore().doc(`forms/${settings.id}`);
+  const doc = await formRef.get();
+
+  if (!doc.exists) {
+    return assistant.respond('Form not found', { code: 404 });
+  }
+
+  // Ownership check
+  if (doc.data().owner !== uid) {
+    return assistant.respond('Not authorized to delete this form', { code: 403 });
+  }
+
+  await formRef.delete();
+
+  assistant.log(`Deleted form ${settings.id} for user ${uid}`);
+
+  analytics.event('forms', { action: 'delete' });
+
+  return assistant.respond({ data: { deleted: true } });
+};

package/src/manager/routes/forms/get.js

@@ -0,0 +1,46 @@
+/**
+ * GET /forms - Get a single form or list all forms for the authenticated user
+ * Requires authentication.
+ * - With ?id=xxx: returns a single form (with ownership check)
+ * - Without id: returns all forms owned by the user
+ */
+module.exports = async ({ assistant, user, settings, analytics, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  const uid = user.auth.uid;
+
+  // Single form
+  if (settings.id) {
+    const doc = await admin.firestore().doc(`forms/${settings.id}`).get();
+
+    if (!doc.exists) {
+      return assistant.respond('Form not found', { code: 404 });
+    }
+
+    if (doc.data().owner !== uid) {
+      return assistant.respond('Not authorized to view this form', { code: 403 });
+    }
+
+    analytics.event('forms', { action: 'get' });
+
+    return assistant.respond({ data: { form: doc.data() } });
+  }
+
+  // List all forms
+  const snapshot = await admin.firestore()
+    .collection('forms')
+    .where('owner', '==', uid)
+    .orderBy('created.timestampUNIX', 'desc')
+    .get();
+
+  const forms = snapshot.docs.map(doc => doc.data());
+
+  analytics.event('forms', { action: 'list' });
+
+  return assistant.respond({ data: { forms } });
+};

package/src/manager/routes/forms/post.js

@@ -0,0 +1,45 @@
+/**
+ * POST /forms - Create a new form
+ * Requires authentication. Creates a Firestore doc in the `forms` collection.
+ */
+module.exports = async ({ assistant, Manager, user, settings, analytics, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  const uid = user.auth.uid;
+  const now = new Date().toISOString();
+  const nowUnix = Date.now();
+
+  // Generate a new document reference
+  const docRef = admin.firestore().collection('forms').doc();
+
+  const form = {
+    id: docRef.id,
+    owner: uid,
+    name: settings.name || 'Untitled Form',
+    description: settings.description || '',
+    settings: settings.settings || {},
+    pages: settings.pages || [],
+    created: {
+      timestamp: now,
+      timestampUNIX: nowUnix,
+    },
+    edited: {
+      timestamp: now,
+      timestampUNIX: nowUnix,
+    },
+    metadata: Manager.Metadata().set({ tag: 'forms/post' }),
+  };
+
+  await docRef.set(form);
+
+  assistant.log(`Created form ${docRef.id} for user ${uid}`);
+
+  analytics.event('forms', { action: 'create' });
+
+  return assistant.respond({ data: { id: docRef.id, form } });
+};

package/src/manager/routes/forms/public/get.js

@@ -0,0 +1,37 @@
+/**
+ * GET /forms/public - Get a public form by ID
+ * No authentication required. Only returns forms with settings.public = true.
+ */
+module.exports = async ({ assistant, settings, analytics, libraries }) => {
+  const { admin } = libraries;
+
+  if (!settings.id) {
+    return assistant.respond('Missing required parameter: id', { code: 400 });
+  }
+
+  const doc = await admin.firestore().doc(`forms/${settings.id}`).get();
+
+  if (!doc.exists) {
+    return assistant.respond('Form not found', { code: 404 });
+  }
+
+  const form = doc.data();
+
+  // Only allow access to public forms
+  if (!form.settings?.public) {
+    return assistant.respond('Form not found', { code: 404 });
+  }
+
+  // Strip sensitive fields
+  const publicForm = {
+    id: form.id,
+    name: form.name,
+    description: form.description,
+    settings: form.settings,
+    pages: form.pages,
+  };
+
+  analytics.event('forms/public', { action: 'get' });
+
+  return assistant.respond({ payload: publicForm });
+};

package/src/manager/routes/forms/put.js

@@ -0,0 +1,52 @@
+/**
+ * PUT /forms - Update an existing form
+ * Requires authentication and ownership.
+ */
+module.exports = async ({ assistant, Manager, user, settings, analytics, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  if (!settings.id) {
+    return assistant.respond('Missing required parameter: id', { code: 400 });
+  }
+
+  const uid = user.auth.uid;
+  const formRef = admin.firestore().doc(`forms/${settings.id}`);
+  const doc = await formRef.get();
+
+  if (!doc.exists) {
+    return assistant.respond('Form not found', { code: 404 });
+  }
+
+  // Ownership check
+  if (doc.data().owner !== uid) {
+    return assistant.respond('Not authorized to edit this form', { code: 403 });
+  }
+
+  const now = new Date().toISOString();
+  const nowUnix = Date.now();
+
+  const updates = {
+    name: settings.name,
+    description: settings.description,
+    settings: settings.settings,
+    pages: settings.pages,
+    edited: {
+      timestamp: now,
+      timestampUNIX: nowUnix,
+    },
+    metadata: Manager.Metadata().set({ tag: 'forms/put' }),
+  };
+
+  await formRef.update(updates);
+
+  assistant.log(`Updated form ${settings.id} for user ${uid}`);
+
+  analytics.event('forms', { action: 'update' });
+
+  return assistant.respond({ data: { id: settings.id } });
+};

package/src/manager/routes/user/data-request/delete.js

@@ -0,0 +1,39 @@
+/**
+ * DELETE /user/data-request - Cancel a pending data request
+ * Deletes the most recent pending data request for the authenticated user.
+ */
+module.exports = async ({ assistant, user, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  const uid = user.auth.uid;
+
+  // Get the most recent request
+  const mostRecentSnapshot = await admin.firestore()
+    .collection('data-requests')
+    .where('owner', '==', uid)
+    .orderBy('metadata.created.timestampUNIX', 'desc')
+    .limit(1)
+    .get();
+
+  if (mostRecentSnapshot.empty || mostRecentSnapshot.docs[0].data().status !== 'pending') {
+    return assistant.respond('No pending data request found.', { code: 404 });
+  }
+
+  const requestDoc = mostRecentSnapshot.docs[0];
+  const request = requestDoc.data();
+
+  // Delete the request document
+  await admin.firestore().doc(`data-requests/${requestDoc.id}`).delete();
+
+  assistant.log(`Data request cancelled: ${requestDoc.id} for user ${uid}`);
+
+  return assistant.respond({
+    message: 'Your data request has been cancelled.',
+    request: { id: requestDoc.id, ...request },
+  });
+};

package/src/manager/routes/user/data-request/get.js

@@ -0,0 +1,181 @@
+/**
+ * GET /user/data-request - Check data request status or download data
+ *
+ * action=status (default): Returns the most recent request with its stored status.
+ * action=download: Compiles user data live and returns it. Only works when status is 'complete'.
+ *
+ * Statuses:
+ *   pending  — request submitted, waiting to be processed (bm_cronDaily sets to 'complete' after 14 days)
+ *   complete — data is available for download (downloads counter tracks how many times downloaded)
+ */
+module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  const uid = user.auth.uid;
+
+  // Get the most recent request
+  const requestsSnapshot = await admin.firestore()
+    .collection('data-requests')
+    .where('owner', '==', uid)
+    .orderBy('metadata.created.timestampUNIX', 'desc')
+    .limit(1)
+    .get();
+
+  if (requestsSnapshot.empty) {
+    return assistant.respond({ request: null });
+  }
+
+  const requestDoc = requestsSnapshot.docs[0];
+  const request = requestDoc.data();
+  const requestId = requestDoc.id;
+
+  const status = request.status;
+
+  // Status check — return the doc as-is
+  if (settings.action !== 'download') {
+    return assistant.respond({
+      request: { id: requestId, ...request },
+    });
+  }
+
+  // Download action — only allowed when status is 'complete'
+  if (status !== 'complete') {
+    return assistant.respond('Your data request is still being processed. Please check back later.', { code: 400 });
+  }
+
+  // Build query list: BEM defaults + project-specific queries from config
+  const defaultQueries = [
+    { path: 'users/{uid}', redact: ['api.privateKey'] },
+    { collection: 'data-requests', where: [['owner', '==', '{uid}']] },
+    { collection: 'payments-intents', where: [['owner', '==', '{uid}']] },
+    { collection: 'payments-orders', where: [['owner', '==', '{uid}']] },
+  ];
+  const customQueries = Manager.config.dataRequest?.queries || [];
+  const allQueries = defaultQueries.concat(customQueries);
+
+  // Execute all queries in parallel (+ auth record)
+  const queryPromises = allQueries.map(q => {
+    if (q.path) {
+      // Single document fetch
+      const resolvedPath = q.path.replace('{uid}', uid);
+      return admin.firestore().doc(resolvedPath).get();
+    }
+
+    // Collection query
+    let ref = admin.firestore().collection(q.collection);
+
+    for (const [field, op, value] of q.where) {
+      ref = ref.where(field, op, value === '{uid}' ? uid : value);
+    }
+
+    return ref.get();
+  });
+
+  const results = await Promise.all([
+    ...queryPromises,
+    admin.auth().getUser(uid).catch(() => null),
+  ]);
+
+  // Compile data from results
+  const authRecordResult = results.pop();
+  const data = {
+    exportedAt: assistant.meta.startTime.timestamp,
+    authRecord: null,
+  };
+
+  // Process query results
+  allQueries.forEach((q, i) => {
+    const result = results[i];
+
+    if (q.path) {
+      // Single document
+      const key = q.path.split('/')[0];
+      if (!result.exists) {
+        data[key] = null;
+        return;
+      }
+
+      const docData = result.data();
+
+      // Redact sensitive fields
+      if (q.redact) {
+        for (const fieldPath of q.redact) {
+          const parts = fieldPath.split('.');
+          let obj = docData;
+
+          for (let j = 0; j < parts.length - 1; j++) {
+            obj = obj?.[parts[j]];
+          }
+
+          if (obj) {
+            delete obj[parts[parts.length - 1]];
+          }
+        }
+      }
+
+      data[key] = docData;
+      return;
+    }
+
+    // Collection query
+    const docs = [];
+
+    result.forEach(doc => {
+      docs.push({ id: doc.id, ...doc.data() });
+    });
+
+    data[q.collection] = docs;
+  });
+
+  // Auth record (always included)
+  if (authRecordResult) {
+    data.authRecord = {
+      uid: authRecordResult.uid,
+      email: authRecordResult.email,
+      emailVerified: authRecordResult.emailVerified,
+      displayName: authRecordResult.displayName,
+      photoURL: authRecordResult.photoURL,
+      phoneNumber: authRecordResult.phoneNumber,
+      disabled: authRecordResult.disabled,
+      creationTime: authRecordResult.metadata.creationTime,
+      lastSignInTime: authRecordResult.metadata.lastSignInTime,
+      providerData: (authRecordResult.providerData || []).map(p => ({
+        providerId: p.providerId,
+        uid: p.uid,
+        displayName: p.displayName,
+        email: p.email,
+        photoURL: p.photoURL,
+      })),
+    };
+  } else {
+    data.authRecord = { error: 'Unable to retrieve auth record' };
+  }
+
+  // Increment downloads counter + set completed timestamp on first download
+  const updateData = {
+    downloads: admin.firestore.FieldValue.increment(1),
+  };
+
+  if (!request.metadata.completed?.timestampUNIX) {
+    updateData['metadata.completed.timestamp'] = assistant.meta.startTime.timestamp;
+    updateData['metadata.completed.timestampUNIX'] = assistant.meta.startTime.timestampUNIX;
+  }
+
+  await admin.firestore()
+    .doc(`data-requests/${requestId}`)
+    .update(updateData);
+
+  const downloads = (request.downloads || 0) + 1;
+
+  assistant.log(`Data request ${requestId} downloaded by user ${uid} (download #${downloads})`);
+
+  return assistant.respond({
+    request: { id: requestId, ...request, downloads: downloads },
+    data: data,
+  });
+};

package/src/manager/routes/user/data-request/post.js

@@ -0,0 +1,133 @@
+/**
+ * POST /user/data-request - Create a new GDPR data request
+ * Creates a pending data request record for the authenticated user.
+ */
+const uuidv4 = require('uuid').v4;
+
+module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
+  const { admin } = libraries;
+
+  // Require authentication
+  if (!user.authenticated) {
+    return assistant.respond('Authentication required', { code: 401 });
+  }
+
+  // Require confirmation
+  if (!settings.confirmed) {
+    return assistant.respond('You must confirm the data request acknowledgments.', { code: 400 });
+  }
+
+  const uid = user.auth.uid;
+
+  // Sanitize reason — strip HTML tags and trim
+  const reason = (settings.reason || '').replace(/<[^>]*>/g, '').trim().substring(0, 500);
+
+  // Get the most recent request
+  const mostRecentSnapshot = await admin.firestore()
+    .collection('data-requests')
+    .where('owner', '==', uid)
+    .orderBy('metadata.created.timestampUNIX', 'desc')
+    .limit(1)
+    .get();
+
+  if (!mostRecentSnapshot.empty) {
+    const mostRecent = mostRecentSnapshot.docs[0].data();
+
+    // Reject if there's already a pending request
+    if (mostRecent.status === 'pending') {
+      return assistant.respond('You already have a pending data request. Please wait for it to be processed.', { code: 409 });
+    }
+
+    // Reject if last request was created within 30 days (cooldown)
+    const THIRTY_DAYS = 30 * 24 * 60 * 60;
+    const elapsedSeconds = Math.round(Date.now() / 1000) - mostRecent.metadata.created.timestampUNIX;
+
+    if (elapsedSeconds < THIRTY_DAYS) {
+      return assistant.respond('You have already received a data export within the last 30 days. Please try again later.', { code: 429 });
+    }
+  }
+
+  // Create the request document
+  const requestId = uuidv4();
+  const now = assistant.meta.startTime.timestamp;
+  const nowUNIX = assistant.meta.startTime.timestampUNIX;
+
+  const docData = {
+    status: 'pending',
+    reason: reason,
+    downloads: 0,
+    owner: uid,
+    metadata: {
+      ...Manager.Metadata().set({ tag: 'user/data-request' }),
+      created: {
+        timestamp: now,
+        timestampUNIX: nowUNIX,
+      },
+      completed: {
+        timestamp: null,
+        timestampUNIX: 0,
+      },
+    },
+  };
+
+  await admin.firestore()
+    .doc(`data-requests/${requestId}`)
+    .set(docData, { merge: true });
+
+  assistant.log(`Data request created: ${requestId} for user ${uid}`);
+
+  // Send confirmation email (fire-and-forget)
+  sendConfirmationEmail(assistant, user.auth.email, requestId, reason);
+
+  return assistant.respond({
+    request: { id: requestId, ...docData },
+  });
+};
+
+/**
+ * Send data request confirmation email (fire-and-forget)
+ */
+function sendConfirmationEmail(assistant, email, requestId, reason) {
+  const Manager = assistant.Manager;
+  const brandName = Manager.config.brand.name;
+  const mailer = Manager.Email(assistant);
+  const reasonLine = reason
+    ? `\n\n**Reason provided:** ${reason}`
+    : '';
+
+  mailer.send({
+    to: email,
+    categories: ['account/data-request'],
+    subject: `Your data request has been received #${requestId}`,
+    template: 'default',
+    group: 'account',
+    copy: true,
+    data: {
+      email: {
+        preview: `We've received your data export request. Your data will be available for download within 14 business days.`,
+      },
+      body: {
+        title: 'Data Request Received',
+        message: `We've received your request for a copy of your personal data.${reasonLine}
+
+**What happens next:**
+
+- Your request is now being processed.
+- Processing takes up to **14 business days**.
+- Once ready, you must return to your **account page** to download your data. We will not send the data via email for security reasons.
+- Your data will be available as a JSON file download.
+- Only one request can be active at a time, and you may submit a new request once every 30 days.
+
+If you did not make this request, please contact us immediately by replying to this email.
+
+Reference: **#${requestId}**`,
+      },
+    },
+  })
+    .then((result) => {
+      assistant.log(`sendConfirmationEmail(): Success, status=${result.status}`);
+    })
+    .catch((e) => {
+      assistant.error(`sendConfirmationEmail(): Failed: ${e.message}`);
+    });
+}

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

@@ -63,6 +63,11 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
       assistant.error(`Sign out of all sessions failed`, e);
     });
 
+  // Get the user's email before deleting (for confirmation email)
+  const email = uid === user.auth.uid
+    ? user.auth.email
+    : await admin.auth().getUser(uid).then(r => r.email).catch(() => null);
+
   // Delete the user
   try {
     await admin.auth().deleteUser(uid);
@@ -70,5 +75,53 @@ module.exports = async ({ assistant, Manager, user, settings, libraries }) => {
     return assistant.respond(`Failed to delete user: ${e}`, { code: 500 });
   }
 
+  // Send confirmation email (fire-and-forget)
+  if (email) {
+    sendConfirmationEmail(assistant, email);
+  }
+
   return assistant.respond({ success: true });
 };
+
+/**
+ * Send account deletion confirmation email (fire-and-forget)
+ */
+function sendConfirmationEmail(assistant, email) {
+  const Manager = assistant.Manager;
+  const brandName = Manager.config.brand.name;
+  const mailer = Manager.Email(assistant);
+
+  mailer.send({
+    to: email,
+    categories: ['account/delete'],
+    subject: `Your ${brandName} account has been deleted`,
+    template: 'default',
+    group: 'account',
+    data: {
+      email: {
+        preview: `Your ${brandName} account has been permanently deleted. All associated data has been removed.`,
+      },
+      body: {
+        title: 'Account Deleted',
+        message: `Your **${brandName}** account and all associated personal data have been permanently deleted from our systems. This action is irreversible.
+
+**What this means:**
+
+- Your account credentials and profile information have been removed.
+- Any pending data requests have been cancelled.
+- Subscription and billing records have been deleted.
+- You will no longer be able to sign in with this account.
+
+If you did not request this deletion, please contact us immediately by replying to this email.
+
+If you wish to use ${brandName} again in the future, you are welcome to create a new account at any time.`,
+      },
+    },
+  })
+    .then((result) => {
+      assistant.log(`sendConfirmationEmail(): Success, status=${result.status}`);
+    })
+    .catch((e) => {
+      assistant.error(`sendConfirmationEmail(): Failed: ${e.message}`);
+    });
+}

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

@@ -286,17 +286,13 @@ function sendWelcomeEmail(assistant, email) {
       },
       body: {
         title: `Welcome to ${Manager.config.brand.name}!`,
-        message: `
-          Welcome aboard!
-          <br><br>
-          I'm Ian, the founder and CEO of <strong>${Manager.config.brand.name}</strong>, and I'm thrilled to have you with us.
-          Your journey begins today, and we are committed to supporting you every step of the way.
-          <br><br>
-          We are dedicated to ensuring your experience is exceptional.
-          Feel free to reply directly to this email with any questions you may have.
-          <br><br>
-          Thank you for choosing <strong>${Manager.config.brand.name}</strong>. Here's to new beginnings!
-        `,
+        message: `Welcome aboard!
+
+I'm Ian, the founder and CEO of **${Manager.config.brand.name}**, and I'm thrilled to have you with us. Your journey begins today, and we are committed to supporting you every step of the way.
+
+We are dedicated to ensuring your experience is exceptional. Feel free to reply directly to this email with any questions you may have.
+
+Thank you for choosing **${Manager.config.brand.name}**. Here's to new beginnings!`,
       },
       signoff: {
         type: 'personal',
@@ -333,17 +329,15 @@ function sendCheckupEmail(assistant, email) {
       },
       body: {
         title: `How's everything going?`,
-        message: `
-          Hi there,
-          <br><br>
-          It's Ian again from <strong>${Manager.config.brand.name}</strong>. Just checking in to see how things are going for you.
-          <br><br>
-          Have you had a chance to explore all our features? Any questions or feedback for us?
-          <br><br>
-          We're always here to help, so don't hesitate to reach out. Just reply to this email and we'll get back to you as soon as possible.
-          <br><br>
-          Thank you for choosing <strong>${Manager.config.brand.name}</strong>. Here's to new beginnings!
-        `,
+        message: `Hi there,
+
+It's Ian again from **${Manager.config.brand.name}**. Just checking in to see how things are going for you.
+
+Have you had a chance to explore all our features? Any questions or feedback for us?
+
+We're always here to help, so don't hesitate to reach out. Just reply to this email and we'll get back to you as soon as possible.
+
+Thank you for choosing **${Manager.config.brand.name}**. Here's to new beginnings!`,
       },
       signoff: {
         type: 'personal',

package/src/manager/schemas/forms/delete.js

@@ -0,0 +1,6 @@
+/**
+ * Schema for DELETE /forms
+ */
+module.exports = () => ({
+  id: { types: ['string'], default: undefined, required: true },
+});

package/src/manager/schemas/forms/get.js

@@ -0,0 +1,6 @@
+/**
+ * Schema for GET /forms
+ */
+module.exports = () => ({
+  id: { types: ['string'], default: undefined },
+});

package/src/manager/schemas/forms/post.js

@@ -0,0 +1,9 @@
+/**
+ * Schema for POST /forms (create)
+ */
+module.exports = () => ({
+  name: { types: ['string'], default: 'Untitled Form' },
+  description: { types: ['string'], default: '' },
+  settings: { types: ['object'], default: {} },
+  pages: { types: ['array'], default: [] },
+});

package/src/manager/schemas/forms/public/get.js

@@ -0,0 +1,6 @@
+/**
+ * Schema for GET /forms/public
+ */
+module.exports = () => ({
+  id: { types: ['string'], default: undefined, required: true },
+});

package/src/manager/schemas/forms/put.js

@@ -0,0 +1,10 @@
+/**
+ * Schema for PUT /forms (update)
+ */
+module.exports = () => ({
+  id: { types: ['string'], default: undefined, required: true },
+  name: { types: ['string'], default: undefined },
+  description: { types: ['string'], default: undefined },
+  settings: { types: ['object'], default: undefined },
+  pages: { types: ['array'], default: undefined },
+});

package/src/manager/schemas/user/data-request/delete.js

@@ -0,0 +1 @@
+module.exports = () => ({});

package/src/manager/schemas/user/data-request/get.js

@@ -0,0 +1,7 @@
+module.exports = () => ({
+  action: {
+    types: ['string'],
+    default: 'status',
+    required: false,
+  },
+});

package/src/manager/schemas/user/data-request/post.js

@@ -0,0 +1,10 @@
+module.exports = () => ({
+  confirmed: {
+    types: ['boolean'],
+    default: false,
+  },
+  reason: {
+    types: ['string'],
+    default: '',
+  },
+});

package/templates/backend-manager-config.json

@@ -138,4 +138,11 @@
       'trustpilot.com',
     ],
   },
+  dataRequest: {
+    // Additional queries to include in GDPR data exports
+    // BEM always exports: users, auth record, data-requests, payments-intents, payments-orders
+    // Single doc: { path: 'collection/{uid}', redact: ['field.to.redact'] }
+    // Collection query: { collection: 'my-data', where: [['ownerField', '==', '{uid}']] }
+    queries: [],
+  },
 }