@xuda.io/account_module 1.2.2315 → 1.2.2316

package/index.mjs

@@ -6227,6 +6227,12 @@ export const get_contacts = async function (req, job_id, headers) {
         break;
       }
 
+      // UI-221
+      case 'favorites': {
+        opt.selector.favorite = true;
+        break;
+      }
+
       case 'online': {
         opt.limit = 9999;
         break;
@@ -6536,6 +6542,78 @@ export const unpin_contact = async function (req) {
   }
 };
 
+// ─── UI-221: favorites ────────────────────────────────────────────────────────────────
+// The softer half of the pair pin_contact / unpin_contact already covers: pin puts a
+// contact in the pinned bar (a working set of a handful), favorite is the long-lived "I
+// keep coming back to this one" mark and only ever answers the Favorites filter. Separate
+// flags on purpose, an item can carry both.
+//
+// Both contacts and account_profiles route here, as they do for pin: the pair reads and
+// writes a doc by id and the flag sits at the top level on both kinds.
+//
+// The two kinds do NOT live in the same db, though, and that is where pin's version of this
+// is wrong. Contacts are LISTED out of `get_active_account_profile_info(uid).app_id`, which
+// resolves to `shared_from_uid || uid` (see line ~3657), so under a profile shared FROM
+// another account it is the OWNER's project. Profiles are listed out of
+// `get_account_default_project_id(uid)`, always the account's own. Reading only the first
+// (what get_contact does) therefore misses your own profile whenever the active profile is a
+// shared one, and the write fails on a row the user is looking at.
+//
+// So: the contact db first, which keeps today's contact behaviour byte for byte, and the
+// account's own project as the fallback, which is where a profile doc actually is. They are
+// the same db in every case except the shared-profile one, so this is one read either way.
+const _set_contact_favorite = async function (uid, contact_id, favorite) {
+  const contact_app_id = (await get_active_account_profile_info(uid))?.app_id;
+  const own_app_id = await get_account_default_project_id(uid);
+
+  let app_id = contact_app_id;
+  let doc = contact_app_id ? await _try_get_doc(contact_app_id, contact_id) : null;
+  if (!doc && own_app_id && own_app_id !== contact_app_id) {
+    app_id = own_app_id;
+    doc = await _try_get_doc(own_app_id, contact_id);
+  }
+  if (!doc) throw new Error(`${contact_id} not found`);
+
+  doc.favorite = favorite;
+  const save_ret = await db_module.save_app_couch_doc(app_id, doc);
+  log_contact_activity(uid, contact_id, favorite ? 'favorited' : 'unfavorited', { by: 'user' }, app_id);
+
+  return save_ret;
+};
+
+// A missing doc is an expected answer here, not an error: it is how the caller above learns
+// to look in the other db. Same soft-fetch shape as _try_get_profile_doc above, which is the
+// non-throwing form of get_app_couch_doc_native.
+const _try_get_doc = async function (app_id, doc_id) {
+  if (!app_id || !doc_id) return null;
+  const ret = await db_module.get_app_couch_doc(app_id, doc_id, true);
+  return ret && ret.code >= 0 ? ret.data : null;
+};
+
+export const favorite_contact = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    return await _set_contact_favorite(uid, contact_id, true);
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const unfavorite_contact = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    return await _set_contact_favorite(uid, contact_id, false);
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
 export const not_spam_contact = async function (req, job_id, headers) {
   const { contact_id, uid } = req;
   const account_profile_info = await get_active_account_profile_info(uid);
@@ -6840,6 +6918,239 @@ export const get_contact_activity = async function (req) {
     return { code: -25, data: err.message };
   }
 };
+
+//////// CONTACT ITEM LINKS (UI-216)  //////////////
+
+// What a contact's registered-app tabs are made of. A contact_item says "this invoice / this
+// ticket / this file belongs to this person", and it is the ONLY thing those tabs read.
+//
+// Why a link doc and not a query per module: a contact lives in the account's project db, a
+// finance document lives in xuda_accounts, a drive file and a ticket live somewhere else again.
+// Rendering one contact's tabs by asking each module for its own answer means a fan-out across
+// three databases and seven modules on every contact open, and most of those modules cannot
+// filter by contact at all yet. So the link carries a SNAPSHOT of what it points at (title,
+// status, amount, a href), which is what the panel renders. The snapshot is a cache and is
+// documented as one: Open follows the href to the real record, which is always authoritative.
+// Refreshing snapshots, and reading native per-module answers alongside them, is phase 2.
+const MAX_CONTACT_ITEM_ROWS = 2000;
+
+// Fields of `snapshot` that survive the round trip. Anything else a caller sends is dropped,
+// so a module cannot quietly turn the link doc into its own storage.
+const CONTACT_ITEM_SNAPSHOT_FIELDS = ['title', 'subtitle', 'status', 'amount', 'currency', 'ts', 'href', 'kind', 'icon'];
+
+const clean_contact_item_snapshot = function (snapshot) {
+  const out = {};
+  if (!snapshot || typeof snapshot !== 'object') return out;
+  for (const key of CONTACT_ITEM_SNAPSHOT_FIELDS) {
+    let val = snapshot[key];
+    if (typeof val === 'undefined' || val === null) continue;
+    if (typeof val === 'string') val = val.slice(0, 500);
+    out[key] = val;
+  }
+  return out;
+};
+
+// A contact id that came off the wire, checked before anything is written against it. Same
+// ownership test get_contact_activity uses: a contact created by this account or belonging to
+// it. get_app_couch_doc_native throws a bare couch 'missing' for an id from another account,
+// so that has to be caught rather than allowed to surface to the caller as "missing".
+const load_owned_contact = async function (app_id, uid, contact_id) {
+  let contact_doc;
+  try {
+    contact_doc = await db_module.get_app_couch_doc_native(app_id, contact_id);
+  } catch (_) {
+    contact_doc = null;
+  }
+  if (!contact_doc || contact_doc.docType !== 'contact') throw new Error(`contact ${contact_id} not found`);
+  if (contact_doc.uid !== uid && contact_doc?.uid_created !== uid) throw new Error('Operation not allowed');
+  return contact_doc;
+};
+
+export const contact_item_attach = async function (req, job_id, headers) {
+  const { uid, contact_ids, contact_id, app_key, item_id, item_ref, snapshot, note, account_profile_id } = req;
+  try {
+    // "attach items to contact/s": one call, any number of contacts. A single contact_id is
+    // accepted too so a caller holding one does not have to wrap it.
+    const targets = [...new Set((Array.isArray(contact_ids) ? contact_ids : contact_id ? [contact_id] : []).filter(Boolean))];
+    if (!targets.length) throw new Error('contact_ids is missing');
+    if (!app_key) throw new Error('app_key is missing');
+    if (!item_id) throw new Error('item_id is missing');
+
+    const app_id = await get_account_default_project_id(uid);
+
+    // One query answers "already attached?" for every target at once, on the by_item index.
+    const existing_ret = await db_module.find_app_couch_query(app_id, {
+      selector: { docType: 'contact_item', app_key, item_id },
+      limit: MAX_CONTACT_ITEM_ROWS,
+    });
+    const live = (existing_ret?.docs || []).filter((d) => d.stat < 4);
+
+    const created = [];
+    const already = [];
+
+    for (const target of targets) {
+      await load_owned_contact(app_id, uid, target);
+
+      const hit = live.find((d) => d.contact_id === target);
+      if (hit) {
+        already.push({ link_id: hit._id, contact_id: target });
+        continue;
+      }
+
+      const d = Date.now();
+      const doc = {
+        _id: await _common.xuda_get_uuid('contact_item'),
+        docType: 'contact_item',
+        stat: 3,
+        uid,
+        app_key,
+        contact_id: target,
+        account_profile_id: account_profile_id || null,
+        item_id,
+        item_ref: item_ref && typeof item_ref === 'object' ? item_ref : {},
+        snapshot: clean_contact_item_snapshot(snapshot),
+        note: typeof note === 'string' ? note.slice(0, 1000) : '',
+        created_by_uid: uid,
+        date_created_ts: d,
+        ts: d,
+      };
+
+      const save_ret = await db_module.save_app_couch_doc(app_id, doc);
+      if (save_ret.code < 0) throw new Error(`could not attach to ${target}`);
+      created.push({ link_id: doc._id, contact_id: target });
+
+      log_contact_activity(uid, target, 'item_attached', { by: 'user', app_key, item_id, title: doc.snapshot.title }, app_id);
+    }
+
+    return { code: 1, data: { created, existing: already } };
+  } catch (err) {
+    return { code: -26, data: err.message };
+  }
+};
+
+export const contact_item_detach = async function (req, job_id, headers) {
+  const { uid, link_id, contact_id, app_key, item_id } = req;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+
+    let doc = null;
+    if (link_id) {
+      try {
+        doc = await db_module.get_app_couch_doc_native(app_id, link_id);
+      } catch (_) {
+        doc = null;
+      }
+    } else {
+      if (!contact_id || !app_key || !item_id) throw new Error('link_id, or contact_id + app_key + item_id, is missing');
+      const ret = await db_module.find_app_couch_query(app_id, {
+        selector: { docType: 'contact_item', app_key, item_id },
+        limit: MAX_CONTACT_ITEM_ROWS,
+      });
+      doc = (ret?.docs || []).find((d) => d.contact_id === contact_id && d.stat < 4) || null;
+    }
+
+    if (!doc || doc.docType !== 'contact_item') throw new Error('link not found');
+    if (doc.uid !== uid) throw new Error('Operation not allowed');
+    // Already detached is the state the caller asked for, so say so rather than failing a
+    // double click.
+    if (doc.stat >= 4) return { code: 1, data: { link_id: doc._id, already_detached: true } };
+
+    doc.stat = 4;
+    doc.stat_ts = Date.now();
+    doc.ts = doc.stat_ts;
+
+    const save_ret = await db_module.save_app_couch_doc(app_id, doc);
+    if (save_ret.code < 0) throw new Error('could not detach');
+
+    log_contact_activity(uid, doc.contact_id, 'item_detached', { by: 'user', app_key: doc.app_key, item_id: doc.item_id, title: doc?.snapshot?.title }, app_id);
+
+    return { code: 1, data: { link_id: doc._id } };
+  } catch (err) {
+    return { code: -26, data: err.message };
+  }
+};
+
+export const contact_item_list = async function (req, job_id, headers) {
+  const { uid, contact_id, app_key } = req;
+  try {
+    if (!contact_id) throw new Error('contact_id is missing');
+    const app_id = await get_account_default_project_id(uid);
+    await load_owned_contact(app_id, uid, contact_id);
+
+    // Deliberately NOT paged by app_key. The tab strip needs a count for every app at once, so
+    // one query answers the whole strip and the panel filters out what it needs client side.
+    // Opening a contact therefore costs one call, not one per tab.
+    //
+    // `ts: { $gt: null }` is not a filter, it is what makes Couch use the by_contact index for
+    // the sort: the sort field has to appear in the selector for the index to be a candidate.
+    const ret = await db_module.find_app_couch_query(app_id, {
+      selector: { docType: 'contact_item', contact_id, ts: { $gt: null } },
+      limit: MAX_CONTACT_ITEM_ROWS,
+      sort: [{ ts: 'desc' }],
+    });
+
+    const rows = (ret?.docs || []).filter((d) => d.stat < 4);
+
+    const counts = {};
+    for (const row of rows) counts[row.app_key] = (counts[row.app_key] || 0) + 1;
+
+    return {
+      code: 1,
+      data: {
+        contact_id,
+        rows: app_key ? rows.filter((r) => r.app_key === app_key) : rows,
+        counts,
+        total_docs: rows.length,
+        // The cap is a backstop, not a page. Say when it bit, so a short count is never read
+        // as the truth.
+        truncated: (ret?.docs || []).length >= MAX_CONTACT_ITEM_ROWS,
+      },
+    };
+  } catch (err) {
+    return { code: -26, data: err.message };
+  }
+};
+
+// Which contacts an item is attached to, for the attach control that lives on the item.
+export const contact_item_list_for_item = async function (req, job_id, headers) {
+  const { uid, app_key, item_id } = req;
+  try {
+    if (!app_key) throw new Error('app_key is missing');
+    if (!item_id) throw new Error('item_id is missing');
+    const app_id = await get_account_default_project_id(uid);
+
+    const ret = await db_module.find_app_couch_query(app_id, {
+      selector: { docType: 'contact_item', app_key, item_id },
+      limit: MAX_CONTACT_ITEM_ROWS,
+    });
+
+    const rows = (ret?.docs || []).filter((d) => d.stat < 4 && d.uid === uid);
+
+    // The names come from the contacts themselves, so a renamed contact reads correctly here
+    // even though the link's own snapshot describes the ITEM and never the person.
+    const contacts = [];
+    for (const row of rows) {
+      let contact_doc = null;
+      try {
+        contact_doc = await db_module.get_app_couch_doc_native(app_id, row.contact_id);
+      } catch (_) {
+        contact_doc = null;
+      }
+      contacts.push({
+        link_id: row._id,
+        contact_id: row.contact_id,
+        name: contact_doc?.name || contact_doc?.email || '',
+        email: contact_doc?.email || '',
+        profile_avatar: contact_doc?.profile_avatar || contact_doc?.profile_picture || '',
+      });
+    }
+
+    return { code: 1, data: { app_key, item_id, contacts } };
+  } catch (err) {
+    return { code: -26, data: err.message };
+  }
+};
+
 //////// PROFILES  //////////////
 
 export const get_pending_share_profile_in = async function (uid, _id) {
@@ -7038,6 +7349,12 @@ export const get_account_profiles = async function (req) {
       break;
     }
 
+    // UI-221
+    case 'favorites': {
+      opt.selector.favorite = true;
+      break;
+    }
+
     default:
       break;
   }
@@ -7249,6 +7566,14 @@ export const unarchive_account_profile = async function (req) {
   }
 };
 
+// UI-216: what a brand new profile works with before anyone opens the Registered apps tab.
+// The three communication channels, because they are the ones a contact already has data for
+// (the timeline is full of them) and a CRM with no email tab on a contact is not a CRM. The
+// dashboard falls back to the same list for the profiles that predate the field, so this is a
+// default in two places on purpose and the two must agree: see DEFAULT_REGISTERED_APP_KEYS in
+// dashboard/src/lib/registerableApps.js.
+const DEFAULT_REGISTERED_APPS = ['email', 'phone', 'sms'];
+
 export const create_account_profile = async function (req, job_id, headers) {
   const { uid, profile_name, profile_signature, email_account_id, profile_picture, profile_avatar, profile_picture_obj, profile_avatar_obj, main, account_type } = req;
   try {
@@ -7272,6 +7597,7 @@ export const create_account_profile = async function (req, job_id, headers) {
       profile_picture_obj,
       profile_avatar_obj,
       main,
+      registered_apps: [...DEFAULT_REGISTERED_APPS],
     };
     const save_ret = await db_module.save_app_couch_doc(app_id, doc);
     // acc_obj.active_profile_id = save_ret.data.id;
@@ -7306,6 +7632,12 @@ export const update_account_profile = async function (req, job_id, headers) {
     'active_agents',
     // Email Template tab: { style: 'plain' | 'card' | 'accent' | 'minimal' }
     'email_template',
+    // UI-216, Registered apps tab: which apps this profile works with, and therefore which
+    // tabs every contact in it gets. Catalog keys (dashboard/src/lib/registerableApps.js),
+    // ordered, because the order is the order of the icon strip under the composer.
+    // Mini apps are studio doc ids and live in their own field so the two can never collide.
+    'registered_apps',
+    'registered_mini_apps',
   ];
   try {
     let { data: account_profile_doc } = await db_module.get_app_couch_doc(app_id, _id);
@@ -7323,7 +7655,13 @@ export const update_account_profile = async function (req, job_id, headers) {
     for (const key of account_profile_properties) {
       let val = req[key];
       if (typeof val === 'undefined') continue;
-      if (account_profile_doc[key] !== val) {
+      // UI-216: `!==` on an array or an object is ALWAYS true (identity, not value), so every
+      // save of a profile carrying ai_models / auto_respond_agents wrote a revision and an
+      // "updated" activity row whether or not anything moved. registered_apps is a third such
+      // field and it is toggled a lot, so the trail would have become mostly noise. Compare
+      // non-primitives by value; primitives keep the cheap check.
+      const same = val !== null && typeof val === 'object' ? JSON.stringify(account_profile_doc[key]) === JSON.stringify(val) : account_profile_doc[key] === val;
+      if (!same) {
         changes_arr.push(key);
         previous_values[key] = account_profile_doc[key];
         account_profile_doc[key] = val;

package/index_ms.mjs

@@ -433,6 +433,14 @@ export const unpin_contact = async function (...args) {
   return await broker.send_to_queue("unpin_contact", ...args);
 };
 
+export const favorite_contact = async function (...args) {
+  return await broker.send_to_queue("favorite_contact", ...args);
+};
+
+export const unfavorite_contact = async function (...args) {
+  return await broker.send_to_queue("unfavorite_contact", ...args);
+};
+
 export const not_spam_contact = async function (...args) {
   return await broker.send_to_queue("not_spam_contact", ...args);
 };
@@ -453,6 +461,22 @@ export const get_contact_activity = async function (...args) {
   return await broker.send_to_queue("get_contact_activity", ...args);
 };
 
+export const contact_item_attach = async function (...args) {
+  return await broker.send_to_queue("contact_item_attach", ...args);
+};
+
+export const contact_item_detach = async function (...args) {
+  return await broker.send_to_queue("contact_item_detach", ...args);
+};
+
+export const contact_item_list = async function (...args) {
+  return await broker.send_to_queue("contact_item_list", ...args);
+};
+
+export const contact_item_list_for_item = async function (...args) {
+  return await broker.send_to_queue("contact_item_list_for_item", ...args);
+};
+
 export const get_pending_share_profile_in = async function (...args) {
   return await broker.send_to_queue("get_pending_share_profile_in", ...args);
 };

package/index_msa.mjs

@@ -433,6 +433,14 @@ export const unpin_contact =  function (...args) {
    broker.send_to_queue_async("unpin_contact", ...args);
 };
 
+export const favorite_contact =  function (...args) {
+   broker.send_to_queue_async("favorite_contact", ...args);
+};
+
+export const unfavorite_contact =  function (...args) {
+   broker.send_to_queue_async("unfavorite_contact", ...args);
+};
+
 export const not_spam_contact =  function (...args) {
    broker.send_to_queue_async("not_spam_contact", ...args);
 };
@@ -453,6 +461,22 @@ export const get_contact_activity =  function (...args) {
    broker.send_to_queue_async("get_contact_activity", ...args);
 };
 
+export const contact_item_attach =  function (...args) {
+   broker.send_to_queue_async("contact_item_attach", ...args);
+};
+
+export const contact_item_detach =  function (...args) {
+   broker.send_to_queue_async("contact_item_detach", ...args);
+};
+
+export const contact_item_list =  function (...args) {
+   broker.send_to_queue_async("contact_item_list", ...args);
+};
+
+export const contact_item_list_for_item =  function (...args) {
+   broker.send_to_queue_async("contact_item_list_for_item", ...args);
+};
+
 export const get_pending_share_profile_in =  function (...args) {
    broker.send_to_queue_async("get_pending_share_profile_in", ...args);
 };

package/package.json

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