@nolwenture/formik-jsonschema-form 0.22.4 → 0.22.5

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

@@ -159,6 +159,77 @@ const ifThenElseExampleSchema = {
         },
     ],
 };
+const allOfExample = {
+    type: "object",
+    properties: {
+        customerType: { type: "string" },
+    },
+    allOf: [
+        {
+            if: { properties: { customerType: { const: "BUSINESS" } } },
+            then: {
+                properties: {
+                    businessName: { type: "string", title: "Company name" },
+                    code: { type: "string", title: "Code" },
+                    notRequired: { type: "string", title: "Not required" },
+                    address: { $ref: "#/definitions/address" },
+                },
+                required: ["businessName", "code", "address"],
+            },
+        },
+        {
+            if: { properties: { customerType: { const: "INDIVIDUAL" } } },
+            then: {
+                properties: {
+                    firstName: { type: "string", title: "First name" },
+                    code: { type: "number", title: "Code" },
+                    address: { $ref: "#/definitions/address" },
+                },
+                required: ["firstName", "code", "address"],
+            },
+        },
+        {
+            if: { properties: { customerType: { const: "UNKNOWN" } } },
+            then: {
+                properties: {
+                    newCustomer: { type: "boolean", title: "New customer" },
+                    code: { type: "boolean", title: "Code" },
+                    extraField: { type: "number", title: "Extra field" },
+                    address: { $ref: "#/definitions/address" },
+                },
+                required: ["newCustomer", "code", "address"],
+            },
+        },
+    ],
+    definitions: {
+        address: {
+            type: "object",
+            required: ["streetName", "city", "country"],
+            properties: {
+                streetName: {
+                    type: "string",
+                    title: "Street name",
+                },
+                city: {
+                    type: "string",
+                    title: "Town/City",
+                },
+                postcode: {
+                    type: "string",
+                    title: "Postcode",
+                },
+                state: {
+                    type: "string",
+                    title: "State/Province/Region",
+                },
+                country: {
+                    type: "string",
+                    title: "Country",
+                },
+            },
+        },
+    },
+};
 const nestedRequiredConditionalExampleSchema = {
     type: "object",
     properties: {
@@ -189,6 +260,17 @@ const nestedRequiredConditionalExampleSchema = {
     ],
 };
 describe("Create Validation Schema", () => {
+    function listErrors(schema, data) {
+        var _a;
+        const yupSchema = createValidationSchema(schema);
+        try {
+            yupSchema.validateSync(data, { abortEarly: false });
+        }
+        catch (err) {
+            const error = err;
+            return (_a = error === null || error === void 0 ? void 0 : error.inner) === null || _a === void 0 ? void 0 : _a.map((aa) => aa.path);
+        }
+    }
     it("creates yup validationSchema based on given JSON schema", () => __awaiter(void 0, void 0, void 0, function* () {
         const result = createValidationSchema(exampleSchema);
         const expected = result.isValidSync({
@@ -356,6 +438,76 @@ describe("Create Validation Schema", () => {
             expect(firstTrueInvalid3).toEqual(false);
             expect(firstTrueValid).toEqual(true);
         });
+        it("generates validation for if-then", () => __awaiter(void 0, void 0, void 0, function* () {
+            const faultyBusiness = listErrors(allOfExample, {
+                customerType: "BUSINESS",
+            });
+            expect(faultyBusiness).toEqual(expect.arrayContaining([
+                "address.country",
+                "address.city",
+                "address.streetName",
+                "businessName",
+                "code",
+            ]));
+            const business = listErrors(allOfExample, {
+                customerType: "BUSINESS",
+                businessName: ".",
+                code: ".",
+                address: {
+                    streetName: ".",
+                    city: ".",
+                    country: ".",
+                },
+            });
+            expect(business).toEqual(undefined);
+            const faultyIndividual = listErrors(allOfExample, {
+                customerType: "INDIVIDUAL",
+            });
+            expect(faultyIndividual).toEqual(expect.arrayContaining([
+                "address.country",
+                "address.city",
+                "address.streetName",
+                "firstName",
+                "code",
+            ]));
+            const individual = listErrors(allOfExample, {
+                customerType: "INDIVIDUAL",
+                firstName: ".",
+                code: 123,
+                address: {
+                    streetName: ".",
+                    city: ".",
+                    country: ".",
+                },
+            });
+            expect(individual).toEqual(undefined);
+            const faultyUnknown = listErrors(allOfExample, {
+                customerType: "UNKNOWN",
+            });
+            expect(faultyUnknown).toEqual(expect.arrayContaining([
+                "address.country",
+                "address.city",
+                "address.streetName",
+                "newCustomer",
+                "code",
+            ]));
+            const unknown = listErrors(allOfExample, {
+                customerType: "UNKNOWN",
+                newCustomer: true,
+                code: false,
+                address: {
+                    streetName: ".",
+                    city: ".",
+                    country: ".",
+                },
+            });
+            expect(unknown).toEqual(undefined);
+            const yupSchema = createValidationSchema(allOfExample);
+            // Makes sure the context resets between function calls.
+            // eslint-disable-next-line
+            // @ts-expect-error
+            expect(yupSchema.fields.code.deps.length).toEqual(3);
+        }));
         it("generates validation for conditional objects with nested validations", () => {
             const result = createValidationSchema(nestedRequiredConditionalExampleSchema);
             const isValidWhenConditionNotNet = result.isValidSync({

package/dist/utils/createValidationSchema.d.ts

@@ -4,5 +4,9 @@ type Condition = {
     dependentKeys: string[];
     conditionFn: (...value: any[]) => boolean;
 };
-export declare function createValidationSchema(schema: Schema, definitions?: Schema, condition?: Condition): Yup.ObjectSchema<{}, Yup.AnyObject, {}, "">;
+type ConditionsContext = {
+    condition: Condition;
+    yupSchema: Yup.Schema<any, any, any, "">;
+};
+export declare function createValidationSchema(schema: Schema, definitions?: Schema, conditionsContext?: Record<string, ConditionsContext[]>, condition?: Condition): Yup.ObjectSchema<{}, Yup.AnyObject, {}, "">;
 export {};

package/dist/utils/createValidationSchema.js

@@ -9,9 +9,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { solveReferences } from "./solveReferences";
 import * as Yup from "yup";
 import { resolveOneOfValue } from "./resolveSchema";
+import { solveReferences } from "./solveReferences";
 function getConditionalValidations(schema) {
     const { dependencies, allOf } = schema;
     let conditionalValidations = [];
@@ -115,7 +115,7 @@ function getYupType(type) {
             throw new Error("Unsupported schema type");
     }
 }
-export function createValidationSchema(schema, definitions = {}, condition) {
+export function createValidationSchema(schema, definitions = {}, conditionsContext = {}, condition) {
     var _a;
     if (!(schema === null || schema === void 0 ? void 0 : schema.properties)) {
         return Yup.object().shape({});
@@ -123,10 +123,11 @@ export function createValidationSchema(schema, definitions = {}, condition) {
     const schemaDefinitions = Object.assign(Object.assign({}, definitions), ((_a = schema.definitions) !== null && _a !== void 0 ? _a : {}));
     const requiredFields = schema.required;
     function getValue(schema, key) {
+        var _a;
         let type = schema.type;
         let yupSchema;
         if (schema.properties) {
-            yupSchema = createValidationSchema(schema, schemaDefinitions);
+            yupSchema = createValidationSchema(schema, schemaDefinitions, conditionsContext);
             type = type !== null && type !== void 0 ? type : "object";
         }
         else {
@@ -144,12 +145,29 @@ export function createValidationSchema(schema, definitions = {}, condition) {
                 yupSchema = yupSchema["required"]("Required");
             }
         }
-        return condition
-            ? getYupType(type).when(condition.dependentKeys, {
-                is: condition.conditionFn,
-                then: () => yupSchema,
-            })
-            : yupSchema;
+        if (!condition) {
+            return yupSchema;
+        }
+        const existing = (_a = conditionsContext[key]) !== null && _a !== void 0 ? _a : [];
+        conditionsContext[key] = [...existing, { yupSchema, condition }];
+        // TODO: The latest given type for duplicate field is used.
+        // This might become a problem at some point, but testing has not
+        // shown any problems so far.
+        const yupType = getYupType(type).when(condition.dependentKeys, {
+            is: condition.conditionFn,
+            then: () => yupSchema,
+        });
+        // If there are existing conditions for the field with same name
+        // for example definition or duplicate field, add those clauses in.
+        // Otherwise the validation would be overwritten by the latest one
+        // breaking the earlier validations.
+        return existing.reduce((result, context) => {
+            const { condition: ctxCondition, yupSchema: ctxYupSchema } = context;
+            return result.when(ctxCondition.dependentKeys, {
+                is: ctxCondition.conditionFn,
+                then: () => ctxYupSchema,
+            });
+        }, yupType);
     }
     const baseValidationSchema = Object.keys(schema.properties).reduce((validationSchema, key) => {
         var _a;
@@ -159,6 +177,12 @@ export function createValidationSchema(schema, definitions = {}, condition) {
     }, Yup.object().shape({}));
     return getConditionalValidations(schema).reduce((validationSchema, conditionalValidation) => {
         const solvedSchemas = solveReferences(conditionalValidation.schema, schemaDefinitions, {}, {});
-        return validationSchema.concat(createValidationSchema(solvedSchemas.schema, schemaDefinitions, conditionalValidation.condition));
+        /*
+        "Only schemas of the same type can be concatenated. concat is not
+        a "merge" function in the sense that all settings from the provided schema,
+        override ones in the base, including type, presence and nullability."
+        Source: https://github.com/jquense/yup?tab=readme-ov-file#schemaconcatschema-schema-schema
+        */
+        return validationSchema.concat(createValidationSchema(solvedSchemas.schema, schemaDefinitions, conditionsContext, conditionalValidation.condition));
     }, baseValidationSchema);
 }

package/package.json

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