release with setCustomSettings

Author: perki

docs/hds-lib.js

@@ -21279,6 +21279,46 @@ class Application {
     await createAppStreams(this);
   }
 
+  /**
+   * Save anything you want for your app
+   * @param {Object} content will fully replace any existing content
+   */
+  async setCustomSettings (content) {
+    const currentCustomSettings = await this.getCustomSettings();
+    if (currentCustomSettings != null) { // update
+      const id = this.cache.customSettingsEvent.id;
+      const updatedEvent = await this.connection.apiOne('events.update', { id, update: { content } }, 'event');
+      this.cache.customSettingsEvent = updatedEvent;
+    } else {
+      await this.#createCustomSettings(content);
+    }
+    return this.cache.customSettingsEvent?.content;
+  }
+
+  /**
+   * @private
+   * Used by getCustomSettings & setCustomSettings
+   * @param {*} content
+   */
+  async #createCustomSettings (content) {
+    const createdEvent = await this.connection.apiOne('events.create', { streamIds: [this.baseStreamId], type: 'settings/any', content }, 'event');
+    this.cache.customSettingsEvent = createdEvent;
+  }
+
+  /**
+   * Get current settings previously set with setCustomSettings()
+   */
+  async getCustomSettings (forceRefresh = false) {
+    if (forceRefresh || this.cache.customSettingsEvent) {
+      const customSettingsEvent = (await this.connection.apiOne('events.get', { streams: [this.baseStreamId], types: ['settings/any'], limit: 1 }, 'events'))[0];
+      this.cache.customSettingsEvent = customSettingsEvent;
+    }
+    if (!this.cache.customSettingsEvent) {
+      await this.#createCustomSettings({});
+    }
+    return this.cache.customSettingsEvent?.content;
+  }
+
   /**
    * Force loading of streamData
    */
@@ -22716,102 +22756,126 @@ describe('[APAX] Application class', () => {
     user = await createUserAndPermissions(null, permissionsManager, initialStreams, appName);
   });
 
-  it('[APAI] Application extension', async () => {
-    class Dummy extends Application { }
+  describe('[APIX] Application class internal', () => {
+    it('[APIS] Application custom settings', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
+      }
+      const appDummy = await Dummy.newFromApiEndpoint(baseStreamId, user.appApiEndpoint, appName);
+
+      const settings = await appDummy.getCustomSettings();
+      assert.deepEqual(settings, {});
+      const newSettings = { hello: 'Tom', value: 2 };
+      const newSettings1 = await appDummy.setCustomSettings(newSettings);
+      assert.deepEqual(newSettings, newSettings1);
+      const newSettings2 = await appDummy.getCustomSettings();
+      assert.deepEqual(newSettings, newSettings2);
+      // assert.equal(newSettings1, newSettings2, 'should be the same object');
+      const newSettings3 = await appDummy.getCustomSettings(true);
+      assert.deepEqual(newSettings1, newSettings3);
+    });
+  });
 
-    try {
-      await Dummy.newFromApiEndpoint(baseStreamId, user.appApiEndpoint, appName);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'appSettings must be implemented');
-    }
+  describe('[APAE] Application class errors', () => {
+    it('[APAI] Application extension', async () => {
+      class Dummy extends Application { }
 
-    try {
+      try {
+        await Dummy.newFromApiEndpoint(baseStreamId, user.appApiEndpoint, appName);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'appSettings must be implemented');
+      }
+
+      try {
       // eslint-disable-next-line no-new
-      new Dummy('u', user.appApiEndpoint, appName);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'Missing or too short baseStreamId');
-    }
-  });
+        new Dummy('u', user.appApiEndpoint, appName);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'Missing or too short baseStreamId');
+      }
+    });
 
-  it('[APAA] Application name form accessInfo fails in not in settings', () => {
-    class Dummy extends Application {
-      get appSettings () {
-        return { };
+    it('[APAA] Application name form accessInfo fails in not in settings', () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
       }
-    }
 
-    try {
+      try {
       // eslint-disable-next-line no-new
-      new Dummy(baseStreamId, user.appApiEndpoint);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'appName must be given unless appSettings.appNameFromAccessInfo = true');
-    }
-  });
+        new Dummy(baseStreamId, user.appApiEndpoint);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'appName must be given unless appSettings.appNameFromAccessInfo = true');
+      }
+    });
 
-  it('[APAB] Application name form accessInfo', async () => {
-    class Dummy2 extends Application {
-      get appSettings () {
-        return {
-          appNameFromAccessInfo: true
-        };
+    it('[APAB] Application name form accessInfo', async () => {
+      class Dummy2 extends Application {
+        get appSettings () {
+          return {
+            appNameFromAccessInfo: true
+          };
+        }
       }
-    }
 
-    const dummy2 = await Dummy2.newFromApiEndpoint(baseStreamId, user.appApiEndpoint);
-    assert.ok(dummy2, 'if appSettings.appNameFromAccessInfo = true appName is not required');
-  });
+      const dummy2 = await Dummy2.newFromApiEndpoint(baseStreamId, user.appApiEndpoint);
+      assert.ok(dummy2, 'if appSettings.appNameFromAccessInfo = true appName is not required');
+    });
 
-  it('[APAC] Application should throw error if baseStream is not accessible', async () => {
-    class Dummy extends Application {
-      get appSettings () {
-        return { };
+    it('[APAC] Application should throw error if baseStream is not accessible', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
       }
-    }
 
-    try {
+      try {
       // eslint-disable-next-line no-new
-      await Dummy.newFromApiEndpoint('uuuu', user.appApiEndpoint, appName);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'Application with "app" type of access requires  (streamId = "uuuu", level = "manage") or master access');
-    }
-  });
+        await Dummy.newFromApiEndpoint('uuuu', user.appApiEndpoint, appName);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'Application with "app" type of access requires  (streamId = "uuuu", level = "manage") or master access');
+      }
+    });
 
-  it('[APAD] Application should throw error if personaToken are not explicity allowed', async () => {
-    class Dummy extends Application {
-      get appSettings () {
-        return { };
+    it('[APAD] Application should throw error if personaToken are not explicity allowed', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
       }
-    }
 
-    try {
+      try {
       // eslint-disable-next-line no-new
-      await Dummy.newFromApiEndpoint('uuuu', user.personalApiEndpoint, appName);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'Application should not use a personal token');
-    }
-  });
+        await Dummy.newFromApiEndpoint('uuuu', user.personalApiEndpoint, appName);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'Application should not use a personal token');
+      }
+    });
 
-  it('[APAE] Application should throw error if master token not provided and required', async () => {
-    class Dummy extends Application {
-      get appSettings () {
-        return {
-          mustBemaster: true
-        };
+    it('[APAE] Application should throw error if master token not provided and required', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return {
+            mustBemaster: true
+          };
+        }
       }
-    }
 
-    try {
+      try {
       // eslint-disable-next-line no-new
-      await Dummy.newFromApiEndpoint('uuuu', user.appApiEndpoint, appName);
-      throw new Error('Should throw an error');
-    } catch (e) {
-      assert.equal(e.message, 'Application with "app" type of access requires "master" token (streamId = "*", level = "manage")');
-    }
+        await Dummy.newFromApiEndpoint('uuuu', user.appApiEndpoint, appName);
+        throw new Error('Should throw an error');
+      } catch (e) {
+        assert.equal(e.message, 'Application with "app" type of access requires "master" token (streamId = "*", level = "manage")');
+      }
+    });
   });
 });