@caipira/tamandua 0.0.1

package/services/form/form-data-transformers.ts

@@ -0,0 +1,148 @@
+import { FormDataTypes, FormSubmissionFormat } from "@/enums/form";
+import {
+    formValueDateTransformer,
+    formValuePriceTransformer,
+    formValueCountryTransformer,
+    formValuePasswordTransformer,
+} from "@/services/form/form-value-transformers";
+import {
+    FormDataForm,
+    TransformedForm,
+    FormSchemaValueMap,
+    AcceptedFormDataValues,
+} from "@/types/form";
+``;
+const sanitizeValue = (value: string | number): AcceptedFormDataValues => {
+    if (value === null || value === undefined) {
+        value = "";
+    } else if (typeof value === "object") {
+        value = JSON.stringify(value);
+    } else if (typeof value === "number") {
+        value = value.toString();
+    } else if (typeof value === "boolean") {
+        value = value ? "1" : "0";
+    }
+
+    return value;
+};
+
+const transformers = {
+    default: (
+        value:
+            | FormSchemaValueMap[FormDataTypes.String]
+            | FormSchemaValueMap[FormDataTypes.Number],
+        form: FormDataForm,
+        key: string
+    ) => {
+        value = sanitizeValue(value);
+
+        if (value) {
+            form.append(key, value);
+        }
+
+        return form;
+    },
+    price: (
+        price: FormSchemaValueMap[FormDataTypes.Price],
+        form: FormDataForm,
+        key: string,
+        suffixes: string[] = ["Currency", "Value"]
+    ): FormDataForm => {
+        const [iso, value] = formValuePriceTransformer(price);
+
+        form.append(`${key}${suffixes[0]}`, sanitizeValue(iso));
+        form.append(`${key}${suffixes[1]}`, sanitizeValue(value));
+
+        return form;
+    },
+    address: (
+        address: FormSchemaValueMap[FormDataTypes.Address],
+        form: FormDataForm,
+        key: string
+    ): FormDataForm => {
+        form.append(
+            key,
+            JSON.stringify({
+                ...address,
+                country: formValueCountryTransformer(address?.country),
+            })
+        );
+
+        return form;
+    },
+    documents: (
+        files: FormSchemaValueMap[FormDataTypes.Documents],
+        form: FormDataForm,
+        key: string
+    ): FormDataForm => {
+        if (!key.endsWith("[]")) {
+            key = `${key}[]`;
+        }
+
+        Array.from(files).forEach((file: File) => form.append(key, file));
+
+        return form;
+    },
+    document: (
+        file: FormSchemaValueMap[FormDataTypes.Document],
+        form: FormDataForm,
+        key: string
+    ): FormDataForm => {
+        form.append(key, file);
+
+        return form;
+    },
+    stringArray: (
+        value: FormSchemaValueMap[FormDataTypes.StringArray],
+        form: FormDataForm,
+        key: string
+    ) => {
+        if (!key.endsWith("[]")) {
+            key = `${key}[]`;
+        }
+
+        value.forEach((item: string) => form.append(key, sanitizeValue(item)));
+
+        return form;
+    },
+};
+
+export const formValueToFormDataValue = async (
+    schema: FormDataTypes,
+    form: TransformedForm<FormSubmissionFormat.FormData>,
+    value: FormFieldValue<typeof schema>,
+    key: string
+): Promise<FormDataForm> => {
+    switch (schema) {
+        case FormDataTypes.Country:
+            return transformers.default(
+                formValueCountryTransformer(value),
+                form,
+                key
+            );
+        case FormDataTypes.Document:
+            return transformers.document(value, form, key);
+        case FormDataTypes.Documents:
+            return transformers.documents(value, form, key);
+        case FormDataTypes.Date:
+            return transformers.default(
+                formValueDateTransformer(value),
+                form,
+                key
+            );
+        case FormDataTypes.Address:
+            return transformers.address(value, form, key);
+        case FormDataTypes.Price:
+            return transformers.price(value, form, key);
+        case FormDataTypes.Password:
+            return transformers.default(
+                await formValuePasswordTransformer(value),
+                form,
+                key
+            );
+        case FormDataTypes.StringArray:
+            return transformers.stringArray(value, form, key);
+        default:
+            return transformers.default(value, form, key);
+    }
+};

package/services/form/form-json-transformers.ts

@@ -0,0 +1,91 @@
+import { FormDataTypes, FormSubmissionFormat } from "@/enums/form";
+import {
+    JSONForm,
+    FormSchema,
+    TransformedForm,
+    FormSchemaValueMap,
+} from "@/types/form";
+
+import {
+    formValueDateTransformer,
+    formValuePriceTransformer,
+    formValueCountryTransformer,
+    formValuePasswordTransformer,
+} from "@/services/form/form-value-transformers";
+
+const transformers = {
+    default: (
+        value: FormSchemaValueMap[FormDataTypes.String],
+        form: JSONForm,
+        key: string
+    ) => {
+        form[key] = value;
+
+        return form;
+    },
+    price: (
+        date: FormSchemaValueMap[FormDataTypes.Price],
+        form: JSONForm,
+        key: string,
+        suffixes: string[] = ["Currency", "Value"]
+    ): JSONForm => {
+        const [currency, value] = formValuePriceTransformer(date);
+
+        form[`${key}${suffixes[0]}`] = currency;
+        form[`${key}${suffixes[1]}`] = value;
+
+        return form;
+    },
+    password: async (
+        value: FormSchemaValueMap[FormDataTypes.Password],
+        form: JSONForm,
+        key: string
+    ): Promise<JSONForm> => {
+        form[key] = await formValuePasswordTransformer(value);
+
+        return form;
+    },
+    stringArray: (
+        value: FormSchemaValueMap[FormDataTypes.StringArray],
+        form: JSONForm,
+        key: string
+    ) => {
+        form[key] = value;
+
+        return form;
+    },
+};
+
+export const formValueToJSONFormValue = async <T extends FormDataTypes>(
+    schema: FormSchema[T],
+    form: TransformedForm<FormSubmissionFormat.JSON>,
+    value: any,
+    key: string
+): Promise<JSONForm> => {
+    switch (schema) {
+        case FormDataTypes.Country:
+            return transformers.default(
+                formValueCountryTransformer(value),
+                form,
+                key
+            );
+        case FormDataTypes.Documents:
+            return transformers.default(value, form, key);
+        case FormDataTypes.Date:
+            return transformers.default(
+                formValueDateTransformer(value),
+                form,
+                key
+            );
+        case FormDataTypes.Address:
+            return transformers.default(value, form, key);
+        case FormDataTypes.Price:
+            return transformers.price(value, form, key);
+        case FormDataTypes.Password:
+            return await transformers.password(value, form, key);
+        case FormDataTypes.StringArray:
+            return transformers.stringArray(value, form, key);
+        default:
+            return transformers.default(value, form, key);
+    }
+};

package/services/form/form-transformer.ts

@@ -0,0 +1,54 @@
+import { FormSubmissionFormat } from "@/enums/form";
+import {
+    FormSchema,
+    FormInstance,
+    FormSubmissionFormatMap,
+    TransformedForm,
+} from "@/types/form";
+
+import { formValueToJSONFormValue } from "@/services/form/form-json-transformers";
+import { formValueToFormDataValue } from "@/services/form/form-data-transformers";
+
+/**
+ * Transforms the form values to a format that conforms to the submission format
+ */
+export const transformForm = async <
+    F extends FormSubmissionFormat,
+    S extends FormSchema,
+>(
+    form: FormInstance<S>,
+    schema: FormSchema,
+    submissionFormat: F,
+): Promise<FormSubmissionFormatMap[F]> => {
+    switch (submissionFormat) {
+        case FormSubmissionFormat.JSON:
+            let json: TransformedForm<FormSubmissionFormat.JSON> = {};
+
+            for (const key in form) {
+                json = await formValueToJSONFormValue(
+                    schema[key],
+                    json,
+                    form[key],
+                    key,
+                );
+            }
+
+            return json as FormSubmissionFormatMap[F];
+
+        case FormSubmissionFormat.FormData:
+        default:
+            let formData: TransformedForm<FormSubmissionFormat.FormData> =
+                new FormData();
+
+            for (const key in form) {
+                formData = await formValueToFormDataValue(
+                    schema[key],
+                    formData,
+                    form[key],
+                    key,
+                );
+            }
+
+            return formData as FormSubmissionFormatMap[F];
+    }
+};

package/services/form/form-value-transformers.ts

@@ -0,0 +1,35 @@
+import { Country } from "@/types/address";
+import { InputPriceModel, InputPasswordModel } from "@/types/form";
+
+// import useVault from "@/composables/useVault";
+import dateService from "@/services/date";
+
+// const vault = useVault();
+
+const formValueDateTransformer = (date: Date): string => {
+    return date ? dateService.format(date, "yyyy-MM-dd") : "";
+};
+
+const formValuePriceTransformer = (price: InputPriceModel): string[] => {
+    return [`${price?.iso}`, `${price?.value}`];
+};
+
+const formValueCountryTransformer = (country?: Country): string => {
+    return country?.iso2 ?? "";
+};
+
+const formValuePasswordTransformer = async (
+    password?: InputPasswordModel,
+): Promise<string> => {
+    const pass = password?.value ?? "";
+
+    // return password?.encrypt ? await vault.encrypt(pass) : pass;
+    return pass;
+};
+
+export {
+    formValueDateTransformer,
+    formValuePriceTransformer,
+    formValueCountryTransformer,
+    formValuePasswordTransformer,
+};

package/services/form/form.test.ts

@@ -0,0 +1,98 @@
+import { FormInstance } from "@/types/form";
+import { FormDataTypes, FormSubmissionFormat } from "@/enums/form";
+
+import { expect, test } from "vitest";
+import { transformForm } from "@/services/form/form-transformer";
+
+test("Form is transformed into FormData", async () => {
+    const schema = {
+        name: FormDataTypes.String as const,
+        age: FormDataTypes.Number as const,
+        hobbies: FormDataTypes.StringArray as const,
+        birthDate: FormDataTypes.Date as const,
+        password: FormDataTypes.Password as const,
+        price: FormDataTypes.Price as const,
+    };
+
+    const form: FormInstance<typeof schema> = {
+        name: "Theone",
+        age: 27,
+        hobbies: ["Reading", "Coding"],
+        birthDate: new Date("1996-10-06"),
+        password: {
+            value: "123",
+            strength: 100,
+            encrypt: false,
+            updatedAt: new Date(),
+        },
+        price: {
+            iso: "USD",
+            value: 100,
+        },
+    };
+
+    const transformedForm = await transformForm(
+        form,
+        schema,
+        FormSubmissionFormat.FormData,
+    );
+
+    expect(transformedForm instanceof FormData).toBeTruthy();
+
+    // Only the password is extracted from the object
+    expect(transformedForm.get("password")).toBe("123");
+
+    // The price is split into the currency and value
+    expect(transformedForm.get("priceCurrency")).toBe("USD");
+    expect(transformedForm.get("priceValue")).toBe("100");
+
+    expect(transformedForm.get("name")).toBe("Theone");
+    expect(transformedForm.get("age")).toBe("27");
+    expect(transformedForm.getAll("hobbies[]")).toEqual(["Reading", "Coding"]);
+    expect(transformedForm.get("birthDate")).toBe("1996-10-06");
+});
+
+test("Form is transformed into JSON", async () => {
+    const schema = {
+        name: FormDataTypes.String as const,
+        age: FormDataTypes.Number as const,
+        hobbies: FormDataTypes.StringArray as const,
+        birthDate: FormDataTypes.Date as const,
+        password: FormDataTypes.Password as const,
+        price: FormDataTypes.Price as const,
+    };
+
+    const form: FormInstance<typeof schema> = {
+        name: "Theone",
+        age: 27,
+        hobbies: ["Reading", "Coding"],
+        birthDate: new Date("1996-10-06"),
+        password: {
+            value: "123",
+            strength: 100,
+            encrypt: false,
+            updatedAt: new Date(),
+        },
+        price: {
+            iso: "USD",
+            value: 100,
+        },
+    };
+
+    const transformedForm = await transformForm(
+        form,
+        schema,
+        FormSubmissionFormat.JSON,
+    );
+
+    expect(transformedForm instanceof Object).toBeTruthy();
+    expect(transformedForm).toEqual({
+        name: "Theone",
+        age: 27,
+        hobbies: ["Reading", "Coding"],
+        birthDate: "1996-10-06",
+        password: "123",
+        priceCurrency: "USD",
+        priceValue: "100",
+    });
+});

package/services/form/form.ts

@@ -0,0 +1,80 @@
+import { APISearchFilters } from "@/types/api";
+
+const jsonToFormData = (json: any) => {
+    const formData = new FormData();
+
+    if (json) {
+        for (const key in json) {
+            if (json[key] !== null && json[key] !== undefined) {
+                if (Array.isArray(json[key])) {
+                    json[key].forEach((item: any) => {
+                        formData.append(`${key}[]`, item);
+                    });
+                } else {
+                    formData.append(key, json[key]);
+                }
+            }
+        }
+    }
+
+    return formData;
+};
+
+const formDataToJson = (formData: FormData) => {
+    const json: any = {};
+
+    formData.forEach((value, key) => {
+        json[key] = value;
+    });
+
+    return json;
+};
+
+const hitSearchCache = (
+    filters: APISearchFilters | undefined,
+    store: any,
+    key: string
+) => {
+    if (!store) {
+        return;
+    }
+
+    if (filters?.i) {
+        const item = store[
+            filters?.r && filters?.r === "option" ? `${key}Options` : key
+        ]?.find((item: { uuid: string }) => item.uuid === filters.i);
+
+        if (item) {
+            return {
+                items: [item],
+                pagination: {
+                    page: 1,
+                    pages: 1,
+                    perPage: 12,
+                    items: 1,
+                    totalItems: 1,
+                    skip: 0,
+                },
+            };
+        }
+    }
+};
+
+const refreshSearchCache = (
+    filters: APISearchFilters | undefined,
+    store: any,
+    key: string,
+    data: any[]
+) => {
+    if (!store) {
+        return;
+    }
+
+    if (filters?.r && filters?.r === "option") {
+        store[`${key}Options`] = data;
+    } else {
+        store[key] = data;
+    }
+};
+
+export { jsonToFormData, formDataToJson, hitSearchCache, refreshSearchCache };