add path helpers

src/utils/form.ts

@@ -2,6 +2,8 @@ import type { TypedMutationTrigger } from "@reduxjs/toolkit/query/react"
 import type { FieldValidator, FormikHelpers } from "formik"
 import { ValidationError, type Schema, type ValidateOptions } from "yup"
 
+import { excludeKeyPaths } from "./general"
+
 export function isFormError(error: unknown): boolean {
   return (
     typeof error === "object" &&
@@ -31,12 +33,12 @@ export function setFormErrors(
 }
 
 export type SubmitFormOptions<
-  QueryArg,
+  QueryArg extends object,
   ResultType,
   FormValues extends QueryArg,
 > = Partial<{
   clean: (values: FormValues) => QueryArg
-  exclude: Array<keyof FormValues>
+  exclude: string[]
   then: (
     result: ResultType,
     values: FormValues,
@@ -50,12 +52,19 @@ export type SubmitFormOptions<
   finally: (values: FormValues, helpers: FormikHelpers<FormValues>) => void
 }>
 
-export type SubmitFormHandler<QueryArg, FormValues extends QueryArg> = (
+export type SubmitFormHandler<
+  QueryArg extends object,
+  FormValues extends QueryArg,
+> = (
   values: FormValues,
   helpers: FormikHelpers<FormValues>,
 ) => void | Promise<any>
 
-export function submitForm<QueryArg, ResultType, FormValues extends QueryArg>(
+export function submitForm<
+  QueryArg extends object,
+  ResultType,
+  FormValues extends QueryArg,
+>(
   trigger: TypedMutationTrigger<ResultType, QueryArg, any>,
   options?: SubmitFormOptions<QueryArg, ResultType, FormValues>,
 ): SubmitFormHandler<QueryArg, FormValues> {
@@ -70,13 +79,7 @@ export function submitForm<QueryArg, ResultType, FormValues extends QueryArg>(
   return (values, helpers) => {
     let arg: QueryArg = clean ? clean(values) : values
 
-    if (exclude && exclude.length) {
-      arg = Object.fromEntries(
-        Object.entries(arg as object).filter(
-          ([key]) => !exclude.includes(key as keyof FormValues),
-        ),
-      ) as QueryArg
-    }
+    if (exclude) arg = excludeKeyPaths(arg, exclude)
 
     trigger(arg)
       .unwrap()

src/utils/general.test.ts

@@ -1,4 +1,6 @@
-import { getNestedProperty } from "./general"
+import { excludeKeyPaths, getNestedProperty, withKeyPaths } from "./general"
+
+// getNestedProperty
 
 const PERSON = { father: { father: { name: "John" } } }
 
@@ -19,3 +21,22 @@ test("get a nested property that doesn't exist", () => {
 
   expect(name).toBeUndefined()
 })
+
+// withKeyPaths
+
+test("get the paths of nested keys", () => {
+  const obj = withKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } })
+
+  expect(obj).toMatchObject({ a: 1, b: { "b.c": 2, "b.d": { "b.d.e": 3 } } })
+})
+
+// excludeKeyPaths
+
+test("exclude nested keys by their path", () => {
+  const obj = excludeKeyPaths({ a: 1, b: { c: 2, d: { e: 3 } } }, [
+    "b.c",
+    "b.d.e",
+  ])
+
+  expect(obj).toMatchObject({ a: 1, b: { d: {} } })
+})

src/utils/general.ts

@@ -453,3 +453,41 @@ export function getNestedProperty(
 
   return value
 }
+
+export function withKeyPaths(obj: object, delimiter: string = "."): object {
+  function _withKeyPaths(obj: object, path: string[]) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => {
+        const _path = [...path, key]
+
+        if (typeof value === "object") value = _withKeyPaths(value, _path)
+
+        return [_path.join(delimiter), value]
+      }),
+    )
+  }
+
+  return _withKeyPaths(obj, [])
+}
+
+export function excludeKeyPaths(
+  obj: object,
+  exclude: string[],
+  delimiter: string = ".",
+): any {
+  function _excludeKeyPaths(obj: object, path: string[]) {
+    return Object.fromEntries(
+      Object.entries(obj)
+        .map(([key, value]) => {
+          const _path = [...path, key]
+
+          if (typeof value === "object") value = _excludeKeyPaths(value, _path)
+
+          return exclude.includes(_path.join(delimiter)) ? [] : [key, value]
+        })
+        .filter(entry => entry.length),
+    )
+  }
+
+  return exclude.length ? _excludeKeyPaths(obj, []) : obj
+}