testing code for this.relations

simpler version of this.schema_tree

Author: ddooley

lib/AppContext.js

@@ -155,6 +155,7 @@ function updateWithChildrenAndSharedKeys(data) {
  * Builds a schema tree from the given schema.
  * @param {Object} schema - The schema object containing "classes".
  * @returns {Object|null} The schema tree object, or null if no "Container" classes are found.
+
  */
 function buildSchemaTree(schema) {
 
@@ -424,26 +425,26 @@ export default class AppContext {
    * @param {Object} schema_tree - The schema tree from which to create Data Harmonizers.
    * @returns {Object} An object mapping the class names to their respective Data Harmonizer objects.
    */
-  makeDataHarmonizersFromSchemaTree(schema, template_name) {
+  makeDHsFromSchemaTree(schema, template_name) {
     let data_harmonizers = {};
-    const template = this.appConfig.template_path.split('/')[1];
-
-    console.log("SCHEMA TREE", this.schema_tree)
+    //const template_name = this.appConfig.template_path.split('/')[1];
 
-    Object.entries(this.schema_tree)
+    Object.entries(schema.classes)
       // Container class is only used in input and output file coordination.
-      .filter(([class_name]) => class_name !== 'Container')
-      // FOR NOW: 1-many involves getting all children of selected template too.
-      //.filter(([class_name]) => class_name === template)
-
+      .filter(([class_name]) => 
+        // If given template_name found, build it
+        class_name == template_name
+        // Or given class is a child of template
+        || this.relations[class_name]?.parent?.[template_name]
+        // Or given class is a child of child of template etc.
+        // ...
+      )
       .forEach((obj, index) => {
         if (obj.length > 0) {
           const [class_name, tree_obj] = obj;
 
           // if it shares a key with another class which is its parent, this DH must be a child
-          const is_child = tree_obj.shared_keys.some(
-            (shared_key_spec) => shared_key_spec.relation === 'parent'
-          );
+          const is_child = this.relations?.[class_name]?.parent;
 
           // Doesn't build if tab id already exists.
           const dhId = `data-harmonizer-grid-${index}`;
@@ -479,7 +480,6 @@ export default class AppContext {
             dh.useTemplate(class_name);
             dh.validator.useTargetClass(class_name);
 
-
             // Initialization of each child table is to hide all rows until
             // parent primary key record is selected as a foreign key index.
             if (is_child) {
@@ -506,45 +506,47 @@ export default class AppContext {
     // the existence of a container class signifies a 1-M data loading setup with an ID join
     /* e.g.
  
-    const container = {
-      "Container": {
-        "name": "Container",
-        "from_schema": "https://example.com/GRDI",
-        "attributes": {
-          "GRDISamples": {
-            "name": "GRDISamples",
-            "from_schema": "https://example.com/GRDI",
-            "multivalued": true,
-            "alias": "GRDI_samples",
-            "owner": "Container",
-            "domain_of": [
-              "Container"
-            ],
-            "range": "GRDISample",
-            "inlined_as_list": true
-          },
-          "AMRTests": {
-            "name": "AMRTests",
-            "from_schema": "https://example.com/GRDI",
-            "multivalued": true,
-            "alias": "AMR_Tests",
-            "owner": "Container",
-            "domain_of": [
-              "Container"initializeTemplate
-            ],
-            "range": "AMRTest",
-            "inlined_as_list": true
-          }
-        },
-        "tree_root": true
-      }
-    }
- 
+ Each class has one or more slots (attributes) which contain foreign_keys which 
+ determine parent-child relationships.
+
+
     const schema_tree = {
       "Container": { tree_root: true, children: ["AMRTest", "GRDISample"] }
       "GRDISample": { shared_key: ["sample_collector_sample_ID"], children: ["AMRTest"] }
       "AMRTest": { shared_key: ["sample_collector_sample_ID"], children: [] },
     }
+
+ "attributes": {
+        "sample_collector_sample_id": {
+          "name": "sample_collector_sample_id",
+          "annotations": {
+            "required": {
+              "tag": "required",
+              "value": true
+            },
+            "foreign_key": {
+              "tag": "foreign_key",
+              "value": "GRDISample.sample_collector_sample_id"
+            }
+          },
+          "range": 
+
+  relations: {
+    [class_name]: {
+      slots: {[slot_name]: {parent: [table_name], slot: [slot_name]}}
+
+      parents: {
+        [key_name]: {
+          slot: ___ , 
+          parent: ___
+        }, ...
+      }
+      dependents: {
+        [child_name]: {slot1, slot2 ...}
+      }
+    }
+  }
+
  
     */
   async setupDataHarmonizers({
@@ -571,14 +573,31 @@ export default class AppContext {
         ? this.template.localized.schema
         : this.template.default.schema;
 
+    this.relations = {};
+     //[class_name]: { slots: {[slot_name]: {parent: [table_name], slot: [slot_name]}}
+    Object.entries(schema.classes).forEach(([class_name, class_obj]) => {
+      Object.entries(class_obj.attributes ?? {}).forEach(([slot_name, attribute]) => {
+        if (attribute.annotations?.foreign_key?.value) {
+          let [foreign_class, foreign_slot_name] = attribute.annotations.foreign_key.value.split('.',2);
+          //Object.assign(this.relations, {[class_name]: {[slot_name]: {parent: foreign_class, slot: foreign_slot_name}}});
+          Object.assign(this.relations, {[class_name]: {parent: {[foreign_class]: {[slot_name]: foreign_slot_name}}}});
+          //And reverse relation
+          Object.assign(this.relations, {[foreign_class]: {child: {[class_name]: {[foreign_slot_name]: slot_name}}}});
+        }
+      })
+    });
+
+    console.log("RELATIONS", this.relations);
+
     this.schema_tree = buildSchemaTree(schema);
+    console.log("SCHEMA TREE", this.schema_tree)
 
-    let dhs = {
+    // Merges any existing dataharmonizer instances with the ones newly created.
+    this.dhs = {
       ...data_harmonizers,
-      ...this.makeDataHarmonizersFromSchemaTree(schema, template_name),
+      ...this.makeDHsFromSchemaTree(schema, template_name),
     };
 
-    this.dhs = dhs;
     // NOTE: Assumes that first dataharmonizer is starting point.
     this.setCurrentDataHarmonizer(Object.keys(this.dhs)[0]);
 

lib/DataHarmonizer.js

@@ -476,6 +476,10 @@ class DataHarmonizer {
         Object.assign(new_field, this.field_settings[name]);
       }
 
+      if (field.annotations) {
+        new_field.annotations = field.annotations;
+      }
+
       section.children.push(new_field);
     } // End slot processing loop