@xuda.io/account_module 1.2.2304 → 1.2.2306

package/index.mjs

@@ -588,43 +588,88 @@ const _MODULE_SUBSCRIPTIONS = [
   // switched on there as well as here. Both call tickets_set_plan, so the plan
   // is one line item on the consolidated subscription either way.
   { key: 'tickets', scope: 'account', field: 'tickets_plan', default_plan: 'tickets_free' },
-  // No free tier and no account field: the entitlement IS the subscription item
-  // (or a paid membership, which includes the standard tier at no charge).
-  { key: 'bot_protection', scope: 'account' },
+  // Auto response is the single gate for whether the AI answers, on every channel
+  // (chat, the public chat widget, email and the phone). It is account scoped and
+  // billed once however many scenarios are written, so it is a plain line item
+  // here rather than a per-resource charge like phone or email.
+  { key: 'auto_response', scope: 'account', field: 'auto_response_plan', default_plan: 'auto_response_free' },
+  // Four-tier ladder since 2026-08-06 (free / external / api / custom rules),
+  // chosen on the Bot Protection Manager's Plans tab, which calls
+  // bot_protection_set_plan. Free holds no line item at all.
+  { key: 'bot_protection', scope: 'account', field: 'bot_protection_plan', default_plan: 'bot_protection_free' },
   { key: 'static_website', scope: 'resource' },
   { key: 'profile_phone', scope: 'resource' },
+  // UI-96: the hosted resources. Not PLAN_OBJ categories, they are billed per resource
+  // from `app_cost` on the app doc, but they are money on the same invoice, so the card
+  // that answers "what am I paying for" has to show them.
+  { key: 'vps', scope: 'resource' },
+  { key: 'datacenter', scope: 'resource' },
+  { key: 'project', scope: 'resource' },
+  { key: 'preview', scope: 'resource' },
+  { key: 'instance', scope: 'resource' },
+  { key: 'backup', scope: 'resource' },
   // Xuda Verify (verify_module) has no PLAN_OBJ category: every check is metered
   // per call into verify_meter and nothing is charged to the account today.
   { key: 'trust_center', scope: 'metered' },
 ];
 
+// app_type -> the row it belongs under. An app type that is not here is not a
+// recurring hosted charge (or is not something the customer thinks of as one), so it
+// simply does not appear rather than landing in a catch-all.
+const _HOSTING_GROUP = {
+  vps: 'vps',
+  datacenter: 'datacenter',
+  master: 'project',
+  preview: 'preview',
+  instance: 'instance',
+  backup: 'backup',
+  static_website: 'static_website',
+};
+
 // The individual paid things inside a per-resource module, so the billing
 // screen can be the ONE place that shows everything the account pays for.
 // A site or a number on a free tier is not a subscription and is left out.
 const _module_resource_items = async (uid) => {
-  const items = { static_website: [], profile_phone: [] };
-
+  const items = {};
+  for (const m of _MODULE_SUBSCRIPTIONS) if (m.scope === 'resource') items[m.key] = [];
+
+  // UI-96: every hosted resource is a monthly charge, so the card walks the account's
+  // apps the way BILLING itself does (the `user_apps` view plus `is_billable` from
+  // deploy_module/cost.mjs, which is what get_billing_metrics uses) and groups the live
+  // ones by kind. Reading `app_cost.monthly_total` rather than re-deriving a price from
+  // the plan catalog is what keeps this card and the invoice from disagreeing.
   try {
-    const ret = await db_module.find_couch_query(
-      'xuda_master',
-      { selector: { docType: 'app', app_type: 'static_website', app_uId: uid }, limit: 1000 },
-      true,
-    );
-    for (const app of ret?.docs || []) {
-      const tier = app.static_website?.plan_tier || app.deploy_data?.static_website_hosting_plan || 'free';
-      const plan = _conf.PLAN_OBJ?.[`static_website_${tier}`];
-      const price = Number(plan?.price) || 0;
-      if (!price) continue;
-      items.static_website.push({
+    const { is_billable, format_app_cost_summary } = await import(`${module_path}/deploy_module/cost.mjs`);
+    const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps', {
+      startkey: [uid, ''],
+      endkey: [uid, 'ZZZZZ'],
+      include_docs: true,
+    });
+    for (const row of apps_ret?.data?.rows || []) {
+      const app = row.doc;
+      if (!app || !is_billable(app)) continue;
+      // Billing's own definition of live: status 4 and up is gone, and a terminated
+      // deployment stops costing. A deleted website was being counted before this.
+      if (Number(app.app_status_code) >= 4) continue;
+      if (app.app_cost?.terminated_ts) continue;
+      const key = _HOSTING_GROUP[app.app_type];
+      if (!key || !items[key]) continue;
+      let summary = '';
+      try {
+        summary = format_app_cost_summary(app) || '';
+      } catch (e) {
+        summary = '';
+      }
+      items[key].push({
         id: app._id,
         label: app.app_name || app.name || app.deploy_data?.domain || app._id,
-        plan_id: plan.id || `static_website_${tier}`,
-        plan_name: plan.name || tier,
-        price,
+        plan_id: app.app_cost?.app_server_type || app.app_type,
+        plan_name: summary || app.app_cost?.app_server_type || '',
+        price: Number(app.app_cost?.monthly_total) || 0,
       });
     }
   } catch (e) {
-    console.error('[get_module_subscriptions static_website]', e.message);
+    console.error('[get_module_subscriptions hosting]', e.message);
   }
 
   try {
@@ -674,7 +719,6 @@ export const get_module_subscriptions = async function (req = {}) {
     if (ar.code < 0 || !ar.data) return { code: -404, data: 'account not found' };
     const account = ar.data;
     const plans = _conf.PLAN_OBJ || {};
-    const is_member = !!(account.membership_plan && account.membership_plan !== 'free');
     // A category is only offerable once its paid tiers carry a real Stripe
     // price, otherwise "activate" would set a plan nobody is billed for.
     const billable = (key) =>
@@ -684,10 +728,6 @@ export const get_module_subscriptions = async function (req = {}) {
 
     const modules = _MODULE_SUBSCRIPTIONS.map((m) => {
       const base = { key: m.key, scope: m.scope, billable: billable(m.key), items: resource_items[m.key] || [] };
-      if (m.key === 'bot_protection') {
-        const has_item = !!account.stripe_subscription_items?.bot_protection;
-        return { ...base, active: has_item || is_member, included: is_member && !has_item, plan_id: '', plan_name: '', price: 0 };
-      }
       if (m.scope === 'resource' || m.scope === 'metered') {
         const price = base.items.reduce((sum, i) => sum + Number(i.price || 0), 0);
         return {
@@ -4052,8 +4092,20 @@ const get_contact_background = function (doc) {
   return ret;
 };
 
+// The card's background pattern doubles as a verification signal: L0..L4 each
+// have their own tile, distinguishable by density and brightness as well as by
+// the level token, so the level reads at a glance without another badge. Level
+// comes from account_info.verify_level, the projection verify_module writes on
+// every recompute; anything missing or out of range reads as L0, which is the
+// honest default for an account we have not scored.
+const level_pattern = function (doc) {
+  const raw = doc?.verify_level ?? doc?.account_info?.verify_level ?? doc?.user_contact?.verify_level;
+  const level = Number.isFinite(Number(raw)) ? Math.max(0, Math.min(4, Math.trunc(Number(raw)))) : 0;
+  return `level-${level}-pattern.png`;
+};
+
 const get_contact_pattern = async function (doc) {
-  let ret = `default-pattern.png`;
+  let ret = level_pattern(doc);
 
   if (doc?.shared_from_uid) {
     const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
@@ -6293,7 +6345,9 @@ export const get_account_profile_info = async function (uid, contact_profile_doc
   }
 
   const get_pattern = async function (doc) {
-    let ret = `default-pattern.png`;
+    // Same level-based default as get_contact_pattern, so a card shows the same
+    // verification tile whichever path built it.
+    let ret = level_pattern(doc);
 
     if (doc.shared_from_uid) {
       // const account_profile_doc = await db_module.get_couch_doc_native('xuda_accounts', doc.share_item_id);
@@ -8208,6 +8262,30 @@ const _nl_one = async (db, docType) => {
   }
 })();
 
+// The banner reconcilers (_ensure_billing_hold_banner, _ensure_bounce_suspension_banner,
+// _clear_bounce_suspension_banner, and the confirm_email cleanup in verify_account) all
+// select xuda_notification on {uid, topic, read}. With no index Couch full-scans the whole
+// notification DB on EVERY get_account_data: "No matching index found" plus a full-DB
+// examine per dashboard load. uid leads (most selective), then topic, then read; the extra
+// docType / delivery_method clauses those callers add are cheap in-memory filters once
+// uid + topic have narrowed the set to a handful. Not host-gated like the content DBs
+// above: xuda_notification exists on every box, so every node should ensure the index.
+// The fleet boxes replicate it through the master hub (so the PUT no-ops once one node
+// has it) but dev is outside that hub and only gets the index from its own run.
+(async () => {
+  try {
+    const ret = await db_module.create_couch_index('xuda_notification', {
+      index: { fields: ['uid', 'topic', 'read'] },
+      name: 'idx_notif_uid_topic_read',
+      ddoc: 'idx_notif_uid_topic_read',
+      type: 'json',
+    });
+    if (ret?.error) console.error('[account] xuda_notification uid/topic/read index create failed:', ret.error);
+  } catch (err) {
+    console.error('[account] xuda_notification uid/topic/read index init failed:', err?.message || err);
+  }
+})();
+
 const _nl_fashion_url = (p) => {
   const rel = p.custom_url || (p.slug ? '/' + p.slug : '');
   return `https://xuda.fashion${rel}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.2304",
+  "version": "1.2.2306",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {