convention_builder 1.4.1 → 1.4.3

package/dist/module/index.js

@@ -8434,10 +8434,15 @@ var require_schema_utilities = __commonJS({
         Object.assign(sharedObjectSection, acum);
       } else {
         chunks = partialPath.split(/\.|\[|\]/).filter((d) => d.length !== 0);
-        let lastAttr = chunks[chunks.length - 1];
-        let remainingPath = path.replace(new RegExp(lastAttr.concat("$")), "").replace(/\.$/, "");
-        let sharedObjectSection = dig(targetObject, remainingPath);
-        sharedObjectSection[lastAttr] = value;
+        let lastAttr = chunks.length == 0 ? chunks[0] : chunks[chunks.length - 1];
+        if (lastAttr) {
+          let remainingPath = path.replace(new RegExp(lastAttr.concat("$")), "").replace(/\.$/, "");
+          let sharedObjectSection = dig(targetObject, remainingPath);
+          sharedObjectSection[lastAttr] = value;
+        } else {
+          targetObject[path] = value;
+        }
+        ;
       }
       ;
       return targetObject;
@@ -8483,7 +8488,6 @@ var require_schema_utilities = __commonJS({
           fs.mkdirSync(`${targetFolder}/${typeKey}/${bundleKey}/`, { recursive: true }, console.error);
           let path = `${targetFolder}/${typeKey}/${bundleKey}/schema.json`;
           fs.writeFileSync(path, JSON.stringify(schema, null, " "));
-          console.log(`writing ${typeKey}--${bundleKey}`);
         });
       });
     }
@@ -8539,7 +8543,6 @@ var require_schema_utilities = __commonJS({
         return files;
       }).filter((filename) => !/\./.test(filename));
       conventions.forEach((conventionName) => {
-        console.log(`Working on ${conventionName}`);
         try {
           let schema = JSON.parse(fs.readFileSync(`${conventionsFolder}/${conventionName}/schema.json`));
           schemasArgument.schemas.push(schema);
@@ -8774,8 +8777,52 @@ var require_schema_utilities = __commonJS({
     function organizeEntitiesArrayByRelationships({ entitiesArray, conventionObject }) {
       let attributesTree = conventionObject.getAttributesTree();
       let mainAttribute = Object.keys(attributesTree);
+      return {
+        tree: attributesTree
+      };
     }
     __name(organizeEntitiesArrayByRelationships, "organizeEntitiesArrayByRelationships");
+    function arrayToStructuredConvention({ entitiesArray, conventionObject }) {
+      let entities = entitiesArray.map((entity) => {
+        let validations = Object.keys(conventionObject.overlays).map((key) => {
+          var _a;
+          conventionObject.overlays[key].validate(entity);
+          let errors = (_a = conventionObject.overlays[key].validate.errors) == null ? void 0 : _a.filter((d) => !/relationships/.test(d.instancePath));
+          return { overlay: key, errors: errors ? errors : [] };
+        });
+        let passedTests = validations.filter((d) => d.errors.length == 0);
+        let amountPassed = passedTests.length;
+        let output2 = {
+          passedTests,
+          possibleOverlays: passedTests ? passedTests.map((d) => d.overlay) : void 0,
+          allTests: validations,
+          amountPassed,
+          entity
+        };
+        return output2;
+      });
+      let output = {
+        identifiedEntities: entities.filter((d) => d.amountPassed == 1),
+        unrecognizedEntities: entities.filter((d) => d.amountPassed == 0),
+        ambiguousEntities: entities.filter((d) => d.amountPassed > 1)
+      };
+      let assembledEntity = {
+        id: randomUUID(),
+        type: "object"
+      };
+      entities.filter((d) => d.possibleOverlays.length == 1).forEach((entityObj) => {
+        assembledEntity[entityObj.possibleOverlays[0]] = entityObj.entity;
+      });
+      let assembledValidation = conventionObject.validate(assembledEntity);
+      if (conventionObject.validate.errors) {
+        output.errors = conventionObject.validate.errors;
+      }
+      ;
+      output.is_valid = assembledValidation;
+      output.assembled_entity = assembledEntity;
+      return output;
+    }
+    __name(arrayToStructuredConvention, "arrayToStructuredConvention");
     function trimNonRequiredFields(schema, attribute = false) {
       let data;
       if (attribute) {
@@ -8934,7 +8981,14 @@ var require_schema_utilities = __commonJS({
           let schema = schemataTree[typeKey][bundleKey];
           let topLevelAttributes = new Set(Object.keys(schema.properties.attributes.properties));
           let objectTypeAttributes = Array.from(topLevelAttributes).filter((attr) => schema.properties.attributes.properties[attr].type == "object");
-          objectTypeAttributes.forEach((attr) => {
+          objectTypeAttributes.flatMap((objAttr) => {
+            let output2 = [];
+            let subAttrs = Object.keys(schema.properties.attributes.properties[objAttr].properties);
+            subAttrs.forEach((subAttr) => {
+              output2.push(`${objAttr}.properties.${subAttr}`);
+            });
+            return output2;
+          }).forEach((attr) => {
             let entry = output.find((attrDescription) => attrDescription.attribute == attr);
             if (entry) {
               entry.instances.push(
@@ -8962,6 +9016,42 @@ var require_schema_utilities = __commonJS({
       return output;
     }
     __name(findAllObjectAttributesInTree, "findAllObjectAttributesInTree");
+    function findAllNonObjectAttributesInTree(schemataTree) {
+      let output = [];
+      Object.keys(schemataTree).forEach((typeKey) => {
+        Object.keys(schemataTree[typeKey]).forEach((bundleKey) => {
+          let schema = schemataTree[typeKey][bundleKey];
+          let topLevelAttributes = new Set(Object.keys(schema.properties.attributes.properties));
+          let objectTypeAttributes = Array.from(topLevelAttributes).filter((attr) => schema.properties.attributes.properties[attr].type == "object");
+          let otherAttributes = Array.from(topLevelAttributes).filter((attr) => !objectTypeAttributes.includes(attr));
+          otherAttributes.forEach((attr) => {
+            let entry = output.find((attrDescription) => attrDescription.attribute == attr);
+            if (entry) {
+              entry.instances.push(
+                {
+                  type: typeKey,
+                  bundle: bundleKey,
+                  schema: `${typeKey}--${bundleKey}`
+                }
+              );
+            } else {
+              output.push({
+                attribute: attr,
+                instances: [
+                  {
+                    type: typeKey,
+                    bundle: bundleKey,
+                    schema: `${typeKey}--${bundleKey}`
+                  }
+                ]
+              });
+            }
+          });
+        });
+      });
+      return output;
+    }
+    __name(findAllNonObjectAttributesInTree, "findAllNonObjectAttributesInTree");
     exports.dig = dig;
     exports.bury = bury;
     exports.fixRelationshipDataField = fixRelationshipDataField;
@@ -8976,12 +9066,14 @@ var require_schema_utilities = __commonJS({
     exports.findMissingEntitiesInExample = findMissingEntitiesInExample;
     exports.organizeEntitiesArrayIntoConvention = organizeEntitiesArrayIntoConvention;
     exports.organizeEntitiesArrayByRelationships = organizeEntitiesArrayByRelationships;
+    exports.arrayToStructuredConvention = arrayToStructuredConvention;
     exports.trimNonRequiredFields = trimNonRequiredFields;
     exports.reduceSchemaToRequiredFields = reduceSchemaToRequiredFields;
     exports.flattenObjectBranch = flattenObjectBranch;
     exports.flattenJSONSchema = flattenJSONSchema;
     exports.listAttributesAndSubAttributes = listAttributesAndSubAttributes;
     exports.findAllObjectAttributesInTree = findAllObjectAttributesInTree;
+    exports.findAllNonObjectAttributesInTree = findAllNonObjectAttributesInTree;
   }
 });
 
@@ -8989,7 +9081,15 @@ var require_schema_utilities = __commonJS({
 var require_convention_builder = __commonJS({
   "src/convention_builder.js"(exports) {
     var fs = __require("fs");
-    var { buildValidator, urlToStringPair, dig, bury, listAttributesAndSubAttributes } = require_schema_utilities();
+    var {
+      buildValidator,
+      urlToStringPair,
+      dig,
+      bury,
+      listAttributesAndSubAttributes,
+      findAllObjectAttributesInTree,
+      findAllNonObjectAttributesInTree
+    } = require_schema_utilities();
     function getAttributes(root, convention) {
       let branches = convention.relationships.filter((rel) => rel.containerEntity == root).map((d) => d.mentionedEntity);
       let output = {};
@@ -9010,7 +9110,8 @@ var require_convention_builder = __commonJS({
         originalSrcScript,
         trivial = false,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
-        requiredFields = []
+        requiredFields = [],
+        modifiedAttributes
       }) {
         this.name = name;
         this.typeAndBundle = typeAndBundle;
@@ -9045,7 +9146,7 @@ var require_convention_builder = __commonJS({
         ;
         this.baseSchema = baseSchema;
         this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
-        this.modifiedAttributes = /* @__PURE__ */ new Set([]);
+        this.modifiedAttributes = modifiedAttributes ? modifiedAttributes : /* @__PURE__ */ new Set([]);
         if (!overlay) {
           this.overlay = {
             properties: {
@@ -9061,11 +9162,17 @@ var require_convention_builder = __commonJS({
         this.schema = baseSchema;
         let validatorObj = buildValidator();
         this.validate = validatorObj.compile(this.schema);
-        this.updateSchema();
       }
       storagePath() {
         return `${this.storageFolder}`;
       }
+      /**
+       * Given an attribute path (such as "attributes.properties.geometry.properties.value"), it will set is as required in the adequate containing attribute (for this example, "attributes.properties.geometry.required").
+       * @param {string} path -- Attribute path.
+       * @returns {} 
+       */
+      requireFieldByPath(path) {
+      }
       /**
        * User input only works over the overlay, the schema should always be the direct result of applying the overlay over the baseSchema.
        */
@@ -9075,9 +9182,11 @@ var require_convention_builder = __commonJS({
         Object.assign(this.schema, this.baseSchema);
         let allModifiedAttributes = listAttributesAndSubAttributes(this.overlay);
         this.modifiedAttributes = allModifiedAttributes;
+        this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
+        this.modifiedAttributes.forEach((attr) => this.updateAttributeStatus(attr));
         Array.from(this.modifiedAttributes).forEach((attr) => {
           let currentValue = dig(this.overlay.properties.attributes.properties, attr);
-          bury(this.schema, `properties.attributes.properties.${attr}`, currentValue, true);
+          bury(this.schema, `properties.attributes.properties.${attr}`, currentValue, false);
         });
         let originalRequiredFields = this.schema.properties.attributes.required ? this.schema.properties.attributes.required : [];
         let allRequiredSet = Array.from(/* @__PURE__ */ new Set([...originalRequiredFields, ...Array.from(this.requiredFields)]));
@@ -9119,12 +9228,18 @@ var require_convention_builder = __commonJS({
         this.requiredFields.add(attribute);
         this.updateSchema();
       }
-      setGenericSection({ attribute, section, description }) {
+      /**
+       * The section body "section" will replace the previous schema content in full.
+       * @param {} attribute
+       * @param {} section
+       * @param {} description
+       */
+      setGenericSection({ attribute, section, description, merge = true }) {
         this.checkAttributeStatus(attribute);
-        bury(this.overlay.properties.attributes.properties, attribute, section, true);
+        bury(this.overlay.properties.attributes.properties, attribute, section, merge);
         if (attribute.match(/\./)) {
           let firstLevel = attribute.split(/\./)[0];
-          this.overlay.properties.attributes.properties[firstLevel].type = "object";
+          bury(this.overlay.properties.attributes.properties, `${firstLevel}.type`, "object", merge);
         }
         ;
         if (description) {
@@ -9261,6 +9376,42 @@ var require_convention_builder = __commonJS({
     };
     __name(_SchemaOverlay, "SchemaOverlay");
     var SchemaOverlay = _SchemaOverlay;
+    var _AttributePatchingSchemaOverlay = class _AttributePatchingSchemaOverlay extends SchemaOverlay {
+      constructor({
+        typeAndBundle,
+        attributeOverlayName,
+        repoURL,
+        strictEnums = true,
+        baseSchemataFolder = `${__dirname}/../../../../input/collection`
+      }) {
+        super({
+          typeAndBundle,
+          repoURL,
+          storageFolder: baseSchemataFolder,
+          baseSchemataFolder,
+          strictEnums
+        });
+        this.attributeOverlayName = attributeOverlayName;
+      }
+      store() {
+        this.updateSchema();
+        if (this.schema.appliedOverlays) {
+          this.schema.appliedOverlays.push(this.attributeOverlayName);
+        } else {
+          this.schema.appliedOverlays = [this.attributeOverlayName];
+        }
+        ;
+        let targetPath = `${this.storagePath()}/${this.typeAndBundle.split("--")[0]}/${this.typeAndBundle.split("--")[1]}/schema.json`;
+        fs.writeFileSync(targetPath, JSON.stringify(this.schema, null, " "), console.error);
+        let output = {
+          path: targetPath,
+          test: false
+        };
+        return output;
+      }
+    };
+    __name(_AttributePatchingSchemaOverlay, "AttributePatchingSchemaOverlay");
+    var AttributePatchingSchemaOverlay = _AttributePatchingSchemaOverlay;
     var _ConventionSchema = class _ConventionSchema {
       constructor({
         title,
@@ -9296,7 +9447,10 @@ var require_convention_builder = __commonJS({
         if (overlays) {
           let overlayNames = Object.keys(overlays);
           this.overlays = {};
-          overlayNames.forEach((ovrl) => this.overlays[ovrl] = new SchemaOverlay(overlays[ovrl]));
+          overlayNames.forEach((ovrl) => {
+            this.overlays[ovrl] = new SchemaOverlay(overlays[ovrl]);
+            this.overlays[ovrl].updateSchema();
+          });
         }
         ;
         if (relationships) {
@@ -9372,6 +9526,7 @@ var require_convention_builder = __commonJS({
           required: this.required
         };
         Object.keys(this.overlays).forEach((attributeName) => {
+          this.overlays[attributeName].updateSchema();
           this.schema.properties[attributeName] = this.overlays[attributeName].schema;
           delete this.schema.properties[attributeName].$id;
           if (!this.overlays[attributeName].originalSrcScript) {
@@ -9705,17 +9860,121 @@ import TabItem from '@theme/TabItem';
     };
     __name(_ConventionSchema, "ConventionSchema");
     var ConventionSchema = _ConventionSchema;
+    var _AttributeOverlay = class _AttributeOverlay {
+      constructor({
+        type,
+        bundle,
+        attribute,
+        baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        sourceSchemataFile = `${__dirname}/../../../../input/farmos.json`,
+        overlayName,
+        overlayDescription
+      }) {
+        let integralSchemataFile = JSON.parse(fs.readFileSync(sourceSchemataFile));
+        this.type = type;
+        this.bundle = bundle;
+        this.overlayName = overlayName;
+        this.overlayDescription = overlayDescription;
+        this.attribute = attribute;
+        this.sourceSchemata = integralSchemataFile;
+        this.lexicon = [...findAllObjectAttributesInTree(this.sourceSchemata), ...findAllNonObjectAttributesInTree(this.sourceSchemata)];
+        this.baseSchemataFolder = baseSchemataFolder;
+        let involvedSchemata = this.lexicon.filter((entry) => this.attribute == entry.attribute).flatMap((entry) => entry.instances).filter((instance) => this.type ? instance.type == this.type : true).filter((instance) => this.bundle ? instance.bundle == this.bundle : true).map((d) => d.schema);
+        this.targetSchemata = Array.from(new Set(involvedSchemata));
+        this.overlays = [];
+        this.targetSchemata.forEach((target) => {
+          let currentOverlay = new AttributePatchingSchemaOverlay({
+            typeAndBundle: target,
+            attributeOverlayName: this.overlayName,
+            baseSchemataFolder: this.baseSchemataFolder
+          });
+          this.overlays.push(currentOverlay);
+        });
+      }
+      setRequire() {
+        this.overlays.forEach((overlay) => {
+          overlay.setRequiredAttribute(this.attribute);
+        });
+      }
+      setGenericSection({
+        section,
+        description
+      }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setGenericSection({
+            attribute: this.attribute,
+            section,
+            description,
+            merge: false
+          });
+        });
+      }
+      setPattern({ pattern, string, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setPattern({
+            attribute: this.attribute,
+            pattern,
+            string,
+            description
+          });
+        });
+      }
+      /**
+       * An all involved schemata, sets the target attribute for this overlay as a constant as indicated by the given value.
+       * @param {any} value -- The constant, which should be of the type allowed by the base schema for the attribute.
+       * @param {string} description -- Describes the rationale behind the chosing of the value.
+       */
+      setConstant({ value, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setConstant({
+            attribute: this.attribute,
+            value,
+            description
+          });
+        });
+      }
+      /**
+       * Sets this overlay's target attribute as a constrained to a list of possible values in all involved schemata.
+       * @param {string} attribute -- Attribute name for the attribute which will be set to a constant.
+       * @param {any[]} valuesArray -- The array of possible values, which should be of the type allowed by the base schema for the attribute.
+       * @param {string} description -- Describes the rationale behind the chosing of the value.
+       */
+      setEnum({ valuesArray, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setConstant({
+            attribute: this.attribute,
+            valuesArray,
+            description
+          });
+        });
+      }
+      /**
+       * Stores all involved schemas into the folder structure for `base schemata` (provided as the parameter `baseSchemataFolder`) which will be consumed by our conventions later.
+       * @returns {} -- It returns objects containing all paths.
+       */
+      store() {
+        let output = this.overlays.map((overlay) => {
+          let operation = overlay.store();
+          return operation;
+        });
+        return output;
+      }
+    };
+    __name(_AttributeOverlay, "AttributeOverlay");
+    var AttributeOverlay = _AttributeOverlay;
     exports.SchemaOverlay = SchemaOverlay;
     exports.ConventionSchema = ConventionSchema;
+    exports.AttributeOverlay = AttributeOverlay;
   }
 });
 
 // src/index.js
 var require_src = __commonJS({
   "src/index.js"(exports) {
-    var { SchemaOverlay, ConventionSchema } = require_convention_builder();
+    var { SchemaOverlay, ConventionSchema, AttributeOverlay } = require_convention_builder();
     var schemaUtils = require_schema_utilities();
     exports.SchemaOverlay = SchemaOverlay;
+    exports.AttributeOverlay = AttributeOverlay;
     exports.ConventionSchema = ConventionSchema;
     exports.fixRelationshipDataField = schemaUtils.fixRelationshipDataField;
     exports.buildValidator = schemaUtils.buildValidator;
@@ -9728,7 +9987,7 @@ var require_src = __commonJS({
     exports.exampleImporter = schemaUtils.exampleImporter;
     exports.findMissingEntitiesInExample = schemaUtils.findMissingEntitiesInExample;
     exports.organizeEntitiesArrayIntoConvention = schemaUtils.organizeEntitiesArrayIntoConvention;
-    exports.organizeEntitiesArrayByRelationships = schemaUtils.organizeEntitiesArrayByRelationships;
+    exports.arrayToStructuredConvention = schemaUtils.arrayToStructuredConvention;
     exports.trimNonRequiredFields = schemaUtils.trimNonRequiredFields;
     exports.reduceSchemaToRequiredFields = schemaUtils.reduceSchemaToRequiredFields;
     exports.flattenJSONSchema = schemaUtils.flattenJSONSchema;

package/dist/node/index.js

@@ -8427,10 +8427,15 @@ var require_schema_utilities = __commonJS({
         Object.assign(sharedObjectSection, acum);
       } else {
         chunks = partialPath.split(/\.|\[|\]/).filter((d) => d.length !== 0);
-        let lastAttr = chunks[chunks.length - 1];
-        let remainingPath = path.replace(new RegExp(lastAttr.concat("$")), "").replace(/\.$/, "");
-        let sharedObjectSection = dig(targetObject, remainingPath);
-        sharedObjectSection[lastAttr] = value;
+        let lastAttr = chunks.length == 0 ? chunks[0] : chunks[chunks.length - 1];
+        if (lastAttr) {
+          let remainingPath = path.replace(new RegExp(lastAttr.concat("$")), "").replace(/\.$/, "");
+          let sharedObjectSection = dig(targetObject, remainingPath);
+          sharedObjectSection[lastAttr] = value;
+        } else {
+          targetObject[path] = value;
+        }
+        ;
       }
       ;
       return targetObject;
@@ -8476,7 +8481,6 @@ var require_schema_utilities = __commonJS({
           fs.mkdirSync(`${targetFolder}/${typeKey}/${bundleKey}/`, { recursive: true }, console.error);
           let path = `${targetFolder}/${typeKey}/${bundleKey}/schema.json`;
           fs.writeFileSync(path, JSON.stringify(schema, null, " "));
-          console.log(`writing ${typeKey}--${bundleKey}`);
         });
       });
     }
@@ -8532,7 +8536,6 @@ var require_schema_utilities = __commonJS({
         return files;
       }).filter((filename) => !/\./.test(filename));
       conventions.forEach((conventionName) => {
-        console.log(`Working on ${conventionName}`);
         try {
           let schema = JSON.parse(fs.readFileSync(`${conventionsFolder}/${conventionName}/schema.json`));
           schemasArgument.schemas.push(schema);
@@ -8767,8 +8770,52 @@ var require_schema_utilities = __commonJS({
     function organizeEntitiesArrayByRelationships({ entitiesArray, conventionObject }) {
       let attributesTree = conventionObject.getAttributesTree();
       let mainAttribute = Object.keys(attributesTree);
+      return {
+        tree: attributesTree
+      };
     }
     __name(organizeEntitiesArrayByRelationships, "organizeEntitiesArrayByRelationships");
+    function arrayToStructuredConvention({ entitiesArray, conventionObject }) {
+      let entities = entitiesArray.map((entity) => {
+        let validations = Object.keys(conventionObject.overlays).map((key) => {
+          var _a;
+          conventionObject.overlays[key].validate(entity);
+          let errors = (_a = conventionObject.overlays[key].validate.errors) == null ? void 0 : _a.filter((d) => !/relationships/.test(d.instancePath));
+          return { overlay: key, errors: errors ? errors : [] };
+        });
+        let passedTests = validations.filter((d) => d.errors.length == 0);
+        let amountPassed = passedTests.length;
+        let output2 = {
+          passedTests,
+          possibleOverlays: passedTests ? passedTests.map((d) => d.overlay) : void 0,
+          allTests: validations,
+          amountPassed,
+          entity
+        };
+        return output2;
+      });
+      let output = {
+        identifiedEntities: entities.filter((d) => d.amountPassed == 1),
+        unrecognizedEntities: entities.filter((d) => d.amountPassed == 0),
+        ambiguousEntities: entities.filter((d) => d.amountPassed > 1)
+      };
+      let assembledEntity = {
+        id: randomUUID(),
+        type: "object"
+      };
+      entities.filter((d) => d.possibleOverlays.length == 1).forEach((entityObj) => {
+        assembledEntity[entityObj.possibleOverlays[0]] = entityObj.entity;
+      });
+      let assembledValidation = conventionObject.validate(assembledEntity);
+      if (conventionObject.validate.errors) {
+        output.errors = conventionObject.validate.errors;
+      }
+      ;
+      output.is_valid = assembledValidation;
+      output.assembled_entity = assembledEntity;
+      return output;
+    }
+    __name(arrayToStructuredConvention, "arrayToStructuredConvention");
     function trimNonRequiredFields(schema, attribute = false) {
       let data;
       if (attribute) {
@@ -8927,7 +8974,14 @@ var require_schema_utilities = __commonJS({
           let schema = schemataTree[typeKey][bundleKey];
           let topLevelAttributes = new Set(Object.keys(schema.properties.attributes.properties));
           let objectTypeAttributes = Array.from(topLevelAttributes).filter((attr) => schema.properties.attributes.properties[attr].type == "object");
-          objectTypeAttributes.forEach((attr) => {
+          objectTypeAttributes.flatMap((objAttr) => {
+            let output2 = [];
+            let subAttrs = Object.keys(schema.properties.attributes.properties[objAttr].properties);
+            subAttrs.forEach((subAttr) => {
+              output2.push(`${objAttr}.properties.${subAttr}`);
+            });
+            return output2;
+          }).forEach((attr) => {
             let entry = output.find((attrDescription) => attrDescription.attribute == attr);
             if (entry) {
               entry.instances.push(
@@ -8955,6 +9009,42 @@ var require_schema_utilities = __commonJS({
       return output;
     }
     __name(findAllObjectAttributesInTree, "findAllObjectAttributesInTree");
+    function findAllNonObjectAttributesInTree(schemataTree) {
+      let output = [];
+      Object.keys(schemataTree).forEach((typeKey) => {
+        Object.keys(schemataTree[typeKey]).forEach((bundleKey) => {
+          let schema = schemataTree[typeKey][bundleKey];
+          let topLevelAttributes = new Set(Object.keys(schema.properties.attributes.properties));
+          let objectTypeAttributes = Array.from(topLevelAttributes).filter((attr) => schema.properties.attributes.properties[attr].type == "object");
+          let otherAttributes = Array.from(topLevelAttributes).filter((attr) => !objectTypeAttributes.includes(attr));
+          otherAttributes.forEach((attr) => {
+            let entry = output.find((attrDescription) => attrDescription.attribute == attr);
+            if (entry) {
+              entry.instances.push(
+                {
+                  type: typeKey,
+                  bundle: bundleKey,
+                  schema: `${typeKey}--${bundleKey}`
+                }
+              );
+            } else {
+              output.push({
+                attribute: attr,
+                instances: [
+                  {
+                    type: typeKey,
+                    bundle: bundleKey,
+                    schema: `${typeKey}--${bundleKey}`
+                  }
+                ]
+              });
+            }
+          });
+        });
+      });
+      return output;
+    }
+    __name(findAllNonObjectAttributesInTree, "findAllNonObjectAttributesInTree");
     exports2.dig = dig;
     exports2.bury = bury;
     exports2.fixRelationshipDataField = fixRelationshipDataField;
@@ -8969,12 +9059,14 @@ var require_schema_utilities = __commonJS({
     exports2.findMissingEntitiesInExample = findMissingEntitiesInExample;
     exports2.organizeEntitiesArrayIntoConvention = organizeEntitiesArrayIntoConvention;
     exports2.organizeEntitiesArrayByRelationships = organizeEntitiesArrayByRelationships;
+    exports2.arrayToStructuredConvention = arrayToStructuredConvention;
     exports2.trimNonRequiredFields = trimNonRequiredFields;
     exports2.reduceSchemaToRequiredFields = reduceSchemaToRequiredFields;
     exports2.flattenObjectBranch = flattenObjectBranch;
     exports2.flattenJSONSchema = flattenJSONSchema;
     exports2.listAttributesAndSubAttributes = listAttributesAndSubAttributes;
     exports2.findAllObjectAttributesInTree = findAllObjectAttributesInTree;
+    exports2.findAllNonObjectAttributesInTree = findAllNonObjectAttributesInTree;
   }
 });
 
@@ -8982,7 +9074,15 @@ var require_schema_utilities = __commonJS({
 var require_convention_builder = __commonJS({
   "src/convention_builder.js"(exports2) {
     var fs = require("fs");
-    var { buildValidator, urlToStringPair, dig, bury, listAttributesAndSubAttributes } = require_schema_utilities();
+    var {
+      buildValidator,
+      urlToStringPair,
+      dig,
+      bury,
+      listAttributesAndSubAttributes,
+      findAllObjectAttributesInTree,
+      findAllNonObjectAttributesInTree
+    } = require_schema_utilities();
     function getAttributes(root, convention) {
       let branches = convention.relationships.filter((rel) => rel.containerEntity == root).map((d) => d.mentionedEntity);
       let output = {};
@@ -9003,7 +9103,8 @@ var require_convention_builder = __commonJS({
         originalSrcScript,
         trivial = false,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
-        requiredFields = []
+        requiredFields = [],
+        modifiedAttributes
       }) {
         this.name = name;
         this.typeAndBundle = typeAndBundle;
@@ -9038,7 +9139,7 @@ var require_convention_builder = __commonJS({
         ;
         this.baseSchema = baseSchema;
         this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
-        this.modifiedAttributes = /* @__PURE__ */ new Set([]);
+        this.modifiedAttributes = modifiedAttributes ? modifiedAttributes : /* @__PURE__ */ new Set([]);
         if (!overlay) {
           this.overlay = {
             properties: {
@@ -9054,11 +9155,17 @@ var require_convention_builder = __commonJS({
         this.schema = baseSchema;
         let validatorObj = buildValidator();
         this.validate = validatorObj.compile(this.schema);
-        this.updateSchema();
       }
       storagePath() {
         return `${this.storageFolder}`;
       }
+      /**
+       * Given an attribute path (such as "attributes.properties.geometry.properties.value"), it will set is as required in the adequate containing attribute (for this example, "attributes.properties.geometry.required").
+       * @param {string} path -- Attribute path.
+       * @returns {} 
+       */
+      requireFieldByPath(path) {
+      }
       /**
        * User input only works over the overlay, the schema should always be the direct result of applying the overlay over the baseSchema.
        */
@@ -9068,9 +9175,11 @@ var require_convention_builder = __commonJS({
         Object.assign(this.schema, this.baseSchema);
         let allModifiedAttributes = listAttributesAndSubAttributes(this.overlay);
         this.modifiedAttributes = allModifiedAttributes;
+        this.unmodifiedAttributes = listAttributesAndSubAttributes(this.baseSchema);
+        this.modifiedAttributes.forEach((attr) => this.updateAttributeStatus(attr));
         Array.from(this.modifiedAttributes).forEach((attr) => {
           let currentValue = dig(this.overlay.properties.attributes.properties, attr);
-          bury(this.schema, `properties.attributes.properties.${attr}`, currentValue, true);
+          bury(this.schema, `properties.attributes.properties.${attr}`, currentValue, false);
         });
         let originalRequiredFields = this.schema.properties.attributes.required ? this.schema.properties.attributes.required : [];
         let allRequiredSet = Array.from(/* @__PURE__ */ new Set([...originalRequiredFields, ...Array.from(this.requiredFields)]));
@@ -9112,12 +9221,18 @@ var require_convention_builder = __commonJS({
         this.requiredFields.add(attribute);
         this.updateSchema();
       }
-      setGenericSection({ attribute, section, description }) {
+      /**
+       * The section body "section" will replace the previous schema content in full.
+       * @param {} attribute
+       * @param {} section
+       * @param {} description
+       */
+      setGenericSection({ attribute, section, description, merge = true }) {
         this.checkAttributeStatus(attribute);
-        bury(this.overlay.properties.attributes.properties, attribute, section, true);
+        bury(this.overlay.properties.attributes.properties, attribute, section, merge);
         if (attribute.match(/\./)) {
           let firstLevel = attribute.split(/\./)[0];
-          this.overlay.properties.attributes.properties[firstLevel].type = "object";
+          bury(this.overlay.properties.attributes.properties, `${firstLevel}.type`, "object", merge);
         }
         ;
         if (description) {
@@ -9254,6 +9369,42 @@ var require_convention_builder = __commonJS({
     };
     __name(_SchemaOverlay, "SchemaOverlay");
     var SchemaOverlay2 = _SchemaOverlay;
+    var _AttributePatchingSchemaOverlay = class _AttributePatchingSchemaOverlay extends SchemaOverlay2 {
+      constructor({
+        typeAndBundle,
+        attributeOverlayName,
+        repoURL,
+        strictEnums = true,
+        baseSchemataFolder = `${__dirname}/../../../../input/collection`
+      }) {
+        super({
+          typeAndBundle,
+          repoURL,
+          storageFolder: baseSchemataFolder,
+          baseSchemataFolder,
+          strictEnums
+        });
+        this.attributeOverlayName = attributeOverlayName;
+      }
+      store() {
+        this.updateSchema();
+        if (this.schema.appliedOverlays) {
+          this.schema.appliedOverlays.push(this.attributeOverlayName);
+        } else {
+          this.schema.appliedOverlays = [this.attributeOverlayName];
+        }
+        ;
+        let targetPath = `${this.storagePath()}/${this.typeAndBundle.split("--")[0]}/${this.typeAndBundle.split("--")[1]}/schema.json`;
+        fs.writeFileSync(targetPath, JSON.stringify(this.schema, null, " "), console.error);
+        let output = {
+          path: targetPath,
+          test: false
+        };
+        return output;
+      }
+    };
+    __name(_AttributePatchingSchemaOverlay, "AttributePatchingSchemaOverlay");
+    var AttributePatchingSchemaOverlay = _AttributePatchingSchemaOverlay;
     var _ConventionSchema = class _ConventionSchema {
       constructor({
         title,
@@ -9289,7 +9440,10 @@ var require_convention_builder = __commonJS({
         if (overlays) {
           let overlayNames = Object.keys(overlays);
           this.overlays = {};
-          overlayNames.forEach((ovrl) => this.overlays[ovrl] = new SchemaOverlay2(overlays[ovrl]));
+          overlayNames.forEach((ovrl) => {
+            this.overlays[ovrl] = new SchemaOverlay2(overlays[ovrl]);
+            this.overlays[ovrl].updateSchema();
+          });
         }
         ;
         if (relationships) {
@@ -9365,6 +9519,7 @@ var require_convention_builder = __commonJS({
           required: this.required
         };
         Object.keys(this.overlays).forEach((attributeName) => {
+          this.overlays[attributeName].updateSchema();
           this.schema.properties[attributeName] = this.overlays[attributeName].schema;
           delete this.schema.properties[attributeName].$id;
           if (!this.overlays[attributeName].originalSrcScript) {
@@ -9698,15 +9853,119 @@ import TabItem from '@theme/TabItem';
     };
     __name(_ConventionSchema, "ConventionSchema");
     var ConventionSchema2 = _ConventionSchema;
+    var _AttributeOverlay = class _AttributeOverlay {
+      constructor({
+        type,
+        bundle,
+        attribute,
+        baseSchemataFolder = `${__dirname}/../../../../input/collection`,
+        sourceSchemataFile = `${__dirname}/../../../../input/farmos.json`,
+        overlayName,
+        overlayDescription
+      }) {
+        let integralSchemataFile = JSON.parse(fs.readFileSync(sourceSchemataFile));
+        this.type = type;
+        this.bundle = bundle;
+        this.overlayName = overlayName;
+        this.overlayDescription = overlayDescription;
+        this.attribute = attribute;
+        this.sourceSchemata = integralSchemataFile;
+        this.lexicon = [...findAllObjectAttributesInTree(this.sourceSchemata), ...findAllNonObjectAttributesInTree(this.sourceSchemata)];
+        this.baseSchemataFolder = baseSchemataFolder;
+        let involvedSchemata = this.lexicon.filter((entry) => this.attribute == entry.attribute).flatMap((entry) => entry.instances).filter((instance) => this.type ? instance.type == this.type : true).filter((instance) => this.bundle ? instance.bundle == this.bundle : true).map((d) => d.schema);
+        this.targetSchemata = Array.from(new Set(involvedSchemata));
+        this.overlays = [];
+        this.targetSchemata.forEach((target) => {
+          let currentOverlay = new AttributePatchingSchemaOverlay({
+            typeAndBundle: target,
+            attributeOverlayName: this.overlayName,
+            baseSchemataFolder: this.baseSchemataFolder
+          });
+          this.overlays.push(currentOverlay);
+        });
+      }
+      setRequire() {
+        this.overlays.forEach((overlay) => {
+          overlay.setRequiredAttribute(this.attribute);
+        });
+      }
+      setGenericSection({
+        section,
+        description
+      }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setGenericSection({
+            attribute: this.attribute,
+            section,
+            description,
+            merge: false
+          });
+        });
+      }
+      setPattern({ pattern, string, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setPattern({
+            attribute: this.attribute,
+            pattern,
+            string,
+            description
+          });
+        });
+      }
+      /**
+       * An all involved schemata, sets the target attribute for this overlay as a constant as indicated by the given value.
+       * @param {any} value -- The constant, which should be of the type allowed by the base schema for the attribute.
+       * @param {string} description -- Describes the rationale behind the chosing of the value.
+       */
+      setConstant({ value, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setConstant({
+            attribute: this.attribute,
+            value,
+            description
+          });
+        });
+      }
+      /**
+       * Sets this overlay's target attribute as a constrained to a list of possible values in all involved schemata.
+       * @param {string} attribute -- Attribute name for the attribute which will be set to a constant.
+       * @param {any[]} valuesArray -- The array of possible values, which should be of the type allowed by the base schema for the attribute.
+       * @param {string} description -- Describes the rationale behind the chosing of the value.
+       */
+      setEnum({ valuesArray, description }) {
+        this.overlays.forEach((overlay) => {
+          overlay.setConstant({
+            attribute: this.attribute,
+            valuesArray,
+            description
+          });
+        });
+      }
+      /**
+       * Stores all involved schemas into the folder structure for `base schemata` (provided as the parameter `baseSchemataFolder`) which will be consumed by our conventions later.
+       * @returns {} -- It returns objects containing all paths.
+       */
+      store() {
+        let output = this.overlays.map((overlay) => {
+          let operation = overlay.store();
+          return operation;
+        });
+        return output;
+      }
+    };
+    __name(_AttributeOverlay, "AttributeOverlay");
+    var AttributeOverlay2 = _AttributeOverlay;
     exports2.SchemaOverlay = SchemaOverlay2;
     exports2.ConventionSchema = ConventionSchema2;
+    exports2.AttributeOverlay = AttributeOverlay2;
   }
 });
 
 // src/index.js
-var { SchemaOverlay, ConventionSchema } = require_convention_builder();
+var { SchemaOverlay, ConventionSchema, AttributeOverlay } = require_convention_builder();
 var schemaUtils = require_schema_utilities();
 exports.SchemaOverlay = SchemaOverlay;
+exports.AttributeOverlay = AttributeOverlay;
 exports.ConventionSchema = ConventionSchema;
 exports.fixRelationshipDataField = schemaUtils.fixRelationshipDataField;
 exports.buildValidator = schemaUtils.buildValidator;
@@ -9719,7 +9978,7 @@ exports.apiComposeTaxonomiesTransformation = schemaUtils.apiComposeTaxonomiesTra
 exports.exampleImporter = schemaUtils.exampleImporter;
 exports.findMissingEntitiesInExample = schemaUtils.findMissingEntitiesInExample;
 exports.organizeEntitiesArrayIntoConvention = schemaUtils.organizeEntitiesArrayIntoConvention;
-exports.organizeEntitiesArrayByRelationships = schemaUtils.organizeEntitiesArrayByRelationships;
+exports.arrayToStructuredConvention = schemaUtils.arrayToStructuredConvention;
 exports.trimNonRequiredFields = schemaUtils.trimNonRequiredFields;
 exports.reduceSchemaToRequiredFields = schemaUtils.reduceSchemaToRequiredFields;
 exports.flattenJSONSchema = schemaUtils.flattenJSONSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "convention_builder",
-    "version": "1.4.1",
+    "version": "1.4.3",
     "description": "Helper tools that offer a high level interface that transforms a convention description into it's json schema.",
     "main": "./dist/node/index.js",
     "browser": "./dist/browser/index.js",