redundent class_assignment -> template_name

+ new isEmpty(obj) function

Author: ddooley

lib/AppContext.js

@@ -7,7 +7,7 @@ import {
   Template,
   getTemplatePathInScope,
 } from '../lib/utils/templates';
-import { wait } from '../lib/utils/general';
+import { wait, isEmpty } from '../lib/utils/general';
 import { invert, removeNumericKeys, consolidate } from '../lib/utils/objects';
 import { createDataHarmonizerContainer, createDataHarmonizerTab } from '../web';
 import { getExportFormats } from 'schemas';
@@ -39,7 +39,7 @@ export default class AppContext {
     $(document).on('dhTabChange', (event, data) => {
       console.info(
         'dhTabChange',
-        this.getCurrentDataHarmonizer().class_assignment,
+        this.getCurrentDataHarmonizer().template_name,
         '->',
         data.specName
       );
@@ -278,7 +278,7 @@ export default class AppContext {
             // HoT settings.
             const dh = new DataHarmonizer(dhSubroot, this, {
               loadingScreenRoot: document.body,
-              class_assignment: class_name,
+              template_name: class_name,
               schema: schema, // assign during constructor so validator can init on it.
               hot_override_settings: {
                 minRows: is_child ? 0 : 10,
@@ -291,7 +291,9 @@ export default class AppContext {
             });
 
             data_harmonizers[class_name] = dh;
-            dh.useTemplate(class_name);
+            dh.template = schema.classes[class_name];
+            // Set up the data structure based on LinkML class
+            dh.useTemplate(class_name); 
             dh.validator.useTargetClass(class_name);
 
             if (is_child) {
@@ -354,6 +356,7 @@ export default class AppContext {
         ? this.template.localized.schema
         : this.template.default.schema;
 
+    // FUTURE slot_ptr version of self.context.relations for efficiency?
     this.relations = this.crudGetRelations(schema);
 
     // Merges any existing dataharmonizer instances with the ones newly created.
@@ -409,6 +412,13 @@ export default class AppContext {
           [slot_name]: [foreign_slot_name],
           [slot_name_2]: [foreign_slot_name_2]...
         }
+      },
+      dependent_slots: {
+        [slot_name]: {
+          [foreign_class]: {foreign_slot_name]}...
+      }
+      unique_key_slots: {
+        [slot_name]: {[unique_key_name]:true, ... 
       }
     }
 
@@ -431,15 +441,17 @@ export default class AppContext {
   crudGetRelations(schema) {
     let relations = {};
     Object.entries(schema.classes).forEach(([class_name, class_obj]) => {
+      relations[class_name] = {};
+
       Object.entries(class_obj.attributes ?? {}).forEach(([slot_name, attribute]) => {
         if (attribute.annotations?.foreign_key?.value) {
-
           let foreign_class, foreign_slot_name;
           let key = attribute.annotations.foreign_key.value;
-          // Best syntax is that foreign class is dot prefix:
+          // FIRST, TRY GETTING PARENT CLASS VIA foreign class with dot prefix:
           if (key.includes('.'))
             [foreign_class, foreign_slot_name] = key.split('.',2);
-          // UNTESTED: Workaround is that foreign class is in range of slot:
+          // ALTERNATELY (UNTESTED) USE range of slot having reference to a class:
+          // NOTE: this doesn't handle multiple classes in range.
           else if (attribute.range in schema.classes) {
             foreign_slot_name = key;
             foreign_class = attribute.range;
@@ -448,11 +460,24 @@ export default class AppContext {
             console.log("Class", class_name, "has slot", slot_name, "foreign key", attribute.annotations?.foreign_key?.value, "but no target class information in key or slot range.");
             return;
           }
-          Object.assign(relations, {[class_name]: {parent: {[foreign_class]: {[slot_name]: foreign_slot_name}}}});
-          //And reverse relation
-          Object.assign(relations, {[foreign_class]: {child: {[class_name]: {[foreign_slot_name]: slot_name}}}});
+          Object.assign(relations[class_name],  
+            {parent: {[foreign_class]: {[slot_name]: foreign_slot_name}}});
+          // And reverse relation
+          Object.assign(relations[foreign_class], 
+            {child: {[class_name]: {[foreign_slot_name]: slot_name}}});
+          // And dependent slots
+          Object.assign(relations[class_name], 
+            {dependent_slots: {[slot_name]: {parent: foreign_class, slot: foreign_slot_name}}});
         }
       });
+
+      // Now do unique keys in class_obj
+      Object.entries(class_obj.unique_keys ?? {}).forEach(([key_name, key_obj]) => {
+        Object.entries(key_obj.unique_key_slots ?? {}).forEach(([index, slot_name]) => {
+          Object.assign(relations[class_name], 
+            {unique_key_slots: {[slot_name]: {[key_name]: true}}});
+        });
+      });
     });
     return relations;
   }
@@ -481,27 +506,42 @@ export default class AppContext {
     return this.crudIsAncestor(class_names, ancestor_name)
   }
 
-  /* Retrieves ordered list of tables that ultimately have given template as
+  /** Retrieves ordered list of tables that ultimately have given template as
    * a foreign key.  Whether it is to enact cascading visibility, update or
    * deletion events, this provides the order in which to trigger changes.
    * Issue is that intermediate tables need to be checked in order due to 
    * dependencies by foreign keys. If a table depended on an intermediate that
    * hadn't been refreshed, we'd get a wrong display.
    * Relying on javascript implicit ordering of dictionary added elements.
+   * @param {String} class_names initial value
+   * @param {Array} class_names array of relations
+   * @return {Object} class_names where each descendent class_name is mentioned.
    */
   crudGetDependents(class_names) {
-    // Initialization case
-    if (typeof class_names == "string") {
-      class_names = {...this.crudGetChildren(class_names)};
+    // Initialization case gets single class_name
+    if (class_names && typeof class_names == "string") {
+      class_names = this.crudGetChildren(class_names);
+      console.log("class_names", class_names);
+      if (!class_names)
+        return {};
+    }
+    let children = {};
+    for (const dependent_name in class_names) {
+      children = {...children, ...this.crudGetChildren(dependent_name) }
     }
-    let children = this.crudGetChildren(class_names);
-    if (children) {
-      class_names = {...children};
-      return this.crudGetDependents(class_names);
+    if (children.length >0) {
+      return {...class_names, ...children, ...this.crudGetDependents(children)};
     }
     return class_names;
   }
 
+  crudCheckDependency (self, row, dependent_name, changes) {
+    let keyVals = {};
+    let change_log = '';
+    let found = false;
+    return [found, keyVals, change_log];
+  }
+
   /* For given class, refresh view of all dependent tables that have a direct
    * or indirect foreign key relationship to given class.
    * Performance might show up as an issue later if lots of long dependent
@@ -522,7 +562,10 @@ export default class AppContext {
    * primary key selection has been made! 
    */
   crudFilterByForeignKey(class_name) {
-    const hotInstance = this.dhs[class_name].hot;
+    const hotInstance = this.dhs[class_name]?.hot;
+    // This can happen when one DH is rendered but not other dependents yet.
+    if (!hotInstance) 
+      return;
     const hiddenRowsPlugin = hotInstance.getPlugin('hiddenRows');
 
     // Ensure all rows are visible
@@ -742,4 +785,40 @@ export default class AppContext {
     });
   }
 
+  /** Determine if given dh has a complete set of unique key slot values as 
+   * given by key_name.
+   * @param {Object} dh instance
+   * @param {String} key_name of 
+   * @param {Object} changes for a row with slot_name as key.
+   * @return {Array} of:
+   * @return {Boolean} found boolean true if complete keyVals
+   * @return {Object} keyVals set of slots and their values from template or change
+   * @return {String} change_log report of changed slot values
+   */
+  crudHasUniqueKey(dh, row, key_name, changes, keyVals={}, change_log='') {
+    const key_obj = dh.template.unique_keys[key_name];
+    let found = Object.entries(key_obj.unique_key_slots).every(([index, slot_name]) => {
+      // Key has a changed value (incl. null?), so update it.
+      if (slot_name in changes) {
+        let change = changes[slot_name];
+        change_log += `* [${slot_name}] change to "${change.value}"\n`;
+        keyVals[slot_name] = change.value;
+        return true;
+      }
+      else {
+        let col = dh.getColumnIndexByFieldName(slot_name);
+        let value = dh.hot.getDataAtCell(row, col);
+        if (value != null) {
+          keyVals[key_name] = value;
+          return true;
+        }
+      }
+
+      // Key value hasn't changed, and is missing a value, so 
+      // unique_key is not established, so user's change can go
+      // through.
+      return false;
+    });
+    return [found, keyVals, change_log];
+  }
 }