Applicatio Client Account

Author: perki

src/appTemplates/AppClientAccount.js

@@ -1,16 +1,66 @@
+const { HDSLibError } = require('../errors');
+const pryv = require('../patchedPryv');
 const Application = require('./Application');
+const CollectorClient = require('./CollectorClient');
+
 /**
  * - applications
  *   - [baseStreamId] "Root" stream from this app
  */
+
+const MAX_COLLECTORS = 1000;
 class AppClientAccount extends Application {
+  constructor (baseStreamId, connection, appName) {
+    super(...arguments);
+    this.cache.collectorClientsMap = {};
+  }
+
   get appSettings () {
     return {
       canBePersonnal: true,
       mustBeMaster: true
     };
   }
 
+  /**
+   * When the app receives a new request for data sharing
+   * @param {string} apiEndpoint
+   * @param {string} [incomingEventId] - Information for the recipient
+   */
+  async handleIncomingRequest (apiEndpoint, incomingEventId) {
+    const requesterConnection = new pryv.Connection(apiEndpoint);
+    const accessInfos = await requesterConnection.accessInfo();
+    // check if request is known
+    if (this.cache.collectorClientsMap[CollectorClient.keyFromInfo(accessInfos)]) {
+      const collectorClient = this.collectoClientsMap[accessInfos.name];
+      if (incomingEventId && collectorClient.requesterEventId !== incomingEventId) {
+        throw new HDSLibError('Found existing collectorClient with a different eventId', { actual: collectorClient.requesterEventId, incoming: incomingEventId });
+      }
+      return collectorClient;
+    }
+    // check if comming form hdsCollector
+    if (!accessInfos?.clientData?.hdsCollector) {
+      throw new HDSLibError('Invalid collector request, cannot find clientData.hdsCollector', { clientData: accessInfos?.clientData });
+    }
+    // else create it
+
+    const collectorClient = await CollectorClient.create(this, apiEndpoint, incomingEventId, accessInfos);
+    this.cache.collectorClientsMap[collectorClient.key] = collectorClient;
+    return collectorClient;
+  }
+
+  async getCollectorClients () {
+    const apiCalls = [{
+      method: 'accesses.get',
+      params: { includeDeletions: true }
+    }, {
+      method: 'events.get',
+      params: { types: ['request/collector-client-v1'], streamIds: [this.baseStreamId], limit: MAX_COLLECTORS }
+    }
+    ];
+    const [accessesRes, eventRes] = await this.connection.api(apiCalls);
+  }
+
   /**
    * - Check connection validity
    * - Make sure stream structure exists

src/appTemplates/Application.js

@@ -1,4 +1,7 @@
 const pryv = require('../patchedPryv');
+/**
+ * Common code for AppClientAccount and AppManagingAccount
+ */
 class Application {
   /** @type {Pryv.Connection} */
   connection;
@@ -114,7 +117,8 @@ async function createAppStreams (app) {
     isPersonalOrMaster = true;
     if (app.appSettings.mustBemaster && !masterFound) {
       throw new Error('Application with "app" type of access requires "master" token (streamId = "*", level = "manage")');
-    } else { // check that app has "manage" level on baseStreamId
+    }
+    if (!masterFound) { // check that app has "manage" level on baseStreamId
       const baseStreamFound = infos.permissions.find(p => (p.streamId === app.baseStreamId && p.level === 'manage'));
       if (!baseStreamFound) throw new Error(`Application with "app" type of access requires  (streamId = '${app.baseStreamId}', level = "manage") or master access`);
     }

src/appTemplates/Collector.js

@@ -153,10 +153,10 @@ class Collector {
     const clientData = {
       hdsCollector: {
         public: {
-          streamId: this.streamIdFor(Collector.public)
+          streamId: this.streamIdFor(Collector.STREAMID_SUFFIXES.public)
         },
         inbox: {
-          streamId: this.streamIdFor(Collector.inbox)
+          streamId: this.streamIdFor(Collector.STREAMID_SUFFIXES.inbox)
         }
       }
     };

src/appTemplates/CollectorClient.js

@@ -5,11 +5,47 @@
  */
 
 class CollectorClient {
-  apiEndpoint;
-  eventId;
-  constructor (apiEndpoint, eventId) {
-    this.apiEndpoint = apiEndpoint;
-    this.eventId = eventId;
+  /** @type {AppClientAccount} */
+  app;
+  /** @type {PryvEvent} */
+  eventData;
+
+  get key () {
+    return CollectorClient.keyFromInfo(this.eventData.content.accessInfo);
+  }
+
+  get requesterEventId () {
+    return this.eventData.content.requesterEventId;
+  }
+
+  constructor (app, eventData) {
+    this.app = app;
+    this.eventData = eventData;
+  }
+
+  /**
+   * Create a new Event
+   */
+  static async create (app, apiEndpoint, requesterEventId, accessInfo) {
+    const eventData = {
+      type: 'request/collector-client-v1',
+      streamIds: [app.baseStreamId],
+      content: {
+        apiEndpoint,
+        requesterEventId,
+        accessInfo
+      }
+    };
+    const event = await app.connection.apiOne('events.create', eventData, 'event');
+    return new CollectorClient(app, event);
+  }
+
+  /**
+   * return the key to discriminate collectorClients
+   * @param {PryvAccessInfo} accessInfo
+   */
+  static keyFromInfo (info) {
+    return info.user.username + ':' + info.name;
   }
 }
 

src/patchedPryv.js

@@ -4,23 +4,25 @@
  */
 const pryv = require('pryv');
 
+// patch Pryv only if needed.
+if (!pryv.Connection.prototype.apiOne) {
 /**
  * Make one api Api call
  * @param {string} method - methodId
  * @param {object} [params] - the method associated with this result
  * @param {string} [resultKey] - if given, returns the value or throws an error if not present
  * @throws {Error} if .error is present the response
  */
-pryv.Connection.prototype.apiOne = async function (method, params = {}, expectedKey) {
-  const result = await this.api([{ method, params }]);
-  if (result[0] == null || result[0].error || (expectedKey != null && result[0][expectedKey] == null)) {
-    const innerObject = result[0]?.error || result;
-    const error = new Error(`Error for api method: "${method}" with params: ${JSON.stringify(params)} >> Result: ${JSON.stringify(innerObject)}"`);
-    error.innerObject = innerObject;
-    throw error;
-  }
-  if (expectedKey != null) return result[0][expectedKey];
-  return result[0];
-};
-
+  pryv.Connection.prototype.apiOne = async function (method, params = {}, expectedKey) {
+    const result = await this.api([{ method, params }]);
+    if (result[0] == null || result[0].error || (expectedKey != null && result[0][expectedKey] == null)) {
+      const innerObject = result[0]?.error || result;
+      const error = new Error(`Error for api method: "${method}" with params: ${JSON.stringify(params)} >> Result: ${JSON.stringify(innerObject)}"`);
+      error.innerObject = innerObject;
+      throw error;
+    }
+    if (expectedKey != null) return result[0][expectedKey];
+    return result[0];
+  };
+}
 module.exports = pryv;

tests/apptemplates.test.js

@@ -19,7 +19,7 @@ describe('[APTX] appTemplates', function () {
     managingUser = await createUserAndPermissions(null, permissionsManager, initialStreams, appName);
     const connection = new pryv.Connection(managingUser.appApiEndpoint);
     appManaging = await AppManagingAccount.newFromConnection(baseStreamIdManager, connection);
-    // -- user
+    // -- receiving user
     user = await createUser();
   });
 
@@ -125,12 +125,20 @@ describe('[APTX] appTemplates', function () {
     assert.deepEqual(inviteEvent.content, { name: 'Invite One', customData: options.customData });
 
     // Invitee receives the invite
+    const permissionsClient = [{ streamId: '*', level: 'manage' }];
+    const clientUser = await createUserPermissions(user, permissionsClient, [], appClientName);
+    const appClient = await AppClientAccount.newFromApiEndpoint(baseStreamIdClient, clientUser.appApiEndpoint, appClientName);
+    const collectorClient = await appClient.handleIncomingRequest(invite.apiEndpoint, invite.eventId);
+    assert.equal(collectorClient.eventData.streamIds[0], appClient.baseStreamId);
+    assert.equal(collectorClient.eventData.content.apiEndpoint, invite.apiEndpoint);
+    assert.equal(collectorClient.eventData.content.requesterEventId, invite.eventId);
+    // check collectorClient.eventData.accessInfo
   });
 
   describe('[APCX] app Templates Client', function () {
     it('[APCE] Should throw error if not initialized with a personal or master token', async () => {
-      const permissionsManager = [{ streamId: 'dummy', level: 'manage' }];
-      const clientUserNonMaster = await createUserPermissions(user, permissionsManager, [], appName);
+      const permissionsDummy = [{ streamId: 'dummy', level: 'manage' }];
+      const clientUserNonMaster = await createUserPermissions(user, permissionsDummy, [], appName);
       // non master app
       try {
         await AppClientAccount.newFromApiEndpoint(baseStreamIdClient, clientUserNonMaster.appApiEndpoint, appClientName);

tests/test-utils/pryvService.js

@@ -130,7 +130,6 @@ async function createUserPermissions (user, permissions, initialStreams = [], ap
   const res = await personalConnection.api(apiCalls);
   const accessRequestResult = res.pop();
   const appApiEndpoint = accessRequestResult.access?.apiEndpoint;
-
   const result = {
     username: user.username,
     personalApiEndpoint: user.apiEndpoint,