Start Implementation of Collectors and App Templates

Author: perki

package-lock.json

@@ -42,6 +42,7 @@
     "@pryv/monitor": "^2.4.0",
     "@pryv/socket.io": "^2.4.0",
     "c8": "^10.1.3",
-    "pryv": "^2.4.0"
+    "pryv": "^2.4.0",
+    "short-unique-id": "^5.3.2"
   }
 }

package.json

@@ -0,0 +1,131 @@
+const { HDSLibError } = require('../errors');
+const ShortUniqueId = require('short-unique-id');
+const collectorIdGenerator = new ShortUniqueId({ dictionary: 'alphanum_lower', length: 7 });
+
+/**
+ * App which manages Collectors
+ * A "Collector" can be see as a "Request" and set of "Responses"
+ * - Responses are authorization tokens from individuals
+ *
+ * The App can create multiple "collectors e.g. Questionnaries"
+ *
+ * Stream structure
+ * - [baseStreamId]  "Root" stream for this app
+ *     - [baseStreamId]-[collectorsId] Each "questionnary" or "request for a set of data" has it's own stream
+ *       - [baseStreamId]-[collectorsId]-settings Contains events with the current settings of this app (this stream will be shared in "read" with the request)
+ *       - [baseStreamId]-[collectorsId]-pending Contains events with "pending" requests
+ *       - [baseStreamId]-[collectorsId]-active Contains events with "active" users
+ *       - [baseStreamId]-[scollectorsId]-errors Contains events with "revoked" or "erroneous" users
+ */
+class AppManagingAccount {
+  /** @type {Pryv.Connection} */
+  connection;
+  /** @type {string} */
+  baseStreamId;
+  /** @type {string} */
+  appName;
+
+  #cache;
+
+  /**
+   * use AppManagingAccount.newFromConnection() to create new AppManagingAccount
+   * @param {string} appName
+   * @param {string} baseStreamId
+   * @param {Pryv.Connection} connection
+   */
+  constructor (appName, baseStreamId, connection) {
+    this.baseStreamId = baseStreamId;
+    this.appName = appName;
+    this.connection = connection;
+    this.#cache = { };
+  }
+
+  /**
+   * Return an initialized AppManagingAccount instance
+   * @param {Pryv.Connection} connection
+   * @returns {AppManagingAccount}
+   */
+  static async newFromConnection (connection, baseStreamId) {
+    const appManagingAccount = await newAppManagingAccountFromConnection(connection, baseStreamId);
+    await appManagingAccount.init();
+    return appManagingAccount;
+  }
+
+  async init () {
+    // -- check if stream structure exists
+    await this.getCollectors();
+    return this;
+  }
+
+  async getCollectors (forceRefresh) {
+    if (!forceRefresh && this.#cache.collectorsMap) return Object.values(this.#cache.collectorsMap);
+    // Collectors are materialized by streams
+    const apiCalls = [{
+      method: 'streams.get',
+      params: {
+        parentId: this.baseStreamId
+      }
+    }];
+    const result = (await this.connection.api(apiCalls))[0];
+    if (result.error) throw new HDSLibError('Failed getting collectors', result.error);
+    if (!result.streams || !Array.isArray(result.streams)) throw new HDSLibError('Failed getting collectors, invalid result', result);
+    const collectorsMap = {};
+    for (const stream of result.streams) {
+      const collector = new Collector(this, stream);
+      collectorsMap[collector.id] = collector;
+    }
+    this.#cache.collectorsMap = collectorsMap;
+    return Object.values(this.#cache.collectorsMap);
+  }
+
+  async createCollector (name) {
+    const streamId = this.baseStreamId + '-' + collectorIdGenerator.rnd();
+    const apiCalls = [{
+      method: 'streams.create',
+      params: {
+        id: streamId,
+        name,
+        parentId: this.baseStreamId
+      }
+    }];
+    const result = (await this.connection.api(apiCalls))[0];
+    if (result.error) throw new HDSLibError('Failed creating collector', result.error);
+    if (!result.stream?.name) throw new HDSLibError('Failed creating collector, invalid result', result);
+    const collector = new Collector(this, result.stream);
+    this.#cache.collectorsMap[collector.id] = collector;
+    return collector;
+  }
+}
+
+class Collector {
+  appManaging;
+  id;
+  name;
+  /**
+   * @param {AppManagingAccount} appManaging
+   * @param {Pryv.Stream} stream
+   */
+  constructor (appManaging, stream) {
+    this.id = stream.id;
+    this.name = stream.name;
+    this.appManaging = appManaging;
+  }
+}
+
+module.exports = AppManagingAccount;
+
+async function newAppManagingAccountFromConnection (connection, baseStreamId) {
+  const accessInfo = (await connection.api([{ method: 'getAccessInfo', params: {} }]))[0];
+  if (!accessInfo.type === 'app') throw new Error('Failed createing new AppManagingAccount, invalid coonection: ' + JSON.stringify(accessInfo));
+  // check if baseStreamId is in pemission set
+  const found = accessInfo.permissions.find(p => (p.streamId === baseStreamId || p.streamId === '*'));
+  if (found && found.level !== 'manage') { // check if level 'manage'
+    throw new Error(`Failed creating new AppManagingAccount, Not sufficient permissions on stream: ${baseStreamId}`);
+  }
+  if (!found) {
+    // here we may check if we can create or manage baseStreamId as it might be covered by permissions
+    throw new Error(`Failed creating new AppManagingAccount, cannot find "${baseStreamId}" in permission list`);
+  }
+  const appManagingAccount = new AppManagingAccount(accessInfo.name, baseStreamId, connection);
+  return appManagingAccount;
+}

src/appTemplates/AppManagingAccount.js

@@ -0,0 +1,5 @@
+const AppManagingAccount = require('./AppManagingAccount');
+
+module.exports = {
+  AppManagingAccount
+};

src/appTemplates/appTemplates.js

@@ -0,0 +1,16 @@
+class HDSLibError extends Error {
+  constructor (message, innerObject = { }) {
+    const msg = (innerObject.message !== null) ? message + ' >> ' + innerObject.message : message;
+    super(msg);
+    this.innerObject = innerObject;
+  }
+
+  toString () {
+    const res = super.toString();
+    return res + '\nInner Object:\n' + JSON.stringify(this.innerObject, null, 2);
+  }
+}
+
+module.exports = {
+  HDSLibError
+};

src/errors.js

@@ -1,8 +1,9 @@
 import HDSModel from './HDSModel/HDSModel';
-
+import appTemplates from './appTemplates';
 /**
  * Export for webpack build
  */
 export const HDSLib = {
-  HDSModel
+  HDSModel,
+  appTemplates
 };

src/index-webpack.js

@@ -1,3 +1,4 @@
 module.exports = {
-  HDSModel: require('./HDSModel/HDSModel')
+  HDSModel: require('./HDSModel/HDSModel'),
+  appTemplates: require('./appTemplates/appTemplates')
 };

src/index.js

@@ -0,0 +1,49 @@
+/* eslint-env mocha */
+const assert = require('node:assert/strict');
+const { createUserAndPermissions } = require('./test-utils/pryvService');
+const AppManagingAccount = require('../src/appTemplates/AppManagingAccount');
+const pryv = require('pryv');
+
+describe('[APTX] appTemplates', function () {
+  this.timeout(10000);
+  let user, appManaging;
+  const baseStreamId = 'test-app-template';
+  const appName = 'Test HDSLib.appTemplates';
+
+  before(async () => {
+    const permissions = [{ streamId: baseStreamId, level: 'manage' }];
+    user = await createUserAndPermissions(null, permissions, appName);
+    const connection = new pryv.Connection(user.appApiEndpoint);
+    appManaging = await AppManagingAccount.newFromConnection(connection, baseStreamId);
+  });
+
+  it('[APTA] Initial and create One collector', async () => {
+    assert.equal(appManaging.appName, appName);
+    assert.equal(appManaging.baseStreamId, baseStreamId);
+
+    const collectorEmpty = await appManaging.getCollectors();
+    assert.ok(Array.isArray(collectorEmpty), 'Collectors should be an array');
+    assert.equal(collectorEmpty.length, 0, 'Collectors should be an empty array');
+
+    const collectorName = 'Test';
+    // create a Collector
+    const newCollector = await appManaging.createCollector(collectorName);
+    assert.ok(newCollector.id.startsWith(baseStreamId), 'Collectors id should start with baseStreamId');
+    assert.ok(newCollector.name, collectorName);
+
+    // Create a Collector with the same name should fail
+    try {
+      await appManaging.createCollector(collectorName);
+      throw new Error('Creating a Collector with the same name should fail');
+    } catch (e) {
+      assert.equal(e.message, 'Failed creating collector >> A stream with name "Test" already exists');
+      assert.equal(e.innerObject?.id, 'item-already-exists');
+    }
+
+    // check if collector is in the list
+    const collectors = await appManaging.getCollectors();
+    const found = collectors.find(c => c.name === collectorName);
+    if (!found) throw new Error('Should find collector with name: ' + collectorName);
+    assert.equal(found, newCollector);
+  });
+});

tests/apptemplates.test.js

@@ -0,0 +1,5 @@
+module.exports = {
+  serviceInfoURL: 'https://demo.datasafe.dev/reg/service/info',
+  appId: 'hds-lib-tests',
+  modelURL: 'https://model.datasafe.dev/pack.json'
+};