@headless-adminapp/app 1.5.2 → 1.5.7

package/board/types.d.ts

@@ -38,7 +38,7 @@ export interface BoardConfig<S extends SchemaAttributes = SchemaAttributes> {
     title: string;
     description: string;
     schema: Schema<S>;
-    sorting: SortingState<S>;
+    sorting: SortingState<Extract<keyof S, string>>;
     projection: {
         columns: Array<keyof S>;
         expand?: Partial<Record<keyof S, string[]>>;

package/builders/CommandBuilder/ViewCommandBuilder.d.ts

@@ -1,4 +1,5 @@
 import type { EntityMainGridCommandContext, EntityMainGridCommandItemExperience } from '@headless-adminapp/core/experience/view';
+import type { SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { Localized } from '@headless-adminapp/core/types';
 import type { Icon } from '@headless-adminapp/icons';
 export declare namespace EnabledRules {
@@ -79,7 +80,7 @@ export declare namespace ViewCommandBuilder {
         };
     }): EntityMainGridCommandItemExperience;
 }
-export declare function exportRecordsToExcel(context: EntityMainGridCommandContext): Promise<void>;
+export declare function exportRecordsToExcel<S extends SchemaAttributes = SchemaAttributes>(context: EntityMainGridCommandContext<S>): Promise<void>;
 export declare function exportRecordsToCSV(context: EntityMainGridCommandContext): Promise<void>;
 export declare function processDeleteRecordRequest(context: EntityMainGridCommandContext, { stringSet, localizedStringSet, }: {
     stringSet: ViewCommandBuilder.DeleteRecordCommandStringSet;

package/builders/utils.d.ts

@@ -1,6 +1,6 @@
 import type { Locale } from '@headless-adminapp/core/experience/locale';
 import type { ColumnCondition, SortingState, View } from '@headless-adminapp/core/experience/view';
-import type { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import type { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { ISchemaStore } from '@headless-adminapp/core/store';
 import type { Filter, IDataService } from '@headless-adminapp/core/transport';
 import type { TransformedViewColumn } from '../datagrid';
@@ -24,7 +24,7 @@ export declare function retriveRecords<S extends SchemaAttributes = SchemaAttrib
     extraFilter?: Filter;
     columnFilters?: Partial<Record<string, ColumnCondition>>;
     schemaStore: ISchemaStore;
-    sorting: SortingState<S>;
+    sorting: SortingState<Extract<keyof S, string>>;
     skip: number;
     limit: number;
-}): Promise<import("@headless-adminapp/core/transport").RetriveRecordsResult<InferredSchemaType<S>>>;
+}): Promise<import("@headless-adminapp/core/transport").RetriveRecordsResult<S>>;

package/builders/utils.js

@@ -177,7 +177,6 @@ async function retriveRecords({ gridColumns, dataService, schema, search, view,
         columnFilters, schemaStore),
         skip,
         limit,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         sort: sorting,
     });
     return result;

package/dataform/utils/saveRecord.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModifiedValues = getModifiedValues;
 exports.saveRecord = saveRecord;
 exports.saveEditableGridControl = saveEditableGridControl;
-const utils_1 = require("../DataFormProvider/utils");
+const utils_1 = require("@headless-adminapp/core/transport/utils");
+const utils_2 = require("../DataFormProvider/utils");
 function getModifiedValues(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 initialValues, 
@@ -47,8 +48,8 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
     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));
+        ?.map((x) => (0, utils_1.getRecordId)(gridSchema, x))
+        .filter((id) => !gridRows.find((x) => (0, utils_1.getRecordId)(gridSchema, x) === id));
     for (const row of newRows) {
         operations.push({
             type: 'create',
@@ -63,7 +64,7 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
         });
     }
     for (const row of updatedRows) {
-        const initialRow = initialGridRows.find((x) => x[gridSchema.idAttribute] === row[gridSchema.idAttribute]);
+        const initialRow = initialGridRows.find((x) => (0, utils_1.getRecordId)(gridSchema, x) === (0, utils_1.getRecordId)(gridSchema, row));
         if (!initialRow) {
             throw new Error('Initial row not found');
         }
@@ -75,7 +76,7 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
             type: 'update',
             logicalName: control.logicalName,
             data: modifiedRow,
-            id: row[gridSchema.idAttribute],
+            id: (0, utils_1.getRecordId)(gridSchema, row),
         });
     }
     for (const id of deletedIds) {
@@ -88,7 +89,7 @@ function generateSubgridUpdateOperation({ recordId, control, schemaStore, values
     return operations;
 }
 async function createRecord({ values, form, schema, dataService, }) {
-    const controls = (0, utils_1.getControls)(form);
+    const controls = (0, utils_2.getControls)(form);
     const editableGridControls = controls.filter((control) => control.type === 'editablegrid' && control.alias);
     const result = await dataService.createRecord(schema.logicalName, values);
     const recordId = result.id;
@@ -107,7 +108,7 @@ async function createRecord({ values, form, schema, dataService, }) {
     return recordId;
 }
 async function updateRecord({ recordId, values, form, schema, dataService, initialValues, schemaStore, }) {
-    const controls = (0, utils_1.getControls)(form);
+    const controls = (0, utils_2.getControls)(form);
     const editableGridControls = controls.filter((control) => control.type === 'editablegrid' && control.alias);
     const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.alias));
     const operations = [];
@@ -148,9 +149,9 @@ async function updateRecord({ recordId, values, form, schema, dataService, initi
 async function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
     let recordId;
     if (record) {
-        recordId = record[schema.idAttribute];
+        const recordId = (0, utils_1.getRecordId)(schema, record);
         const updateResult = await updateRecord({
-            recordId,
+            recordId: recordId,
             values,
             form,
             schema,

package/datagrid/DataGridProvider/DataResolver.d.ts

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

package/datagrid/DataGridProvider/DataResolver.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataResolver = DataResolver;
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 const react_1 = require("react");
 const auth_1 = require("../../auth");
 const hooks_1 = require("../../hooks");
@@ -12,7 +13,7 @@ const context_2 = require("../context");
 const hooks_2 = require("../hooks");
 const useGridDisabled_1 = require("../hooks/useGridDisabled");
 const useQuickFilter_1 = require("../hooks/useQuickFilter");
-const utils_1 = require("./utils");
+const utils_2 = require("./utils");
 function DataResolver() {
     const schema = (0, hooks_2.useDataGridSchema)();
     const view = (0, hooks_2.useSelectedView)();
@@ -33,14 +34,14 @@ function DataResolver() {
     const [search] = (0, useDebouncedValue_1.useDebouncedValue)(searchText, 500);
     const isMobile = (0, hooks_1.useIsMobile)();
     const columns = (0, react_1.useMemo)(() => isMobile
-        ? (0, utils_1.collectCardColumns)({ cardView: view.experience.card, schema })
-        : (0, utils_1.collectGridColumns)({
+        ? (0, utils_2.collectCardColumns)({ cardView: view.experience.card, schema })
+        : (0, utils_2.collectGridColumns)({
             gridColumns,
             schema,
         }), [isMobile, view.experience.card, schema, gridColumns]);
     const expand = (0, react_1.useMemo)(() => isMobile
-        ? (0, utils_1.collectCardExpandedKeys)({ cardView: view.experience.card })
-        : (0, utils_1.collectExpandedKeys)(gridColumns), [gridColumns, isMobile, view.experience.card]);
+        ? (0, utils_2.collectCardExpandedKeys)({ cardView: view.experience.card })
+        : (0, utils_2.collectExpandedKeys)(gridColumns), [gridColumns, isMobile, view.experience.card]);
     const quickFilterResults = (0, react_1.useMemo)(() => {
         if (!quickFilter) {
             return null;
@@ -51,7 +52,7 @@ function DataResolver() {
         return quickFilter.resolver(quickFilterValues, authSession);
     }, [authSession, quickFilter, quickFilterValues]);
     const filter = (0, react_1.useMemo)(() => {
-        return (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, quickFilterResults, columnFilters, schemaStore);
+        return (0, utils_2.mergeConditions)(schema, view.experience.filter, extraFilter, quickFilterResults, columnFilters, schemaStore);
     }, [
         columnFilters,
         extraFilter,
@@ -85,12 +86,12 @@ function DataResolver() {
             });
             return;
         }
-        const selectedIds = selectedIdsRef.current.filter((x) => data.records.some((y) => y[schema.idAttribute] === x));
+        const selectedIds = selectedIdsRef.current.filter((x) => data.records.some((y) => (0, utils_1.getRecordId)(schema, y) === x));
         setState({
             data,
             selectedIds,
         });
-    }, [data, setState, schema.idAttribute]);
+    }, [data, setState, schema]);
     (0, react_1.useEffect)(() => {
         setState({
             dataState: {

package/datagrid/DataGridProvider/index.d.ts

@@ -4,7 +4,7 @@ import type { EntityMainGridCommandContext, EntitySubGridCommandContext, View }
 import type { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { Filter } from '@headless-adminapp/core/transport';
 import { type PropsWithChildren } from 'react';
-export interface DataGridProviderProps<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext | EntitySubGridCommandContext = EntityMainGridCommandContext> {
+export interface DataGridProviderProps<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext<S> | EntitySubGridCommandContext = EntityMainGridCommandContext<S>> {
     schema: Schema<S>;
     views: LocalizedDataLookup[];
     view: View<S>;
@@ -21,4 +21,4 @@ export interface DataGridProviderProps<S extends SchemaAttributes = SchemaAttrib
     maxRecords?: number;
     disabled?: boolean;
 }
-export declare function DataGridProvider<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext | EntitySubGridCommandContext = EntityMainGridCommandContext>(props: PropsWithChildren<DataGridProviderProps<S, CommandContext>>): import("react/jsx-runtime").JSX.Element;
+export declare function DataGridProvider<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext<S> | EntitySubGridCommandContext = EntityMainGridCommandContext<S>>(props: PropsWithChildren<DataGridProviderProps<S, CommandContext>>): import("react/jsx-runtime").JSX.Element;

package/datagrid/DataGridProvider/useGridCellRangeResolver.d.ts

@@ -2,4 +2,4 @@ import { type MutableValue } from '@headless-adminapp/app/mutable';
 import type { EntityMainGridCommandContext, EntitySubGridCommandContext } from '@headless-adminapp/core/experience/view';
 import type { SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { GridContextState } from '../context';
-export declare function useGridCellRangeResolver<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext | EntitySubGridCommandContext = EntityMainGridCommandContext>(context: MutableValue<GridContextState<S, CommandContext>>): void;
+export declare function useGridCellRangeResolver<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext<S> | EntitySubGridCommandContext = EntityMainGridCommandContext<S>>(context: MutableValue<GridContextState<S, CommandContext>>): void;

package/datagrid/context.d.ts

@@ -1,11 +1,11 @@
-import type { LocalizedDataLookup } from '@headless-adminapp/core/attributes';
+import type { Id, LocalizedDataLookup } from '@headless-adminapp/core/attributes';
 import type { CommandItemExperience } from '@headless-adminapp/core/experience/command';
 import type { ColumnCondition, EntityMainGridCommandContext, EntitySubGridCommandContext, SortingState, View } from '@headless-adminapp/core/experience/view';
 import { type TransformedViewColumn } from '@headless-adminapp/core/experience/view/ViewColumn';
 import type { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { Filter, RetriveRecordsResult } from '@headless-adminapp/core/transport';
 export { type TransformedViewColumn } from '@headless-adminapp/core/experience/view/ViewColumn';
-export interface GridContextState<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext | EntitySubGridCommandContext = EntityMainGridCommandContext> {
+export interface GridContextState<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext<S> | EntitySubGridCommandContext = EntityMainGridCommandContext<S>> {
     schema: Schema<S>;
     view: View<S>;
     viewLookup: LocalizedDataLookup[];
@@ -22,9 +22,9 @@ export interface GridContextState<S extends SchemaAttributes = SchemaAttributes,
     columns: TransformedViewColumn<S>[];
     searchText: string;
     columnFilters: Partial<Record<keyof S, ColumnCondition>>;
-    sorting: SortingState<S>;
+    sorting: SortingState<Extract<keyof S, string>>;
     quickFilterValues: Record<string, unknown>;
-    selectedIds: string[];
+    selectedIds: Id[];
     cellSelectionRange?: CellSelectionRange | null;
     data: RetriveRecordsResult<InferredSchemaType<S>> | null;
     dataState: {
@@ -36,7 +36,7 @@ export interface GridContextState<S extends SchemaAttributes = SchemaAttributes,
     isSubGrid: boolean;
     allowViewSelection: boolean;
 }
-export declare const GridContext: import("react").Context<import("../mutable/context").ContextValue<GridContextState<SchemaAttributes, EntityMainGridCommandContext>>>;
+export declare const GridContext: import("react").Context<import("../mutable/context").ContextValue<GridContextState<SchemaAttributes, EntityMainGridCommandContext<SchemaAttributes>>>>;
 export interface CellSelectionRange {
     start: {
         row: number;

package/datagrid/hooks/useGridSelection.d.ts

@@ -1 +1,2 @@
-export declare function useGridSelection(): readonly [string[], (selectedIds: string[] | ((previousIds: string[]) => string[])) => void];
+import type { Id } from '@headless-adminapp/core';
+export declare function useGridSelection(): readonly [Id[], (selectedIds: Id[] | ((previousIds: Id[]) => Id[])) => void];

package/datagrid/hooks/useGridSorting.d.ts

@@ -1,3 +1,3 @@
 import type { SortingState } from '@headless-adminapp/core/experience/view';
 import type { SchemaAttributes } from '@headless-adminapp/core/schema';
-export declare function useGridSorting<S extends SchemaAttributes = SchemaAttributes>(): readonly [SortingState<SchemaAttributes>, (value: SortingState<S>) => void];
+export declare function useGridSorting<S extends SchemaAttributes = SchemaAttributes>(): readonly [SortingState<Extract<keyof S, string>>, (value: SortingState<Extract<keyof S, string>>) => void];

package/datagrid/hooks/useGridSorting.js

@@ -8,7 +8,6 @@ function useGridSorting() {
     const sorting = (0, context_1.useContextSelector)(context_2.GridContext, (state) => state.sorting);
     const setValue = (0, context_1.useContextSetValue)(context_2.GridContext);
     const setSorting = (0, react_1.useCallback)((value) => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         setValue({ sorting: value });
     }, [setValue]);
     return [sorting, setSorting];

package/datagrid/hooks/useMainGridCommands.d.ts

@@ -1,7 +1,8 @@
 import type { EntityMainGridCommandContext } from '@headless-adminapp/core/experience/view';
+import type { SchemaAttributes } from '@headless-adminapp/core/schema';
 import type { CommandItemState, MenuItemCommandState, UtilityContextState } from '../../command/types';
 export declare function useUtility(): UtilityContextState;
-export declare function useGridControlContext(): EntityMainGridCommandContext['primaryControl'];
-export declare function useMainGridCommandHandlerContext(): EntityMainGridCommandContext;
+export declare function useGridControlContext<S extends SchemaAttributes = SchemaAttributes>(): EntityMainGridCommandContext<S>['primaryControl'];
+export declare function useMainGridCommandHandlerContext<S extends SchemaAttributes = SchemaAttributes>(): EntityMainGridCommandContext<S>;
 export declare function useMainGridCommands(): CommandItemState[][];
 export declare function useMainGridContextCommands(): MenuItemCommandState[][];

package/datagrid/hooks/useMainGridCommands.js

@@ -7,6 +7,7 @@ exports.useMainGridCommands = useMainGridCommands;
 exports.useMainGridContextCommands = useMainGridContextCommands;
 const app_1 = require("@headless-adminapp/app/app");
 const mutable_1 = require("@headless-adminapp/app/mutable");
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 const react_1 = require("react");
 const command_1 = require("../../command");
 const hooks_1 = require("../../dialog/hooks");
@@ -63,7 +64,7 @@ function useGridControlContext() {
         return obj;
     }, [selectedIds]);
     const selectedRecords = (0, react_1.useMemo)(() => {
-        return (data?.records ?? []).filter((record) => selectedIdsObj[record[schema.idAttribute]]);
+        return (data?.records ?? []).filter((record) => selectedIdsObj[(0, utils_1.getRecordId)(schema, record)]);
     }, [data, schema, selectedIdsObj]);
     return (0, react_1.useMemo)(() => ({
         data,

package/datagrid/hooks/useOpenRecord.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useOpenRecord = useOpenRecord;
 const route_1 = require("@headless-adminapp/app/route");
 const app_1 = require("@headless-adminapp/core/experience/app");
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 const react_1 = require("react");
 const useGridData_1 = require("./useGridData");
 const useGridSchema_1 = require("./useGridSchema");
@@ -23,12 +24,12 @@ function useOpenRecord() {
             state: {
                 navigator: logicalName === schema.logicalName
                     ? {
-                        ids: dataRef.current?.records.map((x) => x[schema.idAttribute]) ?? [],
+                        ids: dataRef.current?.records.map((x) => (0, utils_1.getRecordId)(schema, x)) ?? [],
                         visible: false,
                         logicalName: schema.logicalName,
                     }
                     : null,
             },
         });
-    }, [routeResolver, router, schema.idAttribute, schema.logicalName]);
+    }, [routeResolver, router, schema]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "1.5.2",
+  "version": "1.5.7",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -38,5 +38,5 @@
     "uuid": "11.0.3",
     "yup": "^1.4.0"
   },
-  "gitHead": "42d358877a1744b855966feb6d85fcbb7c3c8dae"
+  "gitHead": "85010c33721181b76d6973993ce504e3c5d54aef"
 }

package/quickcreate/hooks/useFormSave.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFormSave = useFormSave;
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const react_hook_form_1 = require("react-hook-form");
@@ -48,8 +49,8 @@ function useFormSave() {
                 schema.avatarAttribute,
             ].filter(Boolean));
             saveResult = {
-                id: record[schema.idAttribute],
-                name: record[schema.primaryAttribute],
+                id: (0, utils_1.getRecordId)(schema, record),
+                name: (0, utils_1.getRecordPrimaryName)(schema, record),
                 avatar: schema.avatarAttribute
                     ? record[schema.avatarAttribute]
                     : undefined,

package/recordset/hooks/useRecordSetResult.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useRecordSetResult = useRecordSetResult;
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 const react_query_1 = require("@tanstack/react-query");
 const lodash_1 = require("lodash");
 const react_1 = require("react");
@@ -55,7 +56,7 @@ function useRecordSetResult() {
                 sort: [],
                 limit: context.ids.length,
             });
-            const sortedData = (0, lodash_1.sortBy)(result.records, (x) => context.ids.indexOf(x[schema.idAttribute]));
+            const sortedData = (0, lodash_1.sortBy)(result.records, (x) => context.ids.indexOf((0, utils_1.getRecordId)(schema, x)));
             return sortedData;
         },
     });

package/transport/InMemoryDataService/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryDataService = void 0;
+const utils_1 = require("@headless-adminapp/core/transport/utils");
 class InMemoryDataService {
     options;
     // , IActionService, IReportService
@@ -24,7 +25,7 @@ class InMemoryDataService {
         const schema = this.getSchema(logicalName);
         const records = this.getCollection(logicalName);
         const record = records.find((record) => {
-            return record[schema.idAttribute] === id;
+            return (0, utils_1.getRecordId)(schema, record) === id;
         });
         if (!record) {
             throw new Error(`Record with id ${id} not found`);

package/transport/hooks/useRetriveRecords.d.ts

@@ -6,7 +6,7 @@ interface UseRetriveRecordProps<S extends SchemaAttributes = SchemaAttributes> {
     schema: Schema<S>;
     search?: string;
     filter?: Filter | null;
-    sorting?: SortingState<S>;
+    sorting?: SortingState<Extract<keyof S, string>>;
     columns: (keyof S)[];
     expand?: Partial<Record<string, string[]>>;
     maxRecords?: number;