disco: support optional JID argument in api.disco.entities.find

Author: jcbrand

src/headless/plugins/disco/api.js

@@ -202,20 +202,39 @@ export default {
              *
              * @method api.disco.entities.find
              * @param {string} feature The feature var to search for.
-             * @returns {Promise<DiscoEntity|null>} The matching DiscoEntity instance or null if not found.
+             * @param {string} [jid] The entity JID whose subtree to search. If omitted, own bare JID and domain are queried.
+             * @returns {Promise<DiscoEntity[]>} An array of matching DiscoEntity instances.
              */
-            async find(feature) {
+            async find(feature, jid) {
                 await api.waitUntil('discoInitialized');
                 const disco_entities = /** @type {DiscoEntities} */ (_converse.state.disco_entities);
                 if (!disco_entities) {
                     return [];
                 }
-                const checks = disco_entities.map(async (entity) => {
+                let candidates = [];
+                if (jid) {
+                    const entity = await api.disco.entities.get(jid, true);
+                    if (entity) candidates.push(entity);
+                    const items = await api.disco.entities.items(jid);
+                    candidates.push(...items);
+                } else {
+                    const bare = _converse.session.get('bare_jid');
+                    const bare_entity = await api.disco.entities.get(bare, true);
+                    if (bare_entity) candidates.push(bare_entity);
+                    const domain = Strophe.getDomainFromJid(bare);
+                    const domain_entity = await api.disco.entities.get(domain, true);
+                    if (domain_entity) candidates.push(domain_entity);
+                    const items = await api.disco.entities.items(domain);
+                    candidates.push(...items);
+                }
+                // Deduplicate by JID
+                const unique = Array.from(new Map(candidates.map(e => [e.get('jid'), e])).values());
+                const checks = unique.map(async (entity) => {
                     const has = await entity.getFeature(feature);
                     return has ? entity : null;
                 });
                 const results = await Promise.all(checks);
-                return results.filter((e) => e instanceof Object);
+                return results.filter(e => e);
             },
 
             /**
@@ -254,10 +273,12 @@ export default {
              */
             async items(jid) {
                 const entity = await api.disco.entities.get(jid);
-                await entity.waitUntilItemsFetched;
-
-                const disco_entities = /** @type {DiscoEntities} */ (_converse.state.disco_entities);
-                return disco_entities.filter((e) => e.get('parent_jids')?.includes(jid));
+                if (entity) {
+                    await entity.waitUntilItemsFetched;
+                    const disco_entities = /** @type {DiscoEntities} */ (_converse.state.disco_entities);
+                    return disco_entities.filter((e) => e.get('parent_jids')?.includes(jid));
+                }
+                return [];
             },
 
             /**

src/headless/plugins/disco/entity.js

@@ -192,7 +192,7 @@ class DiscoEntity extends Model {
             const jid = item.getAttribute('jid');
             let entity = _converse.state.disco_entities.get(jid);
             if (entity) {
-                const parent_jids = entity.get('parent_jids');
+                const parent_jids = entity.get('parent_jids') || [];
                 entity.set({ parent_jids: [...parent_jids, this.get('jid')] });
             } else {
                 entity = api.disco.entities.create({

src/headless/plugins/disco/tests/disco.js

@@ -186,8 +186,8 @@ describe("Service Discovery", function () {
                 const results = await _converse.api.disco.entities.find('feature');
                 expect(Array.isArray(results)).toBe(true);
                 expect(results.length).toBe(4);
-                expect(results[0].get('jid')).toBe(domain);
-                expect(results[1].get('jid')).toBe(bare);
+                expect(results[0].get('jid')).toBe(bare);
+                expect(results[1].get('jid')).toBe(domain);
                 expect(results[2].get('jid')).toBe('a@b');
                 expect(results[3].get('jid')).toBe('c@d');
             })
@@ -211,5 +211,30 @@ describe("Service Discovery", function () {
                 expect(results.length).toBe(0);
             })
         );
+
+        it(
+            'searches only under the provided JID subtree',
+            mock.initConverse([], {}, async function (_converse) {
+                const bare = _converse.session.get('bare_jid');
+                const domain = Strophe.getDomainFromJid(bare);
+                // domain items: a@b supports featureX, c@d does not
+                await mock.waitUntilDiscoConfirmed(
+                    _converse,
+                    domain,
+                    [{ 'category': 'server', 'type': 'IM' }],
+                    ['http://jabber.org/protocol/disco#items']
+                );
+                await mock.waitUntilDiscoConfirmed(_converse, domain, [], [], ['a@b', 'c@d'], 'items');
+                await mock.waitUntilDiscoConfirmed(_converse, 'a@b', [], ['featureX']);
+                await mock.waitUntilDiscoConfirmed(_converse, 'c@d', [], []);
+                const resultsForAB = await _converse.api.disco.entities.find('featureX', 'a@b');
+                expect(Array.isArray(resultsForAB)).toBe(true);
+                expect(resultsForAB.length).toBe(1);
+                expect(resultsForAB[0].get('jid')).toBe('a@b');
+                const resultsForCD = await _converse.api.disco.entities.find('featureX', 'c@d');
+                expect(Array.isArray(resultsForCD)).toBe(true);
+                expect(resultsForCD.length).toBe(0);
+            })
+        );
     });
 });

src/headless/types/plugins/disco/api.d.ts

@@ -84,9 +84,10 @@ declare namespace _default {
              *
              * @method api.disco.entities.find
              * @param {string} feature The feature var to search for.
-             * @returns {Promise<DiscoEntity|null>} The matching DiscoEntity instance or null if not found.
+             * @param {string} [jid] The entity JID whose subtree to search. If omitted, own bare JID and domain are queried.
+             * @returns {Promise<DiscoEntity[]>} An array of matching DiscoEntity instances.
              */
-            function find(feature: string): Promise<import("./entity").default | null>;
+            function find(feature: string, jid?: string): Promise<import("./entity").default[]>;
             /**
              * Get the corresponding `DiscoEntity` instance.
              *