convention_builder 1.4.0 → 1.4.2

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}`);
         });
       });
     }
@@ -8530,12 +8534,15 @@ var require_schema_utilities = __commonJS({
       let mapping = {};
       let conventions = fs.readdirSync(`${conventionsFolder}`, (error, files) => {
         return files;
-      });
+      }).filter((filename) => !/\./.test(filename));
       conventions.forEach((conventionName) => {
-        console.log(`Working on ${conventionName}`);
-        let schema = JSON.parse(fs.readFileSync(`${conventionsFolder}/${conventionName}/schema.json`));
-        schemasArgument.schemas.push(schema);
-        mapping[conventionName] = schema.$id;
+        try {
+          let schema = JSON.parse(fs.readFileSync(`${conventionsFolder}/${conventionName}/schema.json`));
+          schemasArgument.schemas.push(schema);
+          mapping[conventionName] = schema.$id;
+        } catch (e) {
+        }
+        ;
       });
       let validatorObj = buildValidator(extraAJVArguments = schemasArgument);
       let moduleCode = standaloneCode(validatorObj, mapping);
@@ -8763,6 +8770,9 @@ 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 trimNonRequiredFields(schema, attribute = false) {
@@ -8911,7 +8921,6 @@ var require_schema_utilities = __commonJS({
         let subAttrs = Object.keys(schema.properties.attributes.properties[objAttr].properties);
         subAttrs.forEach((subAttr) => {
           output.add(`${objAttr}.properties.${subAttr}`);
-          output.delete(`${objAttr}`);
         });
       });
       return output;
@@ -8924,7 +8933,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(
@@ -8952,6 +8968,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;
@@ -8972,6 +9024,7 @@ var require_schema_utilities = __commonJS({
     exports2.flattenJSONSchema = flattenJSONSchema;
     exports2.listAttributesAndSubAttributes = listAttributesAndSubAttributes;
     exports2.findAllObjectAttributesInTree = findAllObjectAttributesInTree;
+    exports2.findAllNonObjectAttributesInTree = findAllNonObjectAttributesInTree;
   }
 });
 
@@ -8979,7 +9032,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 = {};
@@ -9000,7 +9061,8 @@ var require_convention_builder = __commonJS({
         originalSrcScript,
         trivial = false,
         baseSchemataFolder = `${__dirname}/../../../../input/collection`,
-        requiredFields = []
+        requiredFields = [],
+        modifiedAttributes
       }) {
         this.name = name;
         this.typeAndBundle = typeAndBundle;
@@ -9035,7 +9097,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: {
@@ -9051,11 +9113,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.
        */
@@ -9065,9 +9133,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)]));
@@ -9109,12 +9179,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) {
@@ -9217,7 +9293,10 @@ var require_convention_builder = __commonJS({
           let test2 = this.testExamples();
           valid = test2.success;
           if (!valid) {
-            throw new Error(`The 'testExamples' method failed. The overlay either lacks examples, or is rejecting a valid example or accepting an invalid example.`);
+            throw new Error(`The 'testExamples' method failed. The schema ${this.name} either lacks examples, or is rejecting a valid example or accepting an invalid example.
+ * Valid examples provided: ${test2.validExamples.length} 
+ * Error examples provided: ${test2.erroredExamples.length} 
+ * Failed examples observed: ${test2.failedExamples.length}.`);
           }
           ;
           if (!this.trivial) {
@@ -9248,6 +9327,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,
@@ -9359,6 +9474,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) {
@@ -9692,15 +9808,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;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "convention_builder",
-    "version": "1.4.0",
+    "version": "1.4.2",
     "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",