@headless-adminapp/app 0.0.8-0.0.9-alpha.1.0

package/dist/dataform/hooks/useLoadFormGridPage.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLoadFormGridPage = useLoadFormGridPage;
+const react_query_1 = require("@tanstack/react-query");
+const hooks_1 = require("../../metadata/hooks");
+function useLoadFormGridPage(logicalName, formId) {
+    const schema = (0, hooks_1.useSchema)(logicalName);
+    const experienceStore = (0, hooks_1.useExperienceStore)();
+    const { data: form, isFetching: isFetchingForm } = (0, react_query_1.useQuery)({
+        queryKey: ['experience-schema-form', logicalName, formId],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            return experienceStore.getForm(logicalName, formId);
+        }),
+        placeholderData: react_query_1.keepPreviousData,
+    });
+    const { data: commands } = (0, react_query_1.useQuery)({
+        queryKey: ['experience-schema-form-commands', logicalName],
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            return experienceStore.getFormCommands(logicalName);
+        }),
+        initialData: [],
+    });
+    if (!schema) {
+        return {
+            loading: false,
+            error: true,
+            title: 'Schema not found',
+            message: 'The schema was not found',
+        };
+    }
+    if (!form) {
+        if (isFetchingForm) {
+            return {
+                loading: true,
+            };
+        }
+        return {
+            loading: false,
+            error: true,
+            title: 'Form not found',
+            message: 'The form was not found',
+        };
+    }
+    if (form.logicalName !== schema.logicalName) {
+        if (isFetchingForm) {
+            return {
+                loading: true,
+            };
+        }
+        return {
+            loading: false,
+            error: true,
+            title: 'Form not found',
+            message: 'The form was not found (missmatch)',
+        };
+    }
+    return {
+        loading: false,
+        error: false,
+        schema,
+        form,
+        commands,
+    };
+}

package/dist/dataform/hooks/useMainFormCommands.d.ts

@@ -0,0 +1,16 @@
+import { EntityFormCommandContext } from '@headless-adminapp/core/experience/form';
+import { CommandItemState } from '../../command';
+export declare function useFormControlContext(): {
+    data: any;
+    logicalName: string;
+    schema: import("@headless-adminapp/core/schema").Schema<import("@headless-adminapp/core/schema").SchemaAttributes>;
+    form: import("@headless-adminapp/core/experience/form").Form<import("@headless-adminapp/core/schema").SchemaAttributes>;
+    formId: string;
+    originalData: import("@headless-adminapp/core/transport").Data<import("@headless-adminapp/core/schema").InferredSchemaType<import("@headless-adminapp/core/schema").SchemaAttributes>> | null;
+    recordId: string | number;
+    refresh: () => Promise<void>;
+    save: (mode?: import("@headless-adminapp/core/experience/form").SaveMode) => Promise<void>;
+    readonly: boolean | undefined;
+};
+export declare function useMainFormCommandHandlerContext(): EntityFormCommandContext;
+export declare function useMainFormCommands(): CommandItemState[][];

package/dist/dataform/hooks/useMainFormCommands.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormControlContext = useFormControlContext;
+exports.useMainFormCommandHandlerContext = useMainFormCommandHandlerContext;
+exports.useMainFormCommands = useMainFormCommands;
+const command_1 = require("../../command");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+const useFormInstance_1 = require("./useFormInstance");
+const useFormIsReadonly_1 = require("./useFormIsReadonly");
+const useFormRecord_1 = require("./useFormRecord");
+const useFormSave_1 = require("./useFormSave");
+const useFormSchema_1 = require("./useFormSchema");
+const useRecordId_1 = require("./useRecordId");
+function useFormControlContext() {
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const form = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.form);
+    const originalData = (0, useFormRecord_1.useFormRecord)();
+    const recordId = (0, useRecordId_1.useRecordId)();
+    const save = (0, useFormSave_1.useFormSave)();
+    const refresh = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.refresh);
+    const formInstance = (0, useFormInstance_1.useFormInstance)();
+    const readonly = (0, useFormIsReadonly_1.useFormIsReadonly)();
+    const data = formInstance.watch();
+    return {
+        data,
+        logicalName: schema.logicalName,
+        schema,
+        form,
+        formId: form.id,
+        originalData: originalData !== null && originalData !== void 0 ? originalData : null,
+        recordId,
+        refresh,
+        save,
+        readonly,
+    };
+}
+function useMainFormCommandHandlerContext() {
+    const primaryControl = useFormControlContext();
+    const baseHandlerContext = (0, command_1.useBaseCommandHandlerContext)();
+    return Object.assign(Object.assign({}, baseHandlerContext), { primaryControl });
+}
+function useMainFormCommands() {
+    const commands = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.commands);
+    const handlerContext = useMainFormCommandHandlerContext();
+    return (0, command_1.useCommands)(commands, handlerContext);
+}

package/dist/dataform/hooks/useRecordId.d.ts

@@ -0,0 +1 @@
+export declare function useRecordId<T extends string | number = string>(): T;

package/dist/dataform/hooks/useRecordId.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRecordId = useRecordId;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useRecordId() {
+    return (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.recordId);
+}

package/dist/dataform/hooks/useRecordTitle.d.ts

@@ -0,0 +1 @@
+export declare function useRecordTitle(): string;

package/dist/dataform/hooks/useRecordTitle.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRecordTitle = useRecordTitle;
+const useFormInstance_1 = require("./useFormInstance");
+const useFormSchema_1 = require("./useFormSchema");
+const useRecordId_1 = require("./useRecordId");
+function useRecordTitle() {
+    var _a;
+    const formInstance = (0, useFormInstance_1.useFormInstance)();
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const recordId = (0, useRecordId_1.useRecordId)();
+    const primaryAttributeValue = (_a = formInstance.watch(schema.primaryAttribute)) !== null && _a !== void 0 ? _a : '';
+    if (primaryAttributeValue) {
+        return primaryAttributeValue;
+    }
+    if (recordId) {
+        return '(No name)';
+    }
+    return `New ${schema.label.toLowerCase()}`;
+}

package/dist/dataform/hooks/useSelectedForm.d.ts

@@ -0,0 +1,3 @@
+import { Form } from '@headless-adminapp/core/experience/form';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useSelectedForm<S extends SchemaAttributes = SchemaAttributes>(): Form<S>;

package/dist/dataform/hooks/useSelectedForm.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSelectedForm = useSelectedForm;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useSelectedForm() {
+    return (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.form);
+}

package/dist/dataform/utils/index.d.ts

@@ -0,0 +1,62 @@
+import type { Attribute } from '@headless-adminapp/core/attributes';
+import { Form } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { IDataService } from '@headless-adminapp/core/transport';
+import { Nullable } from '@headless-adminapp/core/types';
+import * as yup from 'yup';
+import { FormValidationStringSet } from '../../form/FormValidationStringContext';
+export declare function getModifiedValues(initialValues: any, values: any, exclude?: string[]): Record<string, any>;
+type SaveRecordResult = {
+    success: true;
+    recordId: string;
+} | {
+    success: false;
+    title?: string;
+    message: string;
+    isError: boolean;
+};
+export declare function saveRecord({ values, form, schema, dataService, initialValues, record, getSchema, }: {
+    values: any;
+    form: Form<SchemaAttributes>;
+    record: InferredSchemaType<SchemaAttributes> | undefined;
+    initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
+    schema: Schema<SchemaAttributes>;
+    dataService: IDataService;
+    getSchema: (logicalName: string) => Schema<SchemaAttributes>;
+}): Promise<SaveRecordResult>;
+export declare function getInitialValues({ cloneRecord, form, record, recordId, defaultParameters, }: {
+    cloneRecord: InferredSchemaType<SchemaAttributes> | undefined;
+    form: Form<SchemaAttributes>;
+    record: InferredSchemaType<SchemaAttributes> | undefined;
+    recordId: string | undefined;
+    schema: Schema<SchemaAttributes>;
+    defaultParameters: Record<string, any>;
+}): Nullable<InferredSchemaType<SchemaAttributes>>;
+export declare const formValidator: (<A extends SchemaAttributes = SchemaAttributes>({ form, schema, readonlyAttributes, formReadOnly, getSchema, language, strings, }: {
+    schema: Schema<A>;
+    form: Form<A>;
+    language: string;
+    formReadOnly?: boolean;
+    readonlyAttributes?: string[];
+    strings: FormValidationStringSet;
+    getSchema: (logicalName: string) => Schema;
+}) => (values: Record<string, any>, context: any, options: any) => Promise<import("react-hook-form").ResolverResult<{}>>) & import("lodash").MemoizedFunction;
+export declare const generateValidationSchema: (<A extends SchemaAttributes = SchemaAttributes>({ columns, editableGrids, language, schema, strings, readonlyAttributes, }: {
+    schema: Schema<A>;
+    columns: string[];
+    readonlyAttributes?: string[];
+    editableGrids: Array<{
+        schema: Schema;
+        columns: string[];
+        attributeName: string;
+        required?: boolean;
+    }> | undefined;
+    language: string;
+    strings: FormValidationStringSet;
+}) => yup.ObjectSchema<{
+    [x: string]: any;
+}, yup.AnyObject, {
+    [x: string]: any;
+}, "">) & import("lodash").MemoizedFunction;
+export declare const generateAttributeValidationSchema: ((attribute: Attribute, language: string, strings: FormValidationStringSet) => yup.Schema<any, any, any, "">) & import("lodash").MemoizedFunction;
+export {};

package/dist/dataform/utils/index.js

@@ -0,0 +1,356 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAttributeValidationSchema = exports.generateValidationSchema = exports.formValidator = void 0;
+exports.getModifiedValues = getModifiedValues;
+exports.saveRecord = saveRecord;
+exports.getInitialValues = getInitialValues;
+const yup_1 = require("@hookform/resolvers/yup");
+const lodash_1 = require("lodash");
+const yup = __importStar(require("yup"));
+const CommandBuilder_1 = require("../../builders/CommandBuilder");
+const DataResolver_1 = require("../../dataform/DataFormProvider/DataResolver");
+function getModifiedValues(initialValues, values, exclude) {
+    const keys = Object.keys(values);
+    return keys.reduce((p, c) => {
+        if (c === '_id') {
+            return p;
+        }
+        if (exclude && exclude.includes(c)) {
+            return p;
+        }
+        if (JSON.stringify(values[c]) !== JSON.stringify(initialValues[c])) {
+            p[c] = values[c];
+        }
+        return p;
+    }, {});
+}
+function saveRecord(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, initialValues, record, getSchema, }) {
+        const controls = (0, DataResolver_1.getControls)(form);
+        const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+        const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.attributeName));
+        let recordId;
+        if (record) {
+            recordId = record[schema.idAttribute];
+            const operations = [];
+            if (Object.keys(modifiedValues).length) {
+                operations.push({
+                    type: 'update',
+                    logicalName: schema.logicalName,
+                    data: modifiedValues,
+                    id: recordId,
+                });
+            }
+            for (const control of editableGridControls) {
+                const gridSchema = getSchema(control.logicalName);
+                const gridRows = values[control.attributeName];
+                const initialGridRows = initialValues[control.attributeName];
+                const newRows = gridRows.filter((x) => !x[gridSchema.idAttribute]);
+                const updatedRows = gridRows.filter((x) => x[gridSchema.idAttribute]);
+                const deletedIds = initialGridRows === null || initialGridRows === void 0 ? void 0 : initialGridRows.map((x) => x[gridSchema.idAttribute]).filter((id) => !gridRows.find((x) => x[gridSchema.idAttribute] === id));
+                for (const row of newRows) {
+                    operations.push({
+                        type: 'create',
+                        logicalName: control.logicalName,
+                        data: Object.assign(Object.assign({}, row), { [control.referenceAttribute]: {
+                                id: recordId,
+                            } }),
+                    });
+                }
+                for (const row of updatedRows) {
+                    const initialRow = initialGridRows.find((x) => x[gridSchema.idAttribute] === row[gridSchema.idAttribute]);
+                    if (!initialRow) {
+                        throw new Error('Initial row not found');
+                    }
+                    const modifiedRow = getModifiedValues(initialRow, row);
+                    if (!Object.keys(modifiedRow).length) {
+                        continue;
+                    }
+                    operations.push({
+                        type: 'update',
+                        logicalName: control.logicalName,
+                        data: modifiedRow,
+                        id: row[gridSchema.idAttribute],
+                    });
+                }
+                for (const id of deletedIds) {
+                    operations.push({
+                        type: 'delete',
+                        logicalName: control.logicalName,
+                        id,
+                    });
+                }
+            }
+            if (!operations.length) {
+                return {
+                    success: false,
+                    title: 'No changes',
+                    message: 'No changes made to the record',
+                    isError: false,
+                };
+            }
+            if (operations.length > 0) {
+                console.log('operations', operations);
+            }
+            for (const operation of operations) {
+                switch (operation.type) {
+                    case 'create':
+                        yield dataService.createRecord(operation.logicalName, operation.data);
+                        break;
+                    case 'update':
+                        yield dataService.updateRecord(operation.logicalName, operation.id, operation.data);
+                        break;
+                    case 'delete':
+                        yield dataService.deleteRecord(operation.logicalName, operation.id);
+                }
+            }
+        }
+        else {
+            const result = yield dataService.createRecord(schema.logicalName, values);
+            recordId = result[schema.idAttribute];
+            for (const control of editableGridControls) {
+                const gridRows = values[control.attributeName];
+                for (const row of gridRows) {
+                    yield dataService.createRecord(control.logicalName, Object.assign(Object.assign({}, row), { [control.referenceAttribute]: {
+                            id: recordId,
+                        } }));
+                }
+            }
+        }
+        return {
+            success: true,
+            recordId,
+        };
+    });
+}
+function getInitialValues({ cloneRecord, form, record, recordId, defaultParameters, }) {
+    const formColumns = (0, DataResolver_1.getColumns)(form);
+    const editableGridControls = (0, DataResolver_1.getControls)(form).filter((control) => control.type === 'editablegrid');
+    const allColumns = [
+        ...formColumns,
+        ...editableGridControls.map((x) => x.attributeName),
+    ];
+    if (!recordId && !record && form.experience.cloneAttributes && cloneRecord) {
+        const cloneAttributesObj = form.experience.cloneAttributes.reduce((acc, item) => {
+            if (typeof item === 'string') {
+                acc[item] = item;
+            }
+            // TODO:
+            //  else if (isEditableGridCloneAttribute(item)) {
+            //   acc[item.attributeName] = item;
+            // }
+            return acc;
+        }, {});
+        return allColumns.reduce((acc, column) => {
+            var _a;
+            const cloneAttributeInfo = cloneAttributesObj[column];
+            // | EditableGridCloneAttribute; // TODO:
+            let value = null;
+            if (cloneAttributeInfo) {
+                if (typeof cloneAttributeInfo === 'string') {
+                    value = cloneRecord[cloneAttributeInfo];
+                }
+                // else {
+                //   const rows = cloneRecord[cloneAttributeInfo.attributeName] as any[];
+                //   if (!rows?.length) {
+                //     value = [];
+                //   } else {
+                //     value = rows.map((row) => {
+                //       return Object.keys(row).reduce((p, c) => {
+                //         if (c === '_id') {
+                //           return p;
+                //         }
+                //         if (cloneAttributeInfo.attributes.includes(c)) {
+                //           p[c] = row[c];
+                //         } else {
+                //           p[c] = null;
+                //         }
+                //         return p;
+                //       }, {} as Record<string, any>);
+                //     });
+                //   }
+                // }
+            }
+            else {
+                value = (_a = defaultParameters[column]) !== null && _a !== void 0 ? _a : null;
+            }
+            return Object.assign(Object.assign({}, acc), { [column]: value });
+        }, {});
+    }
+    return allColumns.reduce((acc, column) => {
+        var _a;
+        const value = record ? record[column] : (_a = defaultParameters[column]) !== null && _a !== void 0 ? _a : null;
+        return Object.assign(Object.assign({}, acc), { [column]: value });
+    }, {});
+}
+exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, schema, readonlyAttributes, formReadOnly, getSchema, language, strings, }) {
+    return (values, context, options) => __awaiter(this, void 0, void 0, function* () {
+        // console.log('formValidator', values);
+        let validator = yup.object().shape({});
+        if (!formReadOnly) {
+            const activeControls = form.experience.tabs
+                .flatMap((tab) => tab.tabColumns)
+                .flatMap((tabColumn) => tabColumn.sections)
+                .flatMap((section) => {
+                return section.controls;
+            })
+                .filter((control) => {
+                if (control.type === 'standard') {
+                    const attribute = schema.attributes[control.attributeName];
+                    if (attribute.readonly) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            const editableGridControls = activeControls.filter((control) => control.type === 'editablegrid');
+            const columns = Array.from(new Set([
+                schema.primaryAttribute,
+                ...activeControls
+                    .filter((control) => control.type === 'standard')
+                    .map((control) => control.attributeName),
+            ]));
+            validator = (0, exports.generateValidationSchema)({
+                editableGrids: editableGridControls.map((control) => {
+                    if (control.type !== 'editablegrid') {
+                        throw new Error('Invalid control type');
+                    }
+                    const schema = getSchema(control.logicalName);
+                    return {
+                        columns: control.attributes,
+                        schema: schema,
+                        attributeName: control.attributeName,
+                        required: control.required,
+                    };
+                }),
+                schema,
+                columns: columns,
+                language,
+                strings,
+                readonlyAttributes,
+            });
+        }
+        const resolver = (0, yup_1.yupResolver)(validator);
+        const result = yield resolver(values, context, options);
+        // console.log(result);
+        return result;
+    });
+}, ({ form, language, schema, strings, readonlyAttributes, formReadOnly }) => JSON.stringify({
+    schema,
+    form,
+    language,
+    strings,
+    readonlyAttributes,
+    formReadOnly,
+}));
+exports.generateValidationSchema = (0, lodash_1.memoize)(function generateValidationSchema({ columns, editableGrids, language, schema, strings, readonlyAttributes, }) {
+    return yup.object().shape(Object.assign(Object.assign({}, columns.reduce((acc, column) => {
+        if (readonlyAttributes === null || readonlyAttributes === void 0 ? void 0 : readonlyAttributes.includes(column)) {
+            return acc;
+        }
+        const attribute = schema.attributes[column];
+        const validationSchema = (0, exports.generateAttributeValidationSchema)(attribute, language, strings);
+        return Object.assign(Object.assign({}, acc), { [column]: validationSchema });
+    }, {})), editableGrids === null || editableGrids === void 0 ? void 0 : editableGrids.reduce((acc, grid) => {
+        let validationSchema = yup
+            .array()
+            .of(yup.object().shape(Object.assign({}, grid.columns.reduce((acc, column) => {
+            const attribute = grid.schema.attributes[column];
+            const validationSchema = (0, exports.generateAttributeValidationSchema)(attribute, language, strings);
+            return Object.assign(Object.assign({}, acc), { [column]: validationSchema });
+        }, {}))))
+            .nullable();
+        if (grid.required) {
+            validationSchema = validationSchema
+                .required(strings.atLeastOneRowRequired)
+                .min(1, strings.atLeastOneRowRequired);
+        }
+        acc[grid.attributeName] = validationSchema;
+        return acc;
+    }, {})));
+}, ({ columns, editableGrids, language, schema, strings, readonlyAttributes }) => JSON.stringify({
+    schema,
+    columns,
+    editableGrids,
+    language,
+    strings,
+    readonlyAttributes,
+}));
+exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings) {
+    let validationSchema;
+    switch (attribute.type) {
+        case 'string':
+            validationSchema = yup.string().nullable();
+            break;
+        case 'number':
+            validationSchema = yup.number().nullable();
+            break;
+        default:
+            validationSchema = yup.mixed().nullable();
+            break;
+    }
+    const label = (0, CommandBuilder_1.localizedLabel)(language, attribute);
+    if (attribute.required) {
+        validationSchema = validationSchema.required(`${label}: ${strings.required}`);
+    }
+    switch (attribute.type) {
+        case 'string':
+            if (attribute.maxLength) {
+                validationSchema = validationSchema.max(attribute.maxLength, `${label}: ${strings.maxLength}`);
+            }
+            if (attribute.minLength) {
+                validationSchema = validationSchema.min(attribute.minLength, `${label}: ${strings.minLength}`);
+            }
+            if (attribute.pattern) {
+                validationSchema = validationSchema.matches(new RegExp(attribute.pattern), `${label}: ${strings.invalidFormat}`);
+            }
+            if (attribute.format === 'email') {
+                validationSchema = validationSchema.email(`${label}: ${strings.invalidEmail}`);
+            }
+            else if (attribute.format === 'phone') {
+                validationSchema = validationSchema.matches(/^(\+\d{1,2}\s?)?\d{10}$/, `${label}: ${strings.invalidPhoneNumber}`);
+            }
+            break;
+        default:
+            break;
+    }
+    validationSchema = validationSchema.transform((value) => {
+        if (value === '') {
+            return null;
+        }
+        return value;
+    });
+    return validationSchema;
+});

package/dist/datagrid/DataGridProvider/DataResolver.d.ts

@@ -0,0 +1,2 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function DataResolver<S extends SchemaAttributes = SchemaAttributes>(): null;