some refactors

Author: perki

docs/hds-lib.js

@@ -77,6 +77,8 @@ class AppClientAccount extends Application {
     for (const event of eventRes.events) {
       const collectorClient = new CollectorClient(this, event);
       if (accessHDSCollectorMap[collectorClient.key] != null) collectorClient.accessData = accessHDSCollectorMap[collectorClient.key];
+      // temp process - might be removed
+      await collectorClient.checkConsistency();
       this.cache.collectorClientsMap[collectorClient.key] = collectorClient;
     }
 

docs/hds-lib.js.map

@@ -1,4 +1,5 @@
 const { HDSLibError } = require('../errors');
+const { waitUntilFalse } = require('../utils');
 const CollectorInvite = require('./CollectorInvite');
 
 const COLLECTOR_STREAMID_SUFFIXES = {
@@ -173,9 +174,9 @@ class Collector {
   }
 
   async #initInvites (forceRefresh) {
-    while (this.#cache.invitesInitializing) (await new Promise((resolve) => { setTimeout(resolve, 100); }));
-    this.#cache.invitesInitializing = true;
+    await waitUntilFalse(() => (this.#cache.invitesInitializing));
     if (!forceRefresh && this.#cache.invitesInitialized) return;
+    this.#cache.invitesInitializing = true;
     const queryParams = { types: ['invite/collector-v1'], streams: [this.streamId], fromTime: 0, toTime: 8640000000000000, limit: 10000 };
     try {
       await this.appManaging.connection.getEventsStreamed(queryParams, (eventData) => {

src/appTemplates/AppClientAccount.js

@@ -1,5 +1,6 @@
 const pryv = require('pryv');
 const { HDSLibError } = require('../errors');
+const logger = require('../logger');
 
 /**
  * Client App in relation to an AppManagingAccount/Collector
@@ -19,24 +20,29 @@ class CollectorClient {
   /** @type {Object} - when active or deactivated - there is a link with accessData */
   accessData;
 
+  /** @property {String} - identified within user's account - can be used to retreive a Collector Client from an app */
   get key () {
     return CollectorClient.keyFromInfo(this.eventData.content.accessInfo);
   }
 
+  /** @property {String} - id matching an event within requester's account - used as a reference to communicate with requester */
   get requesterEventId () {
     return this.eventData.content.requesterEventId;
   }
 
+  /** @property {Object} - full content of the request */
   get requestData () {
     return this.eventData.content.requesterEventData.content;
   }
 
+  /** @property {string} - one of 'Incoming', 'Active', 'Deactivated', 'Refused' */
   get status () {
-    if (!this.accessData) {
-      return CollectorClient.STATUSES.active;
+    const eventStatus = this.eventData.content.status;
+    if (this.accessData && !this.accessData.deleted && this.eventData.content.status !== CollectorClient.STATUSES.active) {
+      console.log(this.accessData);
+      throw new HDSLibError('Should be active, try checkConsiency()');
     }
-    if (this.accessData) return CollectorClient.STATUSES.active;
-    return CollectorClient.STATUSES.incoming;
+    return eventStatus;
   }
 
   constructor (app, eventData, accessData = null) {
@@ -63,38 +69,98 @@ class CollectorClient {
         apiEndpoint,
         requesterEventId,
         requesterEventData: requesterEvents[0],
-        accessInfo
+        accessInfo,
+        status: CollectorClient.STATUSES.incoming
       }
     };
     const event = await app.connection.apiOne('events.create', eventData, 'event');
     return new CollectorClient(app, event);
   }
 
   /**
-   * Accept current request
+   * Update business event with new status
+   * @param {string} newStatus
+   * @param {Object} [extraData] - if given this will be added to content ⚠️ - This can ovveride content!
    */
-  async accept () {
-    // create access for requester
-    if (this.accessData != null) throw new HDSLibError('Access Info already set');
-    // create access
-    const cleanedPermissions = this.requestData.permissions.map((p) => {
-      if (p.streamId) return { streamId: p.streamId, level: p.level };
-      return p;
-    });
-    const accessCreateData = {
-      name: this.key,
-      type: 'shared',
-      permissions: cleanedPermissions,
-      clientData: {
-        hdsCollectorClient: {
-          version: 0,
-          eventData: this.eventData
-        }
+  async #updateStatus (newStatus, extraData = null) {
+    const newContent = structuredClone(this.eventData.content);
+    newContent.status = newStatus;
+    if (extraData !== null) Object.assign(newContent, extraData);
+    const eventData = await this.app.connection.apiOne('events.update', {
+      id: this.eventData.id,
+      update: {
+        content: newContent
+      }
+    }, 'event');
+    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 accessData = await this.app.connection.apiOne('accesses.create', accessCreateData, 'access');
-    this.accessData = accessData;
-    if (!this.accessData.apiEndpoint) throw new HDSLibError('Failed creating request access', accessData);
+
+    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 (forceAndSkipAccessCreation) {
+      if (!this.accessData?.apiEndpoint || this.accessData?.delete) throw new HDSLibError('Cannot force accept with empty or deleted accessData', this.accessData);
+    } else {
+      if (this.status === 'Active') throw new HDSLibError('Cannot accept an Active CollectorClient');
+      // create access for requester
+      const cleanedPermissions = this.requestData.permissions.map((p) => {
+        if (p.streamId) return { streamId: p.streamId, level: p.level };
+        return p;
+      });
+      const accessCreateData = {
+        name: this.key,
+        type: 'shared',
+        permissions: cleanedPermissions,
+        clientData: {
+          hdsCollectorClient: {
+            version: 0,
+            eventData: this.eventData
+          }
+        }
+      };
+      const accessData = await this.app.connection.apiOne('accesses.create', accessCreateData, 'access');
+      this.accessData = accessData;
+      if (!this.accessData?.apiEndpoint) throw new HDSLibError('Failed creating request access', accessData);
+    }
 
     // sent access credentials to requester
     // check content of accessInfo
@@ -112,10 +178,38 @@ class CollectorClient {
       }
     };
 
-    const requesterConnection = new pryv.Connection(requestrerApiEndpoint);
-    const requesterEvent = await requesterConnection.apiOne('events.create', acceptEvent, 'event');
+    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 };
+    } 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;
+    }
+  }
 
-    return { accessData, requesterEvent };
+  /**
+   * Probable temporary internal to fix possible inconsenticies during lib early stages
+   */
+  async checkConsistency () {
+    // 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) {
+        await this.accept(true);
+      } else {
+        await this.revoke();
+      }
+    } else {
+      logger.debug('CollectorClient:checkConsistency', this.accessData);
+    }
   }
 
   /**

src/appTemplates/Collector.js

@@ -2,7 +2,9 @@ import HDSModel from './HDSModel/HDSModel';
 import appTemplates from './appTemplates/appTemplates';
 import pryv from './patchedPryv';
 import { localizeText, setPreferredLocale } from './localizeText';
+import logger from './logger';
 const l = localizeText;
+
 /**
  * Export for webpack build
  */
@@ -12,5 +14,6 @@ export {
   pryv,
   localizeText,
   setPreferredLocale,
-  l
+  l,
+  logger
 };

src/appTemplates/CollectorClient.js

@@ -6,5 +6,6 @@ module.exports = {
   pryv: require('./patchedPryv'),
   localizeText,
   setPreferredLocale,
-  l: localizeText
+  l: localizeText,
+  logger: require('./logger')
 };

src/index-webpack.js

@@ -0,0 +1,29 @@
+/**
+ * Basic logger
+ */
+module.exports = {
+  setLogger,
+  info,
+  error,
+  debug
+};
+
+let logger = {
+  info: log('info'),
+  error: log('error'),
+  debug: log('error')
+};
+
+function setLogger (newLogger) {
+  logger = newLogger;
+}
+
+function info () { logger.info(...arguments); }
+function error () { logger.error(...arguments); }
+function debug () { logger.debug(...arguments); }
+
+function log (type) {
+  return function () {
+    console.log(`Logger: [${type}]`, ...arguments);
+  };
+}

src/index.js

@@ -3,9 +3,21 @@
  */
 
 module.exports = {
-  deepFreeze
+  deepFreeze,
+  waitUntilFalse
 };
 
+/**
+ * Timed semaphore
+ */
+async function waitUntilFalse (callBackToReturnFalse, maxWaitMs = 5000) {
+  const started = Date.now();
+  while (callBackToReturnFalse()) {
+    await new Promise((resolve) => { setTimeout(resolve, 100); });
+    if (Date.now() - started > maxWaitMs) throw new Error(`Timeout after ${maxWaitMs}ms`);
+  }
+}
+
 /**
  * Recursively make immutable an object
  * @param {*} object