Migrate to a monorepo structure (#2909)

packages/twenty-front/src/modules/views/utils/getViewScopedStateValuesFromSnapshot.ts

@@ -0,0 +1,108 @@
+import { Snapshot } from 'recoil';
+
+import { getScopedState } from '@/ui/utilities/recoil-scope/utils/getScopedState';
+import { getSnapshotValue } from '@/ui/utilities/recoil-scope/utils/getSnapshotValue';
+
+import { UNDEFINED_FAMILY_ITEM_ID } from '../constants';
+import { currentViewIdScopedState } from '../states/currentViewIdScopedState';
+
+import { getViewScopedStates } from './internal/getViewScopedStates';
+
+export const getViewScopedStateValuesFromSnapshot = ({
+  snapshot,
+  viewScopeId,
+  viewId,
+}: {
+  snapshot: Snapshot;
+  viewScopeId: string;
+  viewId?: string;
+}) => {
+  const currentViewId = getSnapshotValue(
+    snapshot,
+    getScopedState(currentViewIdScopedState, viewScopeId),
+  );
+
+  const familyItemId = viewId ?? currentViewId ?? UNDEFINED_FAMILY_ITEM_ID;
+
+  const {
+    availableFieldDefinitionsState,
+    availableFilterDefinitionsState,
+    availableSortDefinitionsState,
+    canPersistFiltersSelector,
+    canPersistSortsSelector,
+    currentViewFieldsState,
+    currentViewFiltersState,
+    currentViewIdState,
+    currentViewSelector,
+    currentViewSortsState,
+    entityCountInCurrentViewState,
+    isViewBarExpandedState,
+    isPersistingViewState,
+    onViewFieldsChangeState,
+    onViewFiltersChangeState,
+    onViewSortsChangeState,
+    savedViewFieldsByKeySelector,
+    savedViewFieldsState,
+    savedViewFiltersByKeySelector,
+    savedViewFiltersState,
+    savedViewSortsByKeySelector,
+    savedViewSortsState,
+    viewEditModeState,
+    viewObjectMetadataIdState,
+    viewTypeState,
+    viewsState,
+  } = getViewScopedStates({
+    viewScopeId,
+    viewId: familyItemId,
+  });
+
+  return {
+    availableFieldDefinitions: getSnapshotValue(
+      snapshot,
+      availableFieldDefinitionsState,
+    ),
+    availableFilterDefinitions: getSnapshotValue(
+      snapshot,
+      availableFilterDefinitionsState,
+    ),
+    availableSortDefinitions: getSnapshotValue(
+      snapshot,
+      availableSortDefinitionsState,
+    ),
+    canPersistFilters: getSnapshotValue(snapshot, canPersistFiltersSelector),
+    canPersistSorts: getSnapshotValue(snapshot, canPersistSortsSelector),
+    currentViewFields: getSnapshotValue(snapshot, currentViewFieldsState),
+    currentViewFilters: getSnapshotValue(snapshot, currentViewFiltersState),
+    currentViewId: getSnapshotValue(snapshot, currentViewIdState),
+    currentView: getSnapshotValue(snapshot, currentViewSelector),
+    currentViewSorts: getSnapshotValue(snapshot, currentViewSortsState),
+    entityCountInCurrentView: getSnapshotValue(
+      snapshot,
+      entityCountInCurrentViewState,
+    ),
+    isViewBarExpanded: getSnapshotValue(snapshot, isViewBarExpandedState),
+    isPersistingView: getSnapshotValue(snapshot, isPersistingViewState),
+    onViewFieldsChange: getSnapshotValue(snapshot, onViewFieldsChangeState),
+    onViewFiltersChange: getSnapshotValue(snapshot, onViewFiltersChangeState),
+    onViewSortsChange: getSnapshotValue(snapshot, onViewSortsChangeState),
+    savedViewFieldsByKey: getSnapshotValue(
+      snapshot,
+      savedViewFieldsByKeySelector,
+    ),
+    savedViewFields: getSnapshotValue(snapshot, savedViewFieldsState),
+    savedViewFiltersByKey: getSnapshotValue(
+      snapshot,
+      savedViewFiltersByKeySelector,
+    ),
+    savedViewFilters: getSnapshotValue(snapshot, savedViewFiltersState),
+    savedViewSortsByKey: getSnapshotValue(
+      snapshot,
+      savedViewSortsByKeySelector,
+    ),
+    savedViewSorts: getSnapshotValue(snapshot, savedViewSortsState),
+    viewEditMode: getSnapshotValue(snapshot, viewEditModeState),
+    viewObjectMetadataId: getSnapshotValue(snapshot, viewObjectMetadataIdState),
+    viewType: getSnapshotValue(snapshot, viewTypeState),
+    views: getSnapshotValue(snapshot, viewsState),
+  };
+};

packages/twenty-front/src/modules/views/utils/getViewScopedStatesFromSnapshot.ts

@@ -0,0 +1,87 @@
+import { Snapshot } from 'recoil';
+
+import { getScopedState } from '@/ui/utilities/recoil-scope/utils/getScopedState';
+import { getSnapshotValue } from '@/ui/utilities/recoil-scope/utils/getSnapshotValue';
+
+import { UNDEFINED_FAMILY_ITEM_ID } from '../constants';
+import { currentViewIdScopedState } from '../states/currentViewIdScopedState';
+
+import { getViewScopedStates } from './internal/getViewScopedStates';
+
+export const getViewScopedStatesFromSnapshot = ({
+  snapshot,
+  viewScopeId,
+  viewId,
+}: {
+  snapshot: Snapshot;
+  viewScopeId: string;
+  viewId?: string;
+}) => {
+  const currentViewId = getSnapshotValue(
+    snapshot,
+    getScopedState(currentViewIdScopedState, viewScopeId),
+  );
+
+  const usedViewId = viewId ?? currentViewId ?? UNDEFINED_FAMILY_ITEM_ID;
+
+  const {
+    availableFieldDefinitionsState,
+    availableFilterDefinitionsState,
+    availableSortDefinitionsState,
+    canPersistFiltersSelector: canPersistFiltersSelector,
+    canPersistSortsSelector: canPersistSortsSelector,
+    currentViewFieldsState,
+    currentViewFiltersState,
+    currentViewIdState,
+    currentViewSelector,
+    currentViewSortsState,
+    entityCountInCurrentViewState,
+    isViewBarExpandedState,
+    isPersistingViewState,
+    onViewFieldsChangeState,
+    onViewFiltersChangeState,
+    onViewSortsChangeState,
+    savedViewFieldsByKeySelector: savedViewFieldsByKeySelector,
+    savedViewFieldsState,
+    savedViewFiltersByKeySelector: savedViewFiltersByKeySelector,
+    savedViewFiltersState,
+    savedViewSortsByKeySelector: savedViewSortsByKeySelector,
+    savedViewSortsState,
+    viewEditModeState,
+    viewObjectMetadataIdState,
+    viewTypeState,
+    viewsState,
+  } = getViewScopedStates({
+    viewScopeId,
+    viewId: usedViewId,
+  });
+
+  return {
+    availableFieldDefinitionsState,
+    availableFilterDefinitionsState,
+    availableSortDefinitionsState,
+    canPersistFiltersReadOnlyState: canPersistFiltersSelector,
+    canPersistSortsReadOnlyState: canPersistSortsSelector,
+    currentViewFieldsState,
+    currentViewFiltersState,
+    currentViewIdState,
+    currentViewSelector,
+    currentViewSortsState,
+    entityCountInCurrentViewState,
+    isViewBarExpandedState,
+    isPersistingViewState,
+    onViewFieldsChangeState,
+    onViewFiltersChangeState,
+    onViewSortsChangeState,
+    savedViewFieldsByKeyReadOnlyState: savedViewFieldsByKeySelector,
+    savedViewFieldsState,
+    savedViewFiltersByKeyReadOnlyState: savedViewFiltersByKeySelector,
+    savedViewFiltersState,
+    savedViewSortsByKeyReadOnlyState: savedViewSortsByKeySelector,
+    savedViewSortsState,
+    viewEditModeState,
+    viewObjectMetadataIdState,
+    viewTypeState,
+    viewsState,
+  };
+};

packages/twenty-front/src/modules/views/utils/internal/getViewScopedStates.ts

@@ -0,0 +1,208 @@
+import { getScopedFamilyState } from '@/ui/utilities/recoil-scope/utils/getScopedFamilyState';
+import { getScopedSelector } from '@/ui/utilities/recoil-scope/utils/getScopedSelector';
+import { getScopedState } from '@/ui/utilities/recoil-scope/utils/getScopedState';
+import { currentViewIdScopedState } from '@/views/states/currentViewIdScopedState';
+import { isPersistingViewScopedState } from '@/views/states/isPersistingViewScopedState';
+import { currentViewScopedSelector } from '@/views/states/selectors/currentViewScopedSelector';
+
+import { availableFieldDefinitionsScopedState } from '../../states/availableFieldDefinitionsScopedState';
+import { availableFilterDefinitionsScopedState } from '../../states/availableFilterDefinitionsScopedState';
+import { availableSortDefinitionsScopedState } from '../../states/availableSortDefinitionsScopedState';
+import { currentViewFieldsScopedFamilyState } from '../../states/currentViewFieldsScopedFamilyState';
+import { currentViewFiltersScopedFamilyState } from '../../states/currentViewFiltersScopedFamilyState';
+import { currentViewSortsScopedFamilyState } from '../../states/currentViewSortsScopedFamilyState';
+import { entityCountInCurrentViewScopedState } from '../../states/entityCountInCurrentViewScopedState';
+import { isViewBarExpandedScopedState } from '../../states/isViewBarExpandedScopedState';
+import { onViewFieldsChangeScopedState } from '../../states/onViewFieldsChangeScopedState';
+import { onViewFiltersChangeScopedState } from '../../states/onViewFiltersChangeScopedState';
+import { onViewSortsChangeScopedState } from '../../states/onViewSortsChangeScopedState';
+import { savedViewFieldsScopedFamilyState } from '../../states/savedViewFieldsScopedFamilyState';
+import { savedViewFiltersScopedFamilyState } from '../../states/savedViewFiltersScopedFamilyState';
+import { savedViewSortsScopedFamilyState } from '../../states/savedViewSortsScopedFamilyState';
+import { canPersistViewFiltersScopedFamilySelector } from '../../states/selectors/canPersistViewFiltersScopedFamilySelector';
+import { canPersistViewSortsScopedFamilySelector } from '../../states/selectors/canPersistViewSortsScopedFamilySelector';
+import { savedViewFieldByKeyScopedFamilySelector } from '../../states/selectors/savedViewFieldByKeyScopedFamilySelector';
+import { savedViewFiltersByKeyScopedFamilySelector } from '../../states/selectors/savedViewFiltersByKeyScopedFamilySelector';
+import { savedViewSortsByKeyScopedFamilySelector } from '../../states/selectors/savedViewSortsByKeyScopedFamilySelector';
+import { viewEditModeScopedState } from '../../states/viewEditModeScopedState';
+import { viewObjectMetadataIdScopeState } from '../../states/viewObjectMetadataIdScopeState';
+import { viewsScopedState } from '../../states/viewsScopedState';
+import { viewTypeScopedState } from '../../states/viewTypeScopedState';
+
+export const getViewScopedStates = ({
+  viewScopeId,
+  viewId,
+}: {
+  viewScopeId: string;
+  viewId: string;
+}) => {
+  const viewEditModeState = getScopedState(
+    viewEditModeScopedState,
+    viewScopeId,
+  );
+
+  const viewsState = getScopedState(viewsScopedState, viewScopeId);
+
+  const viewObjectMetadataIdState = getScopedState(
+    viewObjectMetadataIdScopeState,
+    viewScopeId,
+  );
+
+  const viewTypeState = getScopedState(viewTypeScopedState, viewScopeId);
+
+  const entityCountInCurrentViewState = getScopedState(
+    entityCountInCurrentViewScopedState,
+    viewScopeId,
+  );
+
+  const isViewBarExpandedState = getScopedState(
+    isViewBarExpandedScopedState,
+    viewScopeId,
+  );
+
+  const isPersistingViewState = getScopedState(
+    isPersistingViewScopedState,
+    viewScopeId,
+  );
+
+  // ViewSorts
+  const currentViewSortsState = getScopedFamilyState(
+    currentViewSortsScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewSortsState = getScopedFamilyState(
+    savedViewSortsScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewSortsByKeySelector = savedViewSortsByKeyScopedFamilySelector({
+    scopeId: viewScopeId,
+    viewId: viewId,
+  });
+
+  const availableSortDefinitionsState = getScopedState(
+    availableSortDefinitionsScopedState,
+    viewScopeId,
+  );
+
+  const canPersistSortsSelector = canPersistViewSortsScopedFamilySelector({
+    viewScopeId: viewScopeId,
+    viewId: viewId,
+  });
+
+  // ViewFilters
+  const currentViewFiltersState = getScopedFamilyState(
+    currentViewFiltersScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewFiltersState = getScopedFamilyState(
+    savedViewFiltersScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewFiltersByKeySelector =
+    savedViewFiltersByKeyScopedFamilySelector({
+      scopeId: viewScopeId,
+      viewId: viewId,
+    });
+
+  const availableFilterDefinitionsState = getScopedState(
+    availableFilterDefinitionsScopedState,
+    viewScopeId,
+  );
+
+  const canPersistFiltersSelector = canPersistViewFiltersScopedFamilySelector({
+    viewScopeId: viewScopeId,
+    viewId: viewId,
+  });
+
+  // ViewFields
+  const availableFieldDefinitionsState = getScopedState(
+    availableFieldDefinitionsScopedState,
+    viewScopeId,
+  );
+
+  const currentViewFieldsState = getScopedFamilyState(
+    currentViewFieldsScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewFieldsState = getScopedFamilyState(
+    savedViewFieldsScopedFamilyState,
+    viewScopeId,
+    viewId,
+  );
+
+  const savedViewFieldsByKeySelector = savedViewFieldByKeyScopedFamilySelector({
+    viewScopeId,
+    viewId,
+  });
+
+  // ViewChangeHandlers
+  const onViewSortsChangeState = getScopedState(
+    onViewSortsChangeScopedState,
+    viewScopeId,
+  );
+
+  const onViewFiltersChangeState = getScopedState(
+    onViewFiltersChangeScopedState,
+    viewScopeId,
+  );
+
+  const onViewFieldsChangeState = getScopedState(
+    onViewFieldsChangeScopedState,
+    viewScopeId,
+  );
+
+  const currentViewIdState = getScopedState(
+    currentViewIdScopedState,
+    viewScopeId,
+  );
+
+  const currentViewSelector = getScopedSelector(
+    currentViewScopedSelector,
+    viewScopeId,
+  );
+
+  return {
+    currentViewIdState,
+    currentViewSelector,
+
+    isViewBarExpandedState,
+    isPersistingViewState,
+
+    viewsState,
+    viewEditModeState,
+    viewObjectMetadataIdState,
+    viewTypeState,
+    entityCountInCurrentViewState,
+
+    availableSortDefinitionsState,
+    currentViewSortsState,
+    savedViewSortsState,
+    savedViewSortsByKeySelector,
+    canPersistSortsSelector,
+
+    availableFilterDefinitionsState,
+    currentViewFiltersState,
+    savedViewFiltersState,
+    savedViewFiltersByKeySelector,
+    canPersistFiltersSelector,
+
+    availableFieldDefinitionsState,
+    currentViewFieldsState,
+    savedViewFieldsByKeySelector,
+    savedViewFieldsState,
+
+    onViewSortsChangeState,
+    onViewFiltersChangeState,
+    onViewFieldsChangeState,
+  };
+};

packages/twenty-front/src/modules/views/utils/mapColumnDefinitionToViewField.ts

@@ -0,0 +1,17 @@
+import { FieldMetadata } from '@/object-record/field/types/FieldMetadata';
+import { ColumnDefinition } from '@/object-record/record-table/types/ColumnDefinition';
+
+import { ViewField } from '../types/ViewField';
+
+export const mapColumnDefinitionsToViewFields = (
+  columnDefinitions: ColumnDefinition<FieldMetadata>[],
+): ViewField[] => {
+  return columnDefinitions.map((columnDefinition) => ({
+    id: columnDefinition.viewFieldId || '',
+    fieldMetadataId: columnDefinition.fieldMetadataId,
+    position: columnDefinition.position,
+    size: columnDefinition.size,
+    isVisible: columnDefinition.isVisible ?? true,
+    definition: columnDefinition,
+  }));
+};

packages/twenty-front/src/modules/views/utils/mapViewFieldsToBoardFieldDefinitions.ts

@@ -0,0 +1,32 @@
+import { FieldMetadata } from '@/object-record/field/types/FieldMetadata';
+import { BoardFieldDefinition } from '@/object-record/record-board/types/BoardFieldDefinition';
+import { assertNotNull } from '~/utils/assert';
+
+import { ViewField } from '../types/ViewField';
+
+export const mapViewFieldsToBoardFieldDefinitions = (
+  viewFields: ViewField[],
+  fieldsMetadata: BoardFieldDefinition<FieldMetadata>[],
+): BoardFieldDefinition<FieldMetadata>[] => {
+  return viewFields
+    .map((viewField) => {
+      const correspondingFieldMetadata = fieldsMetadata.find(
+        ({ fieldMetadataId }) => viewField.fieldMetadataId === fieldMetadataId,
+      );
+
+      return correspondingFieldMetadata
+        ? {
+            fieldMetadataId: viewField.fieldMetadataId,
+            label: correspondingFieldMetadata.label,
+            metadata: correspondingFieldMetadata.metadata,
+            infoTooltipContent: correspondingFieldMetadata.infoTooltipContent,
+            iconName: correspondingFieldMetadata.iconName,
+            type: correspondingFieldMetadata.type,
+            position: viewField.position,
+            isVisible: viewField.isVisible,
+            viewFieldId: viewField.id,
+          }
+        : null;
+    })
+    .filter(assertNotNull);
+};

packages/twenty-front/src/modules/views/utils/mapViewFieldsToColumnDefinitions.ts

@@ -0,0 +1,33 @@
+import { FieldMetadata } from '@/object-record/field/types/FieldMetadata';
+import { ColumnDefinition } from '@/object-record/record-table/types/ColumnDefinition';
+import { assertNotNull } from '~/utils/assert';
+
+import { ViewField } from '../types/ViewField';
+
+export const mapViewFieldsToColumnDefinitions = (
+  viewFields: ViewField[],
+  fieldsMetadata: ColumnDefinition<FieldMetadata>[],
+): ColumnDefinition<FieldMetadata>[] => {
+  return viewFields
+    .map((viewField) => {
+      const correspondingFieldMetadata = fieldsMetadata.find(
+        ({ fieldMetadataId }) => viewField.fieldMetadataId === fieldMetadataId,
+      );
+
+      return correspondingFieldMetadata
+        ? {
+            fieldMetadataId: viewField.fieldMetadataId,
+            label: correspondingFieldMetadata.label,
+            metadata: correspondingFieldMetadata.metadata,
+            infoTooltipContent: correspondingFieldMetadata.infoTooltipContent,
+            iconName: correspondingFieldMetadata.iconName,
+            type: correspondingFieldMetadata.type,
+            position: viewField.position,
+            size: viewField.size ?? correspondingFieldMetadata.size,
+            isVisible: viewField.isVisible,
+            viewFieldId: viewField.id,
+          }
+        : null;
+    })
+    .filter(assertNotNull);
+};

packages/twenty-front/src/modules/views/utils/mapViewFiltersToFilters.ts

@@ -0,0 +1,17 @@
+import { Filter } from '@/object-record/object-filter-dropdown/types/Filter';
+
+import { ViewFilter } from '../types/ViewFilter';
+
+export const mapViewFiltersToFilters = (
+  viewFilters: ViewFilter[],
+): Filter[] => {
+  return viewFilters.map((viewFilter) => {
+    return {
+      fieldMetadataId: viewFilter.fieldMetadataId,
+      value: viewFilter.value,
+      displayValue: viewFilter.displayValue,
+      operand: viewFilter.operand,
+      definition: viewFilter.definition,
+    };
+  });
+};

packages/twenty-front/src/modules/views/utils/mapViewSortsToSorts.ts

@@ -0,0 +1,13 @@
+import { Sort } from '@/object-record/object-sort-dropdown/types/Sort';
+
+import { ViewSort } from '../types/ViewSort';
+
+export const mapViewSortsToSorts = (viewSorts: ViewSort[]): Sort[] => {
+  return viewSorts.map((viewSort) => {
+    return {
+      fieldMetadataId: viewSort.fieldMetadataId,
+      direction: viewSort.direction,
+      definition: viewSort.definition,
+    };
+  });
+};