@headless-adminapp/app 0.0.17-alpha.47 → 0.0.17-alpha.48

package/dataform/utils/index.d.ts

@@ -2,31 +2,12 @@ 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 { ISchemaStore } from '@headless-adminapp/core/store';
-import { IDataService } from '@headless-adminapp/core/transport';
 import { Nullable } from '@headless-adminapp/core/types';
 import { MemoizedFunction } from 'lodash';
 import { ResolverResult } from 'react-hook-form';
 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, schemaStore, }: {
-    values: any;
-    form: Form<SchemaAttributes>;
-    record: InferredSchemaType<SchemaAttributes> | undefined;
-    initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
-    schema: Schema<SchemaAttributes>;
-    dataService: IDataService;
-    schemaStore: ISchemaStore;
-}): Promise<SaveRecordResult>;
+export { saveRecord } from './saveRecord';
 export declare function getInitialValues({ cloneRecord, form, record, recordId, defaultParameters, }: {
     cloneRecord: InferredSchemaType<SchemaAttributes> | undefined;
     form: Form<SchemaAttributes>;
@@ -64,4 +45,3 @@ export declare const generateValidationSchema: (<A extends SchemaAttributes = Sc
     [x: string]: any;
 }, "">) & MemoizedFunction;
 export declare const generateAttributeValidationSchema: ((attribute: Attribute, language: string, strings: FormValidationStringSet) => yup.Schema<any, any, any, "">) & MemoizedFunction;
-export {};

package/dataform/utils/index.js

@@ -32,126 +32,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 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 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,
-        };
-    });
-}
+var saveRecord_1 = require("./saveRecord");
+Object.defineProperty(exports, "saveRecord", { enumerable: true, get: function () { return saveRecord_1.saveRecord; } });
 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');

package/dataform/utils/saveRecord.d.ts

@@ -0,0 +1,25 @@
+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 declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: {
+    values: any;
+    form: Form<SchemaAttributes>;
+    record: InferredSchemaType<SchemaAttributes> | undefined;
+    initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
+    schema: Schema<SchemaAttributes>;
+    dataService: IDataService;
+    schemaStore: ISchemaStore;
+}): Promise<SaveRecordResult>;
+export {};

package/dataform/utils/saveRecord.js

@@ -0,0 +1,167 @@
+"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.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)) {
+            return p;
+        }
+        if (JSON.stringify(values[c]) !== JSON.stringify(initialValues[c])) {
+            p[c] = values[c];
+        }
+        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);
+        }
+    });
+}
+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 === 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,
+        });
+    }
+    return operations;
+}
+function createRecord(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, }) {
+        const controls = (0, DataResolver_1.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 = (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) {
+            yield executeOperation(operation, dataService);
+        }
+    });
+}
+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,
+            recordId,
+        };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "0.0.17-alpha.47",
+  "version": "0.0.17-alpha.48",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -39,5 +39,5 @@
     "react-hook-form": "7.52.2",
     "yup": "^1.4.0"
   },
-  "gitHead": "749a69f512d51c82f33fe27f8bbe5046fdeab4c5"
+  "gitHead": "e8887232802a525648c316b2b8526b2571bc8b8c"
 }