@headless-adminapp/app 1.1.10 → 1.1.12

package/dataform/DataFormProvider/getRecord.d.ts

@@ -1,3 +1,12 @@
-import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { SectionEditableGridControl } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { IDataService } from '@headless-adminapp/core/transport';
 import { RetriveRecordFnOptions } from './types';
 export declare function getRecord<SA extends SchemaAttributes = SchemaAttributes>({ recordId, dataService, form, schema, columns, schemaStore, }: RetriveRecordFnOptions<SA>): Promise<import("@headless-adminapp/core/transport").Data<SA> | null>;
+export declare function getEditableSubgridRecords({ dataService, schemaStore, control, recordId, }: {
+    dataService: IDataService;
+    schemaStore: ISchemaStore;
+    control: SectionEditableGridControl<SchemaAttributes>;
+    recordId: string;
+}): Promise<import("@headless-adminapp/core/transport").Data<InferredSchemaType<SchemaAttributes>>[]>;

package/dataform/DataFormProvider/getRecord.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRecord = getRecord;
+exports.getEditableSubgridRecords = getEditableSubgridRecords;
 const transport_1 = require("@headless-adminapp/core/transport");
 const utils_1 = require("./utils");
 async function getRecord({ recordId, dataService, form, schema, columns, schemaStore, }) {
@@ -20,37 +21,46 @@ async function getRecord({ recordId, dataService, form, schema, columns, schemaS
     const controls = (0, utils_1.getControls)(form);
     const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
     for (const control of editableGridControls) {
-        if (control.type !== 'editablegrid') {
+        if (!control.alias) {
             continue;
         }
-        const controlSchema = schemaStore.getSchema(control.logicalName);
-        const records = await dataService.retriveRecords({
-            logicalName: controlSchema.logicalName,
-            filter: {
-                type: 'and',
-                conditions: [
-                    {
-                        field: control.referenceAttribute,
-                        operator: 'eq',
-                        value: recordId,
-                    },
-                ],
-            },
-            sort: [
-                {
-                    field: controlSchema.createdAtAttribute ?? controlSchema.idAttribute,
-                    order: 'asc',
-                },
-            ],
-            limit: 5000,
-            search: '',
-            columns: [
-                controlSchema.idAttribute,
-                control.referenceAttribute,
-                ...control.attributes,
-            ],
+        const records = await getEditableSubgridRecords({
+            dataService,
+            control,
+            schemaStore,
+            recordId,
         });
-        record[control.attributeName] = records.records;
+        record[control.alias] = records;
     }
     return record;
 }
+async function getEditableSubgridRecords({ dataService, schemaStore, control, recordId, }) {
+    const controlSchema = schemaStore.getSchema(control.logicalName);
+    const result = await dataService.retriveRecords({
+        logicalName: controlSchema.logicalName,
+        filter: {
+            type: 'and',
+            conditions: [
+                {
+                    field: control.associatedAttribute,
+                    operator: 'eq',
+                    value: recordId,
+                },
+            ],
+        },
+        sort: control.sort ?? [
+            {
+                field: controlSchema.createdAtAttribute ?? controlSchema.idAttribute,
+                order: 'asc',
+            },
+        ],
+        limit: 5000,
+        search: '',
+        columns: [
+            controlSchema.idAttribute,
+            control.associatedAttribute,
+            ...control.controls.map((x) => typeof x === 'string' ? x : x.attributeName),
+        ],
+    });
+    return result.records;
+}

package/dataform/DataFormProvider/utils.d.ts

@@ -7,7 +7,7 @@ export declare function getControls<SA extends SchemaAttributes>(form: Form<SA>)
 export declare function getColumns<SA extends SchemaAttributes>(form: Form<SA>, schema: Schema<SA>): (keyof SA)[];
 export declare function transformFormInternal<SA extends SchemaAttributes>(form: Form<SA>): DataFormContextState<SA>['formInternal'];
 export declare function getIsFieldDisabled<S extends SchemaAttributes = SchemaAttributes>({ attribute, isFormReadonly, disabledFields, control, }: {
-    attribute: AttributeBase;
+    attribute: AttributeBase | null;
     isFormReadonly: boolean | undefined;
     disabledFields: Record<string, boolean>;
     control: Section<S>['controls'][0];

package/dataform/DataFormProvider/utils.js

@@ -76,7 +76,7 @@ function getIsFieldDisabled({ attribute, isFormReadonly, disabledFields, control
         else if ('disabled' in control && control.disabled !== undefined) {
             disabled = control.disabled;
         }
-        else if (attribute.readonly !== undefined) {
+        else if (attribute && attribute.readonly !== undefined) {
             disabled = attribute.readonly;
         }
     }

package/dataform/utils/index.d.ts

@@ -1,5 +1,5 @@
 import type { Attribute } from '@headless-adminapp/core/attributes';
-import { Form } from '@headless-adminapp/core/experience/form';
+import { Form, SectionEditableGridControl } from '@headless-adminapp/core/experience/form';
 import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { ISchemaStore } from '@headless-adminapp/core/store';
 import { Nullable } from '@headless-adminapp/core/types';
@@ -28,6 +28,19 @@ interface FormValidatorOptions<A extends SchemaAttributes = SchemaAttributes> {
 }
 type FormValidator = (<A extends SchemaAttributes = SchemaAttributes>(options: FormValidatorOptions<A>) => (values: Record<string, any>, context: any, options: any) => Promise<ResolverResult<{}>>) & MemoizedFunction;
 export declare const formValidator: FormValidator;
+interface EditableSubgridFormValidatorOptions<A extends SchemaAttributes = SchemaAttributes> {
+    schema: Schema<A>;
+    control: SectionEditableGridControl<A>;
+    language: string;
+    formReadOnly?: boolean;
+    readonlyAttributes?: string[];
+    strings: FormValidationStringSet;
+    schemaStore: ISchemaStore;
+    region: string;
+    alias: string;
+}
+type EditableSubgridFormValidator = (<A extends SchemaAttributes = SchemaAttributes>(options: EditableSubgridFormValidatorOptions<A>) => (values: Record<string, any>, context: any, options: any) => Promise<ResolverResult<{}>>) & MemoizedFunction;
+export declare const editableSubgridFormValidator: EditableSubgridFormValidator;
 export declare const generateValidationSchema: (<A extends SchemaAttributes = SchemaAttributes>({ columns, editableGrids, language, schema, strings, readonlyAttributes, region, }: {
     schema: Schema<A>;
     columns: string[];

package/dataform/utils/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAttributeValidationSchema = exports.generateValidationSchema = exports.formValidator = exports.saveRecord = void 0;
+exports.generateAttributeValidationSchema = exports.generateValidationSchema = exports.editableSubgridFormValidator = 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");
@@ -35,10 +35,10 @@ 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 editableGridControls = (0, utils_1.getControls)(form).filter((control) => control.type === 'editablegrid' && control.alias !== false);
     const allColumns = [
         ...formColumns,
-        ...editableGridControls.map((x) => x.attributeName),
+        ...editableGridControls.map((x) => x.alias),
     ];
     if (!recordId && !record && form.experience.cloneAttributes && cloneRecord) {
         const cloneAttributesObj = form.experience.cloneAttributes.reduce((acc, item) => {
@@ -116,7 +116,7 @@ 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' && control.alias !== false);
             const columns = Array.from(new Set([
                 schema.primaryAttribute,
                 ...activeControls
@@ -125,14 +125,14 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
             ]));
             validator = (0, exports.generateValidationSchema)({
                 editableGrids: editableGridControls.map((control) => {
-                    if (control.type !== 'editablegrid') {
+                    if (control.type !== 'editablegrid' || control.alias === false) {
                         throw new Error('Invalid control type');
                     }
                     const schema = schemaStore.getSchema(control.logicalName);
                     return {
-                        columns: control.attributes,
+                        columns: control.controls.map((x) => typeof x === 'string' ? x : x.attributeName),
                         schema: schema,
-                        attributeName: control.attributeName,
+                        attributeName: control.alias,
                         required: control.required,
                     };
                 }),
@@ -156,6 +156,44 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
     readonlyAttributes,
     formReadOnly,
 }));
+exports.editableSubgridFormValidator = (0, lodash_1.memoize)(function formValidator({ schema, readonlyAttributes, formReadOnly, schemaStore, language, strings, region, control, alias, }) {
+    return async (values, context, options) => {
+        let validator = yup.object().shape({});
+        if (!formReadOnly) {
+            const controlSchema = schemaStore.getSchema(control.logicalName);
+            const columns = [];
+            validator = (0, exports.generateValidationSchema)({
+                editableGrids: [
+                    {
+                        columns: control.controls.map((x) => typeof x === 'string'
+                            ? x
+                            : x.attributeName),
+                        schema: controlSchema,
+                        attributeName: alias,
+                        required: control.required,
+                    },
+                ],
+                schema,
+                columns,
+                language,
+                strings,
+                readonlyAttributes,
+                region,
+            });
+        }
+        const resolver = (0, yup_1.yupResolver)(validator);
+        const result = await resolver(values, context, options);
+        return result;
+    };
+}, ({ language, schema, strings, readonlyAttributes, formReadOnly, alias, control, }) => JSON.stringify({
+    schema,
+    language,
+    strings,
+    readonlyAttributes,
+    formReadOnly,
+    alias,
+    control,
+}));
 exports.generateValidationSchema = (0, lodash_1.memoize)(function generateValidationSchema({ columns, editableGrids, language, schema, strings, readonlyAttributes, region, }) {
     return yup.object().shape({
         ...columns.reduce((acc, column) => {

package/dataform/utils/saveRecord.d.ts

@@ -1,5 +1,5 @@
 import { Id } from '@headless-adminapp/core';
-import { Form } from '@headless-adminapp/core/experience/form';
+import { Form, SectionEditableGridControl } 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';
@@ -25,3 +25,38 @@ export interface SaveRecordFnOptions<S extends SchemaAttributes = SchemaAttribut
 }
 export type SaveRecordFn = (options: SaveRecordFnOptions) => Promise<SaveRecordResult>;
 export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: SaveRecordFnOptions): Promise<SaveRecordResult>;
+interface SaveEditableGridControlOptions {
+    recordId: string;
+    control: SectionEditableGridControl;
+    schemaStore: ISchemaStore;
+    values: any;
+    initialValues: any;
+    dataService: IDataService;
+    alias: string;
+}
+export type SaveEditableGridResult = {
+    success: true;
+    updated: number;
+    created: number;
+} | {
+    success: false;
+    title?: string;
+    message: string;
+    isError: boolean;
+};
+export declare function saveEditableGridControl({ recordId, control, schemaStore, values, initialValues, dataService, alias, }: SaveEditableGridControlOptions): Promise<{
+    success: boolean;
+    title: string;
+    message: string;
+    isError: boolean;
+    updated?: undefined;
+    created?: undefined;
+} | {
+    success: boolean;
+    updated: number;
+    created: number;
+    title?: undefined;
+    message?: undefined;
+    isError?: undefined;
+}>;
+export {};

package/dataform/utils/saveRecord.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModifiedValues = getModifiedValues;
 exports.saveRecord = saveRecord;
+exports.saveEditableGridControl = saveEditableGridControl;
 const utils_1 = require("../../dataform/DataFormProvider/utils");
 function getModifiedValues(initialValues, values, exclude) {
     const keys = Object.keys(values);
@@ -30,11 +31,11 @@ async function executeOperation(operation, dataService) {
             await dataService.deleteRecord(operation.logicalName, operation.id);
     }
 }
-function generateSubgridUpdateOperation({ recordId, control, schemaStore, values, initialValues, }) {
+function generateSubgridUpdateOperation({ recordId, control, schemaStore, values, initialValues, alias, }) {
     const operations = [];
     const gridSchema = schemaStore.getSchema(control.logicalName);
-    const gridRows = values[control.attributeName];
-    const initialGridRows = initialValues[control.attributeName];
+    const gridRows = values[alias];
+    const initialGridRows = initialValues[alias];
     const newRows = gridRows.filter((x) => !x[gridSchema.idAttribute]);
     const updatedRows = gridRows.filter((x) => x[gridSchema.idAttribute]);
     const deletedIds = initialGridRows
@@ -46,9 +47,10 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
             logicalName: control.logicalName,
             data: {
                 ...row,
-                [control.referenceAttribute]: {
+                [control.associatedAttribute]: {
                     id: recordId,
                 },
+                [gridSchema.idAttribute]: undefined,
             },
         });
     }
@@ -79,15 +81,15 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
 }
 async function createRecord({ values, form, schema, dataService, }) {
     const controls = (0, utils_1.getControls)(form);
-    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+    const editableGridControls = controls.filter((control) => control.type === 'editablegrid' && control.alias);
     const result = await dataService.createRecord(schema.logicalName, values);
     const recordId = result.id;
     for (const control of editableGridControls) {
-        const gridRows = values[control.attributeName];
+        const gridRows = values[control.alias];
         for (const row of gridRows) {
             await dataService.createRecord(control.logicalName, {
                 ...row,
-                [control.referenceAttribute]: {
+                [control.associatedAttribute]: {
                     id: recordId,
                 },
             });
@@ -97,8 +99,8 @@ async function createRecord({ values, form, schema, dataService, }) {
 }
 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 editableGridControls = controls.filter((control) => control.type === 'editablegrid' && control.alias);
+    const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.alias));
     const operations = [];
     if (Object.keys(modifiedValues).length) {
         operations.push({
@@ -115,6 +117,7 @@ async function updateRecord({ recordId, values, form, schema, dataService, initi
             schemaStore,
             initialValues,
             values,
+            alias: control.alias,
         }));
     }
     if (!operations.length) {
@@ -161,3 +164,29 @@ async function saveRecord({ values, form, schema, dataService, initialValues, re
         recordId,
     };
 }
+async function saveEditableGridControl({ recordId, control, schemaStore, values, initialValues, dataService, alias, }) {
+    const operations = generateSubgridUpdateOperation({
+        recordId,
+        control,
+        schemaStore,
+        initialValues,
+        values,
+        alias,
+    });
+    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,
+        updated: operations.filter((x) => x.type === 'update').length,
+        created: operations.filter((x) => x.type === 'create').length,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -36,5 +36,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "3920cedff7216fb37b07dff95c50499c0f56f57c"
+  "gitHead": "ead918f1f609c2a260ceae498368ddc2c4980725"
 }