@nolwenture/formik-jsonschema-form 0.23.3 → 0.24.0

package/dist/utils/__tests/createValidationSchema.test.js

@@ -166,7 +166,14 @@ const ifThenElseExampleSchema = {
 const allOfExample = {
     type: "object",
     properties: {
-        customerType: { type: "string" },
+        customerType: {
+            type: "string",
+            oneOf: [
+                { const: "BUSINESS", title: "Business" },
+                { const: "INDIVIDUAL", title: "Individual" },
+                { const: "UNKNOWN", title: "Unknown" },
+            ],
+        },
     },
     allOf: [
         {
@@ -234,6 +241,58 @@ const allOfExample = {
         },
     },
 };
+const anyOfExample = (required = []) => ({
+    type: "object",
+    title: "",
+    required,
+    properties: {
+        warningSymbols: {
+            type: "array",
+            anyOf: [
+                {
+                    const: "GHS01",
+                    title: "Räjähtävä",
+                },
+                {
+                    const: "GHS02",
+                    title: "Syttyvä",
+                },
+                {
+                    const: "GHS03",
+                    title: "Hapettava",
+                },
+                {
+                    const: "GHS04",
+                    title: "Paineen alaiset kaasut",
+                },
+                {
+                    const: "GHS05",
+                    title: "Syövyttävä",
+                },
+                {
+                    const: "GHS06",
+                    title: "Välittömästi myrkyllinen",
+                },
+                {
+                    const: 5678,
+                    title: "Haitallinen / ärsyttävä / herkistävä / vaarallinen otsonikerrokselle",
+                },
+                {
+                    const: 6789,
+                    title: "Vakava terveysvaara",
+                },
+                {
+                    const: 7890,
+                    title: "Ympäristölle vaarallinen",
+                },
+            ],
+            items: {
+                type: "string",
+            },
+            uniqueItems: true,
+        },
+    },
+});
 const nestedRequiredConditionalExampleSchema = {
     type: "object",
     properties: {
@@ -268,7 +327,8 @@ describe("Create Validation Schema", () => {
         var _a;
         const yupSchema = createValidationSchema(schema, definitions);
         try {
-            yupSchema.validateSync(data, { abortEarly: false });
+            // Cannot be strict, since forms always use string based values
+            yupSchema.validateSync(data, { abortEarly: false, strict: false });
         }
         catch (err) {
             const error = err;
@@ -336,7 +396,7 @@ describe("Create Validation Schema", () => {
             age: 17,
             drinksCoffee: false,
             simpleArray: "Hello :)",
-        }, { strict: true })).rejects.toThrow('simpleArray must be a `tuple` type, but the final value was: `"Hello :)"`.');
+        }, { strict: true })).rejects.toThrow("Required");
     }));
     describe("Conditionals", () => {
         it("generates validation for dependencies without oneOf", () => {
@@ -571,7 +631,7 @@ describe("Create Validation Schema", () => {
             });
             const faultyItem1 = listErrors(arraySchema, {
                 arrayOfObjects: [
-                    true,
+                    ["array"],
                     123.123,
                     456,
                     ["array"],
@@ -580,12 +640,12 @@ describe("Create Validation Schema", () => {
                 ],
             });
             expect(faultyItem1).toEqual([
-                "arrayOfObjects[0]: must be a `string` type, but the final value was: `true`.",
+                'arrayOfObjects[0]: must be a `string` type, but the final value was: `[\n  "\\"array\\""\n]`.',
             ]);
             const faultyItem2 = listErrors(arraySchema, {
                 arrayOfObjects: [
                     "string",
-                    false,
+                    "not a number",
                     456,
                     ["array"],
                     false,
@@ -593,20 +653,20 @@ describe("Create Validation Schema", () => {
                 ],
             });
             expect(faultyItem2).toEqual([
-                "arrayOfObjects[1]: must be a `number` type, but the final value was: `false`.",
+                'arrayOfObjects[1]: must be a `number` type, but the final value was: `NaN` (cast from the value `"not a number"`).',
             ]);
             const faultyItem3 = listErrors(arraySchema, {
                 arrayOfObjects: [
                     "string",
                     123.123,
-                    "incorrect",
+                    false,
                     ["array"],
                     false,
                     { name: "John", age: 27 },
                 ],
             });
             expect(faultyItem3).toEqual([
-                'arrayOfObjects[2]: must be a `number` type, but the final value was: `"incorrect"`.',
+                "arrayOfObjects[2]: must be a `number` type, but the final value was: `NaN` (cast from the value `false`).",
             ]);
             const faultyItem4 = listErrors(arraySchema, {
                 arrayOfObjects: [
@@ -618,9 +678,7 @@ describe("Create Validation Schema", () => {
                     { name: "John", age: 27 },
                 ],
             });
-            expect(faultyItem4).toEqual([
-                'arrayOfObjects[3]: must be a `tuple` type, but the final value was: `{\n  "id": "123"\n}`.',
-            ]);
+            expect(faultyItem4).toEqual(["arrayOfObjects[3]: Required"]);
             const faultyItem5 = listErrors(arraySchema, {
                 arrayOfObjects: [
                     "string",
@@ -667,9 +725,9 @@ describe("Create Validation Schema", () => {
                 "arrayOfObjects[0]: Required",
                 "arrayOfObjects[1]: Required",
                 "arrayOfObjects[2]: Required",
-                "arrayOfObjects[3]: tuple value has too few items, expected a length of 1 but got 0 for value: `[]`",
+                "arrayOfObjects[3]: Required",
                 "arrayOfObjects[4]: Required",
-                "arrayOfObjects[5]: Required",
+                "arrayOfObjects[5].name: Required",
             ]);
             const correct = listErrors(arraySchema, {
                 arrayOfObjects: [
@@ -693,19 +751,19 @@ describe("Create Validation Schema", () => {
                 ],
             });
             const faulty = listErrors(arraySchema, {
-                arrayOfObjects: ["name", undefined, undefined, false],
+                arrayOfObjects: ["name", undefined, undefined, {}],
             });
             expect(faulty).toEqual([
                 "arrayOfObjects[1]: Required",
                 "arrayOfObjects[2]: Required",
-                "arrayOfObjects[3]: must be a `number` type, but the final value was: `false`.",
+                "arrayOfObjects[3]: must be a `number` type, but the final value was: `NaN` (cast from the value `{}`).",
             ]);
             const coprrecorrect = listErrors(arraySchema, {
                 arrayOfObjects: ["name", 123, true, 123.141241],
             });
             expect(coprrecorrect).toEqual(undefined);
         }));
-        it.only("requires fields with array items and additionalItems with definitions", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("requires fields with array items and additionalItems with definitions", () => __awaiter(void 0, void 0, void 0, function* () {
             const arraySchema = {
                 title: "TITLE",
                 properties: {
@@ -750,12 +808,142 @@ describe("Create Validation Schema", () => {
             ]);
             const correct = listErrors(arraySchema, {
                 arrayOfDefinitions: [
-                    { commodityId: "1", insuredValue: "123" },
-                    { commodityId: "2", insuredValue: "456" },
-                    { commodityId: "3", insuredValue: "789" },
+                    { commodityId: "1", insuredValue: 123 },
+                    { commodityId: "2", insuredValue: 456 },
+                    { commodityId: "3", insuredValue: 789 },
                 ],
             }, definitions);
             expect(correct).toEqual(undefined);
         }));
+        it("validates anyOf correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const optionalInput = listErrors(anyOfExample(), { warningSymbols: [] });
+            expect(optionalInput).toEqual(undefined);
+            const requiredInput = listErrors(anyOfExample(["warningSymbols"]), {
+                warningSymbols: [],
+            });
+            expect(requiredInput).toEqual(["warningSymbols: Required"]);
+            const requiredInput2 = listErrors(anyOfExample(["warningSymbols"]), {
+                warningSymbols: [6789],
+            });
+            expect(requiredInput2).toEqual(undefined);
+            const wrongInput = listErrors(anyOfExample(), {
+                // false and 1234 are stringified
+                warningSymbols: [false, {}, [], 1234, "invalid value"],
+            });
+            expect(wrongInput).toEqual([
+                "warningSymbols[0]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
+                "warningSymbols[1]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
+                "warningSymbols[2]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
+                "warningSymbols[3]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
+                "warningSymbols[4]: must be one of the following values: GHS01, GHS02, GHS03, GHS04, GHS05, GHS06, 5678, 6789, 7890",
+            ]);
+            const validInput = listErrors(anyOfExample(), {
+                warningSymbols: ["GHS01", "GHS05", 7890],
+            });
+            expect(validInput).toEqual(undefined);
+        }));
+    });
+    describe("Infinite loop validation", () => {
+        const definitions = {
+            Organization: {
+                type: "array",
+                additionalItems: {
+                    type: "object",
+                    properties: {
+                        name: { title: "Name", type: "string" },
+                        subOrganizations: {
+                            $ref: "#/definitions/Organization",
+                        },
+                    },
+                },
+            },
+        };
+        const treeSchema = {
+            title: "Form editor",
+            type: "object",
+            properties: {
+                organization: {
+                    type: "object",
+                    properties: {
+                        name: { title: "Title", type: "string" },
+                        subOrganizations: {
+                            $ref: "#/definitions/Organization",
+                        },
+                    },
+                },
+            },
+        };
+        it("does not throw RangeError: Maximum call stack size exceeded", () => __awaiter(void 0, void 0, void 0, function* () {
+            const validInput1 = listErrors(treeSchema, {
+                organization: {
+                    name: "Org A",
+                    subOrganizations: [],
+                },
+            }, definitions);
+            expect(validInput1).toEqual(undefined);
+            const validInput2 = listErrors(treeSchema, {
+                organization: {
+                    name: "Org A",
+                    subOrganizations: [
+                        {
+                            name: "Sub A1",
+                            subOrganizations: [
+                                {
+                                    name: "Sub A2",
+                                    subOrganizations: [
+                                        {
+                                            name: "Sub A3",
+                                            subOrganizations: [
+                                                {
+                                                    name: "Sub A4",
+                                                    subOrganizations: [
+                                                        {
+                                                            name: "Sub A5",
+                                                            subOrganizations: [
+                                                                {
+                                                                    name: "Sub A6",
+                                                                    subOrganizations: [
+                                                                        {
+                                                                            name: "Sub A7",
+                                                                            subOrganizations: [
+                                                                                {
+                                                                                    name: "Sub A8",
+                                                                                    subOrganizations: [],
+                                                                                },
+                                                                            ],
+                                                                        },
+                                                                    ],
+                                                                },
+                                                            ],
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            name: "Sub B1",
+                            subOrganizations: [
+                                {
+                                    name: "Sub B2",
+                                    subOrganizations: [],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            }, definitions);
+            expect(validInput2).toEqual(undefined);
+            const invalidInput = listErrors(treeSchema, {
+                organization: {
+                    name: "Org A",
+                    subOrganizations: 123,
+                },
+            }, definitions);
+            expect(invalidInput).toEqual(["organization.subOrganizations: Required"]);
+        }));
     });
 });

package/dist/utils/__tests/hasReferences.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests/hasReferences.test.js

@@ -0,0 +1,100 @@
+import { hasReferences } from "../hasReferences";
+describe("hasReferences", () => {
+    it("returns false if no references are found", () => {
+        const schema = {
+            title: "Deep object",
+            properties: {
+                value: { type: "number" },
+                level1: {
+                    title: "Level1",
+                    properties: {
+                        value: { type: "number" },
+                        level2: {
+                            title: "Level2",
+                            properties: {
+                                value: { type: "number" },
+                                level3: {
+                                    title: "Level3",
+                                    properties: {
+                                        value: { type: "number" },
+                                        level4: {
+                                            title: "Level4",
+                                            properties: {
+                                                value: { type: "number" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect(hasReferences(schema)).toEqual(false);
+    });
+    it("returns true if any references are found", () => {
+        const schema = {
+            title: "Deep object",
+            properties: {
+                value: { type: "number" },
+                level1: {
+                    title: "Level1",
+                    properties: {
+                        value: { type: "number" },
+                        level2: {
+                            title: "Level2",
+                            properties: {
+                                value: { type: "number" },
+                                level3: {
+                                    title: "Level3",
+                                    properties: {
+                                        value: { type: "number" },
+                                        level4: {
+                                            title: "Level4",
+                                            properties: {
+                                                value: { $ref: "#/definitions/organization" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect(hasReferences(schema)).toEqual(true);
+        const schema2 = {
+            title: "Deep object",
+            properties: {
+                value: { type: "number" },
+                level1: {
+                    title: "Level1",
+                    properties: {
+                        value: { type: "number" },
+                        level2: {
+                            title: "Level2",
+                            properties: {
+                                value: { $ref: "#/definitions/organization" },
+                                level3: {
+                                    title: "Level3",
+                                    properties: {
+                                        value: { type: "number" },
+                                        level4: {
+                                            title: "Level4",
+                                            properties: {
+                                                value: { type: "number" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect(hasReferences(schema2)).toEqual(true);
+    });
+});

package/dist/utils/createValidationSchema.js

@@ -140,20 +140,40 @@ export function createValidationSchema(schema, definitions = {}, conditionsConte
     function getValue(givenSchema, key, required) {
         var _a, _b;
         const { schema } = solveReferences(givenSchema, schemaDefinitions, {}, {});
+        const isRequired = (requiredFields === null || requiredFields === void 0 ? void 0 : requiredFields.includes(key)) || required === true;
         let type = schema.type;
         let yupSchema;
         if (schema.properties) {
             yupSchema = createValidationSchema(schema, schemaDefinitions, conditionsContext);
             type = type !== null && type !== void 0 ? type : "object";
         }
+        else if (type === "array" && schema.anyOf) {
+            const anyOf = schema.anyOf;
+            // anyOf is optional, therefore we cannot change it to array.mixedOf() aka tuple
+            const anyOfSchema = Yup.array().of(Yup.lazy(() => {
+                // value has to match with one of the anyOf values in the schema
+                return Yup.mixed().oneOf(anyOf.map((item) => item.const));
+            }));
+            // In case the property is required, there should be at least one item in the array
+            yupSchema = isRequired ? anyOfSchema.min(1, "Required") : anyOfSchema;
+        }
         else if (type === "array") {
+            const additionalItemSchema = (() => {
+                const additionalItems = schema.additionalItems;
+                if (!additionalItems) {
+                    return undefined;
+                }
+                // Yup.lazy() enables validation for infinitely nested schemas
+                // aka references that refer to themselves or in circular references
+                return Yup.lazy(() => {
+                    return getValue(schema === null || schema === void 0 ? void 0 : schema.additionalItems, "#ignore-this", true);
+                });
+            })();
             const schemaItems = (_a = schema === null || schema === void 0 ? void 0 : schema.items) !== null && _a !== void 0 ? _a : [];
             const items = Array.isArray(schemaItems) ? schemaItems : [schemaItems];
             yupSchema = Yup.array().mixedOf({
                 itemSchemas: items.map((item) => getValue(item, "#ignore-this", true)),
-                additionalItemSchema: (schema === null || schema === void 0 ? void 0 : schema.additionalItems)
-                    ? getValue(schema === null || schema === void 0 ? void 0 : schema.additionalItems, "#ignore-this", true)
-                    : undefined,
+                additionalItemSchema,
             });
         }
         else {
@@ -161,7 +181,6 @@ export function createValidationSchema(schema, definitions = {}, conditionsConte
         }
         if (type === "null")
             yupSchema.nullable();
-        const isRequired = (requiredFields === null || requiredFields === void 0 ? void 0 : requiredFields.includes(key)) || required === true;
         if (isRequired && type !== "array") {
             yupSchema = yupSchema.required("Required");
         }

package/dist/utils/hasReferences.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../types";
+export declare function hasReferences(schema: Schema): boolean;

package/dist/utils/hasReferences.js

@@ -0,0 +1,12 @@
+export function hasReferences(schema) {
+    const properties = schema === null || schema === void 0 ? void 0 : schema.properties;
+    if (!properties)
+        return false;
+    return Object.keys(properties).some((key) => {
+        const value = properties[key];
+        if (value === null || value === void 0 ? void 0 : value.properties) {
+            return hasReferences(value);
+        }
+        return Object.keys(value).includes("$ref");
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolwenture/formik-jsonschema-form",
-  "version": "0.23.3",
+  "version": "0.24.0",
   "description": "Formik form generation from json schema",
   "author": "Antti Vikman <antti.vikman@nolwenture.com>",
   "contributors": [