Changing response eventType - Adding revoke and refuse

Author: perki

docs/hds-lib.js

@@ -4,8 +4,8 @@
   "description": "Health Data Safe - Library",
   "main": "src/index.js",
   "scripts": {
-    "test": "mocha tests --test-reporter=spec",
-    "test:coverage": "c8 mocha tests --test-reporter=spec",
+    "test": "NODE_ENV=test mocha tests --test-reporter=spec",
+    "test:coverage": "NODE_ENV=test c8 mocha tests --test-reporter=spec",
     "build": "webpack",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",

docs/hds-lib.js.map

@@ -2,6 +2,7 @@ const { HDSLibError } = require('../errors');
 const pryv = require('../patchedPryv');
 const Application = require('./Application');
 const CollectorClient = require('./CollectorClient');
+const logger = require('../logger');
 
 /**
  * - applications
@@ -29,15 +30,23 @@ class AppClientAccount extends Application {
    */
   async handleIncomingRequest (apiEndpoint, incomingEventId) {
     // make sure that collectorClientsMap is initialized
-    // await this.getCollectorClients();
+    await this.getCollectorClients();
 
     const requesterConnection = new pryv.Connection(apiEndpoint);
     const accessInfo = await requesterConnection.accessInfo();
     // check if request is known
-    if (this.cache.collectorClientsMap[CollectorClient.keyFromInfo(accessInfo)]) {
-      const collectorClient = this.collectoClientsMap[accessInfo.name];
+    const collectorClientKey = CollectorClient.keyFromInfo(accessInfo);
+    logger.debug('AppClient:handleIncomingRequest', { collectorClientKey, accessInfo, incomingEventId });
+    if (this.cache.collectorClientsMap[collectorClientKey]) {
+      const collectorClient = this.cache.collectorClientsMap[collectorClientKey];
+      logger.debug('AppClient:handleIncomingRequest found existing', { collectorClient });
       if (incomingEventId && collectorClient.requesterEventId !== incomingEventId) {
-        throw new HDSLibError('Found existing collectorClient with a different eventId', { actual: collectorClient.requesterEventId, incoming: incomingEventId });
+        logger.error('Found existing collectorClient with a different eventId', { actual: collectorClient.requesterEventId, incoming: incomingEventId });
+        return await collectorClient.reset(apiEndpoint, incomingEventId, accessInfo);
+      }
+      if (collectorClient.apiEndpoint !== apiEndpoint) {
+        logger.error('Found existing collectorClient with a different apiEndpoint', { actual: collectorClient.requesterApiEndpoint, incoming: apiEndpoint });
+        return await collectorClient.reset(apiEndpoint, incomingEventId, accessInfo);
       }
       return collectorClient;
     }
@@ -46,7 +55,6 @@ class AppClientAccount extends Application {
       throw new HDSLibError('Invalid collector request, cannot find clientData.hdsCollector or wrong version', { clientData: accessInfo?.clientData });
     }
     // else create it
-
     const collectorClient = await CollectorClient.create(this, apiEndpoint, incomingEventId, accessInfo);
     this.cache.collectorClientsMap[collectorClient.key] = collectorClient;
     return collectorClient;
@@ -59,7 +67,7 @@ class AppClientAccount extends Application {
   }
 
   async getCollectorClients (forceRefresh = false) {
-    if (!forceRefresh && this.cache.collectorClientsMapInitialized) return Object.values(this.cache.collectoClientsMap);
+    if (!forceRefresh && this.cache.collectorClientsMapInitialized) return Object.values(this.cache.collectorClientsMap);
     const apiCalls = [{
       method: 'accesses.get',
       params: { includeDeletions: true }

package.json

@@ -194,28 +194,49 @@ class Collector {
   async checkInbox () {
     const newCollectorInvites = [];
 
-    const params = { types: ['credentials/collector-v1'], limit: 1, streams: [this.streamIdFor(Collector.STREAMID_SUFFIXES.inbox)] };
-    const incomingCredentials = await this.appManaging.connection.apiOne('events.get', params, 'events');
-    for (const incomingCredential of incomingCredentials) {
+    const params = { types: ['response/collector-v1'], limit: 1000, streams: [this.streamIdFor(Collector.STREAMID_SUFFIXES.inbox)] };
+    const responseEvents = await this.appManaging.connection.apiOne('events.get', params, 'events');
+    for (const responseEvent of responseEvents) {
       // fetch corresponding invite
-      const inviteEvent = await this.appManaging.connection.apiOne('events.getOne', { id: incomingCredential.content.eventId }, 'event');
-      if (inviteEvent == null) throw new HDSLibError(`Cannot find invite event matching id: ${incomingCredential.content.eventId}`, incomingCredential);
+      const inviteEvent = await this.appManaging.connection.apiOne('events.getOne', { id: responseEvent.content.eventId }, 'event');
+      if (inviteEvent == null) throw new HDSLibError(`Cannot find invite event matching id: ${responseEvent.content.eventId}`, responseEvent);
+
+      const updateInvite = {
+        content: structuredClone(inviteEvent.content)
+      };
+      updateInvite.content.sourceEventId = responseEvent.id;
+
+      // check type of response
+      switch (responseEvent.content.type) {
+        case 'accept':
+          updateInvite.streamIds = [this.streamIdFor(Collector.STREAMID_SUFFIXES.active)];
+          Object.assign(updateInvite.content, { apiEndpoint: responseEvent.content.apiEndpoint });
+          break;
+        case 'refuse':
+          updateInvite.streamIds = [this.streamIdFor(Collector.STREAMID_SUFFIXES.error)];
+          updateInvite.content.errorType = 'refused';
+          break;
+        case 'revoke':
+          updateInvite.streamIds = [this.streamIdFor(Collector.STREAMID_SUFFIXES.error)];
+          updateInvite.content.errorType = 'revoked';
+          break;
+        default:
+          throw new HDSLibError(`Unkown or undefined ${responseEvent.content.type}`, responseEvent);
+      }
+
       // update inviteEvent and archive inbox message
       const apiCalls = [
         {
           method: 'events.update',
           params: {
             id: inviteEvent.id,
-            update: {
-              streamIds: [this.streamIdFor(Collector.STREAMID_SUFFIXES.active)],
-              content: Object.assign(inviteEvent.content, { apiEndpoint: incomingCredential.content.apiEndpoint })
-            }
+            update: updateInvite
           }
         },
         {
           method: 'events.update',
           params: {
-            id: incomingCredential.id,
+            id: responseEvent.id,
             update: {
               streamIds: [this.streamIdFor(Collector.STREAMID_SUFFIXES.archive)]
             }
@@ -352,12 +373,14 @@ class Collector {
    * reverse of streamIdFor
    */
   inviteStatusForStreamId (streamId) {
+    // init cache if needed
     if (!this.#cache.inviteStatusForStreamId) {
       this.#cache.inviteStatusForStreamId = {};
       for (const status of [COLLECTOR_STREAMID_SUFFIXES.pending, COLLECTOR_STREAMID_SUFFIXES.active, COLLECTOR_STREAMID_SUFFIXES.error]) {
         this.#cache.inviteStatusForStreamId[this.streamIdFor(status)] = status;
       }
     }
+    // look for status
     const status = this.#cache.inviteStatusForStreamId[streamId];
     if (status == null) throw new HDSLibError(`Cannot find status for streamId: ${streamId}`);
     return status;

src/appTemplates/AppClientAccount.js

@@ -30,6 +30,11 @@ class CollectorClient {
     return this.eventData.content.requesterEventId;
   }
 
+  /** @property {String}  */
+  get requesterApiEndpoint () {
+    return this.eventData.content.apiEndpoint;
+  }
+
   /** @property {Object} - full content of the request */
   get requestData () {
     return this.eventData.content.requesterEventData.content;
@@ -38,10 +43,21 @@ class CollectorClient {
   /** @property {string} - one of 'Incoming', 'Active', 'Deactivated', 'Refused' */
   get status () {
     const eventStatus = this.eventData.content.status;
+    if (eventStatus === 'Deactivated' || eventStatus === 'Refused') {
+      if (!this.accessData?.deleted) {
+        logger.error('>> CollectorClient.status TODO check consitency when access is still valid and deactivated or refused', this.accessData);
+      }
+      return eventStatus;
+    }
+
     if (this.accessData && !this.accessData.deleted && this.eventData.content.status !== CollectorClient.STATUSES.active) {
-      console.log(this.accessData);
+      logger.error('>> CollectorClient.status: accessData ', this.accessData);
       throw new HDSLibError('Should be active, try checkConsiency()');
     }
+    if (!eventStatus) {
+      logger.error('>> CollectorClient.status is null', { eventData: this.eventData, accessData: this.accessData });
+    }
+
     return eventStatus;
   }
 
@@ -77,10 +93,41 @@ class CollectorClient {
     return new CollectorClient(app, event);
   }
 
+  /**
+   * reset with new request Event of ApiEndpoint
+   * Identical as create but keep current event
+   */
+  async reset (apiEndpoint, requesterEventId, accessInfo) {
+    if (this.accessData && this.accessData?.deleted != null) {
+      logger.error('TODO try to revoke current access');
+    }
+    // check content of accessInfo
+    const publicStreamId = accessInfo.clientData.hdsCollector.public.streamId;
+    // get request event cont
+    const requesterConnection = new pryv.Connection(apiEndpoint);
+    const requesterEvents = await requesterConnection.apiOne('events.get', { types: ['request/collector-v1'], streams: [publicStreamId], limit: 1 }, 'events');
+    if (!requesterEvents[0]) throw new HDSLibError('Cannot find requester event in public stream', requesterEvents);
+
+    const eventData = await this.app.connection.apiOne('events.update', {
+      id: this.eventData.id,
+      update: {
+        content: {
+          apiEndpoint,
+          requesterEventId,
+          requesterEventData: requesterEvents[0],
+          accessInfo,
+          status: CollectorClient.STATUSES.incoming
+        }
+      }
+    }, 'event');
+    this.eventData = eventData;
+    return this;
+  }
+
   /**
    * Update business event with new status
    * @param {string} newStatus
-   * @param {Object} [extraData] - if given this will be added to content ⚠️ - This can ovveride content!
+   * @param {Object} [extraData] - if given this will be added to content ⚠️ - This can overide content!
    */
   async #updateStatus (newStatus, extraData = null) {
     const newContent = structuredClone(this.eventData.content);
@@ -95,48 +142,15 @@ class CollectorClient {
     this.eventData = eventData;
   }
 
-  /**
-   * Refuse current request
-   */
-  async refuse () {
-    if (this.status !== 'Incoming') throw new HDSLibError('Cannot only refuse incoming requests');
-    // sent access credentials to requester
-    // check content of accessInfo
-    const publicStreamId = this.eventData.content.accessInfo.clientData.hdsCollector.inbox.streamId;
-    const requesterEventId = this.requesterEventId;
-    const requestrerApiEndpoint = this.eventData.content.apiEndpoint;
-
-    // refuseEvent to be sent to requester
-    const refuseEvent = {
-      type: 'refusal/collector-v1',
-      streamIds: [publicStreamId],
-      content: {
-        eventId: requesterEventId
-      }
-    };
-
-    const requesterConnection = new pryv.Connection(requestrerApiEndpoint);
-    const requesterEvent = await requesterConnection.apiOne('events.create', refuseEvent, 'event');
-
-    await this.#updateStatus(CollectorClient.STATUSES.refused);
-    return { requesterEvent };
-  }
-
-  /**
-   * Revoke current request
-   * @param {boolean} forceAndSkipAccessCreation - internal temporary option,
-   */
-  async revoke () {
-    if (this.status !== 'Active') throw new HDSLibError('Cannot only revoke an Active CollectorClient');
-
-    console.log('Do something for revoke');
-  }
-
   /**
    * Accept current request
    * @param {boolean} forceAndSkipAccessCreation - internal temporary option,
    */
   async accept (forceAndSkipAccessCreation = false) {
+    if (this.accessData && this.accessData.deleted == null && this.status !== 'Active') {
+      forceAndSkipAccessCreation = true;
+      logger.error('CollectorClient.accept TODO fix accept when access valid');
+    }
     if (forceAndSkipAccessCreation) {
       if (!this.accessData?.apiEndpoint || this.accessData?.delete) throw new HDSLibError('Cannot force accept with empty or deleted accessData', this.accessData);
     } else {
@@ -162,36 +176,65 @@ class CollectorClient {
       if (!this.accessData?.apiEndpoint) throw new HDSLibError('Failed creating request access', accessData);
     }
 
+    const responseContent = {
+      apiEndpoint: this.accessData.apiEndpoint
+    };
+
+    const requesterEvent = await this.#updateRequester('accept', responseContent);
+    if (requesterEvent != null) {
+      await this.#updateStatus(CollectorClient.STATUSES.active);
+      return { accessData: this.accessData, requesterEvent };
+    }
+    return null;
+  }
+
+  async refuse () {
+    const responseContent = { };
+
+    const requesterEvent = await this.#updateRequester('refuse', responseContent);
+    if (requesterEvent != null) {
+      await this.#updateStatus(CollectorClient.STATUSES.refused);
+      return { requesterEvent };
+    }
+    return null;
+  }
+
+  /**
+   * @param {string} type - one of 'accpet', 'revoke', 'refuse'
+   * @param {object} responseContent - content is related to type
+   * @returns {Object} - response
+   */
+  async #updateRequester (type, responseContent) {
     // sent access credentials to requester
     // check content of accessInfo
     const publicStreamId = this.eventData.content.accessInfo.clientData.hdsCollector.inbox.streamId;
     const requesterEventId = this.requesterEventId;
     const requestrerApiEndpoint = this.eventData.content.apiEndpoint;
 
+    // add eventId to content
+    const content = Object.assign({ type, eventId: requesterEventId }, responseContent);
+
     // acceptEvent to be sent to requester
-    const acceptEvent = {
-      type: 'credentials/collector-v1',
+    const responseEvent = {
+      type: 'response/collector-v1',
       streamIds: [publicStreamId],
-      content: {
-        apiEndpoint: this.accessData.apiEndpoint,
-        eventId: requesterEventId
-      }
+      content
     };
 
     try {
       const requesterConnection = new pryv.Connection(requestrerApiEndpoint);
-      const requesterEvent = await requesterConnection.apiOne('events.create', acceptEvent, 'event');
-      await this.#updateStatus(CollectorClient.STATUSES.active);
-      return { accessData: this.accessData, requesterEvent };
+      const requesterEvent = await requesterConnection.apiOne('events.create', responseEvent, 'event');
+      return requesterEvent;
     } catch (e) {
       const deactivatedDetail = {
         type: 'error',
         message: e.message
       };
       if (e.innerObject) deactivatedDetail.data = e.innerObject;
       logger.error('Failed activating', deactivatedDetail);
-      await this.#updateStatus(CollectorClient.STATUSES.deactivated, { deactivatedDetail });
-      return false;
+      const deactivatedResult = await this.#updateStatus(CollectorClient.STATUSES.deactivated, { deactivatedDetail });
+      console.log('***** ', { deactivatedResult });
+      return null;
     }
   }
 
@@ -202,13 +245,13 @@ class CollectorClient {
     // accessData but not active
     if (this.accessData && this.eventData.content.status == null) {
       logger.info('Found discrepency with accessData and status not active, fixing it');
-      if (this.accessData.deleted) {
+      if (!this.accessData.deleted) {
         await this.accept(true);
       } else {
         await this.revoke();
       }
     } else {
-      logger.debug('CollectorClient:checkConsistency', this.accessData);
+      // logger.debug('CollectorClient:checkConsistency', this.accessData);
     }
   }
 

src/appTemplates/Collector.js

@@ -35,6 +35,11 @@ class CollectorInvite {
     return this.eventData.content.apiEndpoint;
   }
 
+  /** @type {string} - on of 'revoked', 'refused' */
+  get errorType () {
+    return this.eventData.content?.errorType;
+  }
+
   get dateCreation () {
     return new Date(this.eventData.created * 1000);
   }

src/appTemplates/CollectorClient.js

@@ -11,7 +11,7 @@ module.exports = {
 let logger = {
   info: log('info'),
   error: log('error'),
-  debug: log('error')
+  debug: log('debug')
 };
 
 function setLogger (newLogger) {
@@ -20,7 +20,9 @@ function setLogger (newLogger) {
 
 function info () { logger.info(...arguments); }
 function error () { logger.error(...arguments); }
-function debug () { logger.debug(...arguments); }
+function debug () {
+  // logger.debug(...arguments);
+}
 
 function log (type) {
   return function () {