Skip to content

The open alternative to Salesforce, designed for AI.

feat(settings): edit the object default layout from the data model page (#24829)

Thomas Trompetteb9888f97acd9
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/components/SettingsObjectFieldItemTableRow.tsx b/packages/twenty-front/src/modules/settings/data-model/object-details/components/SettingsObjectFieldItemTableRow.tsx
index d1494dd6096..14188e372b7 100644
--- a/packages/twenty-front/src/modules/settings/data-model/object-details/components/SettingsObjectFieldItemTableRow.tsx
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/components/SettingsObjectFieldItemTableRow.tsx
@@ -19,9 +19,12 @@ import { useLingui } from '@lingui/react/macro';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { useSetAtomFamilyState } from '@/ui/utilities/state/jotai/hooks/useSetAtomFamilyState';
import { FieldMetadataType, SettingsPath } from 'twenty-shared/types';
+import { DragDropItemSortableHandle } from '@/ui/utilities/drag-and-drop/components/DragDropItemSortableHandle';
import { getSettingsPath, isDefined } from 'twenty-shared/utils';
import {
IconChevronRight,
+ IconEyeOff,
+ IconGripVertical,
IconMinus,
IconPlus,
useIcons,
@@ -40,6 +43,10 @@ type SettingsObjectFieldItemTableRowProps = {
status: 'active' | 'disabled';
mode: 'view' | 'new-field';
isMostlyEmpty?: boolean;
+ hasDragGripGutter?: boolean;
+ showDragGrip?: boolean;
+ isVisibleInLayout?: boolean;
+ onToggleVisibility?: () => void;
};
export const OBJECT_FIELD_TABLE_ROW_GRID_TEMPLATE_COLUMNS =
@@ -65,11 +72,41 @@ const StyledIconChevronRightContainer = styled.span`
display: flex;
`;
+const StyledGripContainer = styled.span`
+ align-items: center;
+ color: ${themeCssVariables.font.color.extraLight};
+ cursor: grab;
+ display: flex;
+`;
+
+const StyledGripGutter = styled.span<{ gutterWidth: number }>`
+ display: flex;
+ min-width: ${({ gutterWidth }) => `${gutterWidth}px`};
+`;
+
+const StyledVisibilityToggleContainer = styled.span<{
+ isAlwaysShown: boolean;
+}>`
+ align-items: center;
+ display: flex;
+ opacity: ${({ isAlwaysShown }) => (isAlwaysShown ? 1 : 0)};
+`;
+
+const StyledRowWrapper = styled.div`
+ &:hover ${StyledVisibilityToggleContainer} {
+ opacity: 1;
+ }
+`;
+
export const SettingsObjectFieldItemTableRow = ({
settingsObjectDetailTableItem,
mode,
status,
isMostlyEmpty = false,
+ hasDragGripGutter = false,
+ showDragGrip = false,
+ isVisibleInLayout = true,
+ onToggleVisibility,
}: SettingsObjectFieldItemTableRowProps) => {
const { theme } = useContext(ThemeContext);
const { t } = useLingui();
@@ -134,6 +171,14 @@ export const SettingsObjectFieldItemTableRow = ({
{ objectMetadataItemId: objectMetadataItem.id },
);
+ const handleToggleVisibility = (
+ event: React.MouseEvent<HTMLButtonElement>,
+ ) => {
+ event.stopPropagation();
+ event.preventDefault();
+ onToggleVisibility?.();
+ };
+
const handleToggleField = () => {
setSettingsObjectFields((previousFields) => {
const newFields = isDefined(previousFields)
@@ -167,125 +212,157 @@ export const SettingsObjectFieldItemTableRow = ({
: relationObjectMetadataItem?.labelPlural;
return (
- <TableRow
- gridTemplateColumns={OBJECT_FIELD_TABLE_ROW_GRID_TEMPLATE_COLUMNS}
- onClick={mode === 'view' ? navigateToFieldEdit : undefined}
- >
- <UndecoratedLink to={linkToNavigate}>
- <TableCell
- color={themeCssVariables.font.color.primary}
- gap={themeCssVariables.spacing[2]}
- >
- {isDefined(Icon) && (
- <Icon
- style={{
- minWidth: theme.icon.size.md,
- }}
- size={theme.icon.size.md}
- stroke={theme.icon.stroke.sm}
- />
- )}
- <StyledNameContainer>
- <StyledNameLabel title={fieldMetadataItem.label}>
- {fieldMetadataItem.label}
- </StyledNameLabel>
- {!fieldMetadataItem.isActive && (
- <SettingsNameCellSecondaryLabel>
- {t`Deactivated`}
- </SettingsNameCellSecondaryLabel>
+ <StyledRowWrapper>
+ <TableRow
+ gridTemplateColumns={OBJECT_FIELD_TABLE_ROW_GRID_TEMPLATE_COLUMNS}
+ onClick={mode === 'view' ? navigateToFieldEdit : undefined}
+ >
+ <UndecoratedLink to={linkToNavigate}>
+ <TableCell
+ color={themeCssVariables.font.color.primary}
+ gap={themeCssVariables.spacing[2]}
+ >
+ {hasDragGripGutter && (
+ <StyledGripGutter gutterWidth={theme.icon.size.md}>
+ {showDragGrip && (
+ <DragDropItemSortableHandle>
+ <StyledGripContainer>
+ <IconGripVertical
+ size={theme.icon.size.md}
+ stroke={theme.icon.stroke.sm}
+ />
+ </StyledGripContainer>
+ </DragDropItemSortableHandle>
+ )}
+ </StyledGripGutter>
)}
- {fieldMetadataItem.isActive && isMostlyEmpty && (
- <>
- <SettingsNameCellSecondaryLabel id={mostlyEmptyLabelId}>
- {t`Mostly empty`}
- </SettingsNameCellSecondaryLabel>
- <AppTooltip
- anchorSelect={`#${mostlyEmptyLabelId}`}
- content={t`Appears filled in fewer than 5% of ${objectMetadataItem.labelPlural}. Fields that stay empty can be deactivated.`}
- delay={TooltipDelay.shortDelay}
- />
- </>
+ {isDefined(Icon) && (
+ <Icon
+ style={{
+ minWidth: theme.icon.size.md,
+ }}
+ size={theme.icon.size.md}
+ stroke={theme.icon.stroke.sm}
+ />
)}
- </StyledNameContainer>
+ <StyledNameContainer>
+ <StyledNameLabel title={fieldMetadataItem.label}>
+ {fieldMetadataItem.label}
+ </StyledNameLabel>
+ {!fieldMetadataItem.isActive && (
+ <SettingsNameCellSecondaryLabel>
+ {t`Deactivated`}
+ </SettingsNameCellSecondaryLabel>
+ )}
+ {fieldMetadataItem.isActive && isMostlyEmpty && (
+ <>
+ <SettingsNameCellSecondaryLabel id={mostlyEmptyLabelId}>
+ {t`Mostly empty`}
+ </SettingsNameCellSecondaryLabel>
+ <AppTooltip
+ anchorSelect={`#${mostlyEmptyLabelId}`}
+ content={t`Appears filled in fewer than 5% of ${objectMetadataItem.labelPlural}. Fields that stay empty can be deactivated.`}
+ delay={TooltipDelay.shortDelay}
+ />
+ </>
+ )}
+ {isDefined(onToggleVisibility) && canToggleField && (
+ <StyledVisibilityToggleContainer
+ isAlwaysShown={!isVisibleInLayout}
+ >
+ <LightIconButton
+ Icon={IconEyeOff}
+ accent={isVisibleInLayout ? 'tertiary' : 'secondary'}
+ onClick={handleToggleVisibility}
+ />
+ </StyledVisibilityToggleContainer>
+ )}
+ </StyledNameContainer>
+ </TableCell>
+ </UndecoratedLink>
+
+ <TableCell>
+ <SettingsItemTypeTag
+ item={{
+ applicationId: fieldMetadataItem.applicationId,
+ }}
+ />
</TableCell>
- </UndecoratedLink>
-
- <TableCell>
- <SettingsItemTypeTag
- item={{
- applicationId: fieldMetadataItem.applicationId,
- }}
- />
- </TableCell>
- <TableCell>
- <SettingsObjectFieldDataType
- Icon={RelationIcon}
- label={label}
- labelDetail={
- fieldMetadataItem.settings?.type === 'percentage' ? '%' : undefined
- }
- to={
- isRelatedObjectLinkable
- ? getSettingsPath(SettingsPath.Objects, {
- objectNamePlural: relationObjectMetadataItem.namePlural,
- })
- : undefined
- }
- value={fieldType}
- onClick={(e) => {
- if (isRelatedObjectLinkable) {
- e.stopPropagation();
- }
- }}
- />
- </TableCell>
- <TableCell
- align="center"
- padding={`0 ${themeCssVariables.spacing[1]} 0 ${themeCssVariables.spacing[2]}`}
- >
- {status === 'active' ? (
- mode === 'view' ? (
- <UndecoratedLink to={linkToNavigate}>
- <StyledIconChevronRightContainer>
- <IconChevronRight
- size={theme.icon.size.md}
- stroke={theme.icon.stroke.sm}
- />
- </StyledIconChevronRightContainer>
- </UndecoratedLink>
- ) : (
- canToggleField && (
- <LightIconButton
- Icon={IconMinus}
- accent="tertiary"
- onClick={handleToggleField}
- />
- )
- )
- ) : mode === 'view' ? (
- <SettingsObjectFieldInactiveActionDropdown
- isCustomField={getIsMetadataItemCustom(fieldMetadataItem)}
- isSystemField={fieldMetadataItem.isSystem === true}
- readonly={readonly}
- fieldMetadataItemId={fieldMetadataItem.id}
- onEdit={navigateToFieldEdit}
- onActivate={() =>
- activateMetadataField(fieldMetadataItem.id, objectMetadataItem.id)
+ <TableCell>
+ <SettingsObjectFieldDataType
+ Icon={RelationIcon}
+ label={label}
+ labelDetail={
+ fieldMetadataItem.settings?.type === 'percentage'
+ ? '%'
+ : undefined
}
- onDelete={() =>
- deleteOneFieldMetadataItem({
- idToDelete: fieldMetadataItem.id,
- })
+ to={
+ isRelatedObjectLinkable
+ ? getSettingsPath(SettingsPath.Objects, {
+ objectNamePlural: relationObjectMetadataItem.namePlural,
+ })
+ : undefined
}
+ value={fieldType}
+ onClick={(e) => {
+ if (isRelatedObjectLinkable) {
+ e.stopPropagation();
+ }
+ }}
/>
- ) : (
- <LightIconButton
- Icon={IconPlus}
- accent="tertiary"
- onClick={handleToggleField}
- />
- )}
- </TableCell>
- </TableRow>
+ </TableCell>
+ <TableCell
+ align="center"
+ padding={`0 ${themeCssVariables.spacing[1]} 0 ${themeCssVariables.spacing[2]}`}
+ >
+ {status === 'active' ? (
+ mode === 'view' ? (
+ <UndecoratedLink to={linkToNavigate}>
+ <StyledIconChevronRightContainer>
+ <IconChevronRight
+ size={theme.icon.size.md}
+ stroke={theme.icon.stroke.sm}
+ />
+ </StyledIconChevronRightContainer>
+ </UndecoratedLink>
+ ) : (
+ canToggleField && (
+ <LightIconButton
+ Icon={IconMinus}
+ accent="tertiary"
+ onClick={handleToggleField}
+ />
+ )
+ )
+ ) : mode === 'view' ? (
+ <SettingsObjectFieldInactiveActionDropdown
+ isCustomField={getIsMetadataItemCustom(fieldMetadataItem)}
+ isSystemField={fieldMetadataItem.isSystem === true}
+ readonly={readonly}
+ fieldMetadataItemId={fieldMetadataItem.id}
+ onEdit={navigateToFieldEdit}
+ onActivate={() =>
+ activateMetadataField(
+ fieldMetadataItem.id,
+ objectMetadataItem.id,
+ )
+ }
+ onDelete={() =>
+ deleteOneFieldMetadataItem({
+ idToDelete: fieldMetadataItem.id,
+ })
+ }
+ />
+ ) : (
+ <LightIconButton
+ Icon={IconPlus}
+ accent="tertiary"
+ onClick={handleToggleField}
+ />
+ )}
+ </TableCell>
+ </TableRow>
+ </StyledRowWrapper>
);
};
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/hooks/useDefaultViewFieldsLayout.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/hooks/useDefaultViewFieldsLayout.ts
new file mode 100644
index 00000000000..67cec70dcd3
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/hooks/useDefaultViewFieldsLayout.ts
@@ -0,0 +1,301 @@
+import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { computeFieldMetadataLayoutPositionUpdates } from '@/settings/data-model/object-details/utils/computeFieldMetadataLayoutPositionUpdates';
+import { sortFieldMetadataItemsByViewLayout } from '@/settings/data-model/object-details/utils/sortFieldMetadataItemsByViewLayout';
+import {
+ settingsObjectFieldsPendingLayoutFamilyState,
+ type PendingViewFieldLayout,
+} from '@/settings/data-model/object-details/states/settingsObjectFieldsPendingLayoutFamilyState';
+import { type DraggableListDropResult } from '@/ui/layout/draggable-list/types/DraggableListDropResult';
+import { usePerformViewFieldAPIPersist } from '@/views/hooks/internal/usePerformViewFieldAPIPersist';
+import { useViewOrDefaultView } from '@/views/hooks/useViewOrDefaultView';
+import { useAtomFamilyStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomFamilyStateValue';
+import { useStore } from 'jotai';
+import { useMemo } from 'react';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
+
+const DEFAULT_CREATED_VIEW_FIELD_SIZE = 100;
+
+type ViewFieldLayoutUpdate = {
+ fieldMetadataId: string;
+ layout: PendingViewFieldLayout;
+};
+
+export const useDefaultViewFieldsLayout = ({
+ objectMetadataItem,
+ fieldMetadataItems,
+}: {
+ objectMetadataItem: EnrichedObjectMetadataItem;
+ fieldMetadataItems: FieldMetadataItem[];
+}) => {
+ const { view: defaultView } = useViewOrDefaultView({
+ objectMetadataItemId: objectMetadataItem.id,
+ });
+
+ const { performViewFieldAPICreate, performViewFieldAPIUpdate } =
+ usePerformViewFieldAPIPersist();
+
+ const store = useStore();
+ const pendingLayoutFamilyKey = {
+ objectMetadataItemId: objectMetadataItem.id,
+ };
+ const pendingLayoutAtom =
+ settingsObjectFieldsPendingLayoutFamilyState.atomFamily(
+ pendingLayoutFamilyKey,
+ );
+ const settingsObjectFieldsPendingLayout = useAtomFamilyStateValue(
+ settingsObjectFieldsPendingLayoutFamilyState,
+ pendingLayoutFamilyKey,
+ );
+
+ const applyPendingLayoutUpdates = (
+ layoutUpdates: ViewFieldLayoutUpdate[],
+ ) => {
+ const newPending = new Map(store.get(pendingLayoutAtom));
+
+ for (const { fieldMetadataId, layout } of layoutUpdates) {
+ newPending.set(fieldMetadataId, {
+ ...newPending.get(fieldMetadataId),
+ ...layout,
+ });
+ }
+
+ store.set(pendingLayoutAtom, newPending);
+ };
+
+ const clearPendingLayoutUpdates = (fieldMetadataIds: string[]) => {
+ const newPending = new Map(store.get(pendingLayoutAtom));
+
+ for (const fieldMetadataId of fieldMetadataIds) {
+ newPending.delete(fieldMetadataId);
+ }
+
+ store.set(pendingLayoutAtom, newPending);
+ };
+
+ const viewFieldByFieldMetadataId = useMemo(
+ () =>
+ new Map(
+ (defaultView?.viewFields ?? []).map((viewField) => [
+ viewField.fieldMetadataId,
+ viewField,
+ ]),
+ ),
+ [defaultView],
+ );
+
+ const getEffectiveLayout = (
+ fieldMetadataId: string,
+ ): { position: number | null; isVisible: boolean } => {
+ const pending = settingsObjectFieldsPendingLayout.get(fieldMetadataId);
+ const viewField = viewFieldByFieldMetadataId.get(fieldMetadataId);
+
+ return {
+ position: pending?.position ?? viewField?.position ?? null,
+ isVisible: pending?.isVisible ?? viewField?.isVisible ?? false,
+ };
+ };
+
+ const positionByFieldMetadataId = useMemo(() => {
+ const positions = new Map<string, number>();
+
+ for (const field of fieldMetadataItems) {
+ const pending = settingsObjectFieldsPendingLayout.get(field.id);
+ const viewField = viewFieldByFieldMetadataId.get(field.id);
+ const position = pending?.position ?? viewField?.position;
+
+ if (isDefined(position)) {
+ positions.set(field.id, position);
+ }
+ }
+
+ return positions;
+ }, [
+ fieldMetadataItems,
+ settingsObjectFieldsPendingLayout,
+ viewFieldByFieldMetadataId,
+ ]);
+
+ const layoutOrderedFields = useMemo(
+ () =>
+ sortFieldMetadataItemsByViewLayout({
+ fieldMetadataItems,
+ positionByFieldMetadataId,
+ }),
+ [fieldMetadataItems, positionByFieldMetadataId],
+ );
+
+ const persistLayoutUpdates = async (
+ layoutUpdates: ViewFieldLayoutUpdate[],
+ ) => {
+ if (!isDefined(defaultView)) {
+ return;
+ }
+
+ applyPendingLayoutUpdates(layoutUpdates);
+
+ const lastPosition = Math.max(
+ -1,
+ ...Array.from(positionByFieldMetadataId.values()),
+ );
+
+ const viewFieldsToCreate = [];
+ const viewFieldsToUpdate = [];
+
+ for (const { fieldMetadataId, layout } of layoutUpdates) {
+ const existingViewField = viewFieldByFieldMetadataId.get(fieldMetadataId);
+
+ if (isDefined(existingViewField)) {
+ viewFieldsToUpdate.push({
+ input: {
+ id: existingViewField.id,
+ update: {
+ ...(isDefined(layout.position)
+ ? { position: layout.position }
+ : {}),
+ ...(isDefined(layout.isVisible)
+ ? { isVisible: layout.isVisible }
+ : {}),
+ },
+ },
+ });
+ } else {
+ viewFieldsToCreate.push({
+ id: v4(),
+ viewId: defaultView.id,
+ fieldMetadataId,
+ position: layout.position ?? lastPosition + 1,
+ isVisible: layout.isVisible ?? false,
+ size: DEFAULT_CREATED_VIEW_FIELD_SIZE,
+ });
+ }
+ }
+
+ try {
+ if (viewFieldsToCreate.length > 0) {
+ await performViewFieldAPICreate({ inputs: viewFieldsToCreate });
+ }
+ if (viewFieldsToUpdate.length > 0) {
+ await performViewFieldAPIUpdate(viewFieldsToUpdate);
+ }
+ } finally {
+ clearPendingLayoutUpdates(
+ layoutUpdates.map(({ fieldMetadataId }) => fieldMetadataId),
+ );
+ }
+ };
+
+ const toggleFieldVisibility = async (fieldMetadataId: string) => {
+ const currentIsVisible =
+ store.get(pendingLayoutAtom).get(fieldMetadataId)?.isVisible ??
+ viewFieldByFieldMetadataId.get(fieldMetadataId)?.isVisible ??
+ false;
+
+ await persistLayoutUpdates([
+ { fieldMetadataId, layout: { isVisible: !currentIsVisible } },
+ ]);
+ };
+
+ const findPrecedingFieldMetadataId = ({
+ movedFieldMetadataId,
+ destinationIndex,
+ visibleFieldMetadataItems,
+ }: {
+ movedFieldMetadataId: string;
+ destinationIndex: number;
+ visibleFieldMetadataItems: FieldMetadataItem[];
+ }): string | null => {
+ const visibleFieldsWithoutMoved = visibleFieldMetadataItems.filter(
+ (field) => field.id !== movedFieldMetadataId,
+ );
+ const layoutOrderedFieldsWithoutMoved = layoutOrderedFields.filter(
+ (field) => field.id !== movedFieldMetadataId,
+ );
+
+ const nextVisibleField = visibleFieldsWithoutMoved[destinationIndex];
+
+ if (!isDefined(nextVisibleField)) {
+ const lastVisibleField =
+ visibleFieldsWithoutMoved[visibleFieldsWithoutMoved.length - 1];
+
+ return lastVisibleField?.id ?? null;
+ }
+
+ const precedingField =
+ layoutOrderedFieldsWithoutMoved[
+ layoutOrderedFieldsWithoutMoved.findIndex(
+ (field) => field.id === nextVisibleField.id,
+ ) - 1
+ ];
+
+ if (isDefined(precedingField)) {
+ return precedingField.id;
+ }
+
+ const firstLayoutField = layoutOrderedFieldsWithoutMoved[0];
+
+ if (
+ isDefined(firstLayoutField) &&
+ firstLayoutField.id === objectMetadataItem.labelIdentifierFieldMetadataId
+ ) {
+ return firstLayoutField.id;
+ }
+
+ return null;
+ };
+
+ const reorderFieldFromDropResult = async ({
+ dropResult,
+ visibleFieldMetadataItems,
+ }: {
+ dropResult: DraggableListDropResult;
+ visibleFieldMetadataItems: FieldMetadataItem[];
+ }) => {
+ if (!isDefined(dropResult.destination)) {
+ return;
+ }
+
+ const movedFieldMetadataId = dropResult.draggableId;
+
+ if (
+ movedFieldMetadataId === objectMetadataItem.labelIdentifierFieldMetadataId
+ ) {
+ return;
+ }
+
+ const precedingFieldMetadataId = findPrecedingFieldMetadataId({
+ movedFieldMetadataId,
+ destinationIndex: dropResult.destination.index,
+ visibleFieldMetadataItems,
+ });
+
+ const positionUpdates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: layoutOrderedFields.map((field) => ({
+ id: field.id,
+ position: positionByFieldMetadataId.get(field.id) ?? null,
+ })),
+ movedFieldMetadataId,
+ precedingFieldMetadataId,
+ });
+
+ if (positionUpdates.length === 0) {
+ return;
+ }
+
+ await persistLayoutUpdates(
+ positionUpdates.map((update) => ({
+ fieldMetadataId: update.fieldMetadataId,
+ layout: { position: update.position },
+ })),
+ );
+ };
+
+ return {
+ hasEditableDefaultView: isDefined(defaultView),
+ layoutOrderedFields,
+ getEffectiveLayout,
+ toggleFieldVisibility,
+ reorderFieldFromDropResult,
+ };
+};
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/states/settingsObjectFieldsPendingLayoutFamilyState.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/states/settingsObjectFieldsPendingLayoutFamilyState.ts
new file mode 100644
index 00000000000..a71ccd499b0
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/states/settingsObjectFieldsPendingLayoutFamilyState.ts
@@ -0,0 +1,19 @@
+import { createAtomFamilyState } from '@/ui/utilities/state/jotai/utils/createAtomFamilyState';
+
+export type PendingViewFieldLayout = {
+ position?: number;
+ isVisible?: boolean;
+};
+
+export type SettingsObjectFieldsPendingLayoutFamilyStateKey = {
+ objectMetadataItemId: string;
+};
+
+export const settingsObjectFieldsPendingLayoutFamilyState =
+ createAtomFamilyState<
+ Map<string, PendingViewFieldLayout>,
+ SettingsObjectFieldsPendingLayoutFamilyStateKey
+ >({
+ key: 'settingsObjectFieldsPendingLayoutFamilyState',
+ defaultValue: new Map(),
+ });
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/computeFieldMetadataLayoutPositionUpdates.test.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/computeFieldMetadataLayoutPositionUpdates.test.ts
new file mode 100644
index 00000000000..b63e94574a3
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/computeFieldMetadataLayoutPositionUpdates.test.ts
@@ -0,0 +1,129 @@
+import { computeFieldMetadataLayoutPositionUpdates } from '@/settings/data-model/object-details/utils/computeFieldMetadataLayoutPositionUpdates';
+
+describe('computeFieldMetadataLayoutPositionUpdates', () => {
+ it('writes a single fractional position between two positioned neighbors', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ { id: 'c', position: 2 },
+ ],
+ movedFieldMetadataId: 'c',
+ precedingFieldMetadataId: 'a',
+ });
+
+ expect(updates).toEqual([{ fieldMetadataId: 'c', position: 0.5 }]);
+ });
+
+ it('places the moved field before every positioned one when dropped first', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ ],
+ movedFieldMetadataId: 'b',
+ precedingFieldMetadataId: null,
+ });
+
+ expect(updates).toEqual([{ fieldMetadataId: 'b', position: -1 }]);
+ });
+
+ it('appends after the last positioned field when dropped after it', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ ],
+ movedFieldMetadataId: 'a',
+ precedingFieldMetadataId: 'b',
+ });
+
+ expect(updates).toEqual([{ fieldMetadataId: 'a', position: 2 }]);
+ });
+
+ it('appends after the last positioned field when dropped into the unpositioned tail', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 4 },
+ { id: 'tail-1', position: null },
+ { id: 'tail-2', position: null },
+ ],
+ movedFieldMetadataId: 'a',
+ precedingFieldMetadataId: 'tail-1',
+ });
+
+ expect(updates).toEqual([{ fieldMetadataId: 'a', position: 5 }]);
+ });
+
+ it('positions an unpositioned field dropped between positioned neighbors', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ { id: 'tail-1', position: null },
+ ],
+ movedFieldMetadataId: 'tail-1',
+ precedingFieldMetadataId: 'a',
+ });
+
+ expect(updates).toEqual([{ fieldMetadataId: 'tail-1', position: 0.5 }]);
+ });
+
+ it('never touches unpositioned bystanders', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ { id: 'c', position: 2 },
+ { id: 'tail-1', position: null },
+ ],
+ movedFieldMetadataId: 'c',
+ precedingFieldMetadataId: 'a',
+ });
+
+ expect(updates.map((update) => update.fieldMetadataId)).toEqual(['c']);
+ });
+
+ it('reindexes only the positioned fields when neighbor positions collide', () => {
+ const updates = computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 1 },
+ { id: 'b', position: 1 },
+ { id: 'c', position: 3 },
+ { id: 'tail-1', position: null },
+ ],
+ movedFieldMetadataId: 'c',
+ precedingFieldMetadataId: 'a',
+ });
+
+ expect(updates).toEqual([
+ { fieldMetadataId: 'a', position: 0 },
+ { fieldMetadataId: 'c', position: 1 },
+ { fieldMetadataId: 'b', position: 2 },
+ ]);
+ });
+
+ it('returns no update for an unknown moved field', () => {
+ expect(
+ computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [{ id: 'a', position: 0 }],
+ movedFieldMetadataId: 'unknown',
+ precedingFieldMetadataId: null,
+ }),
+ ).toEqual([]);
+ });
+
+ it('returns no update for an unknown preceding field', () => {
+ expect(
+ computeFieldMetadataLayoutPositionUpdates({
+ orderedFieldMetadataItems: [
+ { id: 'a', position: 0 },
+ { id: 'b', position: 1 },
+ ],
+ movedFieldMetadataId: 'a',
+ precedingFieldMetadataId: 'unknown',
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/sortFieldMetadataItemsByViewLayout.test.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/sortFieldMetadataItemsByViewLayout.test.ts
new file mode 100644
index 00000000000..3104b0ac055
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/__tests__/sortFieldMetadataItemsByViewLayout.test.ts
@@ -0,0 +1,64 @@
+import { sortFieldMetadataItemsByViewLayout } from '@/settings/data-model/object-details/utils/sortFieldMetadataItemsByViewLayout';
+
+describe('sortFieldMetadataItemsByViewLayout', () => {
+ it('orders positioned fields by position before unpositioned ones', () => {
+ const sorted = sortFieldMetadataItemsByViewLayout({
+ fieldMetadataItems: [
+ { id: 'unpositioned', label: 'AAA' },
+ { id: 'second', label: 'ZZZ' },
+ { id: 'first', label: 'MMM' },
+ ],
+ positionByFieldMetadataId: new Map([
+ ['second', 4],
+ ['first', 1],
+ ]),
+ });
+
+ expect(sorted.map((field) => field.id)).toEqual([
+ 'first',
+ 'second',
+ 'unpositioned',
+ ]);
+ });
+
+ it('breaks position ties by label', () => {
+ const sorted = sortFieldMetadataItemsByViewLayout({
+ fieldMetadataItems: [
+ { id: 'b', label: 'Beta' },
+ { id: 'a', label: 'Alpha' },
+ ],
+ positionByFieldMetadataId: new Map([
+ ['a', 2],
+ ['b', 2],
+ ]),
+ });
+
+ expect(sorted.map((field) => field.id)).toEqual(['a', 'b']);
+ });
+
+ it('orders unpositioned fields by label', () => {
+ const sorted = sortFieldMetadataItemsByViewLayout({
+ fieldMetadataItems: [
+ { id: 'b', label: 'Beta' },
+ { id: 'a', label: 'Alpha' },
+ ],
+ positionByFieldMetadataId: new Map(),
+ });
+
+ expect(sorted.map((field) => field.id)).toEqual(['a', 'b']);
+ });
+
+ it('does not mutate the input array', () => {
+ const input = [
+ { id: 'b', label: 'Beta' },
+ { id: 'a', label: 'Alpha' },
+ ];
+
+ sortFieldMetadataItemsByViewLayout({
+ fieldMetadataItems: input,
+ positionByFieldMetadataId: new Map(),
+ });
+
+ expect(input.map((field) => field.id)).toEqual(['b', 'a']);
+ });
+});
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/utils/computeFieldMetadataLayoutPositionUpdates.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/computeFieldMetadataLayoutPositionUpdates.ts
new file mode 100644
index 00000000000..075a6d6cf48
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/computeFieldMetadataLayoutPositionUpdates.ts
@@ -0,0 +1,109 @@
+import { isDefined } from 'twenty-shared/utils';
+
+type FieldMetadataLayoutOrderItem = {
+ id: string;
+ position: number | null;
+};
+
+type FieldMetadataLayoutPositionUpdate = {
+ fieldMetadataId: string;
+ position: number;
+};
+
+export const computeFieldMetadataLayoutPositionUpdates = ({
+ orderedFieldMetadataItems,
+ movedFieldMetadataId,
+ precedingFieldMetadataId,
+}: {
+ orderedFieldMetadataItems: FieldMetadataLayoutOrderItem[];
+ movedFieldMetadataId: string;
+ precedingFieldMetadataId: string | null;
+}): FieldMetadataLayoutPositionUpdate[] => {
+ const movedFieldMetadataItem = orderedFieldMetadataItems.find(
+ (item) => item.id === movedFieldMetadataId,
+ );
+
+ if (!isDefined(movedFieldMetadataItem)) {
+ return [];
+ }
+
+ const itemsWithoutMoved = orderedFieldMetadataItems.filter(
+ (item) => item.id !== movedFieldMetadataId,
+ );
+
+ const positionedItems = itemsWithoutMoved.filter(
+ (item): item is { id: string; position: number } =>
+ isDefined(item.position),
+ );
+
+ if (precedingFieldMetadataId === null) {
+ const firstPositionedItem = positionedItems[0];
+
+ return [
+ {
+ fieldMetadataId: movedFieldMetadataId,
+ position: isDefined(firstPositionedItem)
+ ? firstPositionedItem.position - 1
+ : 0,
+ },
+ ];
+ }
+
+ const precedingItem = itemsWithoutMoved.find(
+ (item) => item.id === precedingFieldMetadataId,
+ );
+
+ if (!isDefined(precedingItem)) {
+ return [];
+ }
+
+ const lastPositionedItem = positionedItems[positionedItems.length - 1];
+
+ if (!isDefined(precedingItem.position)) {
+ return [
+ {
+ fieldMetadataId: movedFieldMetadataId,
+ position: isDefined(lastPositionedItem)
+ ? lastPositionedItem.position + 1
+ : 0,
+ },
+ ];
+ }
+
+ const precedingPositionedIndex = positionedItems.findIndex(
+ (item) => item.id === precedingFieldMetadataId,
+ );
+ const nextPositionedItem = positionedItems[precedingPositionedIndex + 1];
+
+ if (!isDefined(nextPositionedItem)) {
+ return [
+ {
+ fieldMetadataId: movedFieldMetadataId,
+ position: precedingItem.position + 1,
+ },
+ ];
+ }
+
+ if (precedingItem.position < nextPositionedItem.position) {
+ return [
+ {
+ fieldMetadataId: movedFieldMetadataId,
+ position: (precedingItem.position + nextPositionedItem.position) / 2,
+ },
+ ];
+ }
+
+ const reorderedPositionedItems = [
+ ...positionedItems.slice(0, precedingPositionedIndex + 1),
+ { id: movedFieldMetadataId, position: movedFieldMetadataItem.position },
+ ...positionedItems.slice(precedingPositionedIndex + 1),
+ ];
+
+ return reorderedPositionedItems
+ .map((item, index) => ({ item, index }))
+ .filter(({ item, index }) => item.position !== index)
+ .map(({ item, index }) => ({
+ fieldMetadataId: item.id,
+ position: index,
+ }));
+};
diff --git a/packages/twenty-front/src/modules/settings/data-model/object-details/utils/sortFieldMetadataItemsByViewLayout.ts b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/sortFieldMetadataItemsByViewLayout.ts
new file mode 100644
index 00000000000..58e1f2c5c6a
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/data-model/object-details/utils/sortFieldMetadataItemsByViewLayout.ts
@@ -0,0 +1,38 @@
+import { isDefined } from 'twenty-shared/utils';
+
+type FieldMetadataLayoutSortable = {
+ id: string;
+ label: string;
+};
+
+export const sortFieldMetadataItemsByViewLayout = <
+ TField extends FieldMetadataLayoutSortable,
+>({
+ fieldMetadataItems,
+ positionByFieldMetadataId,
+}: {
+ fieldMetadataItems: TField[];
+ positionByFieldMetadataId: Map<string, number>;
+}): TField[] =>
+ [...fieldMetadataItems].sort((fieldA, fieldB) => {
+ const positionA = positionByFieldMetadataId.get(fieldA.id);
+ const positionB = positionByFieldMetadataId.get(fieldB.id);
+
+ if (isDefined(positionA) && isDefined(positionB)) {
+ if (positionA !== positionB) {
+ return positionA - positionB;
+ }
+
+ return fieldA.label.localeCompare(fieldB.label);
+ }
+
+ if (isDefined(positionA)) {
+ return -1;
+ }
+
+ if (isDefined(positionB)) {
+ return 1;
+ }
+
+ return fieldA.label.localeCompare(fieldB.label);
+ });
diff --git a/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldTable.tsx b/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldTable.tsx
index 96f755202cb..9dbe6ef20ab 100644
--- a/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldTable.tsx
+++ b/packages/twenty-front/src/pages/settings/data-model/SettingsObjectFieldTable.tsx
@@ -1,5 +1,11 @@
import { type EnrichedObjectMetadataItem } from '@/object-metadata/types/EnrichedObjectMetadataItem';
import { isHiddenSystemField } from '@/object-metadata/utils/isHiddenSystemField';
+import { isDDLLockedState } from '@/client-config/states/isDDLLockedState';
+import { isObjectMetadataReadOnly } from '@/object-record/read-only/utils/isObjectMetadataReadOnly';
+import { DraggableItem } from '@/ui/layout/draggable-list/components/DraggableItem';
+import { DraggableList } from '@/ui/layout/draggable-list/components/DraggableList';
+import { type DraggableListDropResult } from '@/ui/layout/draggable-list/types/DraggableListDropResult';
+import { sortedFieldByTableFamilyState } from '@/ui/layout/table/states/sortedFieldByTableFamilyState';
import { TableRow } from '@/ui/layout/table/components/TableRow';
import {
OBJECT_FIELD_TABLE_ROW_GRID_TEMPLATE_COLUMNS,
@@ -25,10 +31,12 @@ import { useAtomFamilyStateValue } from '@/ui/utilities/state/jotai/hooks/useAto
import { useSetAtomFamilyState } from '@/ui/utilities/state/jotai/hooks/useSetAtomFamilyState';
import { useEffect, useMemo, useState } from 'react';
import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
import { IconArchive, IconCircleDashed, IconSettings } from 'twenty-ui/icon';
import { SearchInput } from 'twenty-ui/input';
import { MenuItemToggle } from 'twenty-ui/navigation';
import { themeCssVariables } from 'twenty-ui/theme-constants';
+import { useDefaultViewFieldsLayout } from '@/settings/data-model/object-details/hooks/useDefaultViewFieldsLayout';
import { useMostlyEmptyFieldMetadataIds } from '@/settings/data-model/object-details/hooks/useMostlyEmptyFieldMetadataIds';
import { useMapFieldMetadataItemToSettingsObjectDetailTableItem } from '~/pages/settings/data-model/hooks/useMapFieldMetadataItemToSettingsObjectDetailTableItem';
import { type SettingsObjectDetailTableItem } from '~/pages/settings/data-model/types/SettingsObjectDetailTableItem';
@@ -61,10 +69,6 @@ const SETTINGS_OBJECT_FIELD_TABLE_METADATA: TableMetadata<SettingsObjectDetailTa
align: 'left',
},
],
- initialSort: {
- fieldName: 'label',
- direction: 'asc',
- },
};
export type SettingsObjectFieldTableProps = {
@@ -110,28 +114,37 @@ export const SettingsObjectFieldTable = ({
setSettingsObjectFields(objectMetadataItem.fields);
}, [objectMetadataItem, setSettingsObjectFields]);
+ const {
+ hasEditableDefaultView,
+ layoutOrderedFields,
+ getEffectiveLayout,
+ toggleFieldVisibility,
+ reorderFieldFromDropResult,
+ } = useDefaultViewFieldsLayout({
+ objectMetadataItem,
+ fieldMetadataItems: settingsObjectFields ?? [],
+ });
+
const allObjectSettingsDetailItems = useMemo(() => {
const filteredBySystem = showSystemFields
- ? settingsObjectFields
- : settingsObjectFields?.filter(
+ ? layoutOrderedFields
+ : layoutOrderedFields.filter(
(fieldMetadataItem) => !isHiddenSystemField(fieldMetadataItem),
);
const fieldsToDisplay = excludeRelations
- ? filteredBySystem?.filter(
+ ? filteredBySystem.filter(
(fieldMetadataItem) =>
fieldMetadataItem.type !== FieldMetadataType.RELATION &&
fieldMetadataItem.type !== FieldMetadataType.MORPH_RELATION,
)
: filteredBySystem;
- return (
- fieldsToDisplay?.map(
- mapFieldMetadataItemToSettingsObjectDetailTableItem,
- ) ?? []
+ return fieldsToDisplay.map(
+ mapFieldMetadataItemToSettingsObjectDetailTableItem,
);
}, [
- settingsObjectFields,
+ layoutOrderedFields,
mapFieldMetadataItemToSettingsObjectDetailTableItem,
excludeRelations,
showSystemFields,
@@ -142,6 +155,26 @@ export const SettingsObjectFieldTable = ({
tableMetadata,
);
+ const isDDLLocked = useAtomStateValue(isDDLLockedState);
+
+ const readonly =
+ isObjectMetadataReadOnly({
+ objectMetadataItem,
+ }) || isDDLLocked;
+
+ const sortedFieldByTable = useAtomFamilyStateValue(
+ sortedFieldByTableFamilyState,
+ { tableId: tableMetadata.tableId },
+ );
+ const setSortedFieldByTable = useSetAtomFamilyState(
+ sortedFieldByTableFamilyState,
+ { tableId: tableMetadata.tableId },
+ );
+
+ useEffect(() => {
+ setSortedFieldByTable(null);
+ }, [setSortedFieldByTable]);
+
const filteredItems = useMemo(() => {
const searchNormalized = normalizeSearchText(searchTerm);
@@ -167,6 +200,71 @@ export const SettingsObjectFieldTable = ({
mostlyEmptyFieldMetadataIds,
]);
+ const isLayoutEditable =
+ mode === 'view' && !readonly && hasEditableDefaultView;
+
+ const isReorderEnabled =
+ isLayoutEditable && !isDefined(sortedFieldByTable) && searchTerm === '';
+
+ const handleReorderDragEnd = async (result: DraggableListDropResult) => {
+ await reorderFieldFromDropResult({
+ dropResult: result,
+ visibleFieldMetadataItems: filteredItems.map(
+ (tableItem) => tableItem.fieldMetadataItem,
+ ),
+ });
+ };
+
+ const fieldTableRows = filteredItems.map(
+ (objectSettingsDetailItem, index) => {
+ const fieldMetadataId = objectSettingsDetailItem.fieldMetadataItem.id;
+ const isLabelIdentifierField =
+ fieldMetadataId === objectMetadataItem.labelIdentifierFieldMetadataId;
+ const isLayoutManageableField =
+ !isLabelIdentifierField &&
+ (objectSettingsDetailItem.fieldMetadataItem.isActive ?? false) &&
+ !isHiddenSystemField(objectSettingsDetailItem.fieldMetadataItem);
+ const status = objectSettingsDetailItem.fieldMetadataItem.isActive
+ ? 'active'
+ : 'disabled';
+
+ const row = (
+ <SettingsObjectFieldItemTableRow
+ key={fieldMetadataId}
+ settingsObjectDetailTableItem={objectSettingsDetailItem}
+ status={status}
+ mode={mode}
+ isMostlyEmpty={mostlyEmptyFieldMetadataIds.has(fieldMetadataId)}
+ hasDragGripGutter={isReorderEnabled}
+ showDragGrip={isReorderEnabled && isLayoutManageableField}
+ isVisibleInLayout={
+ isLabelIdentifierField ||
+ getEffectiveLayout(fieldMetadataId).isVisible
+ }
+ onToggleVisibility={
+ isLayoutEditable && isLayoutManageableField
+ ? () => toggleFieldVisibility(fieldMetadataId)
+ : undefined
+ }
+ />
+ );
+
+ if (!isReorderEnabled) {
+ return row;
+ }
+
+ return (
+ <DraggableItem
+ key={fieldMetadataId}
+ draggableId={fieldMetadataId}
+ index={index}
+ isDragDisabled={!isLayoutManageableField}
+ itemComponent={row}
+ />
+ );
+ },
+ );
+
return (
<>
<StyledSearchContainer>
@@ -237,23 +335,14 @@ export const SettingsObjectFieldTable = ({
</TableRow>
<StyledSettingsDataModelTableBodyContainer>
<TableBody>
- {filteredItems.map((objectSettingsDetailItem) => {
- const status = objectSettingsDetailItem.fieldMetadataItem.isActive
- ? 'active'
- : 'disabled';
-
- return (
- <SettingsObjectFieldItemTableRow
- key={objectSettingsDetailItem.fieldMetadataItem.id}
- settingsObjectDetailTableItem={objectSettingsDetailItem}
- status={status}
- mode={mode}
- isMostlyEmpty={mostlyEmptyFieldMetadataIds.has(
- objectSettingsDetailItem.fieldMetadataItem.id,
- )}
- />
- );
- })}
+ {isReorderEnabled ? (
+ <DraggableList
+ onDragEnd={handleReorderDragEnd}
+ draggableItems={<>{fieldTableRows}</>}
+ />
+ ) : (
+ fieldTableRows
+ )}
</TableBody>
</StyledSettingsDataModelTableBodyContainer>
</Table>