@headless-adminapp/app 0.0.17-alpha.53 → 0.0.17-alpha.55

package/dataform/utils/index.js

@@ -1,21 +1,40 @@
-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());
-    });
+"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;
 };
-import { yupResolver } from '@hookform/resolvers/yup';
-import { memoize } from 'lodash';
-import * as yup from 'yup';
-import { getColumns, getControls, } from '../../dataform/DataFormProvider/DataResolver';
-import { localizedLabel } from '../../locale/utils';
-export { saveRecord } from './saveRecord';
-export function getInitialValues({ cloneRecord, form, record, recordId, schema, defaultParameters, }) {
-    const formColumns = getColumns(form, schema);
-    const editableGridControls = getControls(form).filter((control) => control.type === 'editablegrid');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAttributeValidationSchema = exports.generateValidationSchema = exports.formValidator = exports.saveRecord = void 0;
+exports.getInitialValues = getInitialValues;
+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");
+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, DataResolver_1.getColumns)(form, schema);
+    const editableGridControls = (0, DataResolver_1.getControls)(form).filter((control) => control.type === 'editablegrid');
     const allColumns = [
         ...formColumns,
         ...editableGridControls.map((x) => x.attributeName),
@@ -32,7 +51,6 @@ export function getInitialValues({ cloneRecord, form, record, recordId, schema,
             return acc;
         }, {});
         return allColumns.reduce((acc, column) => {
-            var _a;
             const cloneAttributeInfo = cloneAttributesObj[column];
             // | EditableGridCloneAttribute; // TODO:
             let value = null;
@@ -62,19 +80,24 @@ export function getInitialValues({ cloneRecord, form, record, recordId, schema,
                 // }
             }
             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,
+        };
     }, {});
 }
-export const formValidator = 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, }) {
+    return async (values, context, options) => {
         let validator = yup.object().shape({});
         if (!formReadOnly) {
             const activeControls = form.experience.tabs
@@ -99,7 +122,7 @@ export const formValidator = memoize(function formValidator({ form, schema, read
                     .filter((control) => control.type === 'standard')
                     .map((control) => control.attributeName),
             ]));
-            validator = generateValidationSchema({
+            validator = (0, exports.generateValidationSchema)({
                 editableGrids: editableGridControls.map((control) => {
                     if (control.type !== 'editablegrid') {
                         throw new Error('Invalid control type');
@@ -119,10 +142,10 @@ export const formValidator = memoize(function formValidator({ form, schema, read
                 readonlyAttributes,
             });
         }
-        const resolver = yupResolver(validator);
-        const result = yield resolver(values, context, options);
+        const resolver = (0, yup_1.yupResolver)(validator);
+        const result = await resolver(values, context, options);
         return result;
-    });
+    };
 }, ({ form, language, schema, strings, readonlyAttributes, formReadOnly }) => JSON.stringify({
     schema,
     form,
@@ -131,31 +154,42 @@ export const formValidator = memoize(function formValidator({ form, schema, read
     readonlyAttributes,
     formReadOnly,
 }));
-export const generateValidationSchema = 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, }) {
+    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);
+            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);
+                    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 = 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 = 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,
@@ -247,14 +281,14 @@ function extendAttributeAttachmentsValidationSchema({ attribute, validationSchem
             if (!value) {
                 return true;
             }
-            return value.every((file) => (file === null || file === void 0 ? void 0 : file.size) && file.size <= attribute.maxSize);
+            return value.every((file) => file?.size && file.size <= attribute.maxSize);
         });
     }
     return validationSchema;
 }
-export const generateAttributeValidationSchema = memoize(function generateAttributeValidationSchema(attribute, language, strings) {
+exports.generateAttributeValidationSchema = (0, lodash_1.memoize)(function generateAttributeValidationSchema(attribute, language, strings) {
     let validationSchema = createAttributeValidationSchema(attribute);
-    const label = localizedLabel(language, attribute);
+    const label = (0, utils_1.localizedLabel)(language, attribute);
     validationSchema = extendAttributeRequiredValidationSchema({
         attribute,
         validationSchema,

package/dataform/utils/saveRecord.js

@@ -1,20 +1,15 @@
-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());
-    });
-};
-import { getControls } from '../../dataform/DataFormProvider/DataResolver';
-export function getModifiedValues(initialValues, values, exclude) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModifiedValues = getModifiedValues;
+exports.saveRecord = saveRecord;
+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 === null || exclude === void 0 ? void 0 : exclude.includes(c)) {
+        if (exclude?.includes(c)) {
             return p;
         }
         if (JSON.stringify(values[c]) !== JSON.stringify(initialValues[c])) {
@@ -23,19 +18,17 @@ export function getModifiedValues(initialValues, values, exclude) {
         return p;
     }, {});
 }
-function executeOperation(operation, dataService) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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);
-        }
-    });
+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 = [];
@@ -44,14 +37,19 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
     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));
+    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: Object.assign(Object.assign({}, row), { [control.referenceAttribute]: {
+            data: {
+                ...row,
+                [control.referenceAttribute]: {
                     id: recordId,
-                } }),
+                },
+            },
         });
     }
     for (const row of updatedRows) {
@@ -79,85 +77,82 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
     }
     return operations;
 }
-function createRecord(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, }) {
-        const controls = getControls(form);
-        const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
-        const result = yield 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) {
-                yield dataService.createRecord(control.logicalName, Object.assign(Object.assign({}, row), { [control.referenceAttribute]: {
-                        id: recordId,
-                    } }));
-            }
-        }
-        return recordId;
-    });
-}
-function updateRecord(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ recordId, values, form, schema, dataService, initialValues, schemaStore, }) {
-        const controls = 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,
+async function createRecord({ values, form, schema, dataService, }) {
+    const controls = (0, DataResolver_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,
+                },
             });
         }
-        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) {
-            yield executeOperation(operation, dataService);
-        }
-    });
+    }
+    return recordId;
 }
-export function saveRecord(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
-        let recordId;
-        if (record) {
-            recordId = record[schema.idAttribute];
-            yield updateRecord({
-                recordId,
-                values,
-                form,
-                schema,
-                dataService,
-                initialValues,
-                schemaStore,
-            });
-        }
-        else {
-            recordId = yield createRecord({
-                dataService,
-                form,
-                schema,
-                values,
-            });
-        }
-        return {
-            success: true,
+async function updateRecord({ recordId, values, form, schema, dataService, initialValues, 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));
+    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);
+    }
+}
+async function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
+    let recordId;
+    if (record) {
+        recordId = record[schema.idAttribute];
+        await updateRecord({
+            recordId,
+            values,
+            form,
+            schema,
+            dataService,
+            initialValues,
+            schemaStore,
+        });
+    }
+    else {
+        recordId = await createRecord({
+            dataService,
+            form,
+            schema,
+            values,
+        });
+    }
+    return {
+        success: true,
+        recordId,
+    };
 }

package/datagrid/DataGridProvider/DataResolver.js

@@ -1,29 +1,31 @@
-import { useClearDataExceptFirstPage, useRetrieveRecordsKey, useRetriveRecords, } from '@headless-adminapp/app/transport/hooks/useRetriveRecords';
-import { useEffect, useMemo, useRef } from 'react';
-import { useDebouncedValue } from '../../hooks/useDebouncedValue';
-import { useMetadata } from '../../metadata/hooks/useMetadata';
-import { useContextSetValue } from '../../mutable/context';
-import { GridContext } from '../context';
-import { useDataGridSchema, useGridColumnFilter, useGridColumns, useGridExtraFilter, useGridSelection, useGridSorting, useMaxRecords, useSearchText, useSelectedView, } from '../hooks';
-import { collectExpandedKeys, mergeConditions } from './utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataResolver = DataResolver;
+const react_1 = require("react");
+const useDebouncedValue_1 = require("../../hooks/useDebouncedValue");
+const useMetadata_1 = require("../../metadata/hooks/useMetadata");
+const context_1 = require("../../mutable/context");
+const useRetriveRecords_1 = require("../../transport/hooks/useRetriveRecords");
+const context_2 = require("../context");
+const hooks_1 = require("../hooks");
+const utils_1 = require("./utils");
 const MAX_RECORDS = 10000;
-export function DataResolver() {
-    var _a;
-    const schema = useDataGridSchema();
-    const view = useSelectedView();
-    const [sorting] = useGridSorting();
-    const [searchText] = useSearchText();
-    const extraFilter = useGridExtraFilter();
-    const [columnFilters] = useGridColumnFilter();
-    const gridColumns = useGridColumns();
-    const maxRecords = (_a = useMaxRecords()) !== null && _a !== void 0 ? _a : MAX_RECORDS;
-    const [selectedIds] = useGridSelection();
-    const { schemaStore } = useMetadata();
-    const selectedIdsRef = useRef(selectedIds);
+function DataResolver() {
+    const schema = (0, hooks_1.useDataGridSchema)();
+    const view = (0, hooks_1.useSelectedView)();
+    const [sorting] = (0, hooks_1.useGridSorting)();
+    const [searchText] = (0, hooks_1.useSearchText)();
+    const extraFilter = (0, hooks_1.useGridExtraFilter)();
+    const [columnFilters] = (0, hooks_1.useGridColumnFilter)();
+    const gridColumns = (0, hooks_1.useGridColumns)();
+    const maxRecords = (0, hooks_1.useMaxRecords)() ?? MAX_RECORDS;
+    const [selectedIds] = (0, hooks_1.useGridSelection)();
+    const { schemaStore } = (0, useMetadata_1.useMetadata)();
+    const selectedIdsRef = (0, react_1.useRef)(selectedIds);
     selectedIdsRef.current = selectedIds;
-    const setState = useContextSetValue(GridContext);
-    const [search] = useDebouncedValue(searchText, 500);
-    const columns = useMemo(() => {
+    const setState = (0, context_1.useContextSetValue)(context_2.GridContext);
+    const [search] = (0, useDebouncedValue_1.useDebouncedValue)(searchText, 500);
+    const columns = (0, react_1.useMemo)(() => {
         const set = new Set([
             ...gridColumns.filter((x) => !x.expandedKey).map((x) => x.name),
             schema.primaryAttribute,
@@ -32,12 +34,12 @@ export function DataResolver() {
             set.add(schema.avatarAttribute);
         }
         return Array.from(set);
-    }, [gridColumns, schema.primaryAttribute]);
-    const expand = useMemo(() => collectExpandedKeys(gridColumns), [gridColumns]);
-    const filter = useMemo(() => {
-        return mergeConditions(schema, view.experience.filter, extraFilter, columnFilters, schemaStore);
+    }, [gridColumns, schema.avatarAttribute, schema.primaryAttribute]);
+    const expand = (0, react_1.useMemo)(() => (0, utils_1.collectExpandedKeys)(gridColumns), [gridColumns]);
+    const filter = (0, react_1.useMemo)(() => {
+        return (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, columnFilters, schemaStore);
     }, [columnFilters, extraFilter, schema, schemaStore, view.experience.filter]);
-    const queryKey = useRetrieveRecordsKey({
+    const queryKey = (0, useRetriveRecords_1.useRetrieveRecordsKey)({
         columns,
         expand,
         filter,
@@ -46,8 +48,8 @@ export function DataResolver() {
         search,
         sorting,
     });
-    useClearDataExceptFirstPage(queryKey);
-    const { fetchNextPage, data, hasNextPage, isFetching, isFetchingNextPage } = useRetriveRecords(queryKey, {
+    (0, useRetriveRecords_1.useClearDataExceptFirstPage)(queryKey);
+    const { fetchNextPage, data, hasNextPage, isFetching, isFetchingNextPage } = (0, useRetriveRecords_1.useRetriveRecords)(queryKey, {
         columns,
         expand,
         filter,
@@ -56,12 +58,12 @@ export function DataResolver() {
         search,
         sorting,
     });
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         setState({
             fetchNextPage: () => fetchNextPage,
         });
     }, [fetchNextPage, setState]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!data) {
             setState({
                 data: null,
@@ -74,7 +76,7 @@ export function DataResolver() {
             selectedIds,
         });
     }, [data, setState, schema.idAttribute]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         setState({
             dataState: {
                 isFetching,