The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsxindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxindex 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/useAtoimport { 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<SettingsObjectDetailTaalign: '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>