remix-validated-form 0.0.4 → 1.1.1-beta.1

package/build/internal/formContext.d.ts

@@ -1,11 +1,29 @@
 /// <reference types="react" />
 import { FieldErrors } from "../validation/types";
 export declare type FormContextValue = {
+    /**
+     * All the errors in all the fields in the form.
+     */
     fieldErrors: FieldErrors;
+    /**
+     * Clear the errors of the specified fields.
+     */
     clearError: (...names: string[]) => void;
+    /**
+     * Validate the specified field.
+     */
     validateField: (fieldName: string) => void;
+    /**
+     * The `action` prop of the form.
+     */
     action?: string;
+    /**
+     * Whether or not the form is submitting.
+     */
     isSubmitting: boolean;
+    /**
+     * The default values of the form.
+     */
     defaultValues?: {
         [fieldName: string]: any;
     };

package/build/server.d.ts

@@ -1,2 +1,7 @@
 import { FieldErrors } from "./validation/types";
+/**
+ * Takes the errors from a `Validator` and returns a `Response`.
+ * The `ValidatedForm` on the frontend will automatically display the errors
+ * if this is returned from the action.
+ */
 export declare const validationError: (errors: FieldErrors) => Response;

package/build/server.js

@@ -2,5 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validationError = void 0;
 const server_runtime_1 = require("@remix-run/server-runtime");
+/**
+ * Takes the errors from a `Validator` and returns a `Response`.
+ * The `ValidatedForm` on the frontend will automatically display the errors
+ * if this is returned from the action.
+ */
 const validationError = (errors) => (0, server_runtime_1.json)({ fieldErrors: errors }, { status: 422 });
 exports.validationError = validationError;

package/build/test-data/testFormData.d.ts

@@ -0,0 +1,15 @@
+export declare class TestFormData implements FormData {
+    private _params;
+    constructor(body?: string);
+    append(name: string, value: string | Blob, fileName?: string): void;
+    delete(name: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    set(name: string, value: string | Blob, fileName?: string): void;
+    forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, FormDataEntryValue]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<FormDataEntryValue>;
+    [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+}

package/build/test-data/testFormData.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestFormData = void 0;
+// Copied from remix to use in tests
+// https://github.com/remix-run/remix/blob/a69a631cb5add72d5fb24211ab2a0be367b6f2fd/packages/remix-node/form-data.ts
+class TestFormData {
+    constructor(body) {
+        this._params = new URLSearchParams(body);
+    }
+    append(name, value, fileName) {
+        if (typeof value !== "string") {
+            throw new Error("formData.append can only accept a string");
+        }
+        this._params.append(name, value);
+    }
+    delete(name) {
+        this._params.delete(name);
+    }
+    get(name) {
+        return this._params.get(name);
+    }
+    getAll(name) {
+        return this._params.getAll(name);
+    }
+    has(name) {
+        return this._params.has(name);
+    }
+    set(name, value, fileName) {
+        if (typeof value !== "string") {
+            throw new Error("formData.set can only accept a string");
+        }
+        this._params.set(name, value);
+    }
+    forEach(callbackfn, thisArg) {
+        this._params.forEach(callbackfn, thisArg);
+    }
+    entries() {
+        return this._params.entries();
+    }
+    keys() {
+        return this._params.keys();
+    }
+    values() {
+        return this._params.values();
+    }
+    *[Symbol.iterator]() {
+        yield* this._params;
+    }
+}
+exports.TestFormData = TestFormData;

package/build/validation/createValidator.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from "..";
+/**
+ * Used to create a validator for a form.
+ * It provides built-in handling for unflattening nested objects and
+ * extracting the values from FormData.
+ */
+export declare function createValidator<T>(validator: Validator<T>): Validator<T>;

package/build/validation/createValidator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidator = void 0;
+const flatten_1 = require("../internal/flatten");
+const preprocessFormData = (data) => {
+    // A slightly janky way of determining if the data is a FormData object
+    // since node doesn't really have FormData
+    if ("entries" in data && typeof data.entries === "function")
+        return (0, flatten_1.objectFromPathEntries)([...data.entries()]);
+    return (0, flatten_1.objectFromPathEntries)(Object.entries(data));
+};
+/**
+ * Used to create a validator for a form.
+ * It provides built-in handling for unflattening nested objects and
+ * extracting the values from FormData.
+ */
+function createValidator(validator) {
+    return {
+        validate: (value) => validator.validate(preprocessFormData(value)),
+        validateField: (data, field) => validator.validateField(preprocessFormData(data), field),
+    };
+}
+exports.createValidator = createValidator;

package/build/validation/types.d.ts

@@ -1,4 +1,10 @@
 export declare type FieldErrors = Record<string, string>;
+export declare type GenericObject = {
+    [key: string]: any;
+};
+/**
+ * The result when validating a form.
+ */
 export declare type ValidationResult<DataType> = {
     data: DataType;
     error: undefined;
@@ -6,10 +12,16 @@ export declare type ValidationResult<DataType> = {
     error: FieldErrors;
     data: undefined;
 };
+/**
+ * The result when validating an individual field in a form.
+ */
 export declare type ValidateFieldResult = {
     error?: string;
 };
+/**
+ * A `Validator` can be passed to the `validator` prop of a `ValidatedForm`.
+ */
 export declare type Validator<DataType> = {
-    validate: (unvalidatedData: unknown) => ValidationResult<DataType>;
-    validateField: (unvalidatedData: unknown, field: string) => ValidateFieldResult;
+    validate: (unvalidatedData: GenericObject) => ValidationResult<DataType>;
+    validateField: (unvalidatedData: GenericObject, field: string) => ValidateFieldResult;
 };

package/build/validation/validation.test.js

@@ -20,7 +20,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const yup = __importStar(require("yup"));
+const zod_1 = require("zod");
 const __1 = require("..");
+const testFormData_1 = require("../test-data/testFormData");
+const withZod_1 = require("./withZod");
 const validationTestCases = [
     {
         name: "yup",
@@ -28,6 +31,37 @@ const validationTestCases = [
             firstName: yup.string().required(),
             lastName: yup.string().required(),
             age: yup.number(),
+            address: yup
+                .object({
+                streetAddress: yup.string().required(),
+                city: yup.string().required(),
+                country: yup.string().required(),
+            })
+                .required(),
+            pets: yup.array().of(yup.object({
+                animal: yup.string().required(),
+                name: yup.string().required(),
+            })),
+        })),
+    },
+    {
+        name: "zod",
+        validator: (0, withZod_1.withZod)(zod_1.z.object({
+            firstName: zod_1.z.string().nonempty(),
+            lastName: zod_1.z.string().nonempty(),
+            age: zod_1.z.optional(zod_1.z.number()),
+            address: zod_1.z.preprocess((value) => (value == null ? {} : value), zod_1.z.object({
+                streetAddress: zod_1.z.string().nonempty(),
+                city: zod_1.z.string().nonempty(),
+                country: zod_1.z.string().nonempty(),
+            })),
+            pets: zod_1.z
+                .object({
+                animal: zod_1.z.string().nonempty(),
+                name: zod_1.z.string().nonempty(),
+            })
+                .array()
+                .optional(),
         })),
     },
 ];
@@ -37,41 +71,220 @@ describe("Validation", () => {
     describe.each(validationTestCases)("Adapter for $name", ({ validator }) => {
         describe("validate", () => {
             it("should return the data when valid", () => {
-                const obj = {
+                const person = {
                     firstName: "John",
                     lastName: "Doe",
                     age: 30,
+                    address: {
+                        streetAddress: "123 Main St",
+                        city: "Anytown",
+                        country: "USA",
+                    },
+                    pets: [{ animal: "dog", name: "Fido" }],
                 };
-                expect(validator.validate(obj)).toEqual({
-                    data: obj,
+                expect(validator.validate(person)).toEqual({
+                    data: person,
                     error: undefined,
                 });
             });
             it("should return field errors when invalid", () => {
-                const obj = { age: "hi!" };
+                const obj = { age: "hi!", pets: [{ animal: "dog" }] };
                 expect(validator.validate(obj)).toEqual({
                     data: undefined,
                     error: {
                         firstName: anyString,
                         lastName: anyString,
                         age: anyString,
+                        "address.city": anyString,
+                        "address.country": anyString,
+                        "address.streetAddress": anyString,
+                        "pets[0].name": anyString,
                     },
                 });
             });
+            it("should unflatten data when validating", () => {
+                const data = {
+                    firstName: "John",
+                    lastName: "Doe",
+                    age: 30,
+                    "address.streetAddress": "123 Main St",
+                    "address.city": "Anytown",
+                    "address.country": "USA",
+                    "pets[0].animal": "dog",
+                    "pets[0].name": "Fido",
+                };
+                expect(validator.validate(data)).toEqual({
+                    data: {
+                        firstName: "John",
+                        lastName: "Doe",
+                        age: 30,
+                        address: {
+                            streetAddress: "123 Main St",
+                            city: "Anytown",
+                            country: "USA",
+                        },
+                        pets: [{ animal: "dog", name: "Fido" }],
+                    },
+                    error: undefined,
+                });
+            });
+            it("should accept FormData directly and return errors", () => {
+                const formData = new testFormData_1.TestFormData();
+                formData.set("firstName", "John");
+                formData.set("lastName", "Doe");
+                formData.set("address.streetAddress", "123 Main St");
+                formData.set("address.country", "USA");
+                formData.set("pets[0].animal", "dog");
+                expect(validator.validate(formData)).toEqual({
+                    data: undefined,
+                    error: {
+                        "address.city": anyString,
+                        "pets[0].name": anyString,
+                    },
+                });
+            });
+            it("should accept FormData directly and return valid data", () => {
+                const formData = new testFormData_1.TestFormData();
+                formData.set("firstName", "John");
+                formData.set("lastName", "Doe");
+                formData.set("address.streetAddress", "123 Main St");
+                formData.set("address.country", "USA");
+                formData.set("address.city", "Anytown");
+                formData.set("pets[0].animal", "dog");
+                formData.set("pets[0].name", "Fido");
+                expect(validator.validate(formData)).toEqual({
+                    data: {
+                        firstName: "John",
+                        lastName: "Doe",
+                        address: {
+                            streetAddress: "123 Main St",
+                            country: "USA",
+                            city: "Anytown",
+                        },
+                        pets: [{ animal: "dog", name: "Fido" }],
+                    },
+                    error: undefined,
+                });
+            });
         });
         describe("validateField", () => {
             it("should not return an error if field is valid", () => {
-                const obj = { firstName: "John", lastName: 123 };
-                expect(validator.validateField(obj, "firstName")).toEqual({
+                const person = {
+                    firstName: "John",
+                    lastName: {}, // invalid, but we should only be validating firstName
+                };
+                expect(validator.validateField(person, "firstName")).toEqual({
+                    error: undefined,
+                });
+            });
+            it("should not return an error if a nested field is valid", () => {
+                const person = {
+                    firstName: "John",
+                    lastName: {},
+                    address: {
+                        streetAddress: "123 Main St",
+                        city: "Anytown",
+                        country: "USA",
+                    },
+                    pets: [{ animal: "dog", name: "Fido" }],
+                };
+                expect(validator.validateField(person, "address.streetAddress")).toEqual({
+                    error: undefined,
+                });
+                expect(validator.validateField(person, "address.city")).toEqual({
+                    error: undefined,
+                });
+                expect(validator.validateField(person, "address.country")).toEqual({
+                    error: undefined,
+                });
+                expect(validator.validateField(person, "pets[0].animal")).toEqual({
+                    error: undefined,
+                });
+                expect(validator.validateField(person, "pets[0].name")).toEqual({
                     error: undefined,
                 });
             });
             it("should return an error if field is invalid", () => {
-                const obj = { firstName: "John", lastName: {} };
-                expect(validator.validateField(obj, "lastName")).toEqual({
+                const person = {
+                    firstName: "John",
+                    lastName: {},
+                    address: {
+                        streetAddress: "123 Main St",
+                        city: 1234,
+                    },
+                };
+                expect(validator.validateField(person, "lastName")).toEqual({
+                    error: anyString,
+                });
+            });
+            it("should return an error if a nested field is invalid", () => {
+                const person = {
+                    firstName: "John",
+                    lastName: {},
+                    address: {
+                        streetAddress: "123 Main St",
+                        city: 1234,
+                    },
+                    pets: [{ animal: "dog" }],
+                };
+                expect(validator.validateField(person, "address.country")).toEqual({
+                    error: anyString,
+                });
+                expect(validator.validateField(person, "pets[0].name")).toEqual({
                     error: anyString,
                 });
             });
         });
     });
 });
+describe("withZod", () => {
+    it("returns coherent errors for complex schemas", () => {
+        const schema = zod_1.z.union([
+            zod_1.z.object({
+                type: zod_1.z.literal("foo"),
+                foo: zod_1.z.string(),
+            }),
+            zod_1.z.object({
+                type: zod_1.z.literal("bar"),
+                bar: zod_1.z.string(),
+            }),
+        ]);
+        const obj = {
+            type: "foo",
+            bar: 123,
+            foo: 123,
+        };
+        expect((0, withZod_1.withZod)(schema).validate(obj)).toEqual({
+            data: undefined,
+            error: {
+                type: anyString,
+                bar: anyString,
+                foo: anyString,
+            },
+        });
+    });
+    it("returns errors for fields that are unions", () => {
+        const schema = zod_1.z.object({
+            field1: zod_1.z.union([zod_1.z.literal("foo"), zod_1.z.literal("bar")]),
+            field2: zod_1.z.union([zod_1.z.literal("foo"), zod_1.z.literal("bar")]),
+        });
+        const obj = {
+            field1: "a value",
+            // field2 missing
+        };
+        const validator = (0, withZod_1.withZod)(schema);
+        expect(validator.validate(obj)).toEqual({
+            data: undefined,
+            error: {
+                field1: anyString,
+                field2: anyString,
+            },
+        });
+        expect(validator.validateField(obj, "field1")).toEqual({
+            error: anyString,
+        });
+        expect(validator.validateField(obj, "field2")).toEqual({
+            error: anyString,
+        });
+    });
+});

package/build/validation/withYup.d.ts

@@ -1,3 +1,6 @@
 import type { AnyObjectSchema, InferType } from "yup";
 import { Validator } from "./types";
+/**
+ * Create a `Validator` using a `yup` schema.
+ */
 export declare const withYup: <Schema extends AnyObjectSchema>(validationSchema: Schema) => Validator<InferType<Schema>>;

package/build/validation/withYup.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withYup = void 0;
+const createValidator_1 = require("./createValidator");
 const validationErrorToFieldErrors = (error) => {
     const fieldErrors = {};
     error.inner.forEach((innerError) => {
@@ -10,29 +11,34 @@ const validationErrorToFieldErrors = (error) => {
     });
     return fieldErrors;
 };
-const withYup = (validationSchema) => ({
-    validate: (data) => {
-        try {
-            const validated = validationSchema.validateSync(data, {
-                abortEarly: false,
-            });
-            return { data: validated, error: undefined };
-        }
-        catch (err) {
-            return {
-                error: validationErrorToFieldErrors(err),
-                data: undefined,
-            };
-        }
-    },
-    validateField: (data, field) => {
-        try {
-            validationSchema.validateSyncAt(field, data);
-            return {};
-        }
-        catch (err) {
-            return { error: err.message };
-        }
-    },
-});
+/**
+ * Create a `Validator` using a `yup` schema.
+ */
+const withYup = (validationSchema) => {
+    return (0, createValidator_1.createValidator)({
+        validate: (data) => {
+            try {
+                const validated = validationSchema.validateSync(data, {
+                    abortEarly: false,
+                });
+                return { data: validated, error: undefined };
+            }
+            catch (err) {
+                return {
+                    error: validationErrorToFieldErrors(err),
+                    data: undefined,
+                };
+            }
+        },
+        validateField: (data, field) => {
+            try {
+                validationSchema.validateSyncAt(field, data);
+                return {};
+            }
+            catch (err) {
+                return { error: err.message };
+            }
+        },
+    });
+};
 exports.withYup = withYup;

package/build/validation/withZod.d.ts

@@ -0,0 +1,6 @@
+import type { z } from "zod";
+import { Validator } from "..";
+/**
+ * Create a validator using a `zod` schema.
+ */
+export declare function withZod<T>(zodSchema: z.Schema<T>): Validator<T>;

package/build/validation/withZod.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withZod = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const toPath_1 = __importDefault(require("lodash/toPath"));
+const createValidator_1 = require("./createValidator");
+const getIssuesForError = (err) => {
+    return err.issues.flatMap((issue) => {
+        if ("unionErrors" in issue) {
+            return issue.unionErrors.flatMap((err) => getIssuesForError(err));
+        }
+        else {
+            return [issue];
+        }
+    });
+};
+function pathToString(array) {
+    return array.reduce(function (string, item) {
+        var prefix = string === "" ? "" : ".";
+        return string + (isNaN(Number(item)) ? prefix + item : "[" + item + "]");
+    }, "");
+}
+/**
+ * Create a validator using a `zod` schema.
+ */
+function withZod(zodSchema) {
+    return (0, createValidator_1.createValidator)({
+        validate: (value) => {
+            const result = zodSchema.safeParse(value);
+            if (result.success)
+                return { data: result.data, error: undefined };
+            const fieldErrors = {};
+            getIssuesForError(result.error).forEach((issue) => {
+                const path = pathToString(issue.path);
+                if (!fieldErrors[path])
+                    fieldErrors[path] = issue.message;
+            });
+            return { error: fieldErrors, data: undefined };
+        },
+        validateField: (data, field) => {
+            var _a;
+            const result = zodSchema.safeParse(data);
+            if (result.success)
+                return { error: undefined };
+            return {
+                error: (_a = getIssuesForError(result.error).find((issue) => {
+                    const allPathsAsString = issue.path.map((p) => `${p}`);
+                    return (0, isEqual_1.default)(allPathsAsString, (0, toPath_1.default)(field));
+                })) === null || _a === void 0 ? void 0 : _a.message,
+            };
+        },
+    });
+}
+exports.withZod = withZod;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remix-validated-form",
-  "version": "0.0.4",
+  "version": "1.1.1-beta.1",
   "description": "Form component and utils for easy form validation in remix",
   "browser": "./browser/index.js",
   "main": "./build/index.js",
@@ -14,7 +14,10 @@
     "build:browser": "tsc --project tsconfig.json --module ESNext --outDir ./browser",
     "build:main": "tsc --project tsconfig.json --module CommonJS --outDir ./build",
     "build:tests": "tsc --project tsconfig.json --module CommonJS --outDir ./test-app/remix-validated-form",
+    "build:sample": "tsc --project tsconfig.json --module CommonJS --outDir ./sample-app/remix-validated-form",
+    "sample-app": "npm run build:sample && cd sample-app && npm run dev",
     "test": "jest src",
+    "test:watch": "jest src --watch",
     "lint": "eslint .",
     "prettier": "prettier . --write",
     "prepare": "husky install",
@@ -35,22 +38,23 @@
     "validation"
   ],
   "peerDependencies": {
-    "@remix-run/react": "^1.0.0",
-    "@remix-run/server-runtime": "^1.0.0",
+    "@remix-run/react": "^1.0.6",
+    "@remix-run/server-runtime": "^1.0.6",
     "react": "^17.0.2"
   },
   "devDependencies": {
-    "@remix-run/react": "^1.0.0",
-    "@remix-run/server-runtime": "^1.0.0",
+    "@remix-run/react": "^1.0.6",
+    "@remix-run/server-runtime": "^1.0.6",
     "@types/jest": "^27.0.3",
-    "@types/react": "^17.0.36",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
+    "@types/lodash": "^4.14.178",
+    "@types/react": "^17.0.37",
+    "@typescript-eslint/eslint-plugin": "^5.6.0",
+    "@typescript-eslint/parser": "^5.6.0",
     "babel-eslint": "^10.1.0",
     "eslint": "^7.32.0",
     "eslint-config-react-app": "^6.0.0",
     "eslint-plugin-cypress": "^2.12.1",
-    "eslint-plugin-flowtype": "^5.10.0",
+    "eslint-plugin-flowtype": "^8.0.3",
     "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-jsx-a11y": "^6.5.1",
     "eslint-plugin-prettier": "^4.0.0",
@@ -58,15 +62,17 @@
     "eslint-plugin-react-hooks": "^4.3.0",
     "fetch-blob": "^3.1.3",
     "husky": "^7.0.4",
-    "jest": "^27.3.1",
+    "jest": "^27.4.4",
     "lint-staged": "^12.1.2",
-    "prettier": "^2.5.0",
+    "prettier": "^2.5.1",
     "react": "^17.0.2",
-    "ts-jest": "^27.0.7",
-    "typescript": "^4.5.2",
-    "yup": "^0.32.11"
+    "ts-jest": "^27.1.1",
+    "typescript": "^4.5.3",
+    "yup": "^0.32.11",
+    "zod": "^3.11.6"
   },
   "dependencies": {
+    "lodash": "^4.17.21",
     "tiny-invariant": "^1.2.0"
   },
   "lint-staged": {