@remoteoss/json-schema-form 0.5.0-dev.20230901130231 → 0.6.1-beta.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+#### 0.6.1-beta.0 (2023-09-13)
+
+##### Changes
+
+
+
+- Computed string based values for json-logic ([#37](https://github.com/remoteoss/json-schema-form/pull/37)) ([6e042ea5](https://github.com/remoteoss/json-schema-form/commit/6e042ea579497ea573710c307a6ff7ee2f19b931))
+
+#### 0.5.0-beta.0 (2023-09-12)
+
+##### Changes
+
+- Computed Attributes ([#36](https://github.com/remoteoss/json-schema-form/pull/36)) ([80c29589](https://github.com/remoteoss/json-schema-form/commit/80c29589ac0972e0f33add70a59df15a46db1b43))
+- JSON Logic Skeleton ([#35](https://github.com/remoteoss/json-schema-form/pull/35)) ([63149ae8](https://github.com/remoteoss/json-schema-form/commit/63149ae863cf1b5ad76a3b2a49c7f343e55ce07b))
+
 #### 0.4.5-beta.0 (2023-08-31)
 
 ##### Changes

package/dist/index.cjs

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.5.0-dev.20230901130231
- Generated: Fri, 01 Sep 2023 13:03:04 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
+ Generated: Wed, 13 Sep 2023 09:54:37 GMT
 
  MIT License
 
@@ -417,6 +417,7 @@ var import_json_logic_js = __toESM(require("json-logic-js"));
 function createValidationChecker(schema) {
   const scopes = /* @__PURE__ */ new Map();
   function createScopes(jsonSchema, key = "root") {
+    const sampleEmptyObject = buildSampleEmptyObject(schema);
     scopes.set(key, createValidationsScope(jsonSchema));
     Object.entries(jsonSchema?.properties ?? {}).filter(([, property]) => property.type === "object" || property.type === "array").forEach(([key2, property]) => {
       if (property.type === "array") {
@@ -425,6 +426,7 @@ function createValidationChecker(schema) {
         createScopes(property, key2);
       }
     });
+    validateInlineRules(jsonSchema, sampleEmptyObject);
   }
   createScopes(schema);
   return {
@@ -443,10 +445,19 @@ function createValidationsScope(schema) {
   };
   const validations = Object.entries(logic.validations ?? {});
   const computedValues = Object.entries(logic.computedValues ?? {});
+  const sampleEmptyObject = buildSampleEmptyObject(schema);
   validations.forEach(([id, validation]) => {
+    if (!validation.rule) {
+      throw Error(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
     validationMap.set(id, validation);
   });
   computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
     computedValuesMap.set(id, computedValue);
   });
   function validate(rule, values) {
@@ -460,8 +471,13 @@ function createValidationsScope(schema) {
       const validation = validationMap.get(id);
       return validate(validation.rule, values);
     },
-    applyComputedValueInField(id, values) {
+    applyComputedValueInField(id, values, fieldName) {
       const validation = computedValuesMap.get(id);
+      if (validation === void 0) {
+        throw Error(
+          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
+        );
+      }
       return validate(validation.rule, values);
     },
     applyComputedValueRuleInCondition(id, values) {
@@ -478,6 +494,11 @@ function replaceUndefinedValuesWithNulls(values = {}) {
 function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
   const { parentID = "root" } = config;
   const validation = logic.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(
+      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" doesn't exist.`
+    );
+  }
   return (yupSchema) => yupSchema.test(
     `${field.name}-validation-${id}`,
     validation?.errorMessage ?? "This field is invalid.",
@@ -488,24 +509,152 @@ function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
     }
   );
 }
+var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  logic,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  } else if (typeof toReplace === "object") {
+    const { value, ...rules } = toReplace;
+    if (Object.keys(rules).length > 1 && !value) {
+      throw Error("Cannot define multiple rules without a template string with key `value`.");
+    }
+    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
+      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  }
+  return toReplace;
+}
 function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
-  return ({ logic, formValues }) => {
-    const { computedAttributes } = fieldParams;
+  return ({ logic, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
     const attributes = Object.fromEntries(
-      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID)).filter(([, value]) => value !== null)
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
     );
-    return attributes;
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        logic
+      )
+    };
   };
 }
-function handleComputedAttribute(logic, formValues, parentID) {
+function handleComputedAttribute(logic, formValues, parentID, name) {
   return ([key, value]) => {
-    if (key === "const")
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
-    if (typeof value === "string") {
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
+    switch (key) {
+      case "description":
+        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "title":
+        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "x-jsf-errorMessage":
+        return [
+          "errorMessage",
+          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
+        ];
+      case "x-jsf-presentation": {
+        if (value.statement) {
+          return [
+            "statement",
+            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+          ];
+        }
+        return [
+          key,
+          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+        ];
+      }
+      case "const":
+      default:
+        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
     }
   };
 }
+function handleNestedObjectForComputedValues(values, formValues, parentID, logic, name) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+    })
+  );
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
+  }
+  for (const key in schema.properties) {
+    if (schema.properties[key].type === "object") {
+      sample[key] = buildSampleEmptyObject(schema.properties[key]);
+    } else if (schema.properties[key].type === "array") {
+      const itemSchema = schema.properties[key].items;
+      sample[key] = buildSampleEmptyObject(itemSchema);
+    } else {
+      sample[key] = true;
+    }
+  }
+  return sample;
+}
+function validateInlineRules(jsonSchema, sampleEmptyObject) {
+  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
+  Object.entries(properties).filter(([, property]) => property["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property]) => {
+    Object.entries(property["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
+      Object.values(item).forEach((rule) => {
+        checkRuleIntegrity(
+          rule,
+          fieldName,
+          sampleEmptyObject,
+          (item2) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
+        );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
+  Object.entries(rule ?? {}).map(([operator, subRule]) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    throwIfUnknownOperator(operator, subRule, id);
+    subRule.map((item) => {
+      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
+      if (isVar) {
+        const exists = import_json_logic_js.default.apply({ var: removeIndicesFromPath(item.var) }, data);
+        if (exists === null) {
+          throw Error(errorMessage(item));
+        }
+      } else {
+        checkRuleIntegrity(item, id, data);
+      }
+    });
+  });
+}
+function throwIfUnknownOperator(operator, subRule, id) {
+  try {
+    import_json_logic_js.default.apply({ [operator]: subRule });
+  } catch (e) {
+    if (e.message === `Unrecognized operation ${operator}`) {
+      throw Error(
+        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
+      );
+    }
+  }
+}
+var regexToGetIndices = /\.\d+\./g;
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(regexToGetIndices, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
+}
 
 // src/yupSchema.js
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
@@ -1098,6 +1247,7 @@ function extractParametersFromNode(schemaNode) {
   return (0, import_omitBy.default)(
     {
       const: node.const,
+      ...node.const && node.default ? { value: node.const } : {},
       label: node.title,
       readOnly: node.readOnly,
       ...node.deprecated && {

package/dist/index.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.5.0-dev.20230901130231
- Generated: Fri, 01 Sep 2023 13:03:04 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
+ Generated: Wed, 13 Sep 2023 09:54:37 GMT
 
  MIT License
 
@@ -381,6 +381,7 @@ import jsonLogic from "json-logic-js";
 function createValidationChecker(schema) {
   const scopes = /* @__PURE__ */ new Map();
   function createScopes(jsonSchema, key = "root") {
+    const sampleEmptyObject = buildSampleEmptyObject(schema);
     scopes.set(key, createValidationsScope(jsonSchema));
     Object.entries(jsonSchema?.properties ?? {}).filter(([, property]) => property.type === "object" || property.type === "array").forEach(([key2, property]) => {
       if (property.type === "array") {
@@ -389,6 +390,7 @@ function createValidationChecker(schema) {
         createScopes(property, key2);
       }
     });
+    validateInlineRules(jsonSchema, sampleEmptyObject);
   }
   createScopes(schema);
   return {
@@ -407,10 +409,19 @@ function createValidationsScope(schema) {
   };
   const validations = Object.entries(logic.validations ?? {});
   const computedValues = Object.entries(logic.computedValues ?? {});
+  const sampleEmptyObject = buildSampleEmptyObject(schema);
   validations.forEach(([id, validation]) => {
+    if (!validation.rule) {
+      throw Error(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
     validationMap.set(id, validation);
   });
   computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
     computedValuesMap.set(id, computedValue);
   });
   function validate(rule, values) {
@@ -424,8 +435,13 @@ function createValidationsScope(schema) {
       const validation = validationMap.get(id);
       return validate(validation.rule, values);
     },
-    applyComputedValueInField(id, values) {
+    applyComputedValueInField(id, values, fieldName) {
       const validation = computedValuesMap.get(id);
+      if (validation === void 0) {
+        throw Error(
+          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
+        );
+      }
       return validate(validation.rule, values);
     },
     applyComputedValueRuleInCondition(id, values) {
@@ -442,6 +458,11 @@ function replaceUndefinedValuesWithNulls(values = {}) {
 function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
   const { parentID = "root" } = config;
   const validation = logic.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(
+      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" doesn't exist.`
+    );
+  }
   return (yupSchema) => yupSchema.test(
     `${field.name}-validation-${id}`,
     validation?.errorMessage ?? "This field is invalid.",
@@ -452,24 +473,152 @@ function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
     }
   );
 }
+var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  logic,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  } else if (typeof toReplace === "object") {
+    const { value, ...rules } = toReplace;
+    if (Object.keys(rules).length > 1 && !value) {
+      throw Error("Cannot define multiple rules without a template string with key `value`.");
+    }
+    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
+      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  }
+  return toReplace;
+}
 function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
-  return ({ logic, formValues }) => {
-    const { computedAttributes } = fieldParams;
+  return ({ logic, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
     const attributes = Object.fromEntries(
-      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID)).filter(([, value]) => value !== null)
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
     );
-    return attributes;
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        logic
+      )
+    };
   };
 }
-function handleComputedAttribute(logic, formValues, parentID) {
+function handleComputedAttribute(logic, formValues, parentID, name) {
   return ([key, value]) => {
-    if (key === "const")
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
-    if (typeof value === "string") {
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
+    switch (key) {
+      case "description":
+        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "title":
+        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "x-jsf-errorMessage":
+        return [
+          "errorMessage",
+          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
+        ];
+      case "x-jsf-presentation": {
+        if (value.statement) {
+          return [
+            "statement",
+            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+          ];
+        }
+        return [
+          key,
+          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+        ];
+      }
+      case "const":
+      default:
+        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
     }
   };
 }
+function handleNestedObjectForComputedValues(values, formValues, parentID, logic, name) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+    })
+  );
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
+  }
+  for (const key in schema.properties) {
+    if (schema.properties[key].type === "object") {
+      sample[key] = buildSampleEmptyObject(schema.properties[key]);
+    } else if (schema.properties[key].type === "array") {
+      const itemSchema = schema.properties[key].items;
+      sample[key] = buildSampleEmptyObject(itemSchema);
+    } else {
+      sample[key] = true;
+    }
+  }
+  return sample;
+}
+function validateInlineRules(jsonSchema, sampleEmptyObject) {
+  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
+  Object.entries(properties).filter(([, property]) => property["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property]) => {
+    Object.entries(property["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
+      Object.values(item).forEach((rule) => {
+        checkRuleIntegrity(
+          rule,
+          fieldName,
+          sampleEmptyObject,
+          (item2) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
+        );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
+  Object.entries(rule ?? {}).map(([operator, subRule]) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    throwIfUnknownOperator(operator, subRule, id);
+    subRule.map((item) => {
+      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
+      if (isVar) {
+        const exists = jsonLogic.apply({ var: removeIndicesFromPath(item.var) }, data);
+        if (exists === null) {
+          throw Error(errorMessage(item));
+        }
+      } else {
+        checkRuleIntegrity(item, id, data);
+      }
+    });
+  });
+}
+function throwIfUnknownOperator(operator, subRule, id) {
+  try {
+    jsonLogic.apply({ [operator]: subRule });
+  } catch (e) {
+    if (e.message === `Unrecognized operation ${operator}`) {
+      throw Error(
+        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
+      );
+    }
+  }
+}
+var regexToGetIndices = /\.\d+\./g;
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(regexToGetIndices, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
+}
 
 // src/yupSchema.js
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
@@ -1062,6 +1211,7 @@ function extractParametersFromNode(schemaNode) {
   return omitBy(
     {
       const: node.const,
+      ...node.const && node.default ? { value: node.const } : {},
       label: node.title,
       readOnly: node.readOnly,
       ...node.deprecated && {

package/dist/standalone.js

@@ -1,8 +1,8 @@
 
 /*!
  Copyright (c) 2023 Remote Technology, Inc.
- NPM Package: @remoteoss/json-schema-form@0.5.0-dev.20230901130231
- Generated: Fri, 01 Sep 2023 13:03:04 GMT
+ NPM Package: @remoteoss/json-schema-form@0.6.1-beta.0
+ Generated: Wed, 13 Sep 2023 09:54:37 GMT
 
  MIT License
 
@@ -11735,6 +11735,7 @@ var import_json_logic_js = __toESM(require_logic());
 function createValidationChecker(schema) {
   const scopes = /* @__PURE__ */ new Map();
   function createScopes(jsonSchema, key = "root") {
+    const sampleEmptyObject = buildSampleEmptyObject(schema);
     scopes.set(key, createValidationsScope(jsonSchema));
     Object.entries(jsonSchema?.properties ?? {}).filter(([, property2]) => property2.type === "object" || property2.type === "array").forEach(([key2, property2]) => {
       if (property2.type === "array") {
@@ -11743,6 +11744,7 @@ function createValidationChecker(schema) {
         createScopes(property2, key2);
       }
     });
+    validateInlineRules(jsonSchema, sampleEmptyObject);
   }
   createScopes(schema);
   return {
@@ -11761,10 +11763,19 @@ function createValidationsScope(schema) {
   };
   const validations = Object.entries(logic.validations ?? {});
   const computedValues = Object.entries(logic.computedValues ?? {});
+  const sampleEmptyObject = buildSampleEmptyObject(schema);
   validations.forEach(([id, validation]) => {
+    if (!validation.rule) {
+      throw Error(`[json-schema-form] json-logic error: Validation "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(validation.rule, id, sampleEmptyObject);
     validationMap.set(id, validation);
   });
   computedValues.forEach(([id, computedValue]) => {
+    if (!computedValue.rule) {
+      throw Error(`[json-schema-form] json-logic error: Computed value "${id}" has missing rule.`);
+    }
+    checkRuleIntegrity(computedValue.rule, id, sampleEmptyObject);
     computedValuesMap.set(id, computedValue);
   });
   function validate2(rule, values2) {
@@ -11778,8 +11789,13 @@ function createValidationsScope(schema) {
       const validation = validationMap.get(id);
       return validate2(validation.rule, values2);
     },
-    applyComputedValueInField(id, values2) {
+    applyComputedValueInField(id, values2, fieldName) {
       const validation = computedValuesMap.get(id);
+      if (validation === void 0) {
+        throw Error(
+          `[json-schema-form] json-logic error: Computed value "${id}" doesn't exist in field "${fieldName}".`
+        );
+      }
       return validate2(validation.rule, values2);
     },
     applyComputedValueRuleInCondition(id, values2) {
@@ -11796,6 +11812,11 @@ function replaceUndefinedValuesWithNulls(values2 = {}) {
 function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
   const { parentID = "root" } = config;
   const validation = logic.getScope(parentID).validationMap.get(id);
+  if (validation === void 0) {
+    throw Error(
+      `[json-schema-form] json-logic error: "${field.name}" required validation "${id}" doesn't exist.`
+    );
+  }
   return (yupSchema) => yupSchema.test(
     `${field.name}-validation-${id}`,
     validation?.errorMessage ?? "This field is invalid.",
@@ -11806,24 +11827,152 @@ function yupSchemaWithCustomJSONLogic({ field, logic, config, id }) {
     }
   );
 }
+var HANDLEBARS_REGEX = /\{\{([^{}]+)\}\}/g;
+function replaceHandlebarsTemplates({
+  value: toReplace,
+  logic,
+  formValues,
+  parentID,
+  name: fieldName
+}) {
+  if (typeof toReplace === "string") {
+    return toReplace.replace(HANDLEBARS_REGEX, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  } else if (typeof toReplace === "object") {
+    const { value, ...rules } = toReplace;
+    if (Object.keys(rules).length > 1 && !value) {
+      throw Error("Cannot define multiple rules without a template string with key `value`.");
+    }
+    const computedTemplateValue = Object.entries(rules).reduce((prev, [key, rule]) => {
+      const computedValue = logic.getScope(parentID).evaluateValidation(rule, formValues);
+      return prev.replaceAll(`{{${key}}}`, computedValue);
+    }, value);
+    return computedTemplateValue.replace(/\{\{([^{}]+)\}\}/g, (match, key) => {
+      return logic.getScope(parentID).applyComputedValueInField(key.trim(), formValues, fieldName);
+    });
+  }
+  return toReplace;
+}
 function calculateComputedAttributes(fieldParams, { parentID = "root" } = {}) {
-  return ({ logic, formValues }) => {
-    const { computedAttributes } = fieldParams;
+  return ({ logic, isRequired, config, formValues }) => {
+    const { name, computedAttributes } = fieldParams;
     const attributes = Object.fromEntries(
-      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID)).filter(([, value]) => value !== null)
+      Object.entries(computedAttributes).map(handleComputedAttribute(logic, formValues, parentID, name)).filter(([, value]) => value !== null)
     );
-    return attributes;
+    return {
+      ...attributes,
+      schema: buildYupSchema(
+        { ...fieldParams, ...attributes, required: isRequired },
+        config,
+        logic
+      )
+    };
   };
 }
-function handleComputedAttribute(logic, formValues, parentID) {
+function handleComputedAttribute(logic, formValues, parentID, name) {
   return ([key, value]) => {
-    if (key === "const")
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
-    if (typeof value === "string") {
-      return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues)];
+    switch (key) {
+      case "description":
+        return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "title":
+        return ["label", replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+      case "x-jsf-errorMessage":
+        return [
+          "errorMessage",
+          handleNestedObjectForComputedValues(value, formValues, parentID, logic, name)
+        ];
+      case "x-jsf-presentation": {
+        if (value.statement) {
+          return [
+            "statement",
+            handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+          ];
+        }
+        return [
+          key,
+          handleNestedObjectForComputedValues(value.statement, formValues, parentID, logic, name)
+        ];
+      }
+      case "const":
+      default:
+        return [key, logic.getScope(parentID).applyComputedValueInField(value, formValues, name)];
     }
   };
 }
+function handleNestedObjectForComputedValues(values2, formValues, parentID, logic, name) {
+  return Object.fromEntries(
+    Object.entries(values2).map(([key, value]) => {
+      return [key, replaceHandlebarsTemplates({ value, logic, formValues, parentID, name })];
+    })
+  );
+}
+function buildSampleEmptyObject(schema = {}) {
+  const sample = {};
+  if (typeof schema !== "object" || !schema.properties) {
+    return schema;
+  }
+  for (const key in schema.properties) {
+    if (schema.properties[key].type === "object") {
+      sample[key] = buildSampleEmptyObject(schema.properties[key]);
+    } else if (schema.properties[key].type === "array") {
+      const itemSchema = schema.properties[key].items;
+      sample[key] = buildSampleEmptyObject(itemSchema);
+    } else {
+      sample[key] = true;
+    }
+  }
+  return sample;
+}
+function validateInlineRules(jsonSchema, sampleEmptyObject) {
+  const properties = (jsonSchema?.properties || jsonSchema?.items?.properties) ?? {};
+  Object.entries(properties).filter(([, property2]) => property2["x-jsf-logic-computedAttrs"] !== void 0).forEach(([fieldName, property2]) => {
+    Object.entries(property2["x-jsf-logic-computedAttrs"]).filter(([, value]) => typeof value === "object").forEach(([key, item]) => {
+      Object.values(item).forEach((rule) => {
+        checkRuleIntegrity(
+          rule,
+          fieldName,
+          sampleEmptyObject,
+          (item2) => `[json-schema-form] json-logic error: fieldName "${item2.var}" doesn't exist in field "${fieldName}.x-jsf-logic-computedAttrs.${key}".`
+        );
+      });
+    });
+  });
+}
+function checkRuleIntegrity(rule, id, data, errorMessage = (item) => `[json-schema-form] json-logic error: rule "${id}" has no variable "${item.var}".`) {
+  Object.entries(rule ?? {}).map(([operator, subRule]) => {
+    if (!Array.isArray(subRule) && subRule !== null && subRule !== void 0)
+      return;
+    throwIfUnknownOperator(operator, subRule, id);
+    subRule.map((item) => {
+      const isVar = item !== null && typeof item === "object" && Object.hasOwn(item, "var");
+      if (isVar) {
+        const exists = import_json_logic_js.default.apply({ var: removeIndicesFromPath(item.var) }, data);
+        if (exists === null) {
+          throw Error(errorMessage(item));
+        }
+      } else {
+        checkRuleIntegrity(item, id, data);
+      }
+    });
+  });
+}
+function throwIfUnknownOperator(operator, subRule, id) {
+  try {
+    import_json_logic_js.default.apply({ [operator]: subRule });
+  } catch (e) {
+    if (e.message === `Unrecognized operation ${operator}`) {
+      throw Error(
+        `[json-schema-form] json-logic error: in "${id}" rule there is an unknown operator "${operator}".`
+      );
+    }
+  }
+}
+var regexToGetIndices = /\.\d+\./g;
+function removeIndicesFromPath(path) {
+  const intermediatePath = path.replace(regexToGetIndices, ".");
+  return intermediatePath.replace(/\.\d+$/, "");
+}
 
 // src/yupSchema.js
 var DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
@@ -12416,6 +12565,7 @@ function extractParametersFromNode(schemaNode) {
   return (0, import_omitBy.default)(
     {
       const: node.const,
+      ...node.const && node.default ? { value: node.const } : {},
       label: node.title,
       readOnly: node.readOnly,
       ...node.deprecated && {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remoteoss/json-schema-form",
-  "version": "0.5.0-dev.20230901130231",
+  "version": "0.6.1-beta.0",
   "description": "Headless UI form powered by JSON Schemas",
   "author": "Remote.com <engineering@remote.com> (https://remote.com/)",
   "license": "MIT",

package/src/tests/const.test.js

@@ -83,4 +83,16 @@ describe('validations: const', () => {
     });
     expect(handleValidation({ string: 'hello' }).formErrors).toEqual(undefined);
   });
+
+  it('Should have value attribute for when const & default is present', () => {
+    const { fields } = createHeadlessForm(
+      {
+        properties: {
+          ten_only: { type: 'number', const: 10, default: 10 },
+        },
+      },
+      { strictInputType: false }
+    );
+    expect(fields[0]).toMatchObject({ value: 10, const: 10, default: 10 });
+  });
 });

package/src/tests/createHeadlessForm.test.js

@@ -57,6 +57,7 @@ import {
   schemaForErrorMessageSpecificity,
   jsfConfigForErrorMessageSpecificity,
 } from './helpers';
+import { mockConsole, restoreConsoleAndEnsureItWasNotCalled } from './testUtils';
 
 function buildJSONSchemaInput({ presentationFields, inputFields = {}, required }) {
   return {
@@ -92,17 +93,8 @@ const getField = (fields, name, ...subNames) => {
   return field;
 };
 
-beforeEach(() => {
-  jest.spyOn(console, 'warn').mockImplementation(() => {});
-  jest.spyOn(console, 'error').mockImplementation(() => {});
-});
-
-afterEach(() => {
-  expect(console.error).not.toHaveBeenCalled();
-  console.error.mockRestore();
-  expect(console.warn).not.toHaveBeenCalled();
-  console.warn.mockRestore();
-});
+beforeEach(mockConsole);
+afterEach(restoreConsoleAndEnsureItWasNotCalled);
 
 describe('createHeadlessForm', () => {
   it('returns empty result given no schema', () => {

package/src/tests/jsonLogic.fixtures.js

@@ -77,6 +77,70 @@ export const schemaWithNativeAndJSONLogicChecks = {
   required: ['field_a'],
 };
 
+export const schemaWithMissingRule = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-validations': ['a_greater_than_ten'],
+    },
+  },
+  'x-jsf-logic': {
+    validations: {
+      a_greater_than_ten: {
+        errorMessage: 'Must be greater than 10',
+        // rule: { '>': [{ var: 'field_a' }, 10] }, this missing causes test to fail.
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithUnknownVariableInValidations = {
+  properties: {
+    // field_a: { type: 'number' }, this missing causes test to fail.
+  },
+  'x-jsf-logic': {
+    validations: {
+      a_equals_ten: {
+        errorMessage: 'Must equal 10',
+        rule: { '===': [{ var: 'field_a' }, 10] },
+      },
+    },
+  },
+};
+
+export const schemaWithUnknownVariableInComputedValues = {
+  properties: {
+    // field_a: { type: 'number' }, this missing causes test to fail.
+  },
+  'x-jsf-logic': {
+    computedValues: {
+      a_times_ten: {
+        rule: { '*': [{ var: 'field_a' }, 10] },
+      },
+    },
+  },
+};
+
+export const schemaWithMissingComputedValue = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: '{{a_plus_ten}}',
+      },
+    },
+  },
+  'x-jsf-logic': {
+    computedValues: {
+      a_plus_ten: {
+        // rule: { '+': [{ var: 'field_a' }, 10 ]} this missing causes test to fail.
+      },
+    },
+  },
+  required: [],
+};
+
 export const multiRuleSchema = {
   properties: {
     field_a: {
@@ -144,8 +208,113 @@ export const schemaWithComputedAttributes = {
     field_b: {
       type: 'number',
       'x-jsf-logic-computedAttrs': {
+        title: 'This is {{a_times_two}}!',
         const: 'a_times_two',
         default: 'a_times_two',
+        description: 'This field is 2 times bigger than field_a with value of {{a_times_two}}.',
+      },
+    },
+  },
+  required: ['field_a', 'field_b'],
+  'x-jsf-logic': {
+    computedValues: {
+      a_times_two: {
+        rule: {
+          '*': [{ var: 'field_a' }, 2],
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithInlineRuleForComputedAttributeWithoutCopy = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: {
+          rule: {
+            '+': [{ var: 'field_a' }, 10],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithComputedAttributeThatDoesntExist = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        default: 'iDontExist',
+      },
+    },
+  },
+  // x-jsf-logic: { computedValues: { iDontExist: { rule: 10 }} this missing causes test to fail.
+};
+
+export const schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar = {
+  properties: {
+    // iDontExist: { type: 'number' } this missing causes test to fail.
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: {
+          rule: {
+            '+': [{ var: 'IdontExist' }, 10],
+          },
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithComputedAttributeThatDoesntExistTitle = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        title: `this doesn't exist {{iDontExist}}`,
+      },
+    },
+  },
+};
+
+export const schemaWithComputedAttributeThatDoesntExistDescription = {
+  properties: {
+    // iDontExist: { type: 'number'}, this missing causes test to fail
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        description: `this doesn't exist {{iDontExist}}`,
+      },
+    },
+  },
+};
+
+export const schemaWithComputedAttributesAndErrorMessages = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+    field_b: {
+      type: 'number',
+      'x-jsf-logic-computedAttrs': {
+        minimum: 'a_times_two',
+        maximum: 'a_times_four',
+        'x-jsf-errorMessage': {
+          minimum: 'Must be bigger than {{a_times_two}}',
+          maximum: 'Must be smaller than {{a_times_four}}',
+        },
+        'x-jsf-presentation': {
+          statement: {
+            description: 'Must be bigger than {{a_times_two}} and smaller than {{a_times_four}}',
+          },
+        },
       },
     },
   },
@@ -157,6 +326,116 @@ export const schemaWithComputedAttributes = {
           '*': [{ var: 'field_a' }, 2],
         },
       },
+      a_times_four: {
+        rule: {
+          '*': [{ var: 'field_a' }, 4],
+        },
+      },
+    },
+  },
+};
+
+export const schemaWithDeepVarThatDoesNotExist = {
+  properties: {
+    field_a: {
+      type: 'number',
+    },
+  },
+  'x-jsf-logic': {
+    validations: {
+      dummy_rule: {
+        errorMessage: 'Random stuff to illustrate a deeply nested rule.',
+        rule: {
+          '>': [{ var: 'field_a' }, { '*': [2, { '/': [2, { '*': [1, { var: 'field_b' }] }] }] }],
+        },
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithDeepVarThatDoesNotExistOnFieldset = {
+  properties: {
+    field_a: {
+      type: 'object',
+      properties: {
+        child: {
+          type: 'number',
+        },
+      },
+      'x-jsf-logic': {
+        validations: {
+          dummy_rule: {
+            errorMessage: 'Must be greater than 10',
+            rule: {
+              '>': [{ var: 'child' }, { '*': [2, { '/': [2, { '*': [1, { var: 'field_a' }] }] }] }],
+            },
+          },
+        },
+      },
+    },
+  },
+  required: [],
+};
+
+export const schemaWithValidationThatDoesNotExistOnProperty = {
+  properties: {
+    field_a: {
+      type: 'number',
+      'x-jsf-logic-validations': ['iDontExist'],
+    },
+  },
+};
+
+export const schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset = {
+  properties: {
+    field_a: {
+      type: 'object',
+      'x-jsf-presentation': {
+        inputType: 'fieldset',
+      },
+      properties: {
+        child: {
+          type: 'number',
+          'x-jsf-logic-validations': ['child_greater_than_10'],
+        },
+        other_child: {
+          type: 'number',
+          'x-jsf-logic-validations': ['greater_than_child'],
+        },
+      },
+      required: ['child', 'other_child'],
+    },
+  },
+  // the issue here is that this should be nested inside `field_a` in order to not fail.
+  'x-jsf-logic': {
+    validations: {
+      validation_parent: {
+        errorMessage: 'Must be greater than 10!',
+        rule: {
+          '>': [{ var: 'child' }, 10],
+        },
+      },
+      greater_than_child: {
+        errorMessage: 'Must be greater than child',
+        rule: {
+          '>': [{ var: 'other_child' }, { var: 'child' }],
+        },
+      },
+    },
+  },
+  required: ['field_a'],
+};
+
+export const schemaWithBadOperation = {
+  properties: {},
+  'x-jsf-logic': {
+    validations: {
+      badOperator: {
+        rule: {
+          '++': [10, 2],
+        },
+      },
     },
   },
 };

package/src/tests/jsonLogic.test.js

@@ -4,11 +4,29 @@ import {
   createSchemaWithRulesOnFieldA,
   createSchemaWithThreePropertiesWithRuleOnFieldA,
   multiRuleSchema,
+  schemaWithBadOperation,
+  schemaWithComputedAttributeThatDoesntExist,
+  schemaWithComputedAttributeThatDoesntExistDescription,
+  schemaWithComputedAttributeThatDoesntExistTitle,
   schemaWithComputedAttributes,
+  schemaWithComputedAttributesAndErrorMessages,
+  schemaWithDeepVarThatDoesNotExist,
+  schemaWithDeepVarThatDoesNotExistOnFieldset,
+  schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar,
+  schemaWithMissingComputedValue,
+  schemaWithMissingRule,
   schemaWithNativeAndJSONLogicChecks,
   schemaWithNonRequiredField,
+  schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset,
   schemaWithTwoRules,
+  schemaWithUnknownVariableInComputedValues,
+  schemaWithUnknownVariableInValidations,
+  schemaWithValidationThatDoesNotExistOnProperty,
 } from './jsonLogic.fixtures';
+import { mockConsole, restoreConsoleAndEnsureItWasNotCalled } from './testUtils';
+
+beforeEach(mockConsole);
+afterEach(restoreConsoleAndEnsureItWasNotCalled);
 
 describe('jsonLogic: cross-values validations', () => {
   describe('Does not conflict with native JSON schema', () => {
@@ -82,6 +100,85 @@ describe('jsonLogic: cross-values validations', () => {
     });
   });
 
+  describe('Incorrectly written schemas', () => {
+    afterEach(() => console.error.mockClear());
+
+    const cases = [
+      [
+        'x-jsf-logic.validations: throw when theres a missing rule',
+        schemaWithMissingRule,
+        '[json-schema-form] json-logic error: Validation "a_greater_than_ten" has missing rule.',
+      ],
+      [
+        'x-jsf-logic.validations: throw when theres a value that does not exist in a rule',
+        schemaWithUnknownVariableInValidations,
+        '[json-schema-form] json-logic error: rule "a_equals_ten" has no variable "field_a".',
+      ],
+      [
+        'x-jsf-logic.computedValues: throw when theres a value that does not exist in a rule',
+        schemaWithUnknownVariableInComputedValues,
+        '[json-schema-form] json-logic error: rule "a_times_ten" has no variable "field_a".',
+      ],
+      [
+        'x-jsf-logic.computedValues: throw when theres a missing computed value',
+        schemaWithMissingComputedValue,
+        '[json-schema-form] json-logic error: Computed value "a_plus_ten" has missing rule.',
+      ],
+      [
+        'x-jsf-logic-computedAttrs: error if theres a value that does not exist on an attribute.',
+        schemaWithComputedAttributeThatDoesntExist,
+        `[json-schema-form] json-logic error: Computed value "iDontExist" doesn't exist in field "field_a".`,
+      ],
+      [
+        'x-jsf-logic-computedAttrs: error if theres a value that does not exist on a template string (title).',
+        schemaWithComputedAttributeThatDoesntExistTitle,
+        `[json-schema-form] json-logic error: Computed value "iDontExist" doesn't exist in field "field_a".`,
+      ],
+      [
+        'x-jsf-logic-computedAttrs: error if theres a value that does not exist on a template string (description).',
+        schemaWithComputedAttributeThatDoesntExistDescription,
+        `[json-schema-form] json-logic error: Computed value "iDontExist" doesn't exist in field "field_a".`,
+      ],
+      [
+        'x-jsf-logic-computedAttrs:, error if theres a value referenced that does not exist on an inline rule.',
+        schemaWithInlinedRuleOnComputedAttributeThatReferencesUnknownVar,
+        `[json-schema-form] json-logic error: fieldName "IdontExist" doesn't exist in field "field_a.x-jsf-logic-computedAttrs.title".`,
+      ],
+      [
+        'x-jsf-logic.validations: error if a field does not exist in a deeply nested rule',
+        schemaWithDeepVarThatDoesNotExist,
+        '[json-schema-form] json-logic error: rule "dummy_rule" has no variable "field_b".',
+      ],
+      [
+        'x-jsf-logic.validations: error if rule does not exist on a fieldset property',
+        schemaWithDeepVarThatDoesNotExistOnFieldset,
+        '[json-schema-form] json-logic error: rule "dummy_rule" has no variable "field_a".',
+      ],
+      [
+        'x-jsf-validations: error if a validation name does not exist',
+        schemaWithValidationThatDoesNotExistOnProperty,
+        `[json-schema-form] json-logic error: "field_a" required validation "iDontExist" doesn't exist.`,
+      ],
+      [
+        'x-jsf-logic.validations: A top level logic keyword will not be able to reference fieldset properties',
+        schemaWithPropertyThatDoesNotExistInThatLevelButDoesInFieldset,
+        '[json-schema-form] json-logic error: rule "validation_parent" has no variable "child".',
+      ],
+      [
+        'x-jsf-logic.validations: error if unknown operation',
+        schemaWithBadOperation,
+        '[json-schema-form] json-logic error: in "badOperator" rule there is an unknown operator "++".',
+      ],
+    ];
+
+    test.each(cases)('%p', (_, schema, expectedErrorString) => {
+      const { error } = createHeadlessForm(schema, { strictInputType: false });
+      const expectedError = new Error(expectedErrorString);
+      expect(console.error).toHaveBeenCalledWith('JSON Schema invalid!', expectedError);
+      expect(error).toEqual(expectedError);
+    });
+  });
+
   describe('Arithmetic: +, -, *, /', () => {
     it('multiple: field_a > field_b * 2', () => {
       const schema = createSchemaWithRulesOnFieldA({
@@ -221,10 +318,31 @@ describe('jsonLogic: cross-values validations', () => {
         initialValues: { field_a: 2 },
       });
       const fieldB = fields.find((i) => i.name === 'field_b');
+      expect(fieldB.description).toEqual(
+        'This field is 2 times bigger than field_a with value of 4.'
+      );
       expect(fieldB.default).toEqual(4);
       expect(fieldB.value).toEqual(4);
       handleValidation({ field_a: 4 });
       expect(fieldB.default).toEqual(8);
+      expect(fieldB.label).toEqual('This is 8!');
+    });
+
+    it('Derived errorMessages and statements work', () => {
+      const { fields, handleValidation } = createHeadlessForm(
+        schemaWithComputedAttributesAndErrorMessages,
+        { strictInputType: false }
+      );
+      const fieldB = fields.find((i) => i.name === 'field_b');
+      expect(handleValidation({ field_a: 2, field_b: 0 }).formErrors).toEqual({
+        field_b: 'Must be bigger than 4',
+      });
+      expect(handleValidation({ field_a: 2, field_b: 100 }).formErrors).toEqual({
+        field_b: 'Must be smaller than 8',
+      });
+      expect(fieldB.minimum).toEqual(4);
+      expect(fieldB.maximum).toEqual(8);
+      expect(fieldB.statement).toEqual({ description: 'Must be bigger than 4 and smaller than 8' });
     });
   });
 });

package/src/tests/testUtils.js

@@ -0,0 +1,11 @@
+export function mockConsole() {
+  jest.spyOn(console, 'warn').mockImplementation(() => {});
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+}
+
+export function restoreConsoleAndEnsureItWasNotCalled() {
+  expect(console.error).not.toHaveBeenCalled();
+  console.error.mockRestore();
+  expect(console.warn).not.toHaveBeenCalled();
+  console.warn.mockRestore();
+}