Now creating all manager's account

Author: perki

src/appTemplates/AppManagingAccount.js

@@ -72,7 +72,7 @@ class AppManagingAccount {
     const collectorsMap = {};
     for (const stream of result.streams) {
       const collector = new Collector(this, stream);
-      collectorsMap[collector.id] = collector;
+      collectorsMap[collector.streamId] = collector;
     }
     this.#cache.collectorsMap = collectorsMap;
     return Object.values(this.#cache.collectorsMap);
@@ -92,23 +92,82 @@ class AppManagingAccount {
     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;
+    this.#cache.collectorsMap[collector.streamId] = collector;
     return collector;
   }
 }
 
+const COLLECTOR_STREAMID_SUFFIXES = {
+  settings: 'settings',
+  pending: 'pending',
+  active: 'active',
+  error: 'error'
+};
+Object.freeze(COLLECTOR_STREAMID_SUFFIXES);
 class Collector {
+  static STREAMID_SUFFIXES = COLLECTOR_STREAMID_SUFFIXES;
   appManaging;
-  id;
+  streamId;
   name;
+  #streamData;
+
   /**
    * @param {AppManagingAccount} appManaging
-   * @param {Pryv.Stream} stream
+   * @param {Pryv.Stream} streamData
    */
-  constructor (appManaging, stream) {
-    this.id = stream.id;
-    this.name = stream.name;
+  constructor (appManaging, streamData) {
+    this.streamId = streamData.id;
+    this.name = streamData.name;
     this.appManaging = appManaging;
+    this.#streamData = streamData;
+  }
+
+  /**
+   * check if required streams are present, if not create them
+   */
+  async checkStreamStructure () {
+    // if streamData has correct children structure we assume all is OK
+    const childrenData = this.#streamData.children;
+    const toCreate = Object.values(Collector.STREAMID_SUFFIXES)
+      .filter((suffix) => {
+        if (!childrenData) return true;
+        if (childrenData.find(child => child.id === this.streamIdFor(suffix))) return false;
+        return true;
+      });
+
+    if (toCreate.length === 0) return { created: [] };
+    // create required streams
+    const apiCalls = toCreate.map(suffix => ({
+      method: 'streams.create',
+      params: {
+        id: this.streamIdFor(suffix),
+        parentId: this.streamId,
+        name: this.name + ' ' + suffix
+      }
+    }));
+    const result = { created: [], errors: [] };
+    const resultsApi = await this.appManaging.connection.api(apiCalls);
+    for (const resultCreate of resultsApi) {
+      if (resultCreate.error) {
+        result.errors.push(resultCreate.error);
+        continue;
+      }
+      if (resultCreate.stream) {
+        result.created.push(resultCreate.stream);
+        if (!this.#streamData.children) this.#streamData.children = [];
+        this.#streamData.children.push(resultCreate.stream);
+        continue;
+      }
+      result.errors.push({ id: 'unkown-error', message: 'Cannot find stream in result', data: resultCreate });
+    }
+    return result;
+  }
+
+  /**
+   * @param {string} suffix
+   */
+  streamIdFor (suffix) {
+    return this.streamId + '-' + suffix;
   }
 }
 

tests/apptemplates.test.js

@@ -28,7 +28,7 @@ describe('[APTX] appTemplates', function () {
     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.streamId.startsWith(baseStreamId), 'Collectors id should start with baseStreamId');
     assert.ok(newCollector.name, collectorName);
 
     // Create a Collector with the same name should fail
@@ -45,5 +45,27 @@ describe('[APTX] appTemplates', function () {
     const found = collectors.find(c => c.name === collectorName);
     if (!found) throw new Error('Should find collector with name: ' + collectorName);
     assert.equal(found, newCollector);
+
+    // check StreamStructure
+    const resultCheckStructure = await newCollector.checkStreamStructure();
+    assert.equal(resultCheckStructure.created.length, 4, 'Should create 4 streams');
+    for (const created of resultCheckStructure.created) {
+      assert.equal(created.parentId, newCollector.streamId, 'Should have collector stream as parentid');
+    }
+
+    // 2nd call of StreamStructure should be empty
+    const resultCheckStructure2 = await newCollector.checkStreamStructure();
+    assert.equal(resultCheckStructure2.created.length, 0, 'Should create 0 streams');
+
+    // creating a new Manager with same connection should load the structure
+    const connection2 = new pryv.Connection(appManaging.connection.apiEndpoint);
+    const appManaging2 = await AppManagingAccount.newFromConnection(connection2, baseStreamId);
+    // check if collector is in the list
+    const collectors2 = await appManaging2.getCollectors();
+    const found2 = collectors2.find(c => c.name === collectorName);
+    if (!found2) throw new Error('Should find collector with name: ' + collectorName);
+    // call of StreamStructure should be empty as already created
+    const resultCheckStructure3 = await newCollector.checkStreamStructure();
+    assert.equal(resultCheckStructure3.created.length, 0, 'Should create 0 streams');
   });
 });

tests/test-utils/debug.js

@@ -0,0 +1,25 @@
+const util = require('util');
+
+function log () {
+  for (let i = 0; i < arguments.length; i++) {
+    console.log(util.inspect(arguments[i], { depth: 12, colors: true }));
+  }
+}
+
+function stack (start = 0, length = 100) {
+  const e = new Error();
+  return e.stack.split('\n').filter(l => l.indexOf('node_modules') < 0).slice(start + 1, start + length + 1);
+}
+
+function logstack () {
+  log(...arguments, stack(2, 4));
+}
+
+module.exports = {
+  logstack,
+  log,
+  stack
+};
+
+global.$$ = logstack;
+global.$$$ = log;

tests/test-utils/pryvService.js

@@ -1,3 +1,4 @@
+require('./debug');
 const pryv = require('pryv');
 const superagent = pryv.utils.superagent;