Introducting HDSItemDef and maps

Author: perki

src/HDSItemDef.js

@@ -0,0 +1,18 @@
+class HDSItemDef {
+  #data;
+
+  constructor (definitionData) {
+    this.#data = definitionData;
+  }
+
+  get types () {
+    if (this.#data.eventType) return [this.#data.eventType];
+    return Object.keys(this.#data.variations.eventType);
+  }
+
+  get data () {
+    return this.#data;
+  }
+}
+
+module.exports = HDSItemDef;

src/HDSModel.js

@@ -1,3 +1,5 @@
+const HDSItemDef = require('./HDSItemDef');
+
 class HDSModel {
   /**
    * JSON definition file
@@ -12,13 +14,26 @@ class HDSModel {
    */
   #modelData;
 
+  /**
+   * ItemDefs Cache
+   * KeyValue of itemsDefs
+   */
+  #itemsDefs;
+
+  /**
+   * get itemsDefs by streamId and eventType
+   */
+  #modelDataByStreamIdEventTypes;
+
   /**
    * JSON definition file
    * Should come from service/info assets.hds-model
    * @type {string}
    */
   constructor (modelUrl) {
     this.#modelUrl = modelUrl;
+    this.#itemsDefs = {};
+    this.#modelDataByStreamIdEventTypes = {};
   }
 
   /**
@@ -28,15 +43,47 @@ class HDSModel {
     const response = await fetch(this.#modelUrl);
     const resultText = await response.text();
     const result = JSON.parse(resultText);
-    this.#modelData = deepFreeze(result);
+    this.#modelData = result;
+    loadModelDataByStreamIdEventTypes(this.#modelData.items, this.#modelDataByStreamIdEventTypes);
+    deepFreeze(this.#modelData); // make sure it cannot be modified
   }
 
   /**
    * get item for a key
    * @param {string} key
+   * @param {boolean} [throwErrorIfNotFound] default `true`
+   */
+  itemDefForKey (key, throwErrorIfNotFound = true) {
+    if (this.#itemsDefs[key]) return this.#itemsDefs[key];
+    const defData = this.#modelData.items[key];
+    if (!defData) {
+      if (throwErrorIfNotFound) throw new Error('Cannot find item definition with key: ' + key);
+      return null;
+    }
+    this.#itemsDefs[key] = new HDSItemDef(defData);
+    return this.#itemsDefs[key];
+  }
+
+  /**
+   * get a definition for an event
+   * @param {Event} event
+   * @param {boolean} [throwErrorIfNotFound] default `true`
    */
-  itemForKey (key) {
-    return this.#modelData.items[key];
+  itemDefForEvent (event, throwErrorIfNotFound = true) {
+    const candidates = [];
+    for (const streamId of event.streamIds) {
+      const keyStreamIdEventType = streamId + ':' + event.type;
+      const candidate = this.#modelDataByStreamIdEventTypes[keyStreamIdEventType];
+      if (candidate) candidates.push(candidate);
+    }
+    if (candidates.length === 0) {
+      if (throwErrorIfNotFound) throw new Error('Cannot find definition for event: ' + JSON.stringify(event));
+      return null;
+    }
+    if (candidates.length > 1) {
+      throw new Error(`Found multiple matching definitions "${candidates.map(c => (c.key)).join(', ')}" for event: ${JSON.stringify(event)}`);
+    }
+    return this.itemDefForKey(candidates[0].key, throwErrorIfNotFound);
   }
 }
 
@@ -62,3 +109,26 @@ function deepFreeze (object) {
 
   return Object.freeze(object);
 }
+
+/**
+ * @private
+ * Add key to model items and
+ * load modeldata item into modelDataByStreamIdEventTypes for fast search
+ */
+function loadModelDataByStreamIdEventTypes (model, map) {
+  for (const [key, item] of Object.entries(model)) {
+    // add key to item
+    item.key = key;
+    const eventTypes = [];
+    if (item.eventType) {
+      eventTypes.push(item.eventType);
+    } else {
+      eventTypes.push(...Object.keys(item.variations.eventType));
+    }
+    for (const eventType of eventTypes) {
+      const keyStreamIdEventType = item.streamId + ':' + eventType;
+      if (map[keyStreamIdEventType]) throw new Error(`Duplicate sreamId + eventType "${keyStreamIdEventType}" for item ${JSON.stringify(item)}`);
+      map[keyStreamIdEventType] = item;
+    }
+  }
+}

tests/hdsModel.test.js

@@ -6,10 +6,53 @@ const modelURL = 'https://model.datasafe.dev/pack.json';
 const { HDSModel } = require('../');
 
 describe('[MODX] Model', () => {
-  it('[MODL] Load model', async () => {
-    const model = new HDSModel(modelURL);
+  let model;
+  before(async () => {
+    model = new HDSModel(modelURL);
     await model.load();
-    const item = model.itemForKey('body-weight');
-    assert.equal(item.streamId, 'body-weight');
+  });
+
+  it('[MODL] Load model', async () => {
+    const modelLoad = new HDSModel(modelURL);
+    await modelLoad.load();
+    const itemDef = modelLoad.itemDefForKey('body-weight');
+    assert.equal(itemDef.data.streamId, 'body-weight');
+    assert.deepEqual(itemDef.types, ['mass/kg', 'mass/lb']);
+  });
+
+  it('[MODS] Get definition from event data', async () => {
+    const fakeEvent = {
+      streamIds: ['body-weight', 'dummy'],
+      type: 'mass/kg'
+    };
+    const itemDef = model.itemDefForEvent(fakeEvent);
+    assert.equal(itemDef.data.streamId, 'body-weight');
+    assert.deepEqual(itemDef.types, ['mass/kg', 'mass/lb']);
+  });
+
+  it('[MOEN] Throw error if itemDefForEvent not found', async () => {
+    const fakeEvent = {
+      streamIds: ['dummy'],
+      type: 'mass/kg'
+    };
+    try {
+      model.itemDefForEvent(fakeEvent);
+      throw new Error('Should throw Error');
+    } catch (e) {
+      assert.equal(e.message, 'Cannot find definition for event: {"streamIds":["dummy"],"type":"mass/kg"}');
+    }
+  });
+
+  it('[MOED] Throw error if itemDefForEvent finds duplicates', async () => {
+    const fakeEvent = {
+      streamIds: ['body-vulva-wetness-feeling', 'body-vulva-mucus-stretch'],
+      type: 'ratio/generic'
+    };
+    try {
+      model.itemDefForEvent(fakeEvent);
+      throw new Error('Should throw Error');
+    } catch (e) {
+      assert.equal(e.message, 'Found multiple matching definitions "body-vulva-wetness-feeling, body-vulva-mucus-stretch" for event: {"streamIds":["body-vulva-wetness-feeling","body-vulva-mucus-stretch"],"type":"ratio/generic"}');
+    }
   });
 });