Added tests

Added if then else logic to resolve schemas

Author: Juansasa

packages/core/src/utils.js

@@ -572,7 +572,7 @@ export function optionsList(schema) {
     });
   } else {
     const altSchemas = schema.oneOf || schema.anyOf;
-    return altSchemas.map((schema, i) => {
+    return altSchemas.map(schema => {
       const value = toConstant(schema);
       const label = schema.title || String(value);
       return {
@@ -662,12 +662,37 @@ export function stubExistingAdditionalProperties(
   return schema;
 }
 
+const _resolveCondition = (schema, rootSchema, formdata) => {
+  let {
+    if: expression,
+    then,
+    else: otherwise,
+    ...resolvedSchemaLessConditional
+  } = schema;
+
+  const conditionalSchema = isValid(expression, formdata, rootSchema)
+    ? then
+    : otherwise;
+
+  if (conditionalSchema) {
+    return retrieveSchema(
+      mergeSchemas(conditionalSchema, resolvedSchemaLessConditional),
+      rootSchema,
+      formdata
+    );
+  } else {
+    return retrieveSchema(resolvedSchemaLessConditional, rootSchema, formdata);
+  }
+};
+
 export function resolveSchema(schema, rootSchema = {}, formData = {}) {
   if (schema.hasOwnProperty("$ref")) {
     return resolveReference(schema, rootSchema, formData);
   } else if (schema.hasOwnProperty("dependencies")) {
     const resolvedSchema = resolveDependencies(schema, rootSchema, formData);
     return retrieveSchema(resolvedSchema, rootSchema, formData);
+  } else if (schema.hasOwnProperty("if")) {
+    return _resolveCondition(schema, rootSchema, formData);
   } else if (schema.hasOwnProperty("allOf")) {
     return {
       ...schema,

packages/core/test/utils_test.js

@@ -2388,6 +2388,142 @@ describe("utils", () => {
         });
       });
     });
+
+    describe("ifElseThen", () => {
+      it("should resolve if, then", () => {
+        const schema = {
+          type: "object",
+          properties: {
+            country: {
+              default: "United States of America",
+              enum: ["United States of America", "Canada"],
+            },
+          },
+          if: {
+            properties: { country: { const: "United States of America" } },
+          },
+          then: {
+            properties: { postal_code: { pattern: "[0-9]{5}(-[0-9]{4})?" } },
+          },
+          else: {
+            properties: {
+              postal_code: { pattern: "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" },
+            },
+          },
+        };
+        const definitions = {};
+        const formData = {
+          country: "United States of America",
+          postal_code: "20500",
+        };
+        expect(retrieveSchema(schema, { definitions }, formData)).eql({
+          type: "object",
+          properties: {
+            country: {
+              default: "United States of America",
+              enum: ["United States of America", "Canada"],
+            },
+            postal_code: { pattern: "[0-9]{5}(-[0-9]{4})?" },
+          },
+        });
+      });
+      it("should resolve if, else", () => {
+        const schema = {
+          type: "object",
+          properties: {
+            country: {
+              default: "United States of America",
+              enum: ["United States of America", "Canada"],
+            },
+          },
+          if: {
+            properties: { country: { const: "United States of America" } },
+          },
+          then: {
+            properties: { postal_code: { pattern: "[0-9]{5}(-[0-9]{4})?" } },
+          },
+          else: {
+            properties: {
+              postal_code: { pattern: "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" },
+            },
+          },
+        };
+        const definitions = {};
+        const formData = {
+          country: "Canada",
+          postal_code: "K1M 1M4",
+        };
+        expect(retrieveSchema(schema, { definitions }, formData)).eql({
+          type: "object",
+          properties: {
+            country: {
+              default: "United States of America",
+              enum: ["United States of America", "Canada"],
+            },
+            postal_code: { pattern: "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]" },
+          },
+        });
+      });
+      it("should resolve multiple conditions", () => {
+        const schema = {
+          type: "object",
+          properties: {
+            animal: {
+              enum: ["Cat", "Fish"],
+            },
+          },
+          allOf: [
+            {
+              if: {
+                properties: { animal: { const: "Cat" } },
+              },
+              then: {
+                properties: {
+                  food: { type: "string", enum: ["meat", "grass", "fish"] },
+                },
+              },
+              required: ["food"],
+            },
+            {
+              if: {
+                properties: { animal: { const: "Fish" } },
+              },
+              then: {
+                properties: {
+                  food: {
+                    type: "string",
+                    enum: ["insect", "worms"],
+                  },
+                  water: {
+                    type: "string",
+                    enum: ["lake", "sea"],
+                  },
+                },
+                required: ["food", "water"],
+              },
+            },
+            {
+              required: ["animal"],
+            },
+          ],
+        };
+        const definitions = {};
+        const formData = {
+          animal: "Cat",
+        };
+
+        expect(retrieveSchema(schema, { definitions }, formData)).eql({
+          type: "object",
+          properties: {
+            animal: {
+              enum: ["Cat", "Fish"],
+            },
+            food: { type: "string", enum: ["meat", "grass", "fish"] },
+          },
+          required: ["animal", "food"],
+        });
+      });
+    });
   });
 
   describe("shouldRender", () => {

packages/playground/src/samples/ifElseThen.js

@@ -0,0 +1,45 @@
+module.exports = {
+  schema: {
+    type: "object",
+    properties: {
+      animal: {
+        enum: ["Cat", "Fish"],
+      },
+    },
+    allOf: [
+      {
+        if: {
+          properties: { animal: { const: "Cat" } },
+        },
+        then: {
+          properties: {
+            food: { type: "string", enum: ["meat", "grass", "fish"] },
+          },
+          required: ["food"],
+        },
+      },
+      {
+        if: {
+          properties: { animal: { const: "Fish" } },
+        },
+        then: {
+          properties: {
+            food: {
+              type: "string",
+              enum: ["insect", "worms"],
+            },
+            water: {
+              type: "string",
+              enum: ["lake", "sea"],
+            },
+          },
+          required: ["food", "water"],
+        },
+      },
+      {
+        required: ["animal"],
+      },
+    ],
+  },
+  formData: {},
+};

packages/playground/src/samples/index.js

@@ -26,6 +26,7 @@ import nullable from "./nullable";
 import nullField from "./null";
 import errorSchema from "./errorSchema";
 import defaults from "./defaults";
+import ifElseThen from "./ifElseThen";
 
 export const samples = {
   Simple: simple,
@@ -52,6 +53,7 @@ export const samples = {
   "Any Of": anyOf,
   "One Of": oneOf,
   "All Of": allOf,
+  "If Else Then": ifElseThen,
   "Null fields": nullField,
   Nullable: nullable,
   ErrorSchema: errorSchema,