@headless-adminapp/app 0.0.17-alpha.8 → 1.0.0

package/dataform/utils/index.js

@@ -22,142 +22,23 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.generateAttributeValidationSchema = exports.generateValidationSchema = exports.formValidator = exports.saveRecord = void 0;
 exports.getInitialValues = getInitialValues;
+const phone_1 = require("@headless-adminapp/app/utils/phone");
 const yup_1 = require("@hookform/resolvers/yup");
 const lodash_1 = require("lodash");
 const yup = __importStar(require("yup"));
-const DataResolver_1 = require("../../dataform/DataFormProvider/DataResolver");
-const utils_1 = require("../../locale/utils");
-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, schemaStore, }) {
-        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 = schemaStore.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,
-                };
-            }
-            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 utils_1 = require("../../dataform/DataFormProvider/utils");
+const utils_2 = require("../../locale/utils");
+var saveRecord_1 = require("./saveRecord");
+Object.defineProperty(exports, "saveRecord", { enumerable: true, get: function () { return saveRecord_1.saveRecord; } });
+function getInitialValues({ cloneRecord, form, record, recordId, schema, defaultParameters, }) {
+    const formColumns = (0, utils_1.getColumns)(form, schema);
+    const editableGridControls = (0, utils_1.getControls)(form).filter((control) => control.type === 'editablegrid');
     const allColumns = [
         ...formColumns,
-        ...editableGridControls.map(x => x.attributeName),
+        ...editableGridControls.map((x) => x.attributeName),
     ];
     if (!recordId && !record && form.experience.cloneAttributes && cloneRecord) {
         const cloneAttributesObj = form.experience.cloneAttributes.reduce((acc, item) => {
@@ -171,7 +52,6 @@ function getInitialValues({ cloneRecord, form, record, recordId, defaultParamete
             return acc;
         }, {});
         return allColumns.reduce((acc, column) => {
-            var _a;
             const cloneAttributeInfo = cloneAttributesObj[column];
             // | EditableGridCloneAttribute; // TODO:
             let value = null;
@@ -201,28 +81,33 @@ function getInitialValues({ cloneRecord, form, record, recordId, defaultParamete
                 // }
             }
             else {
-                value = (_a = defaultParameters[column]) !== null && _a !== void 0 ? _a : null;
+                value = defaultParameters[column] ?? null;
             }
-            return Object.assign(Object.assign({}, acc), { [column]: value });
+            return {
+                ...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 });
+        const value = record ? record[column] : defaultParameters[column] ?? null;
+        return {
+            ...acc,
+            [column]: value,
+        };
     }, {});
 }
-exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, schema, readonlyAttributes, formReadOnly, schemaStore, language, strings, }) {
-    return (values, context, options) => __awaiter(this, void 0, void 0, function* () {
+exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, schema, readonlyAttributes, formReadOnly, schemaStore, language, strings, region, }) {
+    return async (values, context, options) => {
         let validator = yup.object().shape({});
         if (!formReadOnly) {
             const activeControls = form.experience.tabs
-                .flatMap(tab => tab.tabColumns)
-                .flatMap(tabColumn => tabColumn.sections)
-                .flatMap(section => {
+                .flatMap((tab) => tab.tabColumns)
+                .flatMap((tabColumn) => tabColumn.sections)
+                .flatMap((section) => {
                 return section.controls;
             })
-                .filter(control => {
+                .filter((control) => {
                 if (control.type === 'standard') {
                     const attribute = schema.attributes[control.attributeName];
                     if (attribute.readonly) {
@@ -231,15 +116,15 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
                 }
                 return true;
             });
-            const editableGridControls = activeControls.filter(control => control.type === 'editablegrid');
+            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),
+                    .filter((control) => control.type === 'standard')
+                    .map((control) => control.attributeName),
             ]));
             validator = (0, exports.generateValidationSchema)({
-                editableGrids: editableGridControls.map(control => {
+                editableGrids: editableGridControls.map((control) => {
                     if (control.type !== 'editablegrid') {
                         throw new Error('Invalid control type');
                     }
@@ -256,12 +141,13 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
                 language,
                 strings,
                 readonlyAttributes,
+                region,
             });
         }
         const resolver = (0, yup_1.yupResolver)(validator);
-        const result = yield resolver(values, context, options);
+        const result = await resolver(values, context, options);
         return result;
-    });
+    };
 }, ({ form, language, schema, strings, readonlyAttributes, formReadOnly }) => JSON.stringify({
     schema,
     form,
@@ -270,40 +156,52 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
     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)) {
+exports.generateValidationSchema = (0, lodash_1.memoize)(function generateValidationSchema({ columns, editableGrids, language, schema, strings, readonlyAttributes, region, }) {
+    return yup.object().shape({
+        ...columns.reduce((acc, column) => {
+            if (readonlyAttributes?.includes(column)) {
+                return acc;
+            }
+            const attribute = schema.attributes[column];
+            const validationSchema = (0, exports.generateAttributeValidationSchema)(attribute, language, strings, region);
+            return {
+                ...acc,
+                [column]: validationSchema,
+            };
+        }, {}),
+        ...editableGrids?.reduce((acc, grid) => {
+            let validationSchema = yup
+                .array()
+                .of(yup.object().shape({
+                ...grid.columns.reduce((acc, column) => {
+                    const attribute = grid.schema.attributes[column];
+                    const validationSchema = (0, exports.generateAttributeValidationSchema)(attribute, language, strings, region);
+                    return {
+                        ...acc,
+                        [column]: validationSchema,
+                    };
+                }, {}),
+            }))
+                .nullable();
+            if (grid.required) {
+                validationSchema = validationSchema
+                    .required(strings.atLeastOneRowRequired)
+                    .min(1, strings.atLeastOneRowRequired);
+            }
+            acc[grid.attributeName] = validationSchema;
             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({
+        }, {}),
+    });
+}, ({ columns, editableGrids, language, schema, strings, readonlyAttributes, region, }) => JSON.stringify({
     schema,
     columns,
     editableGrids,
     language,
     strings,
     readonlyAttributes,
+    region,
 }));
-exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings) {
+function createAttributeValidationSchema(attribute) {
     let validationSchema;
     switch (attribute.type) {
         case 'string':
@@ -312,36 +210,112 @@ exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function gener
         case 'number':
             validationSchema = yup.number().nullable();
             break;
+        case 'attachments':
+        case 'choices':
+        case 'lookups':
+            validationSchema = yup.array().nullable();
+            break;
         default:
             validationSchema = yup.mixed().nullable();
             break;
     }
-    const label = (0, utils_1.localizedLabel)(language, attribute);
+    return validationSchema;
+}
+function extendAttributeRequiredValidationSchema({ attribute, validationSchema, label, strings, }) {
     if (attribute.required) {
         validationSchema = validationSchema.required(`${label}: ${strings.required}`);
     }
+    return validationSchema;
+}
+function extendAttributeValidationSchema({ attribute, validationSchema, label, strings, region, }) {
     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}`);
-            }
+            validationSchema = extendAttributeStringValidationSchema({
+                attribute,
+                validationSchema: validationSchema,
+                label,
+                strings,
+                region,
+            });
+            break;
+        case 'attachments':
+            validationSchema = extendAttributeAttachmentsValidationSchema({
+                attribute,
+                validationSchema: validationSchema,
+                label,
+                strings,
+            });
             break;
         default:
             break;
     }
-    validationSchema = validationSchema.transform(value => {
+    return validationSchema;
+}
+function extendAttributeStringValidationSchema({ attribute, validationSchema, label, strings, region, }) {
+    if (attribute.maxLength) {
+        // extend the validation schema with the max length
+        validationSchema = validationSchema.max(attribute.maxLength, `${label}: ${strings.maxLength}`);
+    }
+    if (attribute.minLength) {
+        // extend the validation schema with the min length
+        validationSchema = validationSchema.min(attribute.minLength, `${label}: ${strings.minLength}`);
+    }
+    if (attribute.pattern) {
+        // extend the validation schema with the pattern
+        validationSchema = validationSchema.matches(new RegExp(attribute.pattern), `${label}: ${strings.invalidFormat}`);
+    }
+    if (attribute.format === 'email') {
+        // extend the validation schema with the email format
+        validationSchema = validationSchema.email(`${label}: ${strings.invalidEmail}`);
+    }
+    else if (attribute.format === 'phone') {
+        // extend the validation schema with the phone format
+        validationSchema = validationSchema.test({
+            message: `${label}: ${strings.invalidPhoneNumber}`,
+            test: (value) => {
+                if (!value) {
+                    return true;
+                }
+                const phoneNumber = (0, phone_1.parsePhoneNumber)(value, region);
+                return phoneNumber.isValid;
+            },
+        });
+    }
+    return validationSchema;
+}
+function extendAttributeAttachmentsValidationSchema({ attribute, validationSchema, label, strings, }) {
+    if (attribute.required) {
+        // extend the validation schema with the min length
+        validationSchema = validationSchema.min(1, `${label}: ${strings.required}`);
+    }
+    if (attribute.maxSize) {
+        // extend the validation schema with the max size
+        validationSchema = validationSchema.test('fileSize', `${label}: ${strings.fileSizeExceeded}`, (value) => {
+            if (!value) {
+                return true;
+            }
+            return value.every((file) => file?.size && file.size <= attribute.maxSize);
+        });
+    }
+    return validationSchema;
+}
+exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings, region) {
+    let validationSchema = createAttributeValidationSchema(attribute);
+    const label = (0, utils_2.localizedLabel)(language, attribute);
+    validationSchema = extendAttributeRequiredValidationSchema({
+        attribute,
+        validationSchema,
+        label,
+        strings,
+    });
+    validationSchema = extendAttributeValidationSchema({
+        attribute,
+        validationSchema,
+        label,
+        strings,
+        region,
+    });
+    validationSchema = validationSchema.transform((value) => {
         if (value === '') {
             return null;
         }

package/dataform/utils/saveRecord.d.ts

@@ -0,0 +1,27 @@
+import { Form } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { IDataService } from '@headless-adminapp/core/transport';
+import { Nullable } from '@headless-adminapp/core/types';
+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 interface SaveRecordFnOptions {
+    values: any;
+    form: Form<SchemaAttributes>;
+    record: InferredSchemaType<SchemaAttributes> | undefined;
+    initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
+    schema: Schema<SchemaAttributes>;
+    dataService: IDataService;
+    schemaStore: ISchemaStore;
+}
+export type SaveRecordFn = (options: SaveRecordFnOptions) => Promise<SaveRecordResult>;
+export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: SaveRecordFnOptions): Promise<SaveRecordResult>;
+export {};

package/dataform/utils/saveRecord.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModifiedValues = getModifiedValues;
+exports.saveRecord = saveRecord;
+const utils_1 = require("../../dataform/DataFormProvider/utils");
+function getModifiedValues(initialValues, values, exclude) {
+    const keys = Object.keys(values);
+    return keys.reduce((p, c) => {
+        if (c === '_id') {
+            return p;
+        }
+        if (exclude?.includes(c)) {
+            return p;
+        }
+        if (JSON.stringify(values[c]) !== JSON.stringify(initialValues[c])) {
+            p[c] = values[c];
+        }
+        return p;
+    }, {});
+}
+async function executeOperation(operation, dataService) {
+    switch (operation.type) {
+        case 'create':
+            await dataService.createRecord(operation.logicalName, operation.data);
+            break;
+        case 'update':
+            await dataService.updateRecord(operation.logicalName, operation.id, operation.data);
+            break;
+        case 'delete':
+            await dataService.deleteRecord(operation.logicalName, operation.id);
+    }
+}
+function generateSubgridUpdateOperation({ recordId, control, schemaStore, values, initialValues, }) {
+    const operations = [];
+    const gridSchema = schemaStore.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
+        ?.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: {
+                ...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,
+        });
+    }
+    return operations;
+}
+async function createRecord({ values, form, schema, dataService, }) {
+    const controls = (0, utils_1.getControls)(form);
+    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+    const result = await dataService.createRecord(schema.logicalName, values);
+    const recordId = result[schema.idAttribute];
+    for (const control of editableGridControls) {
+        const gridRows = values[control.attributeName];
+        for (const row of gridRows) {
+            await dataService.createRecord(control.logicalName, {
+                ...row,
+                [control.referenceAttribute]: {
+                    id: recordId,
+                },
+            });
+        }
+    }
+    return recordId;
+}
+async function updateRecord({ recordId, values, form, schema, dataService, initialValues, schemaStore, }) {
+    const controls = (0, utils_1.getControls)(form);
+    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+    const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.attributeName));
+    const operations = [];
+    if (Object.keys(modifiedValues).length) {
+        operations.push({
+            type: 'update',
+            logicalName: schema.logicalName,
+            data: modifiedValues,
+            id: recordId,
+        });
+    }
+    for (const control of editableGridControls) {
+        operations.push(...generateSubgridUpdateOperation({
+            recordId,
+            control,
+            schemaStore,
+            initialValues,
+            values,
+        }));
+    }
+    if (!operations.length) {
+        return {
+            success: false,
+            title: 'No changes',
+            message: 'No changes made to the record',
+            isError: false,
+        };
+    }
+    for (const operation of operations) {
+        await executeOperation(operation, dataService);
+    }
+    return {
+        success: true,
+        recordId,
+    };
+}
+async function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
+    let recordId;
+    if (record) {
+        recordId = record[schema.idAttribute];
+        const updateResult = await updateRecord({
+            recordId,
+            values,
+            form,
+            schema,
+            dataService,
+            initialValues,
+            schemaStore,
+        });
+        return updateResult;
+    }
+    else {
+        recordId = await createRecord({
+            dataService,
+            form,
+            schema,
+            values,
+        });
+    }
+    return {
+        success: true,
+        recordId,
+    };
+}