@xuda.io/account_module 1.2.2305 → 1.2.2307

package/index.mjs

@@ -588,43 +588,151 @@ 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' },
+  // UI-97: a registered domain renews yearly and a dedicated IPv4 is a monthly line,
+  // so both carry their own `cycle` on each item rather than being assumed monthly.
+  { key: 'domain', scope: 'resource' },
+  { key: 'ipv4', 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 { 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: 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 hosting]', e.message);
+  }
 
+  // UI-97: domains registered THROUGH Xuda. A domain the customer merely connected
+  // (registered elsewhere, `connection_type: 'connected'`) costs nothing here, so the
+  // Stripe yearly price is what decides whether it is a subscription at all.
   try {
     const ret = await db_module.find_couch_query(
       'xuda_master',
-      { selector: { docType: 'app', app_type: 'static_website', app_uId: uid }, limit: 1000 },
+      { selector: { docType: 'domain_registration', owner_uid: uid }, limit: 500 },
       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;
+    for (const dom of ret?.docs || []) {
+      const price = Number(dom.stripe_price_yr) || 0;
       if (!price) continue;
-      items.static_website.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,
+      const renews = dom.expires_at ? new Date(dom.expires_at) : null;
+      items.domain.push({
+        id: dom._id,
+        label: dom.name || dom._id,
+        // Auto renew off means it lapses at expiry, which is the one thing worth
+        // saying on a billing screen about a domain.
+        plan_name: dom.auto_renew === false
+          ? `Renews ${renews ? renews.toISOString().slice(0, 10) : 'at expiry'}, auto renew off`
+          : `Renews ${renews ? renews.toISOString().slice(0, 10) : 'yearly'}`,
         price,
+        cycle: 'yr',
       });
     }
   } catch (e) {
-    console.error('[get_module_subscriptions static_website]', e.message);
+    console.error('[get_module_subscriptions domains]', e.message);
+  }
+
+  // UI-97: dedicated IPv4. The per-address price depends on what it is doing
+  // (internal / external / parked), which is exactly how ipv4_module prices it, so the
+  // rate is read from PRICE_OBJ the same way rather than assumed.
+  try {
+    const prices = {
+      internal: Number(_conf.PRICE_OBJ?.ipv4?.internal ?? 2),
+      external: Number(_conf.PRICE_OBJ?.ipv4?.external ?? 10),
+      parked: Number(_conf.PRICE_OBJ?.ipv4?.parked ?? 5),
+    };
+    const ret = await db_module.find_couch_query(
+      'xuda_ipv4',
+      { selector: { docType: 'ipv4_addr', account_id: uid }, limit: 1000 },
+      true,
+    );
+    for (const ip of ret?.docs || []) {
+      // A suspended address keeps billing at the rate it held, same as ipv4_module.
+      const bill = ip.state === 'suspended' ? ip.bill_as : ip.state;
+      const price = Number(prices[bill]) || 0;
+      if (!price) continue;
+      items.ipv4.push({
+        id: ip._id,
+        label: ip.address || ip._id,
+        plan_name: [bill, ip.target ? `on ${ip.target}` : ''].filter(Boolean).join(', '),
+        price,
+      });
+    }
+  } catch (e) {
+    console.error('[get_module_subscriptions ipv4]', e.message);
   }
 
   try {
@@ -674,7 +782,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,12 +791,11 @@ 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);
+        // UI-97: a row is only yearly when everything in it is (domains). Anything
+        // else stays monthly, so a total is never a sum of two different cycles.
+        const cycle = base.items.length && base.items.every((i) => i.cycle === 'yr') ? 'yr' : 'mo';
         return {
           ...base,
           active: m.scope === 'metered' || base.items.length > 0,
@@ -697,6 +803,7 @@ export const get_module_subscriptions = async function (req = {}) {
           plan_id: '',
           plan_name: '',
           price,
+          cycle,
         };
       }
       const plan_id = account[m.field] || m.default_plan;
@@ -4052,8 +4159,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 +6412,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);
@@ -8214,8 +8335,10 @@ const _nl_one = async (db, docType) => {
 // 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. Unlike the content DBs above,
-// xuda_notification is node-local on every box, so this runs unconditionally.
+// 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', {

package/package.json

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