Add doctor-side Contact support: CollectorInvite.toContactSource, AppManagingAccount.getContacts

- CollectorInvite: patientUsername getter (from apiEndpoint URL), toContactSource()
- Contact: invites[] array + addInvite() for doctor-side collector+invite pairs
- ContactInvite type exported
- AppManagingAccount.getContacts(): groups invites by patient username across all collectors
- Error-tolerant: skips collectors that fail to load

Author: perki

ts/appTemplates/AppManagingAccount.ts

@@ -1,6 +1,8 @@
 import ShortUniqueId from 'short-unique-id';
 import { Application } from './Application.ts';
 import { Collector } from './Collector.ts';
+import { Contact } from './Contact.ts';
+import type { ContactSource } from './interfaces.ts';
 
 const collectorIdGenerator = new ShortUniqueId({ dictionary: 'alphanum_lower', length: 7 });
 
@@ -62,6 +64,46 @@ export class AppManagingAccount extends Application {
     this.cache.collectorsMap = collectorsMap;
   }
 
+  /**
+   * Get all patient contacts grouped by username, across all collectors.
+   * Each Contact may have invites from multiple forms.
+   */
+  async getContacts (forceRefresh: boolean = false): Promise<Contact[]> {
+    const collectors = await this.getCollectors(forceRefresh);
+    const sources: ContactSource[] = [];
+
+    // Collect all invites from all collectors (with error tolerance)
+    const allInvitePairs: Array<{ collector: any; invite: any }> = [];
+    for (const collector of collectors) {
+      try {
+        await collector.init(forceRefresh);
+        const invites = await collector.getInvites(forceRefresh);
+        for (const invite of invites) {
+          sources.push(invite.toContactSource());
+          allInvitePairs.push({ collector, invite });
+        }
+      } catch (e) {
+        // Skip collectors that fail to load (e.g. network issues)
+        console.error('Contact: failed loading collector', collector.name, e);
+      }
+    }
+
+    // Group by patient username
+    const contacts = Contact.groupByContact(sources);
+
+    // Enrich contacts with collector+invite references (no extra API calls — reuse cached invites)
+    for (const contact of contacts) {
+      for (const { collector, invite } of allInvitePairs) {
+        const username = invite.patientUsername;
+        if (username && username === contact.remoteUsername) {
+          contact.addInvite(collector, invite);
+        }
+      }
+    }
+
+    return contacts;
+  }
+
   /**
    * Create an initialized Collector
    */

ts/appTemplates/CollectorInvite.ts

@@ -1,5 +1,6 @@
 import { pryv } from '../patchedPryv.ts';
 import { HDSLibError } from '../errors.ts';
+import type { ContactSource } from './interfaces.ts';
 
 /**
  * Collector Invite
@@ -105,6 +106,36 @@ export class CollectorInvite {
     return this.eventData.content.name;
   }
 
+  /** Extract patient username from apiEndpoint (only available for active invites) */
+  get patientUsername (): string | null {
+    if (this.status !== 'active') return null;
+    try {
+      const endpoint = this.eventData.content.apiEndpoint;
+      if (!endpoint) return null;
+      // apiEndpoint format: https://token@host/username/
+      const url = new URL(endpoint.replace(/\/\/[^@]+@/, '//'));
+      const path = url.pathname.replace(/^\/|\/$/g, '');
+      return path || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Convert to ContactSource for Contact grouping (doctor side) */
+  toContactSource (): ContactSource {
+    const chat = this.hasChat ? this.chatSettings : null;
+    return {
+      remoteUsername: this.patientUsername,
+      displayName: this.displayName || this.patientUsername || 'Unknown',
+      chatStreams: chat ? { main: chat.streamRead, incoming: chat.streamWrite } : null,
+      appStreamId: null,
+      permissions: [],
+      status: this.status,
+      type: 'collector',
+      accessId: this.key
+    };
+  }
+
   constructor (collector: any, eventData: any) {
     if (eventData.type !== 'invite/collector-v1') throw new HDSLibError('Wrong type of event', eventData);
     this.collector = collector;

ts/appTemplates/Contact.ts

@@ -1,9 +1,17 @@
 import type { ContactSource, ChatStreams, Permission, CollectorSectionInterface } from './interfaces.ts';
 import type { CollectorClient } from './CollectorClient.ts';
+import type { CollectorInvite } from './CollectorInvite.ts';
+import type { Collector } from './Collector.ts';
 import { HDSModelAppStreams } from '../HDSModel/HDSModel-AppStreams.ts';
 import { getStreamIdAndChildrenIds } from '../toolkit/StreamsTools.ts';
 import { pryv } from '../patchedPryv.ts';
 
+/** Doctor-side: a form invite pair (which collector + which invite) */
+export interface ContactInvite {
+  collector: Collector;
+  invite: CollectorInvite;
+}
+
 /**
  * Groups all accesses/relationships from the same remote user (or service).
  *
@@ -19,8 +27,10 @@ export class Contact {
   displayName: string;
   /** All access sources grouped into this contact */
   sources: ContactSource[];
-  /** CollectorClient instances for collector sources (matched by accessId) */
+  /** CollectorClient instances for collector sources — patient side */
   collectorClients: CollectorClient[];
+  /** Doctor-side: collector+invite pairs for this patient */
+  invites: ContactInvite[];
   /** Raw Pryv access objects for all sources */
   accessObjects: any[];
 
@@ -32,6 +42,7 @@ export class Contact {
     this.displayName = displayName;
     this.sources = [];
     this.collectorClients = [];
+    this.invites = [];
     this.accessObjects = [];
     this.#accessibleStreamIds = null;
   }
@@ -57,6 +68,13 @@ export class Contact {
     }
   }
 
+  /** Associate a collector+invite pair (doctor side) */
+  addInvite (collector: Collector, invite: CollectorInvite): void {
+    if (!this.invites.find(i => i.invite.key === invite.key)) {
+      this.invites.push({ collector, invite });
+    }
+  }
+
   // ---- Stream cache & event filtering ---- //
 
   /**

ts/appTemplates/appTemplates.ts

@@ -6,4 +6,5 @@ import { CollectorClient } from './CollectorClient.ts';
 import { CollectorInvite } from './CollectorInvite.ts';
 import { CollectorRequest } from './CollectorRequest.ts';
 import { Contact } from './Contact.ts';
+export type { ContactInvite } from './Contact.ts';
 export { AppManagingAccount, AppClientAccount, Application, Collector, CollectorClient, CollectorInvite, CollectorRequest, Contact };