The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Export views and their children from an installed application (#25600)
Weiko79dc7d0b0ae2
diff --git a/packages/twenty-docs/developers/extend/apps/layout/views.mdx b/packages/twenty-docs/developers/extend/apps/layout/views.mdxindex 042120348dc..55fb6766a89 100644--- a/packages/twenty-docs/developers/extend/apps/layout/views.mdx+++ b/packages/twenty-docs/developers/extend/apps/layout/views.mdx@@ -71,6 +71,16 @@ filters: [],```+Three optional properties refine a filter:++| Property | Description |+|----------|-------------|+| `subFieldName` | Targets one part of a composite field, such as `amountMicros` on a `CURRENCY` field or `primaryLinkUrl` on a `LINKS` field. |+| `relationTargetFieldMetadataUniversalIdentifier` | On a filter over a `RELATION` field, the field of the related object the value is compared against, as the advanced filter sets it when you pick a field of the related record. Leave it out to filter on the related record itself. |+| `viewFilterGroupUniversalIdentifier` + `positionInViewFilterGroup` | Place the filter in one of the view's `filterGroups` (each with a `logicalOperator` of `AND`, `OR` or `NOT` and an optional `parentViewFilterGroupUniversalIdentifier`) and order it within that group. |++`yarn twenty pull` writes all three back exactly as the workspace stored them.+### Supported operands per field type| Field type | Supported operands |diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-group-to-view-field-group-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-group-to-view-field-group-manifest.util.spec.tsnew file mode 100644index 00000000000..77c4b0c7a2b--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-group-to-view-field-group-manifest.util.spec.ts@@ -0,0 +1,85 @@+import { type ViewFieldGroupManifest } from 'twenty-shared/application';++import { fromFlatViewFieldGroupToViewFieldGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util';+import { fromViewFieldGroupManifestToUniversalFlatViewFieldGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-group-manifest-to-universal-flat-view-field-group.util';+import { type UniversalFlatViewFieldGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-field-group.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_FIELD_GROUP_UID = '33333333-3333-4333-8333-333333333333';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_FIELD_GROUP_MANIFEST: Required<ViewFieldGroupManifest> = {+ universalIdentifier: VIEW_FIELD_GROUP_UID,+ name: 'Details',+ position: 1,+ isVisible: false,+};++const forward = (viewFieldGroupManifest: ViewFieldGroupManifest) =>+ fromViewFieldGroupManifestToUniversalFlatViewFieldGroup({+ viewFieldGroupManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewFieldGroup = (+ flatViewFieldGroup: UniversalFlatViewFieldGroup,+) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewFieldGroup,+ toUniversalFlatEntity: forward(+ fromFlatViewFieldGroupToViewFieldGroupManifest({ flatViewFieldGroup }),+ ),+ metadataName: 'viewFieldGroup',+ });++describe('fromFlatViewFieldGroupToViewFieldGroupManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewFieldGroupToViewFieldGroupManifest({+ flatViewFieldGroup: forward(VIEW_FIELD_GROUP_MANIFEST),+ }),+ ).toEqual(VIEW_FIELD_GROUP_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewFieldGroup: UniversalFlatViewFieldGroup = {+ universalIdentifier: VIEW_FIELD_GROUP_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ name: '',+ position: 0,+ isVisible: false,+ isActive: true,+ isSystemSideEffect: false,+ overrides: null,+ viewFieldUniversalIdentifiers: [],+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewFieldGroup(flatViewFieldGroup)).toBeUndefined();+ });++ it('should write the name and the visibility the forward converter defaulted', () => {+ const {+ name: _name,+ isVisible: _isVisible,+ ...manifestWithoutNameAndVisibility+ } = VIEW_FIELD_GROUP_MANIFEST;++ expect(+ fromFlatViewFieldGroupToViewFieldGroupManifest({+ flatViewFieldGroup: forward(manifestWithoutNameAndVisibility),+ }),+ ).toStrictEqual({+ ...manifestWithoutNameAndVisibility,+ name: '',+ isVisible: true,+ });+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-to-view-field-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-to-view-field-manifest.util.spec.tsnew file mode 100644index 00000000000..a4d9eb79152--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-field-to-view-field-manifest.util.spec.ts@@ -0,0 +1,121 @@+import { type ViewFieldManifest } from 'twenty-shared/application';+import { AggregateOperations } from 'twenty-shared/types';++import { fromFlatViewFieldToStandaloneViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util';+import { fromFlatViewFieldToViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util';+import { fromViewFieldManifestToUniversalFlatViewField } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-manifest-to-universal-flat-view-field.util';+import { type UniversalFlatViewField } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-field.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_FIELD_UID = '33333333-3333-4333-8333-333333333333';+const FIELD_UID = '44444444-4444-4444-8444-444444444444';+const VIEW_FIELD_GROUP_UID = '55555555-5555-4555-8555-555555555555';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_FIELD_MANIFEST: Required<ViewFieldManifest> = {+ universalIdentifier: VIEW_FIELD_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ isVisible: false,+ size: 240,+ position: 3,+ aggregateOperation: AggregateOperations.SUM,+ viewFieldGroupUniversalIdentifier: VIEW_FIELD_GROUP_UID,+};++const MINIMAL_VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: VIEW_FIELD_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ position: 3,+};++const forward = (viewFieldManifest: ViewFieldManifest) =>+ fromViewFieldManifestToUniversalFlatViewField({+ viewFieldManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewField = (flatViewField: UniversalFlatViewField) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewField,+ toUniversalFlatEntity: forward(+ fromFlatViewFieldToViewFieldManifest({ flatViewField }),+ ),+ metadataName: 'viewField',+ });++describe('fromFlatViewFieldToViewFieldManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewFieldToViewFieldManifest({+ flatViewField: forward(VIEW_FIELD_MANIFEST),+ }),+ ).toEqual(VIEW_FIELD_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewField: UniversalFlatViewField = {+ universalIdentifier: VIEW_FIELD_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ viewFieldGroupUniversalIdentifier: VIEW_FIELD_GROUP_UID,+ isVisible: false,+ size: 240,+ position: 3,+ aggregateOperation: AggregateOperations.SUM,+ isActive: true,+ isSystemSideEffect: false,+ universalOverrides: null,+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewField(flatViewField)).toBeUndefined();+ });++ it('should write the visibility and size the forward converter defaulted and omit the null slots', () => {+ const viewFieldManifest = fromFlatViewFieldToViewFieldManifest({+ flatViewField: forward(MINIMAL_VIEW_FIELD_MANIFEST),+ });++ expect(viewFieldManifest).toStrictEqual({+ ...MINIMAL_VIEW_FIELD_MANIFEST,+ isVisible: true,+ size: 0,+ });+ expect(viewFieldManifest).not.toHaveProperty('aggregateOperation');+ expect(viewFieldManifest).not.toHaveProperty(+ 'viewFieldGroupUniversalIdentifier',+ );+ });+});++describe('fromFlatViewFieldToStandaloneViewFieldManifest', () => {+ it('should add the view universal identifier of the flat view field and keep every other property of the nested manifest', () => {+ expect(+ fromFlatViewFieldToStandaloneViewFieldManifest({+ flatViewField: forward(VIEW_FIELD_MANIFEST),+ }),+ ).toEqual({+ ...VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: VIEW_UID,+ });+ });++ it('should list the universal identifier first and the view universal identifier second', () => {+ const standaloneViewFieldManifest =+ fromFlatViewFieldToStandaloneViewFieldManifest({+ flatViewField: forward(VIEW_FIELD_MANIFEST),+ });++ expect(Object.keys(standaloneViewFieldManifest).slice(0, 2)).toEqual([+ 'universalIdentifier',+ 'viewUniversalIdentifier',+ ]);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-group-to-view-filter-group-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-group-to-view-filter-group-manifest.util.spec.tsnew file mode 100644index 00000000000..6a6d196d192--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-group-to-view-filter-group-manifest.util.spec.ts@@ -0,0 +1,95 @@+import { type ViewFilterGroupManifest } from 'twenty-shared/application';+import { ViewFilterGroupLogicalOperator } from 'twenty-shared/types';++import { fromFlatViewFilterGroupToViewFilterGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util';+import { fromViewFilterGroupManifestToUniversalFlatViewFilterGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-group-manifest-to-universal-flat-view-filter-group.util';+import { type UniversalFlatViewFilterGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-filter-group.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_FILTER_GROUP_UID = '33333333-3333-4333-8333-333333333333';+const PARENT_VIEW_FILTER_GROUP_UID = '44444444-4444-4444-8444-444444444444';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_FILTER_GROUP_MANIFEST: Required<ViewFilterGroupManifest> = {+ universalIdentifier: VIEW_FILTER_GROUP_UID,+ logicalOperator: ViewFilterGroupLogicalOperator.NOT,+ parentViewFilterGroupUniversalIdentifier: PARENT_VIEW_FILTER_GROUP_UID,+ positionInViewFilterGroup: 1,+};++const forward = (viewFilterGroupManifest: ViewFilterGroupManifest) =>+ fromViewFilterGroupManifestToUniversalFlatViewFilterGroup({+ viewFilterGroupManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewFilterGroup = (+ flatViewFilterGroup: UniversalFlatViewFilterGroup,+) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewFilterGroup,+ toUniversalFlatEntity: forward(+ fromFlatViewFilterGroupToViewFilterGroupManifest({ flatViewFilterGroup }),+ ),+ metadataName: 'viewFilterGroup',+ });++describe('fromFlatViewFilterGroupToViewFilterGroupManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewFilterGroupToViewFilterGroupManifest({+ flatViewFilterGroup: forward(VIEW_FILTER_GROUP_MANIFEST),+ }),+ ).toEqual(VIEW_FILTER_GROUP_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewFilterGroup: UniversalFlatViewFilterGroup = {+ universalIdentifier: VIEW_FILTER_GROUP_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ parentViewFilterGroupUniversalIdentifier: null,+ logicalOperator: ViewFilterGroupLogicalOperator.OR,+ positionInViewFilterGroup: null,+ childViewFilterGroupUniversalIdentifiers: [],+ viewFilterUniversalIdentifiers: [],+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewFilterGroup(flatViewFilterGroup)).toBeUndefined();+ });++ it('should omit the parent group and the position of a root group', () => {+ const {+ parentViewFilterGroupUniversalIdentifier:+ _parentViewFilterGroupUniversalIdentifier,+ positionInViewFilterGroup: _positionInViewFilterGroup,+ ...rootGroupManifest+ } = VIEW_FILTER_GROUP_MANIFEST;++ expect(+ fromFlatViewFilterGroupToViewFilterGroupManifest({+ flatViewFilterGroup: forward(rootGroupManifest),+ }),+ ).toStrictEqual(rootGroupManifest);+ });++ it('should keep a zero position inside the parent group', () => {+ const firstChildGroupManifest: Required<ViewFilterGroupManifest> = {+ ...VIEW_FILTER_GROUP_MANIFEST,+ positionInViewFilterGroup: 0,+ };++ expect(+ fromFlatViewFilterGroupToViewFilterGroupManifest({+ flatViewFilterGroup: forward(firstChildGroupManifest),+ }),+ ).toEqual(firstChildGroupManifest);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-to-view-filter-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-to-view-filter-manifest.util.spec.tsnew file mode 100644index 00000000000..e92810e5656--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-filter-to-view-filter-manifest.util.spec.ts@@ -0,0 +1,129 @@+import { type ViewFilterManifest } from 'twenty-shared/application';+import { ViewFilterOperand } from 'twenty-shared/types';++import { fromFlatViewFilterToViewFilterManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util';+import { fromViewFilterManifestToUniversalFlatViewFilter } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util';+import { type UniversalFlatViewFilter } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-filter.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_FILTER_UID = '33333333-3333-4333-8333-333333333333';+const FIELD_UID = '44444444-4444-4444-8444-444444444444';+const RELATION_TARGET_FIELD_UID = '55555555-5555-4555-8555-555555555555';+const VIEW_FILTER_GROUP_UID = '66666666-6666-4666-8666-666666666666';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_FILTER_MANIFEST: Required<ViewFilterManifest> = {+ universalIdentifier: VIEW_FILTER_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ operand: ViewFilterOperand.IS,+ value: ['a', 'b'],+ subFieldName: 'primaryEmail',+ relationTargetFieldMetadataUniversalIdentifier: RELATION_TARGET_FIELD_UID,+ viewFilterGroupUniversalIdentifier: VIEW_FILTER_GROUP_UID,+ positionInViewFilterGroup: 2,+};++const MINIMAL_VIEW_FILTER_MANIFEST: ViewFilterManifest = {+ universalIdentifier: VIEW_FILTER_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ operand: ViewFilterOperand.CONTAINS,+ value: 'x',+};++const forward = (viewFilterManifest: ViewFilterManifest) =>+ fromViewFilterManifestToUniversalFlatViewFilter({+ viewFilterManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewFilter = (flatViewFilter: UniversalFlatViewFilter) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewFilter,+ toUniversalFlatEntity: forward(+ fromFlatViewFilterToViewFilterManifest({ flatViewFilter }),+ ),+ metadataName: 'viewFilter',+ });++describe('fromFlatViewFilterToViewFilterManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: forward(VIEW_FILTER_MANIFEST),+ }),+ ).toEqual(VIEW_FILTER_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewFilter: UniversalFlatViewFilter = {+ universalIdentifier: VIEW_FILTER_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ operand: ViewFilterOperand.IS_NOT,+ value: {+ selectedRecordIds: ['77777777-7777-4777-8777-777777777777'],+ isCurrentWorkspaceMemberSelected: true,+ },+ subFieldName: null,+ relationTargetFieldMetadataUniversalIdentifier: RELATION_TARGET_FIELD_UID,+ viewFilterGroupUniversalIdentifier: null,+ positionInViewFilterGroup: 1.5,+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewFilter(flatViewFilter)).toBeUndefined();+ });++ it('should omit the optional properties the forward converter nulled', () => {+ expect(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: forward(MINIMAL_VIEW_FILTER_MANIFEST),+ }),+ ).toStrictEqual(MINIMAL_VIEW_FILTER_MANIFEST);+ });++ it('should keep an object value unchanged', () => {+ const objectValue = {+ selectedRecordIds: ['77777777-7777-4777-8777-777777777777'],+ nested: { isCurrentWorkspaceMemberSelected: false, depth: 2 },+ };++ expect(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: forward({+ ...MINIMAL_VIEW_FILTER_MANIFEST,+ value: objectValue,+ }),+ }).value,+ ).toStrictEqual(objectValue);+ });++ it('should keep a boolean value unchanged', () => {+ expect(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: forward({+ ...MINIMAL_VIEW_FILTER_MANIFEST,+ value: false,+ }),+ }).value,+ ).toBe(false);+ });++ it('should write a zero position in view filter group', () => {+ expect(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: forward({+ ...MINIMAL_VIEW_FILTER_MANIFEST,+ positionInViewFilterGroup: 0,+ }),+ }),+ ).toHaveProperty('positionInViewFilterGroup', 0);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-group-to-view-group-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-group-to-view-group-manifest.util.spec.tsnew file mode 100644index 00000000000..7fa3e54f17a--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-group-to-view-group-manifest.util.spec.ts@@ -0,0 +1,72 @@+import { type ViewGroupManifest } from 'twenty-shared/application';++import { fromFlatViewGroupToViewGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util';+import { fromViewGroupManifestToUniversalFlatViewGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-group-manifest-to-universal-flat-view-group.util';+import { type UniversalFlatViewGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-group.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_GROUP_UID = '33333333-3333-4333-8333-333333333333';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_GROUP_MANIFEST: Required<ViewGroupManifest> = {+ universalIdentifier: VIEW_GROUP_UID,+ fieldValue: 'won',+ isVisible: false,+ position: 4,+};++const forward = (viewGroupManifest: ViewGroupManifest) =>+ fromViewGroupManifestToUniversalFlatViewGroup({+ viewGroupManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewGroup = (flatViewGroup: UniversalFlatViewGroup) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewGroup,+ toUniversalFlatEntity: forward(+ fromFlatViewGroupToViewGroupManifest({ flatViewGroup }),+ ),+ metadataName: 'viewGroup',+ });++describe('fromFlatViewGroupToViewGroupManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewGroupToViewGroupManifest({+ flatViewGroup: forward(VIEW_GROUP_MANIFEST),+ }),+ ).toEqual(VIEW_GROUP_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewGroup: UniversalFlatViewGroup = {+ universalIdentifier: VIEW_GROUP_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ fieldValue: '',+ isVisible: false,+ position: 0,+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewGroup(flatViewGroup)).toBeUndefined();+ });++ it('should write the visibility the forward converter defaulted', () => {+ const { isVisible: _isVisible, ...manifestWithoutVisibility } =+ VIEW_GROUP_MANIFEST;++ expect(+ fromFlatViewGroupToViewGroupManifest({+ flatViewGroup: forward(manifestWithoutVisibility),+ }),+ ).toStrictEqual({ ...manifestWithoutVisibility, isVisible: true });+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-sort-to-view-sort-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-sort-to-view-sort-manifest.util.spec.tsnew file mode 100644index 00000000000..990b1da24ab--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-sort-to-view-sort-manifest.util.spec.ts@@ -0,0 +1,74 @@+import { type ViewSortManifest } from 'twenty-shared/application';+import { ViewSortDirection } from 'twenty-shared/types';++import { fromFlatViewSortToViewSortManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util';+import { fromViewSortManifestToUniversalFlatViewSort } from 'src/engine/core-modules/application/application-manifest/converters/from-view-sort-manifest-to-universal-flat-view-sort.util';+import { type UniversalFlatViewSort } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-sort.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const VIEW_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_SORT_UID = '33333333-3333-4333-8333-333333333333';+const FIELD_UID = '44444444-4444-4444-8444-444444444444';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_SORT_MANIFEST: Required<ViewSortManifest> = {+ universalIdentifier: VIEW_SORT_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ direction: ViewSortDirection.DESC,+ subFieldName: 'amountMicros',+};++const forward = (viewSortManifest: ViewSortManifest) =>+ fromViewSortManifestToUniversalFlatViewSort({+ viewSortManifest,+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatViewSort = (flatViewSort: UniversalFlatViewSort) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatViewSort,+ toUniversalFlatEntity: forward(+ fromFlatViewSortToViewSortManifest({ flatViewSort }),+ ),+ metadataName: 'viewSort',+ });++describe('fromFlatViewSortToViewSortManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewSortToViewSortManifest({+ flatViewSort: forward(VIEW_SORT_MANIFEST),+ }),+ ).toEqual(VIEW_SORT_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatViewSort: UniversalFlatViewSort = {+ universalIdentifier: VIEW_SORT_UID,+ applicationUniversalIdentifier: APP_UID,+ viewUniversalIdentifier: VIEW_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ direction: ViewSortDirection.ASC,+ subFieldName: null,+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatViewSort(flatViewSort)).toBeUndefined();+ });++ it('should omit the sub field name of a sort stored without one', () => {+ const { subFieldName: _subFieldName, ...manifestWithoutSubFieldName } =+ VIEW_SORT_MANIFEST;++ expect(+ fromFlatViewSortToViewSortManifest({+ flatViewSort: forward(manifestWithoutSubFieldName),+ }),+ ).toStrictEqual(manifestWithoutSubFieldName);+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-to-view-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-to-view-manifest.util.spec.tsnew file mode 100644index 00000000000..3c8fea28741--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-view-to-view-manifest.util.spec.ts@@ -0,0 +1,258 @@+import {+ type ViewFieldGroupManifest,+ type ViewFieldManifest,+ type ViewFilterGroupManifest,+ type ViewFilterManifest,+ type ViewGroupManifest,+ type ViewManifest,+ type ViewSortManifest,+} from 'twenty-shared/application';+import {+ AggregateOperations,+ ViewCalendarLayout,+ ViewFilterGroupLogicalOperator,+ ViewFilterOperand,+ ViewKey,+ ViewOpenRecordIn,+ ViewSortDirection,+ ViewType,+ ViewVisibility,+} from 'twenty-shared/types';++import { fromFlatViewToViewManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util';+import { fromViewManifestToUniversalFlatView } from 'src/engine/core-modules/application/application-manifest/converters/from-view-manifest-to-universal-flat-view.util';+import { type UniversalFlatView } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view.type';+import { compareTwoFlatEntity } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/utils/compare-two-universal-flat-entity.util';++const APP_UID = '11111111-1111-4111-8111-111111111111';+const OBJECT_UID = '22222222-2222-4222-8222-222222222222';+const VIEW_UID = '33333333-3333-4333-8333-333333333333';+const STAGE_FIELD_UID = '44444444-4444-4444-8444-444444444444';+const AMOUNT_FIELD_UID = '55555555-5555-4555-8555-555555555555';+const START_DATE_FIELD_UID = '66666666-6666-4666-8666-666666666666';+const END_DATE_FIELD_UID = '77777777-7777-4777-8777-777777777777';+const VIEW_FIELD_UID = '88888888-8888-4888-8888-888888888888';+const VIEW_FILTER_UID = '99999999-9999-4999-8999-999999999999';+const VIEW_FILTER_GROUP_UID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';+const VIEW_GROUP_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';+const VIEW_FIELD_GROUP_UID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';+const VIEW_SORT_UID = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd';+const NOW = '2026-09-03T10:00:00.000Z';++const VIEW_MANIFEST: Required<+ Omit<+ ViewManifest,+ | 'key'+ | 'fields'+ | 'filters'+ | 'filterGroups'+ | 'groups'+ | 'fieldGroups'+ | 'sorts'+ >+> = {+ universalIdentifier: VIEW_UID,+ name: 'Pipeline',+ objectUniversalIdentifier: OBJECT_UID,+ type: ViewType.KANBAN,+ icon: 'IconLayoutKanban',+ position: 3,+ isCompact: true,+ visibility: ViewVisibility.UNLISTED,+ openRecordIn: ViewOpenRecordIn.RECORD_PAGE,+ mainGroupByFieldMetadataUniversalIdentifier: STAGE_FIELD_UID,+ shouldHideEmptyGroups: true,+ anyFieldFilterValue: 'acme',+ kanbanColumnWidth: 240,+ kanbanAggregateOperation: AggregateOperations.SUM,+ kanbanAggregateOperationFieldMetadataUniversalIdentifier: AMOUNT_FIELD_UID,+ calendarLayout: ViewCalendarLayout.WEEK,+ calendarFieldMetadataUniversalIdentifier: START_DATE_FIELD_UID,+ calendarEndFieldMetadataUniversalIdentifier: END_DATE_FIELD_UID,+};++const MINIMAL_VIEW_MANIFEST: ViewManifest = {+ universalIdentifier: VIEW_UID,+ name: 'All pets',+ objectUniversalIdentifier: OBJECT_UID,+};++const VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: VIEW_FIELD_UID,+ fieldMetadataUniversalIdentifier: AMOUNT_FIELD_UID,+ position: 0,+ isVisible: true,+ size: 150,+};++const VIEW_FILTER_MANIFEST: ViewFilterManifest = {+ universalIdentifier: VIEW_FILTER_UID,+ fieldMetadataUniversalIdentifier: STAGE_FIELD_UID,+ operand: ViewFilterOperand.IS,+ value: ['won'],+};++const VIEW_FILTER_GROUP_MANIFEST: ViewFilterGroupManifest = {+ universalIdentifier: VIEW_FILTER_GROUP_UID,+ logicalOperator: ViewFilterGroupLogicalOperator.AND,+};++const VIEW_GROUP_MANIFEST: ViewGroupManifest = {+ universalIdentifier: VIEW_GROUP_UID,+ fieldValue: 'won',+ position: 0,+};++const VIEW_FIELD_GROUP_MANIFEST: ViewFieldGroupManifest = {+ universalIdentifier: VIEW_FIELD_GROUP_UID,+ name: 'Details',+ position: 0,+};++const VIEW_SORT_MANIFEST: ViewSortManifest = {+ universalIdentifier: VIEW_SORT_UID,+ fieldMetadataUniversalIdentifier: AMOUNT_FIELD_UID,+ direction: ViewSortDirection.DESC,+};++const NULLABLE_VIEW_MANIFEST_PROPERTIES: (keyof ViewManifest)[] = [+ 'mainGroupByFieldMetadataUniversalIdentifier',+ 'anyFieldFilterValue',+ 'kanbanColumnWidth',+ 'kanbanAggregateOperation',+ 'kanbanAggregateOperationFieldMetadataUniversalIdentifier',+ 'calendarLayout',+ 'calendarFieldMetadataUniversalIdentifier',+ 'calendarEndFieldMetadataUniversalIdentifier',+];++const VIEW_CHILD_COLLECTION_PROPERTIES_OTHER_THAN_FIELDS: (keyof ViewManifest)[] =+ ['filters', 'filterGroups', 'groups', 'fieldGroups', 'sorts'];++const forward = (viewManifest: ViewManifest) =>+ fromViewManifestToUniversalFlatView({+ viewManifest,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ });++const roundTripFlatView = (flatView: UniversalFlatView) =>+ compareTwoFlatEntity({+ fromUniversalFlatEntity: flatView,+ toUniversalFlatEntity: forward(fromFlatViewToViewManifest({ flatView })),+ metadataName: 'view',+ });++describe('fromFlatViewToViewManifest', () => {+ it('should reproduce the manifest after a forward then an inverse conversion', () => {+ expect(+ fromFlatViewToViewManifest({ flatView: forward(VIEW_MANIFEST) }),+ ).toEqual(VIEW_MANIFEST);+ });++ it('should reproduce the flat entity after an inverse then a forward conversion', () => {+ const flatView: UniversalFlatView = {+ universalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ name: 'Agenda',+ objectMetadataUniversalIdentifier: OBJECT_UID,+ type: ViewType.CALENDAR,+ icon: 'IconCalendar',+ position: 1,+ isCompact: false,+ isCustom: false,+ visibility: ViewVisibility.WORKSPACE,+ openRecordIn: ViewOpenRecordIn.SIDE_PANEL,+ key: ViewKey.INDEX,+ kanbanAggregateOperation: null,+ kanbanAggregateOperationFieldMetadataUniversalIdentifier: null,+ calendarLayout: ViewCalendarLayout.MONTH,+ calendarFieldMetadataUniversalIdentifier: START_DATE_FIELD_UID,+ calendarEndFieldMetadataUniversalIdentifier: null,+ mainGroupByFieldMetadataUniversalIdentifier: null,+ shouldHideEmptyGroups: false,+ kanbanColumnWidth: null,+ anyFieldFilterValue: null,+ createdByUserWorkspaceId: null,+ isActive: true,+ isSystemSideEffect: false,+ universalOverrides: null,+ viewFieldUniversalIdentifiers: [],+ viewFilterUniversalIdentifiers: [],+ viewFilterGroupUniversalIdentifiers: [],+ viewGroupUniversalIdentifiers: [],+ viewFieldGroupUniversalIdentifiers: [],+ viewSortUniversalIdentifiers: [],+ createdAt: NOW,+ updatedAt: NOW,+ deletedAt: null,+ };++ expect(roundTripFlatView(flatView)).toBeUndefined();+ });++ it('should write the defaults the forward converter applied to a minimal manifest', () => {+ const viewManifest = fromFlatViewToViewManifest({+ flatView: forward(MINIMAL_VIEW_MANIFEST),+ });++ expect(viewManifest).toEqual({+ ...MINIMAL_VIEW_MANIFEST,+ type: ViewType.TABLE,+ icon: 'IconList',+ position: 0,+ isCompact: false,+ visibility: ViewVisibility.WORKSPACE,+ openRecordIn: ViewOpenRecordIn.SIDE_PANEL,+ shouldHideEmptyGroups: false,+ });+ for (const property of NULLABLE_VIEW_MANIFEST_PROPERTIES) {+ expect(viewManifest).not.toHaveProperty(property);+ }+ });++ it('should emit the provided children and omit the empty child collections', () => {+ const viewManifest = fromFlatViewToViewManifest({+ flatView: forward(VIEW_MANIFEST),+ children: {+ fields: [VIEW_FIELD_MANIFEST],+ filters: [],+ filterGroups: [],+ groups: [],+ fieldGroups: [],+ sorts: [],+ },+ });++ expect(viewManifest.fields).toEqual([VIEW_FIELD_MANIFEST]);+ for (const property of VIEW_CHILD_COLLECTION_PROPERTIES_OTHER_THAN_FIELDS) {+ expect(viewManifest).not.toHaveProperty(property);+ }+ });++ it('should emit every non-empty child collection under its own key', () => {+ const children = {+ fields: [VIEW_FIELD_MANIFEST],+ filters: [VIEW_FILTER_MANIFEST],+ filterGroups: [VIEW_FILTER_GROUP_MANIFEST],+ groups: [VIEW_GROUP_MANIFEST],+ fieldGroups: [VIEW_FIELD_GROUP_MANIFEST],+ sorts: [VIEW_SORT_MANIFEST],+ };++ expect(+ fromFlatViewToViewManifest({+ flatView: forward(VIEW_MANIFEST),+ children,+ }),+ ).toEqual({ ...VIEW_MANIFEST, ...children });+ });++ it('should never emit the key even when the flat view carries one', () => {+ expect(+ fromFlatViewToViewManifest({+ flatView: { ...forward(VIEW_MANIFEST), key: ViewKey.INDEX },+ }),+ ).not.toHaveProperty('key');+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-view-filter-manifest-to-universal-flat-view-filter.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-view-filter-manifest-to-universal-flat-view-filter.util.spec.tsindex 38003109771..914c7f8fe46 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-view-filter-manifest-to-universal-flat-view-filter.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-view-filter-manifest-to-universal-flat-view-filter.util.spec.ts@@ -26,10 +26,30 @@ describe('fromViewFilterManifestToUniversalFlatViewFilter', () => {expect(result.operand).toBe(ViewFilterOperand.CONTAINS);expect(result.value).toBe('test');expect(result.subFieldName).toBeNull();+ expect(result.relationTargetFieldMetadataUniversalIdentifier).toBeNull();expect(result.viewFilterGroupUniversalIdentifier).toBeNull();expect(result.positionInViewFilterGroup).toBeNull();});+ it('should copy an explicit relation target field metadata universal identifier', () => {+ const result = fromViewFilterManifestToUniversalFlatViewFilter({+ viewFilterManifest: {+ universalIdentifier: 'vfilter-uuid-3',+ fieldMetadataUniversalIdentifier: 'field-uuid-3',+ operand: ViewFilterOperand.IS,+ value: { selectedRecordIds: ['record-uuid-1'] },+ relationTargetFieldMetadataUniversalIdentifier: 'target-field-uuid-1',+ },+ viewUniversalIdentifier,+ applicationUniversalIdentifier,+ now,+ });++ expect(result.relationTargetFieldMetadataUniversalIdentifier).toBe(+ 'target-field-uuid-1',+ );+ });+it('should respect explicit optional values', () => {const result = fromViewFilterManifestToUniversalFlatViewFilter({viewFilterManifest: {diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util.tsnew file mode 100644index 00000000000..dce32339148--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util.ts@@ -0,0 +1,14 @@+import { type ViewFieldGroupManifest } from 'twenty-shared/application';++import { type UniversalFlatViewFieldGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-field-group.type';++export const fromFlatViewFieldGroupToViewFieldGroupManifest = ({+ flatViewFieldGroup,+}: {+ flatViewFieldGroup: UniversalFlatViewFieldGroup;+}): ViewFieldGroupManifest => ({+ universalIdentifier: flatViewFieldGroup.universalIdentifier,+ name: flatViewFieldGroup.name,+ position: flatViewFieldGroup.position,+ isVisible: flatViewFieldGroup.isVisible,+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util.tsnew file mode 100644index 00000000000..f1f51957e0b--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util.ts@@ -0,0 +1,19 @@+import { type StandaloneViewFieldManifest } from 'twenty-shared/application';++import { fromFlatViewFieldToViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util';+import { type UniversalFlatViewField } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-field.type';++export const fromFlatViewFieldToStandaloneViewFieldManifest = ({+ flatViewField,+}: {+ flatViewField: UniversalFlatViewField;+}): StandaloneViewFieldManifest => {+ const { universalIdentifier, ...viewFieldManifest } =+ fromFlatViewFieldToViewFieldManifest({ flatViewField });++ return {+ universalIdentifier,+ viewUniversalIdentifier: flatViewField.viewUniversalIdentifier,+ ...viewFieldManifest,+ };+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util.tsnew file mode 100644index 00000000000..d25d93d4625--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util.ts@@ -0,0 +1,26 @@+import { type ViewFieldManifest } from 'twenty-shared/application';+import { isDefined } from 'twenty-shared/utils';++import { type UniversalFlatViewField } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-field.type';++export const fromFlatViewFieldToViewFieldManifest = ({+ flatViewField,+}: {+ flatViewField: UniversalFlatViewField;+}): ViewFieldManifest => ({+ universalIdentifier: flatViewField.universalIdentifier,+ fieldMetadataUniversalIdentifier:+ flatViewField.fieldMetadataUniversalIdentifier,+ position: flatViewField.position,+ isVisible: flatViewField.isVisible,+ size: flatViewField.size,+ ...(isDefined(flatViewField.aggregateOperation)+ ? { aggregateOperation: flatViewField.aggregateOperation }+ : {}),+ ...(isDefined(flatViewField.viewFieldGroupUniversalIdentifier)+ ? {+ viewFieldGroupUniversalIdentifier:+ flatViewField.viewFieldGroupUniversalIdentifier,+ }+ : {}),+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util.tsnew file mode 100644index 00000000000..0d221e5ee3c--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util.ts@@ -0,0 +1,25 @@+import { type ViewFilterGroupManifest } from 'twenty-shared/application';+import { isDefined } from 'twenty-shared/utils';++import { type UniversalFlatViewFilterGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-filter-group.type';++export const fromFlatViewFilterGroupToViewFilterGroupManifest = ({+ flatViewFilterGroup,+}: {+ flatViewFilterGroup: UniversalFlatViewFilterGroup;+}): ViewFilterGroupManifest => ({+ universalIdentifier: flatViewFilterGroup.universalIdentifier,+ logicalOperator: flatViewFilterGroup.logicalOperator,+ ...(isDefined(flatViewFilterGroup.parentViewFilterGroupUniversalIdentifier)+ ? {+ parentViewFilterGroupUniversalIdentifier:+ flatViewFilterGroup.parentViewFilterGroupUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatViewFilterGroup.positionInViewFilterGroup)+ ? {+ positionInViewFilterGroup:+ flatViewFilterGroup.positionInViewFilterGroup,+ }+ : {}),+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util.tsnew file mode 100644index 00000000000..25f3da1e3e2--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util.ts@@ -0,0 +1,34 @@+import { type ViewFilterManifest } from 'twenty-shared/application';+import { isDefined } from 'twenty-shared/utils';++import { type UniversalFlatViewFilter } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-filter.type';++export const fromFlatViewFilterToViewFilterManifest = ({+ flatViewFilter,+}: {+ flatViewFilter: UniversalFlatViewFilter;+}): ViewFilterManifest => ({+ universalIdentifier: flatViewFilter.universalIdentifier,+ fieldMetadataUniversalIdentifier:+ flatViewFilter.fieldMetadataUniversalIdentifier,+ operand: flatViewFilter.operand,+ value: flatViewFilter.value,+ ...(isDefined(flatViewFilter.subFieldName)+ ? { subFieldName: flatViewFilter.subFieldName }+ : {}),+ ...(isDefined(flatViewFilter.relationTargetFieldMetadataUniversalIdentifier)+ ? {+ relationTargetFieldMetadataUniversalIdentifier:+ flatViewFilter.relationTargetFieldMetadataUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatViewFilter.viewFilterGroupUniversalIdentifier)+ ? {+ viewFilterGroupUniversalIdentifier:+ flatViewFilter.viewFilterGroupUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatViewFilter.positionInViewFilterGroup)+ ? { positionInViewFilterGroup: flatViewFilter.positionInViewFilterGroup }+ : {}),+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util.tsnew file mode 100644index 00000000000..a2336628268--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util.ts@@ -0,0 +1,14 @@+import { type ViewGroupManifest } from 'twenty-shared/application';++import { type UniversalFlatViewGroup } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-group.type';++export const fromFlatViewGroupToViewGroupManifest = ({+ flatViewGroup,+}: {+ flatViewGroup: UniversalFlatViewGroup;+}): ViewGroupManifest => ({+ universalIdentifier: flatViewGroup.universalIdentifier,+ fieldValue: flatViewGroup.fieldValue,+ position: flatViewGroup.position,+ isVisible: flatViewGroup.isVisible,+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util.tsnew file mode 100644index 00000000000..90a6cd5923f--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util.ts@@ -0,0 +1,18 @@+import { type ViewSortManifest } from 'twenty-shared/application';+import { isDefined } from 'twenty-shared/utils';++import { type UniversalFlatViewSort } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view-sort.type';++export const fromFlatViewSortToViewSortManifest = ({+ flatViewSort,+}: {+ flatViewSort: UniversalFlatViewSort;+}): ViewSortManifest => ({+ universalIdentifier: flatViewSort.universalIdentifier,+ fieldMetadataUniversalIdentifier:+ flatViewSort.fieldMetadataUniversalIdentifier,+ direction: flatViewSort.direction,+ ...(isDefined(flatViewSort.subFieldName)+ ? { subFieldName: flatViewSort.subFieldName }+ : {}),+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util.tsnew file mode 100644index 00000000000..4ed443f21fa--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util.ts@@ -0,0 +1,83 @@+import { type ViewManifest } from 'twenty-shared/application';+import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';++import { type UniversalFlatView } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-view.type';++export type ViewChildrenManifests = Pick<+ ViewManifest,+ 'fields' | 'filters' | 'filterGroups' | 'groups' | 'fieldGroups' | 'sorts'+>;++const withoutEmptyCollections = ({+ fields,+ filters,+ filterGroups,+ groups,+ fieldGroups,+ sorts,+}: ViewChildrenManifests): ViewChildrenManifests => ({+ ...(isNonEmptyArray(fields) ? { fields } : {}),+ ...(isNonEmptyArray(filters) ? { filters } : {}),+ ...(isNonEmptyArray(filterGroups) ? { filterGroups } : {}),+ ...(isNonEmptyArray(groups) ? { groups } : {}),+ ...(isNonEmptyArray(fieldGroups) ? { fieldGroups } : {}),+ ...(isNonEmptyArray(sorts) ? { sorts } : {}),+});++export const fromFlatViewToViewManifest = ({+ flatView,+ children = {},+}: {+ flatView: UniversalFlatView;+ children?: ViewChildrenManifests;+}): ViewManifest => ({+ universalIdentifier: flatView.universalIdentifier,+ name: flatView.name,+ objectUniversalIdentifier: flatView.objectMetadataUniversalIdentifier,+ type: flatView.type,+ icon: flatView.icon,+ position: flatView.position,+ isCompact: flatView.isCompact,+ visibility: flatView.visibility,+ openRecordIn: flatView.openRecordIn,+ shouldHideEmptyGroups: flatView.shouldHideEmptyGroups,+ ...(isDefined(flatView.mainGroupByFieldMetadataUniversalIdentifier)+ ? {+ mainGroupByFieldMetadataUniversalIdentifier:+ flatView.mainGroupByFieldMetadataUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatView.anyFieldFilterValue)+ ? { anyFieldFilterValue: flatView.anyFieldFilterValue }+ : {}),+ ...(isDefined(flatView.kanbanColumnWidth)+ ? { kanbanColumnWidth: flatView.kanbanColumnWidth }+ : {}),+ ...(isDefined(flatView.kanbanAggregateOperation)+ ? { kanbanAggregateOperation: flatView.kanbanAggregateOperation }+ : {}),+ ...(isDefined(+ flatView.kanbanAggregateOperationFieldMetadataUniversalIdentifier,+ )+ ? {+ kanbanAggregateOperationFieldMetadataUniversalIdentifier:+ flatView.kanbanAggregateOperationFieldMetadataUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatView.calendarLayout)+ ? { calendarLayout: flatView.calendarLayout }+ : {}),+ ...(isDefined(flatView.calendarFieldMetadataUniversalIdentifier)+ ? {+ calendarFieldMetadataUniversalIdentifier:+ flatView.calendarFieldMetadataUniversalIdentifier,+ }+ : {}),+ ...(isDefined(flatView.calendarEndFieldMetadataUniversalIdentifier)+ ? {+ calendarEndFieldMetadataUniversalIdentifier:+ flatView.calendarEndFieldMetadataUniversalIdentifier,+ }+ : {}),+ ...withoutEmptyCollections(children),+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util.tsindex b0bda0b9c7c..671c72c3c80 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util.ts@@ -24,7 +24,8 @@ export const fromViewFilterManifestToUniversalFlatViewFilter = ({operand: viewFilterManifest.operand,value: viewFilterManifest.value,subFieldName: viewFilterManifest.subFieldName ?? null,- relationTargetFieldMetadataUniversalIdentifier: null,+ relationTargetFieldMetadataUniversalIdentifier:+ viewFilterManifest.relationTargetFieldMetadataUniversalIdentifier ?? null,positionInViewFilterGroup:viewFilterManifest.positionInViewFilterGroup ?? null,createdAt: now,diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-manifest-export.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-manifest-export.service.tsindex b392000bc6a..9f1d8cde79e 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-manifest-export.service.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/application-manifest-export.service.ts@@ -10,6 +10,7 @@ import { assertFlatApplicationIsExportable } from 'src/engine/core-modules/appliimport { classifyApplicationFlatEntities } from 'src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util';import { getApplicationSubAllFlatEntityMaps } from 'src/engine/core-modules/application/application-manifest/utils/get-application-sub-all-flat-entity-maps.util';import { reconstructDataModelManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-data-model-manifest.util';+import { reconstructViewsManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-views-manifest.util';import { ApplicationTranslationCacheService } from 'src/engine/core-modules/application/application-translation/application-translation-cache.service';import {ApplicationException,@@ -71,9 +72,23 @@ export class ApplicationManifestExportService {fromAllFlatEntityMaps: allFlatEntityMaps,});- const { objects, fields, indexes, coverage } = reconstructDataModelManifest(- { applicationAllFlatEntityMaps },- );+ const {+ objects,+ fields,+ indexes,+ coverage: dataModelCoverage,+ } = reconstructDataModelManifest({ applicationAllFlatEntityMaps });+ const {+ views,+ viewFields,+ coverage: viewsCoverage,+ } = reconstructViewsManifest({+ applicationAllFlatEntityMaps,+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: new Set(+ objects.map(({ universalIdentifier }) => universalIdentifier),+ ),+ });const translations = isDefined(flatApplication.applicationRegistrationId)? await this.applicationTranslationCacheService.getCatalogsByLocale(flatApplication.applicationRegistrationId,@@ -99,8 +114,8 @@ export class ApplicationManifestExportService {skills: [],agents: [],publicAssets: [],- views: [],- viewFields: [],+ views,+ viewFields,navigationMenuItems: [],pageLayouts: [],pageLayoutTabs: [],@@ -120,7 +135,7 @@ export class ApplicationManifestExportService {flatApplication,applicationAllFlatEntityMaps,allFlatEntityMaps,- reconstructedCoverage: coverage,+ reconstructedCoverage: [...dataModelCoverage, ...viewsCoverage],}),files: [],};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/types/view-export-classification.type.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/types/view-export-classification.type.tsnew file mode 100644index 00000000000..f5b3fb04f26--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/types/view-export-classification.type.ts@@ -0,0 +1,17 @@+import { type AllMetadataName } from 'twenty-shared/metadata';++export type ParentViewStatus =+ | 'exported'+ | 'engineDerived'+ | 'unsupported'+ | 'outside';++export type ViewChildMetadataName = Extract<+ AllMetadataName,+ | 'viewField'+ | 'viewFieldGroup'+ | 'viewFilter'+ | 'viewFilterGroup'+ | 'viewGroup'+ | 'viewSort'+>;diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/export-covers-compared-properties.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/export-covers-compared-properties.spec.tsindex e81ad077f0e..486f341b5d7 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/export-covers-compared-properties.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/export-covers-compared-properties.spec.ts@@ -1,8 +1,42 @@-import { FieldMetadataType } from 'twenty-shared/types';+import {+ type StandaloneViewFieldManifest,+ type ViewFieldGroupManifest,+ type ViewFieldManifest,+ type ViewFilterGroupManifest,+ type ViewFilterManifest,+ type ViewGroupManifest,+ type ViewManifest,+ type ViewSortManifest,+} from 'twenty-shared/application';+import {+ AggregateOperations,+ FieldMetadataType,+ ViewCalendarLayout,+ ViewFilterGroupLogicalOperator,+ ViewFilterOperand,+ ViewOpenRecordIn,+ ViewSortDirection,+ ViewType,+ ViewVisibility,+} from 'twenty-shared/types';import { fromFlatFieldMetadataToFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-field-metadata-to-field-manifest.util';import { fromFlatIndexMetadataToIndexManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-index-metadata-to-index-manifest.util';import { fromFlatObjectMetadataToObjectManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-object-metadata-to-object-manifest.util';+import { fromFlatViewFieldGroupToViewFieldGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util';+import { fromFlatViewFieldToStandaloneViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util';+import { fromFlatViewFilterGroupToViewFilterGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util';+import { fromFlatViewFilterToViewFilterManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util';+import { fromFlatViewGroupToViewGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util';+import { fromFlatViewSortToViewSortManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util';+import { fromFlatViewToViewManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util';+import { fromViewFieldGroupManifestToUniversalFlatViewFieldGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-group-manifest-to-universal-flat-view-field-group.util';+import { fromViewFieldManifestToUniversalFlatViewField } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-manifest-to-universal-flat-view-field.util';+import { fromViewFilterGroupManifestToUniversalFlatViewFilterGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-group-manifest-to-universal-flat-view-filter-group.util';+import { fromViewFilterManifestToUniversalFlatViewFilter } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util';+import { fromViewGroupManifestToUniversalFlatViewGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-group-manifest-to-universal-flat-view-group.util';+import { fromViewManifestToUniversalFlatView } from 'src/engine/core-modules/application/application-manifest/converters/from-view-manifest-to-universal-flat-view.util';+import { fromViewSortManifestToUniversalFlatViewSort } from 'src/engine/core-modules/application/application-manifest/converters/from-view-sort-manifest-to-universal-flat-view-sort.util';import { ALL_UNIVERSAL_FLAT_ENTITY_PROPERTIES_TO_COMPARE_AND_STRINGIFY } from 'src/engine/metadata-modules/flat-entity/constant/all-universal-flat-entity-properties-to-compare-and-stringify.constant';import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';import { getFlatIndexMetadataMock } from 'src/engine/metadata-modules/flat-index-metadata/__mocks__/get-flat-index-metadata.mock';@@ -12,9 +46,110 @@ const APP_UID = '11111111-1111-4111-8111-111111111111';const OBJECT_UID = '22222222-2222-4222-8222-222222222222';const FIELD_UID = '33333333-3333-4333-8333-333333333333';const INDEX_UID = '44444444-4444-4444-8444-444444444444';+const VIEW_UID = '55555555-5555-4555-8555-555555555555';+const VIEW_FIELD_UID = '66666666-6666-4666-8666-666666666666';+const VIEW_FILTER_UID = '77777777-7777-4777-8777-777777777777';+const VIEW_FILTER_GROUP_UID = '88888888-8888-4888-8888-888888888888';+const PARENT_VIEW_FILTER_GROUP_UID = '99999999-9999-4999-8999-999999999999';+const VIEW_GROUP_UID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';+const VIEW_FIELD_GROUP_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';+const VIEW_SORT_UID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';+const NOW = '2026-09-08T00:00:00.000Z';++const VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: VIEW_FIELD_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ isVisible: true,+ size: 150,+ position: 0,+ aggregateOperation: AggregateOperations.COUNT,+ viewFieldGroupUniversalIdentifier: VIEW_FIELD_GROUP_UID,+};++const STANDALONE_VIEW_FIELD_MANIFEST: StandaloneViewFieldManifest = {+ ...VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: VIEW_UID,+};++const VIEW_FILTER_MANIFEST: ViewFilterManifest = {+ universalIdentifier: VIEW_FILTER_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ operand: ViewFilterOperand.CONTAINS,+ value: 'acme',+ subFieldName: 'primaryLinkUrl',+ relationTargetFieldMetadataUniversalIdentifier: FIELD_UID,+ viewFilterGroupUniversalIdentifier: VIEW_FILTER_GROUP_UID,+ positionInViewFilterGroup: 0,+};++const VIEW_FILTER_GROUP_MANIFEST: ViewFilterGroupManifest = {+ universalIdentifier: VIEW_FILTER_GROUP_UID,+ logicalOperator: ViewFilterGroupLogicalOperator.AND,+ parentViewFilterGroupUniversalIdentifier: PARENT_VIEW_FILTER_GROUP_UID,+ positionInViewFilterGroup: 0,+};++const VIEW_GROUP_MANIFEST: ViewGroupManifest = {+ universalIdentifier: VIEW_GROUP_UID,+ fieldValue: 'won',+ isVisible: true,+ position: 0,+};++const VIEW_FIELD_GROUP_MANIFEST: ViewFieldGroupManifest = {+ universalIdentifier: VIEW_FIELD_GROUP_UID,+ name: 'Details',+ position: 0,+ isVisible: true,+};++const VIEW_SORT_MANIFEST: ViewSortManifest = {+ universalIdentifier: VIEW_SORT_UID,+ fieldMetadataUniversalIdentifier: FIELD_UID,+ direction: ViewSortDirection.DESC,+ subFieldName: 'primaryLinkUrl',+};++const VIEW_MANIFEST: ViewManifest = {+ universalIdentifier: VIEW_UID,+ name: 'Pipeline',+ objectUniversalIdentifier: OBJECT_UID,+ type: ViewType.KANBAN,+ icon: 'IconLayoutKanban',+ position: 3,+ isCompact: true,+ visibility: ViewVisibility.UNLISTED,+ openRecordIn: ViewOpenRecordIn.RECORD_PAGE,+ mainGroupByFieldMetadataUniversalIdentifier: FIELD_UID,+ shouldHideEmptyGroups: true,+ anyFieldFilterValue: 'acme',+ kanbanColumnWidth: 240,+ kanbanAggregateOperation: AggregateOperations.SUM,+ kanbanAggregateOperationFieldMetadataUniversalIdentifier: FIELD_UID,+ calendarLayout: ViewCalendarLayout.WEEK,+ calendarFieldMetadataUniversalIdentifier: FIELD_UID,+ calendarEndFieldMetadataUniversalIdentifier: FIELD_UID,+};++const VIEW_CHILD_CONVERSION_CONTEXT = {+ viewUniversalIdentifier: VIEW_UID,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+};++const VIEW_KIND_GAPS = {+ deletedAt:+ 'views and their children are never soft-deleted; the column is scheduled for removal',+};++const NESTED_VIEW_CHILD_GAPS = {+ ...VIEW_KIND_GAPS,+ viewUniversalIdentifier:+ 'a nested child is written under its view; the standalone view field converter emits it',+};type ExportedKind = {- metadataName: 'objectMetadata' | 'fieldMetadata' | 'index';+ metadataName: keyof typeof ALL_UNIVERSAL_FLAT_ENTITY_PROPERTIES_TO_COMPARE_AND_STRINGIFY;emittedProperties: string[];renamedProperties: Record<string, string>;workspaceLocalProperties: string[];@@ -87,6 +222,119 @@ const EXPORTED_KINDS: ExportedKind[] = ['partial indexes are reported as unsupported instead of exported',},},+ {+ metadataName: 'view',+ emittedProperties: Object.keys(+ fromFlatViewToViewManifest({+ flatView: fromViewManifestToUniversalFlatView({+ viewManifest: VIEW_MANIFEST,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ children: {+ fields: [VIEW_FIELD_MANIFEST],+ filters: [VIEW_FILTER_MANIFEST],+ filterGroups: [VIEW_FILTER_GROUP_MANIFEST],+ groups: [VIEW_GROUP_MANIFEST],+ fieldGroups: [VIEW_FIELD_GROUP_MANIFEST],+ sorts: [VIEW_SORT_MANIFEST],+ },+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: [+ 'isActive',+ 'universalOverrides',+ 'createdByUserWorkspaceId',+ ],+ knownGaps: VIEW_KIND_GAPS,+ },+ {+ metadataName: 'viewField',+ emittedProperties: Object.keys(+ fromFlatViewFieldToStandaloneViewFieldManifest({+ flatViewField: fromViewFieldManifestToUniversalFlatViewField({+ viewFieldManifest: STANDALONE_VIEW_FIELD_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: ['isActive', 'universalOverrides'],+ knownGaps: VIEW_KIND_GAPS,+ },+ {+ metadataName: 'viewFilter',+ emittedProperties: Object.keys(+ fromFlatViewFilterToViewFilterManifest({+ flatViewFilter: fromViewFilterManifestToUniversalFlatViewFilter({+ viewFilterManifest: VIEW_FILTER_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: [],+ knownGaps: NESTED_VIEW_CHILD_GAPS,+ },+ {+ metadataName: 'viewFilterGroup',+ emittedProperties: Object.keys(+ fromFlatViewFilterGroupToViewFilterGroupManifest({+ flatViewFilterGroup:+ fromViewFilterGroupManifestToUniversalFlatViewFilterGroup({+ viewFilterGroupManifest: VIEW_FILTER_GROUP_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: [],+ knownGaps: NESTED_VIEW_CHILD_GAPS,+ },+ {+ metadataName: 'viewGroup',+ emittedProperties: Object.keys(+ fromFlatViewGroupToViewGroupManifest({+ flatViewGroup: fromViewGroupManifestToUniversalFlatViewGroup({+ viewGroupManifest: VIEW_GROUP_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: [],+ knownGaps: NESTED_VIEW_CHILD_GAPS,+ },+ {+ metadataName: 'viewFieldGroup',+ emittedProperties: Object.keys(+ fromFlatViewFieldGroupToViewFieldGroupManifest({+ flatViewFieldGroup:+ fromViewFieldGroupManifestToUniversalFlatViewFieldGroup({+ viewFieldGroupManifest: VIEW_FIELD_GROUP_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: ['isActive', 'overrides'],+ knownGaps: NESTED_VIEW_CHILD_GAPS,+ },+ {+ metadataName: 'viewSort',+ emittedProperties: Object.keys(+ fromFlatViewSortToViewSortManifest({+ flatViewSort: fromViewSortManifestToUniversalFlatViewSort({+ viewSortManifest: VIEW_SORT_MANIFEST,+ ...VIEW_CHILD_CONVERSION_CONTEXT,+ }),+ }),+ ),+ renamedProperties: {},+ workspaceLocalProperties: [],+ knownGaps: NESTED_VIEW_CHILD_GAPS,+ },];describe('export coverage of the compared properties', () => {@@ -117,12 +365,27 @@ describe('export coverage of the compared properties', () => {);it.each(EXPORTED_KINDS)(- 'should not keep accounting for a property of $metadataName that is now emitted',- ({ emittedProperties, workspaceLocalProperties, knownGaps }) => {+ 'should not keep accounting for a property of $metadataName that is now emitted or no longer compared',+ ({+ metadataName,+ emittedProperties,+ renamedProperties,+ workspaceLocalProperties,+ knownGaps,+ }) => {+ const comparedProperties: readonly string[] =+ ALL_UNIVERSAL_FLAT_ENTITY_PROPERTIES_TO_COMPARE_AND_STRINGIFY[+ metadataName+ ].propertiesToCompare;const staleEntries = [...workspaceLocalProperties,...Object.keys(knownGaps),- ].filter((property) => emittedProperties.includes(property));+ ...Object.keys(renamedProperties),+ ].filter(+ (property) =>+ emittedProperties.includes(property) ||+ !comparedProperties.includes(property),+ );expect(staleEntries).toEqual([]);},diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-data-model-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-data-model-manifest.util.spec.tsindex a2e98bb0671..8b69478f181 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-data-model-manifest.util.spec.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-data-model-manifest.util.spec.ts@@ -151,7 +151,7 @@ describe('reconstructDataModelManifest', () => {});expect(objects).toHaveLength(1);- expect(objects[0].fields.map(({ name }) => name)).toEqual(['age', 'name']);+ expect(objects[0].fields.map(({ name }) => name)).toEqual(['name', 'age']);expect(fields).toEqual([]);expect(statusOf(coverage, ID_FIELD_UID)?.status).toBe(ApplicationExportCoverageStatus.ENGINE_DERIVED,@@ -281,7 +281,7 @@ describe('reconstructDataModelManifest', () => {}),});- expect(objects[0].fields.map(({ name }) => name)).toEqual(['age', 'name']);+ expect(objects[0].fields.map(({ name }) => name)).toEqual(['name', 'age']);expect(statusOf(coverage, RELATION_FIELD_UID)).toMatchObject({status: ApplicationExportCoverageStatus.UNSUPPORTED,reason: 'relation field without target or settings',diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-views-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-views-manifest.util.spec.tsnew file mode 100644index 00000000000..5cf5578f710--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-views-manifest.util.spec.ts@@ -0,0 +1,1355 @@+import {+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,+ type ViewFieldGroupManifest,+ type ViewFieldManifest,+ type ViewFilterGroupManifest,+ type ViewFilterManifest,+ type ViewGroupManifest,+ type ViewManifest,+ type ViewSortManifest,+} from 'twenty-shared/application';+import {+ AggregateOperations,+ FieldMetadataType,+ ViewFilterGroupLogicalOperator,+ ViewFilterOperand,+ ViewKey,+ ViewOpenRecordIn,+ ViewSortDirection,+ ViewType,+ ViewVisibility,+} from 'twenty-shared/types';++import { fromViewFieldGroupManifestToUniversalFlatViewFieldGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-group-manifest-to-universal-flat-view-field-group.util';+import { fromViewFieldManifestToUniversalFlatViewField } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-manifest-to-universal-flat-view-field.util';+import { fromViewFilterGroupManifestToUniversalFlatViewFilterGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-group-manifest-to-universal-flat-view-filter-group.util';+import { fromViewFilterManifestToUniversalFlatViewFilter } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-manifest-to-universal-flat-view-filter.util';+import { fromViewGroupManifestToUniversalFlatViewGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-group-manifest-to-universal-flat-view-group.util';+import { fromViewManifestToUniversalFlatView } from 'src/engine/core-modules/application/application-manifest/converters/from-view-manifest-to-universal-flat-view.util';+import { fromViewSortManifestToUniversalFlatViewSort } from 'src/engine/core-modules/application/application-manifest/converters/from-view-sort-manifest-to-universal-flat-view-sort.util';+import { reconstructViewsManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-views-manifest.util';+import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';+import { createEmptyAllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-all-flat-entity-maps.constant';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type FlatViewFieldGroup } from 'src/engine/metadata-modules/flat-view-field-group/types/flat-view-field-group.type';+import { type FlatViewField } from 'src/engine/metadata-modules/flat-view-field/types/flat-view-field.type';+import { type FlatViewFilterGroup } from 'src/engine/metadata-modules/flat-view-filter-group/types/flat-view-filter-group.type';+import { type FlatViewFilter } from 'src/engine/metadata-modules/flat-view-filter/types/flat-view-filter.type';+import { type FlatViewGroup } from 'src/engine/metadata-modules/flat-view-group/types/flat-view-group.type';+import { type FlatViewSort } from 'src/engine/metadata-modules/flat-view-sort/types/flat-view-sort.type';+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';++const APP_ID = 'application-id';+const WORKSPACE_ID = 'workspace-id';+const NOW = '2026-09-03T10:00:00.000Z';+const APP_UID = '11111111-1111-4111-8111-111111111111';+const PET_UID = '22222222-2222-4222-8222-222222222222';+const NAME_FIELD_UID = '33333333-3333-4333-8333-333333333333';+const SPECIES_FIELD_UID = '44444444-4444-4444-8444-444444444444';+const AGE_FIELD_UID = '55555555-5555-4555-8555-555555555555';+const COMPANY_UID = '66666666-6666-4666-8666-666666666666';+const MISSING_FIELD_UID = '77777777-7777-4777-8777-777777777777';+const ZOO_PETS_VIEW_UID = '88888888-8888-4888-8888-888888888888';+const ALL_PETS_VIEW_UID = '99999999-9999-4999-8999-999999999999';+const INDEX_VIEW_UID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';+const COMPANIES_VIEW_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';+const PEOPLE_VIEW_UID = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';+const NAMELESS_VIEW_UID = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd';+const PET_OWNERS_VIEW_UID = 'eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee';+const OTHER_ALL_PETS_VIEW_UID = '00000000-0000-4000-8000-000000000000';+const STANDARD_APP_ID = 'standard-application-id';+const EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS = new Set([PET_UID]);++const addAllFlatEntitiesToFlatEntityMaps = <+ TFlatEntity extends SyncableFlatEntity,+>({+ flatEntities,+ flatEntityMaps,+}: {+ flatEntities: TFlatEntity[];+ flatEntityMaps: FlatEntityMaps<TFlatEntity>;+}): FlatEntityMaps<TFlatEntity> =>+ flatEntities.reduce(+ (maps, flatEntity) =>+ addFlatEntityToFlatEntityMapsOrThrow({+ flatEntity,+ flatEntityMaps: maps,+ }),+ flatEntityMaps,+ );++const buildMaps = ({+ objects = [],+ fields = [],+ views = [],+ viewFields = [],+ viewFieldGroups = [],+ viewFilters = [],+ viewFilterGroups = [],+ viewGroups = [],+ viewSorts = [],+}: {+ objects?: FlatObjectMetadata[];+ fields?: FlatFieldMetadata[];+ views?: FlatView[];+ viewFields?: FlatViewField[];+ viewFieldGroups?: FlatViewFieldGroup[];+ viewFilters?: FlatViewFilter[];+ viewFilterGroups?: FlatViewFilterGroup[];+ viewGroups?: FlatViewGroup[];+ viewSorts?: FlatViewSort[];+}): AllFlatEntityMaps => {+ const maps = createEmptyAllFlatEntityMaps();++ return {+ ...maps,+ flatObjectMetadataMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: objects,+ flatEntityMaps: maps.flatObjectMetadataMaps,+ }),+ flatFieldMetadataMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: fields,+ flatEntityMaps: maps.flatFieldMetadataMaps,+ }),+ flatViewMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: views,+ flatEntityMaps: maps.flatViewMaps,+ }),+ flatViewFieldMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewFields,+ flatEntityMaps: maps.flatViewFieldMaps,+ }),+ flatViewFieldGroupMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewFieldGroups,+ flatEntityMaps: maps.flatViewFieldGroupMaps,+ }),+ flatViewFilterMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewFilters,+ flatEntityMaps: maps.flatViewFilterMaps,+ }),+ flatViewFilterGroupMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewFilterGroups,+ flatEntityMaps: maps.flatViewFilterGroupMaps,+ }),+ flatViewGroupMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewGroups,+ flatEntityMaps: maps.flatViewGroupMaps,+ }),+ flatViewSortMaps: addAllFlatEntitiesToFlatEntityMaps({+ flatEntities: viewSorts,+ flatEntityMaps: maps.flatViewSortMaps,+ }),+ };+};++const petObject = getFlatObjectMetadataMock({+ universalIdentifier: PET_UID,+ applicationId: APP_ID,+ applicationUniversalIdentifier: APP_UID,+ nameSingular: 'pet',+ namePlural: 'pets',+ labelIdentifierFieldMetadataUniversalIdentifier: NAME_FIELD_UID,+});++const buildPetField = ({+ universalIdentifier,+ name,+}: {+ universalIdentifier: string;+ name: string;+}) =>+ getFlatFieldMetadataMock({+ universalIdentifier,+ name,+ objectMetadataId: petObject.id,+ objectMetadataUniversalIdentifier: PET_UID,+ applicationId: APP_ID,+ applicationUniversalIdentifier: APP_UID,+ type: FieldMetadataType.TEXT,+ });++const companyObject = getFlatObjectMetadataMock({+ universalIdentifier: COMPANY_UID,+ applicationId: STANDARD_APP_ID,+ applicationUniversalIdentifier:+ TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,+ nameSingular: 'company',+ namePlural: 'companies',+});++const allFlatEntityMaps = buildMaps({+ objects: [petObject, companyObject],+ fields: [+ buildPetField({ universalIdentifier: NAME_FIELD_UID, name: 'name' }),+ buildPetField({ universalIdentifier: SPECIES_FIELD_UID, name: 'species' }),+ buildPetField({ universalIdentifier: AGE_FIELD_UID, name: 'age' }),+ ],+});++const buildFlatView = ({+ viewManifest,+ ...flatViewProperties+}: { viewManifest: ViewManifest } & Partial<FlatView>): FlatView => ({+ ...fromViewManifestToUniversalFlatView({+ viewManifest,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ objectMetadataId: `${viewManifest.objectUniversalIdentifier}-id`,+ kanbanAggregateOperationFieldMetadataId: null,+ calendarFieldMetadataId: null,+ calendarEndFieldMetadataId: null,+ mainGroupByFieldMetadataId: null,+ overrides: null,+ viewFieldIds: [],+ viewFieldGroupIds: [],+ viewFilterIds: [],+ viewGroupIds: [],+ viewFilterGroupIds: [],+ viewSortIds: [],+ ...flatViewProperties,+});++const buildFlatViewField = ({+ viewFieldManifest,+ viewUniversalIdentifier,+ ...flatViewFieldProperties+}: {+ viewFieldManifest: ViewFieldManifest;+ viewUniversalIdentifier: string;+} & Partial<FlatViewField>): FlatViewField => ({+ ...fromViewFieldManifestToUniversalFlatViewField({+ viewFieldManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewFieldManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ fieldMetadataId: `${viewFieldManifest.fieldMetadataUniversalIdentifier}-id`,+ viewId: `${viewUniversalIdentifier}-id`,+ viewFieldGroupId: null,+ overrides: null,+ ...flatViewFieldProperties,+});++const buildFlatViewFieldGroup = ({+ viewFieldGroupManifest,+ viewUniversalIdentifier,+ ...flatViewFieldGroupProperties+}: {+ viewFieldGroupManifest: ViewFieldGroupManifest;+ viewUniversalIdentifier: string;+} & Partial<FlatViewFieldGroup>): FlatViewFieldGroup => ({+ ...fromViewFieldGroupManifestToUniversalFlatViewFieldGroup({+ viewFieldGroupManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewFieldGroupManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ viewId: `${viewUniversalIdentifier}-id`,+ viewFieldIds: [],+ ...flatViewFieldGroupProperties,+});++const buildFlatViewFilter = ({+ viewFilterManifest,+ viewUniversalIdentifier,+ ...flatViewFilterProperties+}: {+ viewFilterManifest: ViewFilterManifest;+ viewUniversalIdentifier: string;+} & Partial<FlatViewFilter>): FlatViewFilter => ({+ ...fromViewFilterManifestToUniversalFlatViewFilter({+ viewFilterManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewFilterManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ fieldMetadataId: `${viewFilterManifest.fieldMetadataUniversalIdentifier}-id`,+ viewId: `${viewUniversalIdentifier}-id`,+ viewFilterGroupId: null,+ relationTargetFieldMetadataId: null,+ ...flatViewFilterProperties,+});++const buildFlatViewFilterGroup = ({+ viewFilterGroupManifest,+ viewUniversalIdentifier,+}: {+ viewFilterGroupManifest: ViewFilterGroupManifest;+ viewUniversalIdentifier: string;+}): FlatViewFilterGroup => ({+ ...fromViewFilterGroupManifestToUniversalFlatViewFilterGroup({+ viewFilterGroupManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewFilterGroupManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ viewId: `${viewUniversalIdentifier}-id`,+ parentViewFilterGroupId: null,+ viewFilterIds: [],+ childViewFilterGroupIds: [],+});++const buildFlatViewGroup = ({+ viewGroupManifest,+ viewUniversalIdentifier,+}: {+ viewGroupManifest: ViewGroupManifest;+ viewUniversalIdentifier: string;+}): FlatViewGroup => ({+ ...fromViewGroupManifestToUniversalFlatViewGroup({+ viewGroupManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewGroupManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ viewId: `${viewUniversalIdentifier}-id`,+});++const buildFlatViewSort = ({+ viewSortManifest,+ viewUniversalIdentifier,+}: {+ viewSortManifest: ViewSortManifest;+ viewUniversalIdentifier: string;+}): FlatViewSort => ({+ ...fromViewSortManifestToUniversalFlatViewSort({+ viewSortManifest,+ viewUniversalIdentifier,+ applicationUniversalIdentifier: APP_UID,+ now: NOW,+ }),+ id: `${viewSortManifest.universalIdentifier}-id`,+ workspaceId: WORKSPACE_ID,+ applicationId: APP_ID,+ fieldMetadataId: `${viewSortManifest.fieldMetadataUniversalIdentifier}-id`,+ viewId: `${viewUniversalIdentifier}-id`,+});++const ALL_PETS_VIEW_MANIFEST: ViewManifest = {+ universalIdentifier: ALL_PETS_VIEW_UID,+ name: 'All pets',+ objectUniversalIdentifier: PET_UID,+ type: ViewType.TABLE,+ icon: 'IconPaw',+ position: 0,+ isCompact: false,+ visibility: ViewVisibility.WORKSPACE,+ openRecordIn: ViewOpenRecordIn.SIDE_PANEL,+ shouldHideEmptyGroups: false,+};++const ZOO_PETS_VIEW_MANIFEST: ViewManifest = {+ universalIdentifier: ZOO_PETS_VIEW_UID,+ name: 'Zoo pets',+ objectUniversalIdentifier: PET_UID,+ type: ViewType.KANBAN,+ icon: 'IconLayoutKanban',+ position: 1,+ isCompact: true,+ visibility: ViewVisibility.WORKSPACE,+ openRecordIn: ViewOpenRecordIn.RECORD_PAGE,+ shouldHideEmptyGroups: true,+ mainGroupByFieldMetadataUniversalIdentifier: SPECIES_FIELD_UID,+};++const OTHER_ALL_PETS_VIEW_MANIFEST: ViewManifest = {+ ...ALL_PETS_VIEW_MANIFEST,+ universalIdentifier: OTHER_ALL_PETS_VIEW_UID,+ icon: 'IconDog',+};++const INDEX_VIEW_MANIFEST: ViewManifest = {+ universalIdentifier: INDEX_VIEW_UID,+ name: 'All',+ objectUniversalIdentifier: PET_UID,+};++const NAME_VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: 'name-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ isVisible: true,+ size: 210,+ viewFieldGroupUniversalIdentifier: 'details-view-field-group',+};++const AGE_VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: 'age-view-field',+ fieldMetadataUniversalIdentifier: AGE_FIELD_UID,+ position: 1,+ isVisible: false,+ size: 100,+ aggregateOperation: AggregateOperations.AVG,+};++const SPECIES_VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: 'species-view-field',+ fieldMetadataUniversalIdentifier: SPECIES_FIELD_UID,+ position: 1,+ isVisible: true,+ size: 150,+};++const CUSTOM_AGE_VIEW_FIELD_MANIFEST: ViewFieldManifest = {+ universalIdentifier: 'custom-age-view-field',+ fieldMetadataUniversalIdentifier: AGE_FIELD_UID,+ position: 1,+ isVisible: true,+ size: 100,+};++const NAME_FILTER_MANIFEST: ViewFilterManifest = {+ universalIdentifier: 'name-view-filter',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ operand: ViewFilterOperand.CONTAINS,+ value: 'Rex',+ viewFilterGroupUniversalIdentifier: 'root-view-filter-group',+ positionInViewFilterGroup: 0,+};++const AGE_FILTER_MANIFEST: ViewFilterManifest = {+ universalIdentifier: 'age-view-filter',+ fieldMetadataUniversalIdentifier: AGE_FIELD_UID,+ operand: ViewFilterOperand.GREATER_THAN_OR_EQUAL,+ value: 5,+ viewFilterGroupUniversalIdentifier: 'root-view-filter-group',+ positionInViewFilterGroup: 1,+};++const ROOT_FILTER_GROUP_MANIFEST: ViewFilterGroupManifest = {+ universalIdentifier: 'root-view-filter-group',+ logicalOperator: ViewFilterGroupLogicalOperator.AND,+};++const DOG_GROUP_MANIFEST: ViewGroupManifest = {+ universalIdentifier: 'dog-view-group',+ fieldValue: 'DOG',+ position: 0,+ isVisible: true,+};++const DETAILS_FIELD_GROUP_MANIFEST: ViewFieldGroupManifest = {+ universalIdentifier: 'details-view-field-group',+ name: 'Details',+ position: 0,+ isVisible: true,+};++const NAME_SORT_MANIFEST: ViewSortManifest = {+ universalIdentifier: 'name-view-sort',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ direction: ViewSortDirection.ASC,+};++const AGE_SORT_MANIFEST: ViewSortManifest = {+ universalIdentifier: 'age-view-sort',+ fieldMetadataUniversalIdentifier: AGE_FIELD_UID,+ direction: ViewSortDirection.DESC,+};++const statusOf = (+ coverage: ReturnType<typeof reconstructViewsManifest>['coverage'],+ universalIdentifier: string,+) =>+ coverage.find((entry) => entry.universalIdentifier === universalIdentifier);++describe('reconstructViewsManifest', () => {+ it('should nest the children of an application view and order every collection by universal identifier', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({ viewManifest: ZOO_PETS_VIEW_MANIFEST }),+ buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST }),+ buildFlatView({ viewManifest: OTHER_ALL_PETS_VIEW_MANIFEST }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: SPECIES_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: NAME_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewFilters: [+ buildFlatViewFilter({+ viewFilterManifest: AGE_FILTER_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewFilter({+ viewFilterManifest: NAME_FILTER_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewFilterGroups: [+ buildFlatViewFilterGroup({+ viewFilterGroupManifest: ROOT_FILTER_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewGroups: [+ buildFlatViewGroup({+ viewGroupManifest: DOG_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewFieldGroups: [+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: DETAILS_FIELD_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewSorts: [+ buildFlatViewSort({+ viewSortManifest: AGE_SORT_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewSort({+ viewSortManifest: NAME_SORT_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([+ OTHER_ALL_PETS_VIEW_MANIFEST,+ ZOO_PETS_VIEW_MANIFEST,+ {+ ...ALL_PETS_VIEW_MANIFEST,+ fields: [+ AGE_VIEW_FIELD_MANIFEST,+ NAME_VIEW_FIELD_MANIFEST,+ SPECIES_VIEW_FIELD_MANIFEST,+ ],+ filters: [AGE_FILTER_MANIFEST, NAME_FILTER_MANIFEST],+ filterGroups: [ROOT_FILTER_GROUP_MANIFEST],+ groups: [DOG_GROUP_MANIFEST],+ fieldGroups: [DETAILS_FIELD_GROUP_MANIFEST],+ sorts: [AGE_SORT_MANIFEST, NAME_SORT_MANIFEST],+ },+ ]);+ expect(viewFields).toEqual([]);+ expect(coverage).toHaveLength(13);+ expect(+ coverage.filter(+ ({ status }) => status !== ApplicationExportCoverageStatus.EXPORTED,+ ),+ ).toEqual([]);+ expect(statusOf(coverage, 'name-view-filter')).toEqual({+ metadataName: 'viewFilter',+ universalIdentifier: 'name-view-filter',+ status: ApplicationExportCoverageStatus.EXPORTED,+ });+ });++ it('should hide an engine-derived view and its flagged children but export its unflagged view field standalone', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: INDEX_VIEW_MANIFEST,+ key: ViewKey.INDEX,+ isSystemSideEffect: true,+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'engine-name-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ isSystemSideEffect: true,+ }),+ buildFlatViewField({+ viewFieldManifest: CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ ],+ viewFieldGroups: [+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: {+ universalIdentifier: 'engine-view-field-group',+ position: 0,+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ isSystemSideEffect: true,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([]);+ expect(viewFields).toEqual([+ {+ ...CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: INDEX_VIEW_UID,+ },+ ]);+ expect(statusOf(coverage, INDEX_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: INDEX_VIEW_UID,+ status: ApplicationExportCoverageStatus.ENGINE_DERIVED,+ });+ expect(statusOf(coverage, 'engine-name-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'engine-name-view-field',+ status: ApplicationExportCoverageStatus.ENGINE_DERIVED,+ });+ expect(statusOf(coverage, 'engine-view-field-group')).toEqual({+ metadataName: 'viewFieldGroup',+ universalIdentifier: 'engine-view-field-group',+ status: ApplicationExportCoverageStatus.ENGINE_DERIVED,+ });+ expect(statusOf(coverage, 'custom-age-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'custom-age-view-field',+ status: ApplicationExportCoverageStatus.EXPORTED,+ });+ });++ it('should export a view field of a view outside the application standalone but refuse the other children of foreign and engine-derived views', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: INDEX_VIEW_MANIFEST,+ isSystemSideEffect: true,+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ viewFilters: [+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'foreign-view-filter',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'engine-view-filter',+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ ],+ viewFilterGroups: [+ buildFlatViewFilterGroup({+ viewFilterGroupManifest: {+ ...ROOT_FILTER_GROUP_MANIFEST,+ universalIdentifier: 'foreign-view-filter-group',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ viewSorts: [+ buildFlatViewSort({+ viewSortManifest: {+ ...NAME_SORT_MANIFEST,+ universalIdentifier: 'foreign-view-sort',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ viewGroups: [+ buildFlatViewGroup({+ viewGroupManifest: {+ ...DOG_GROUP_MANIFEST,+ universalIdentifier: 'foreign-view-group',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ viewFieldGroups: [+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: {+ ...DETAILS_FIELD_GROUP_MANIFEST,+ universalIdentifier: 'foreign-view-field-group',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([]);+ expect(viewFields).toEqual([+ {+ ...CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ },+ ]);+ expect(statusOf(coverage, 'custom-age-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'custom-age-view-field',+ status: ApplicationExportCoverageStatus.EXPORTED,+ });+ expect(+ [+ 'foreign-view-filter',+ 'foreign-view-filter-group',+ 'foreign-view-sort',+ 'foreign-view-group',+ 'foreign-view-field-group',+ ].map((universalIdentifier) => statusOf(coverage, universalIdentifier)),+ ).toEqual([+ {+ metadataName: 'viewFilter',+ universalIdentifier: 'foreign-view-filter',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter on a view outside the application',+ },+ {+ metadataName: 'viewFilterGroup',+ universalIdentifier: 'foreign-view-filter-group',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter group on a view outside the application',+ },+ {+ metadataName: 'viewSort',+ universalIdentifier: 'foreign-view-sort',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view sort on a view outside the application',+ },+ {+ metadataName: 'viewGroup',+ universalIdentifier: 'foreign-view-group',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view group on a view outside the application',+ },+ {+ metadataName: 'viewFieldGroup',+ universalIdentifier: 'foreign-view-field-group',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field group on a view outside the application',+ },+ ]);+ expect(statusOf(coverage, 'engine-view-filter')).toEqual({+ metadataName: 'viewFilter',+ universalIdentifier: 'engine-view-filter',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter on an engine-derived view',+ });+ });++ it('should refuse a view without a name together with its view field', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: {+ universalIdentifier: NAMELESS_VIEW_UID,+ name: '',+ objectUniversalIdentifier: PET_UID,+ },+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'nameless-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: NAMELESS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([]);+ expect(viewFields).toEqual([]);+ expect(statusOf(coverage, NAMELESS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: NAMELESS_VIEW_UID,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view without a name',+ });+ expect(statusOf(coverage, 'nameless-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'nameless-view-field',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field of an unsupported view',+ });+ });++ it('should tell a view on an unsupported application object apart from a view on an object outside the application', () => {+ const { views, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST }),+ buildFlatView({+ viewManifest: {+ universalIdentifier: PET_OWNERS_VIEW_UID,+ name: 'Pet owners',+ objectUniversalIdentifier: COMPANY_UID,+ },+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: new Set(),+ });++ expect(views).toMatchObject([+ {+ universalIdentifier: PET_OWNERS_VIEW_UID,+ name: 'Pet owners',+ objectUniversalIdentifier: COMPANY_UID,+ },+ ]);+ expect(statusOf(coverage, ALL_PETS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: ALL_PETS_VIEW_UID,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view on an unsupported object',+ });+ expect(statusOf(coverage, PET_OWNERS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: PET_OWNERS_VIEW_UID,+ status: ApplicationExportCoverageStatus.EXPORTED,+ });+ });++ it('should refuse a view referencing a field that does not exist together with its children', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: {+ ...ALL_PETS_VIEW_MANIFEST,+ mainGroupByFieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: NAME_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([]);+ expect(viewFields).toEqual([]);+ expect(statusOf(coverage, ALL_PETS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: ALL_PETS_VIEW_UID,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view referencing a field that does not exist',+ });+ expect(+ statusOf(coverage, NAME_VIEW_FIELD_MANIFEST.universalIdentifier),+ ).toEqual({+ metadataName: 'viewField',+ universalIdentifier: NAME_VIEW_FIELD_MANIFEST.universalIdentifier,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field of an unsupported view',+ });+ });++ it('should refuse a view filter on a relation target field that does not exist', () => {+ const { views, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST })],+ viewFilters: [+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'dangling-relation-target-view-filter',+ relationTargetFieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([ALL_PETS_VIEW_MANIFEST]);+ expect(statusOf(coverage, 'dangling-relation-target-view-filter')).toEqual({+ metadataName: 'viewFilter',+ universalIdentifier: 'dangling-relation-target-view-filter',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter on a relation target field that does not exist',+ });+ });++ it('should refuse a view field placed in a field group that is not exported', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: INDEX_VIEW_MANIFEST,+ key: ViewKey.INDEX,+ isSystemSideEffect: true,+ }),+ ],+ viewFieldGroups: [+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: {+ universalIdentifier: 'custom-view-field-group',+ name: 'Details',+ position: 0,+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: {+ ...CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewFieldGroupUniversalIdentifier: 'custom-view-field-group',+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([]);+ expect(viewFields).toEqual([]);+ expect(statusOf(coverage, 'custom-view-field-group')).toEqual({+ metadataName: 'viewFieldGroup',+ universalIdentifier: 'custom-view-field-group',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field group on an engine-derived view',+ });+ expect(+ statusOf(coverage, CUSTOM_AGE_VIEW_FIELD_MANIFEST.universalIdentifier),+ ).toEqual({+ metadataName: 'viewField',+ universalIdentifier: CUSTOM_AGE_VIEW_FIELD_MANIFEST.universalIdentifier,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field in a view field group that is not exported',+ });+ });++ it('should refuse a view filter whose value is nested too deeply', () => {+ const deeplyNestedValue = Array.from({ length: 9 }).reduce<+ Record<string, unknown>+ >((nested) => ({ nested }), {});+ const { views, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST })],+ viewFilters: [+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'deeply-nested-view-filter',+ value: deeplyNestedValue,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([ALL_PETS_VIEW_MANIFEST]);+ expect(statusOf(coverage, 'deeply-nested-view-filter')).toEqual({+ metadataName: 'viewFilter',+ universalIdentifier: 'deeply-nested-view-filter',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter with a value nested deeper than 8 levels',+ });+ });++ it('should refuse a view field, a view filter and a view sort on a field that does not exist', () => {+ const { views, viewFields, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST })],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'dangling-view-field',+ fieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewFilters: [+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'dangling-view-filter',+ fieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ viewSorts: [+ buildFlatViewSort({+ viewSortManifest: {+ ...NAME_SORT_MANIFEST,+ universalIdentifier: 'dangling-view-sort',+ fieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views).toEqual([ALL_PETS_VIEW_MANIFEST]);+ expect(viewFields).toEqual([]);+ expect(statusOf(coverage, 'dangling-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'dangling-view-field',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view field on a field that does not exist',+ });+ expect(statusOf(coverage, 'dangling-view-filter')).toEqual({+ metadataName: 'viewFilter',+ universalIdentifier: 'dangling-view-filter',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view filter on a field that does not exist',+ });+ expect(statusOf(coverage, 'dangling-view-sort')).toEqual({+ metadataName: 'viewSort',+ universalIdentifier: 'dangling-view-sort',+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: 'view sort on a field that does not exist',+ });+ });++ it('should disclose deactivation and workspace overrides on exported rows without applying them', () => {+ const { views, coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views: [+ buildFlatView({+ viewManifest: ALL_PETS_VIEW_MANIFEST,+ isActive: false,+ }),+ buildFlatView({+ viewManifest: ZOO_PETS_VIEW_MANIFEST,+ overrides: { name: 'Zoo animals' },+ }),+ ],+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: NAME_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ overrides: { isVisible: false },+ }),+ buildFlatViewField({+ viewFieldManifest: AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(views.map(({ name }) => name)).toEqual(['Zoo pets', 'All pets']);+ expect(views[1].fields).toEqual([+ AGE_VIEW_FIELD_MANIFEST,+ NAME_VIEW_FIELD_MANIFEST,+ ]);+ expect(statusOf(coverage, ALL_PETS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: ALL_PETS_VIEW_UID,+ status: ApplicationExportCoverageStatus.EXPORTED,+ reason: 'deactivated in this workspace, exported active',+ });+ expect(statusOf(coverage, ZOO_PETS_VIEW_UID)).toEqual({+ metadataName: 'view',+ universalIdentifier: ZOO_PETS_VIEW_UID,+ status: ApplicationExportCoverageStatus.EXPORTED,+ reason: 'workspace overrides not exported',+ });+ expect(statusOf(coverage, 'name-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'name-view-field',+ status: ApplicationExportCoverageStatus.EXPORTED,+ reason: 'workspace overrides not exported',+ });+ expect(statusOf(coverage, 'age-view-field')).toEqual({+ metadataName: 'viewField',+ universalIdentifier: 'age-view-field',+ status: ApplicationExportCoverageStatus.EXPORTED,+ });+ });++ it('should order standalone view fields by universal identifier', () => {+ const { viewFields } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ viewFields: [+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'a-people-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: PEOPLE_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'b-second-companies-view-field',+ fieldMetadataUniversalIdentifier: AGE_FIELD_UID,+ position: 1,+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'z-tied-companies-view-field',+ fieldMetadataUniversalIdentifier: SPECIES_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'c-tied-companies-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ],+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(+ viewFields.map(({ universalIdentifier }) => universalIdentifier),+ ).toEqual([+ 'a-people-view-field',+ 'b-second-companies-view-field',+ 'c-tied-companies-view-field',+ 'z-tied-companies-view-field',+ ]);+ });++ it('should report exactly one coverage entry per input row', () => {+ const views = [+ buildFlatView({ viewManifest: ALL_PETS_VIEW_MANIFEST }),+ buildFlatView({+ viewManifest: INDEX_VIEW_MANIFEST,+ isSystemSideEffect: true,+ }),+ buildFlatView({+ viewManifest: {+ universalIdentifier: NAMELESS_VIEW_UID,+ name: '',+ objectUniversalIdentifier: PET_UID,+ },+ }),+ ];+ const viewFields = [+ buildFlatViewField({+ viewFieldManifest: NAME_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'engine-name-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ isSystemSideEffect: true,+ }),+ buildFlatViewField({+ viewFieldManifest: CUSTOM_AGE_VIEW_FIELD_MANIFEST,+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'nameless-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: NAMELESS_VIEW_UID,+ }),+ buildFlatViewField({+ viewFieldManifest: {+ universalIdentifier: 'foreign-view-field',+ fieldMetadataUniversalIdentifier: NAME_FIELD_UID,+ position: 0,+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ];+ const viewFieldGroups = [+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: DETAILS_FIELD_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: {+ universalIdentifier: 'engine-view-field-group',+ position: 0,+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ isSystemSideEffect: true,+ }),+ buildFlatViewFieldGroup({+ viewFieldGroupManifest: {+ universalIdentifier: 'nameless-view-field-group',+ position: 0,+ },+ viewUniversalIdentifier: NAMELESS_VIEW_UID,+ }),+ ];+ const viewFilterGroups = [+ buildFlatViewFilterGroup({+ viewFilterGroupManifest: ROOT_FILTER_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewFilterGroup({+ viewFilterGroupManifest: {+ ...ROOT_FILTER_GROUP_MANIFEST,+ universalIdentifier: 'foreign-view-filter-group',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ ];+ const viewGroups = [+ buildFlatViewGroup({+ viewGroupManifest: DOG_GROUP_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewGroup({+ viewGroupManifest: {+ ...DOG_GROUP_MANIFEST,+ universalIdentifier: 'engine-view-group',+ },+ viewUniversalIdentifier: INDEX_VIEW_UID,+ }),+ ];+ const viewFilters = [+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'foreign-view-filter',+ },+ viewUniversalIdentifier: COMPANIES_VIEW_UID,+ }),+ buildFlatViewFilter({+ viewFilterManifest: {+ ...NAME_FILTER_MANIFEST,+ universalIdentifier: 'dangling-view-filter',+ fieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ];+ const viewSorts = [+ buildFlatViewSort({+ viewSortManifest: NAME_SORT_MANIFEST,+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ buildFlatViewSort({+ viewSortManifest: {+ ...NAME_SORT_MANIFEST,+ universalIdentifier: 'dangling-view-sort',+ fieldMetadataUniversalIdentifier: MISSING_FIELD_UID,+ },+ viewUniversalIdentifier: ALL_PETS_VIEW_UID,+ }),+ ];+ const rows = [+ ...views,+ ...viewFields,+ ...viewFieldGroups,+ ...viewFilterGroups,+ ...viewGroups,+ ...viewFilters,+ ...viewSorts,+ ];++ const { coverage } = reconstructViewsManifest({+ applicationAllFlatEntityMaps: buildMaps({+ objects: [petObject],+ views,+ viewFields,+ viewFieldGroups,+ viewFilterGroups,+ viewGroups,+ viewFilters,+ viewSorts,+ }),+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,+ });++ expect(coverage).toHaveLength(rows.length);+ expect(+ coverage.map(({ universalIdentifier }) => universalIdentifier).sort(),+ ).toEqual(+ rows.map(({ universalIdentifier }) => universalIdentifier).sort(),+ );+ });+});diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util.tsnew file mode 100644index 00000000000..6f4eeeb01d5--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util.ts@@ -0,0 +1,28 @@+import { type AllMetadataName } from 'twenty-shared/metadata';+import { isDefined } from 'twenty-shared/utils';++import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';+import {+ getWorkspaceLocalStateReason,+ type WorkspaceLocalStateProperties,+} from 'src/engine/core-modules/application/application-manifest/utils/get-workspace-local-state-reason.util';+import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';++export const buildExportedCoverageEntry = ({+ metadataName,+ flatEntity,+}: {+ metadataName: AllMetadataName;+ flatEntity: {+ universalIdentifier: string;+ } & Partial<WorkspaceLocalStateProperties>;+}): ApplicationExportCoverageEntry => {+ const reason = getWorkspaceLocalStateReason(flatEntity);++ return {+ metadataName,+ universalIdentifier: flatEntity.universalIdentifier,+ status: ApplicationExportCoverageStatus.EXPORTED,+ ...(isDefined(reason) ? { reason } : {}),+ };+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/compare-by-universal-identifier.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/compare-by-universal-identifier.util.tsnew file mode 100644index 00000000000..90f31e1d73e--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/compare-by-universal-identifier.util.ts@@ -0,0 +1,7 @@+import { compareByCodePoint } from 'src/engine/core-modules/application/application-manifest/utils/compare-by-code-point.util';++export const compareByUniversalIdentifier = (+ left: { universalIdentifier: string },+ right: { universalIdentifier: string },+): number =>+ compareByCodePoint(left.universalIdentifier, right.universalIdentifier);diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/create-view-child-decider.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/create-view-child-decider.util.tsnew file mode 100644index 00000000000..cf5cbcfd1f7--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/create-view-child-decider.util.ts@@ -0,0 +1,87 @@+import { isDefined } from 'twenty-shared/utils';++import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';+import {+ type ParentViewStatus,+ type ViewChildMetadataName,+} from 'src/engine/core-modules/application/application-manifest/types/view-export-classification.type';+import { buildExportedCoverageEntry } from 'src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util';+import { getParentViewReason } from 'src/engine/core-modules/application/application-manifest/utils/get-parent-view-reason.util';+import { type WorkspaceLocalStateProperties } from 'src/engine/core-modules/application/application-manifest/utils/get-workspace-local-state-reason.util';+import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';++type FlatViewChild = {+ universalIdentifier: string;+ viewUniversalIdentifier: string;+} & Partial<WorkspaceLocalStateProperties>;++export type ViewChildDecision = 'nested' | 'standalone';++export const createViewChildDecider =+ ({+ coverage,+ parentViewStatusByUniversalIdentifier,+ }: {+ coverage: ApplicationExportCoverageEntry[];+ parentViewStatusByUniversalIdentifier: ReadonlyMap<+ string,+ ParentViewStatus+ >;+ }) =>+ ({+ metadataName,+ flatEntity,+ isEngineDerived = false,+ unsupportedReason,+ canStandAlone = false,+ }: {+ metadataName: ViewChildMetadataName;+ flatEntity: FlatViewChild;+ isEngineDerived?: boolean;+ unsupportedReason?: string;+ canStandAlone?: boolean;+ }): ViewChildDecision | undefined => {+ if (isEngineDerived) {+ coverage.push({+ metadataName,+ universalIdentifier: flatEntity.universalIdentifier,+ status: ApplicationExportCoverageStatus.ENGINE_DERIVED,+ });++ return undefined;+ }++ const parentViewStatus =+ parentViewStatusByUniversalIdentifier.get(+ flatEntity.viewUniversalIdentifier,+ ) ?? 'outside';++ if (+ parentViewStatus !== 'exported' &&+ (parentViewStatus === 'unsupported' || !canStandAlone)+ ) {+ coverage.push({+ metadataName,+ universalIdentifier: flatEntity.universalIdentifier,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: getParentViewReason({ metadataName, parentViewStatus }),+ });++ return undefined;+ }++ if (isDefined(unsupportedReason)) {+ coverage.push({+ metadataName,+ universalIdentifier: flatEntity.universalIdentifier,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: unsupportedReason,+ });++ return undefined;+ }++ coverage.push(buildExportedCoverageEntry({ metadataName, flatEntity }));++ return parentViewStatus === 'exported' ? 'nested' : 'standalone';+ };diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.tsindex aa94d2d466c..7a723148df6 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util.ts@@ -35,7 +35,7 @@ const toCandidates = <T extends { universalIdentifier?: string }>(label: getLabel(entity),}));-const MANIFEST_ENTITY_REGISTRY: Record<+export const MANIFEST_ENTITY_REGISTRY: Record<AllMetadataName,ManifestEntityRegistryEntry> = {diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-parent-view-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-parent-view-reason.util.tsnew file mode 100644index 00000000000..0221b39c1e0--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-parent-view-reason.util.ts@@ -0,0 +1,24 @@+import { MANIFEST_ENTITY_REGISTRY } from 'src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util';+import {+ type ParentViewStatus,+ type ViewChildMetadataName,+} from 'src/engine/core-modules/application/application-manifest/types/view-export-classification.type';++export const getParentViewReason = ({+ metadataName,+ parentViewStatus,+}: {+ metadataName: ViewChildMetadataName;+ parentViewStatus: Exclude<ParentViewStatus, 'exported'>;+}): string => {+ const label = MANIFEST_ENTITY_REGISTRY[metadataName].entityKind;++ switch (parentViewStatus) {+ case 'unsupported':+ return `${label} of an unsupported view`;+ case 'engineDerived':+ return `${label} on an engine-derived view`;+ case 'outside':+ return `${label} on a view outside the application`;+ }+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unexported-view-field-group-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unexported-view-field-group-reason.util.tsnew file mode 100644index 00000000000..7e07c36d9bb--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unexported-view-field-group-reason.util.ts@@ -0,0 +1,35 @@+import { isDefined } from 'twenty-shared/utils';++import { type ParentViewStatus } from 'src/engine/core-modules/application/application-manifest/types/view-export-classification.type';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';++export const getUnexportedViewFieldGroupReason = ({+ viewFieldGroupUniversalIdentifier,+ applicationAllFlatEntityMaps,+ parentViewStatusByUniversalIdentifier,+}: {+ viewFieldGroupUniversalIdentifier: string | null;+ applicationAllFlatEntityMaps: AllFlatEntityMaps;+ parentViewStatusByUniversalIdentifier: ReadonlyMap<string, ParentViewStatus>;+}): string | undefined => {+ if (!isDefined(viewFieldGroupUniversalIdentifier)) {+ return undefined;+ }++ const flatViewFieldGroup =+ applicationAllFlatEntityMaps.flatViewFieldGroupMaps.byUniversalIdentifier[+ viewFieldGroupUniversalIdentifier+ ];++ if (+ !isDefined(flatViewFieldGroup) ||+ flatViewFieldGroup.isSystemSideEffect ||+ parentViewStatusByUniversalIdentifier.get(+ flatViewFieldGroup.viewUniversalIdentifier,+ ) === 'exported'+ ) {+ return undefined;+ }++ return 'view field in a view field group that is not exported';+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-field-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-field-reason.util.tsnew file mode 100644index 00000000000..1791de42a5e--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-field-reason.util.ts@@ -0,0 +1,22 @@+import { isDefined } from 'twenty-shared/utils';++import { MANIFEST_ENTITY_REGISTRY } from 'src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util';+import { type ViewChildMetadataName } from 'src/engine/core-modules/application/application-manifest/types/view-export-classification.type';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';++export const getUnresolvableFieldReason = ({+ metadataName,+ fieldMetadataUniversalIdentifier,+ allFlatEntityMaps,+}: {+ metadataName: ViewChildMetadataName;+ fieldMetadataUniversalIdentifier: string;+ allFlatEntityMaps: AllFlatEntityMaps;+}): string | undefined =>+ isDefined(+ allFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[+ fieldMetadataUniversalIdentifier+ ],+ )+ ? undefined+ : `${MANIFEST_ENTITY_REGISTRY[metadataName].entityKind} on a field that does not exist`;diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-filter-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-filter-reason.util.tsnew file mode 100644index 00000000000..ad587e38b9d--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-filter-reason.util.ts@@ -0,0 +1,44 @@+import { isDefined } from 'twenty-shared/utils';++import { getUnresolvableFieldReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-field-reason.util';+import {+ isViewFilterValueNestedTooDeep,+ MAX_VIEW_FILTER_VALUE_DEPTH,+} from 'src/engine/core-modules/application/application-manifest/utils/is-view-filter-value-nested-too-deep.util';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { type FlatViewFilter } from 'src/engine/metadata-modules/flat-view-filter/types/flat-view-filter.type';++export const getUnsupportedViewFilterReason = ({+ flatViewFilter,+ allFlatEntityMaps,+}: {+ flatViewFilter: FlatViewFilter;+ allFlatEntityMaps: AllFlatEntityMaps;+}): string | undefined => {+ if (isViewFilterValueNestedTooDeep(flatViewFilter.value)) {+ return `view filter with a value nested deeper than ${MAX_VIEW_FILTER_VALUE_DEPTH} levels`;+ }++ const unresolvableFieldReason = getUnresolvableFieldReason({+ metadataName: 'viewFilter',+ fieldMetadataUniversalIdentifier:+ flatViewFilter.fieldMetadataUniversalIdentifier,+ allFlatEntityMaps,+ });++ if (isDefined(unresolvableFieldReason)) {+ return unresolvableFieldReason;+ }++ const relationTargetFieldMetadataUniversalIdentifier =+ flatViewFilter.relationTargetFieldMetadataUniversalIdentifier;++ return isDefined(relationTargetFieldMetadataUniversalIdentifier) &&+ !isDefined(+ allFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[+ relationTargetFieldMetadataUniversalIdentifier+ ],+ )+ ? 'view filter on a relation target field that does not exist'+ : undefined;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-reason.util.tsnew file mode 100644index 00000000000..29da17de3ba--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-reason.util.ts@@ -0,0 +1,58 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-shared/utils';++import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';++const VIEW_FIELD_REFERENCE_PROPERTIES = [+ 'mainGroupByFieldMetadataUniversalIdentifier',+ 'kanbanAggregateOperationFieldMetadataUniversalIdentifier',+ 'calendarFieldMetadataUniversalIdentifier',+ 'calendarEndFieldMetadataUniversalIdentifier',+] as const satisfies readonly (keyof FlatView)[];++export const getUnsupportedViewReason = ({+ flatView,+ applicationObjectUniversalIdentifiers,+ exportedObjectUniversalIdentifiers,+ allFlatEntityMaps,+}: {+ flatView: FlatView;+ applicationObjectUniversalIdentifiers: ReadonlySet<string>;+ exportedObjectUniversalIdentifiers: ReadonlySet<string>;+ allFlatEntityMaps: AllFlatEntityMaps;+}): string | undefined => {+ if (!isNonEmptyString(flatView.name)) {+ return 'view without a name';+ }++ const objectUniversalIdentifier = flatView.objectMetadataUniversalIdentifier;++ if (+ applicationObjectUniversalIdentifiers.has(objectUniversalIdentifier) &&+ !exportedObjectUniversalIdentifiers.has(objectUniversalIdentifier)+ ) {+ return 'view on an unsupported object';+ }++ const referencesMissingField = VIEW_FIELD_REFERENCE_PROPERTIES.some(+ (property) => {+ const fieldMetadataUniversalIdentifier = flatView[property];++ return (+ isDefined(fieldMetadataUniversalIdentifier) &&+ !isDefined(+ allFlatEntityMaps.flatFieldMetadataMaps.byUniversalIdentifier[+ fieldMetadataUniversalIdentifier+ ],+ )+ );+ },+ );++ if (referencesMissingField) {+ return 'view referencing a field that does not exist';+ }++ return undefined;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-workspace-local-state-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-workspace-local-state-reason.util.tsnew file mode 100644index 00000000000..449c0873288--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-workspace-local-state-reason.util.ts@@ -0,0 +1,20 @@+import { isDefined, isEmptyObject } from 'twenty-shared/utils';++export type WorkspaceLocalStateProperties = {+ isActive: boolean;+ overrides: object | null;+};++export const getWorkspaceLocalStateReason = ({+ isActive = true,+ overrides = null,+}: Partial<WorkspaceLocalStateProperties>): string | undefined => {+ const reasons = [+ ...(isActive ? [] : ['deactivated in this workspace, exported active']),+ ...(isDefined(overrides) && !isEmptyObject(overrides)+ ? ['workspace overrides not exported']+ : []),+ ];++ return reasons.length > 0 ? reasons.join(', ') : undefined;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/is-view-filter-value-nested-too-deep.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/is-view-filter-value-nested-too-deep.util.tsnew file mode 100644index 00000000000..1241395dd61--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/is-view-filter-value-nested-too-deep.util.ts@@ -0,0 +1,23 @@+import { isDefined } from 'twenty-shared/utils';++export const MAX_VIEW_FILTER_VALUE_DEPTH = 8;++export const isViewFilterValueNestedTooDeep = (value: unknown): boolean => {+ const pending = [{ value, depth: 0 }];++ for (let next = pending.pop(); isDefined(next); next = pending.pop()) {+ if (!isDefined(next.value) || typeof next.value !== 'object') {+ continue;+ }++ if (next.depth >= MAX_VIEW_FILTER_VALUE_DEPTH) {+ return true;+ }++ for (const child of Object.values(next.value)) {+ pending.push({ value: child, depth: next.depth + 1 });+ }+ }++ return false;+};diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-data-model-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-data-model-manifest.util.tsindex 41c5cdb7cb2..7546bd14c63 100644--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-data-model-manifest.util.ts+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-data-model-manifest.util.ts@@ -4,13 +4,14 @@ import {type ObjectFieldManifest,type ObjectManifest,} from 'twenty-shared/application';-import { isDefined, isEmptyObject } from 'twenty-shared/utils';+import { isDefined } from 'twenty-shared/utils';import { fromFlatFieldMetadataToFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-field-metadata-to-field-manifest.util';import { fromFlatIndexMetadataToIndexManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-index-metadata-to-index-manifest.util';import { fromFlatObjectMetadataToObjectManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-object-metadata-to-object-manifest.util';import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';-import { compareByCodePoint } from 'src/engine/core-modules/application/application-manifest/utils/compare-by-code-point.util';+import { buildExportedCoverageEntry } from 'src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util';+import { compareByUniversalIdentifier } from 'src/engine/core-modules/application/application-manifest/utils/compare-by-universal-identifier.util';import { getUnsupportedRelationFieldReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unsupported-relation-field-reason.util';import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';@@ -18,19 +19,6 @@ import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-mimport { type FlatIndexMetadata } from 'src/engine/metadata-modules/flat-index-metadata/types/flat-index-metadata.type';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';-type WorkspaceLocalStateProperties = Pick<- FlatObjectMetadata | FlatFieldMetadata,- 'universalIdentifier' | 'isActive' | 'overrides'->;--const compareByKeyThenUniversalIdentifier =- <TFlatEntity extends { universalIdentifier: string }>(- getKey: (flatEntity: TFlatEntity) => string,- ) =>- (left: TFlatEntity, right: TFlatEntity): number =>- compareByCodePoint(getKey(left), getKey(right)) ||- compareByCodePoint(left.universalIdentifier, right.universalIdentifier);-const toObjectFieldManifest = ({objectUniversalIdentifier: _objectUniversalIdentifier,...objectFieldManifest@@ -48,37 +36,6 @@ const isKeptLabelIdentifierField = ({flatFieldMetadata.universalIdentifier &&!flatFieldMetadata.isSystem;-const getWorkspaceLocalStateReason = ({- isActive,- overrides,-}: WorkspaceLocalStateProperties): string | undefined => {- const reasons = [- ...(isActive ? [] : ['deactivated in this workspace, exported active']),- ...(isDefined(overrides) && !isEmptyObject(overrides)- ? ['workspace overrides not exported']- : []),- ];-- return reasons.length > 0 ? reasons.join(', ') : undefined;-};--const buildExportedCoverageEntry = ({- metadataName,- flatEntity,-}: {- metadataName: 'objectMetadata' | 'fieldMetadata';- flatEntity: WorkspaceLocalStateProperties;-}): ApplicationExportCoverageEntry => {- const reason = getWorkspaceLocalStateReason(flatEntity);-- return {- metadataName,- universalIdentifier: flatEntity.universalIdentifier,- status: ApplicationExportCoverageStatus.EXPORTED,- ...(isDefined(reason) ? { reason } : {}),- };-};-const getUnsupportedIndexReason = ({flatIndexMetadata,applicationObjectUniversalIdentifiers,@@ -137,9 +94,7 @@ export const reconstructDataModelManifest = ({flatObjectMetadataMaps.byUniversalIdentifier,).filter(isDefined)- .sort(- compareByKeyThenUniversalIdentifier(({ nameSingular }) => nameSingular),- );+ .sort(compareByUniversalIdentifier);const exportableObjects = flatObjectMetadatas.flatMap((flatObjectMetadata) => {const labelIdentifierFieldMetadataUniversalIdentifier =@@ -179,7 +134,7 @@ export const reconstructDataModelManifest = ({flatFieldMetadataMaps.byUniversalIdentifier,).filter(isDefined)- .sort(compareByKeyThenUniversalIdentifier(({ name }) => name))) {+ .sort(compareByUniversalIdentifier)) {const flatObjectMetadata =flatObjectMetadataMaps.byUniversalIdentifier[flatFieldMetadata.objectMetadataUniversalIdentifier@@ -280,7 +235,7 @@ export const reconstructDataModelManifest = ({flatIndexMaps.byUniversalIdentifier,).filter(isDefined)- .sort(compareByKeyThenUniversalIdentifier(({ name }) => name))) {+ .sort(compareByUniversalIdentifier)) {if (flatIndexMetadata.isSystemSideEffect) {coverage.push({metadataName: 'index',diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-views-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-views-manifest.util.tsnew file mode 100644index 00000000000..5b9f6865fed--- /dev/null+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-views-manifest.util.ts@@ -0,0 +1,278 @@+import {+ type StandaloneViewFieldManifest,+ type ViewManifest,+} from 'twenty-shared/application';+import { isDefined } from 'twenty-shared/utils';++import { fromFlatViewFieldGroupToViewFieldGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-group-to-view-field-group-manifest.util';+import { fromFlatViewFieldToStandaloneViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-standalone-view-field-manifest.util';+import { fromFlatViewFieldToViewFieldManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-field-to-view-field-manifest.util';+import { fromFlatViewFilterGroupToViewFilterGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-group-to-view-filter-group-manifest.util';+import { fromFlatViewFilterToViewFilterManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-filter-to-view-filter-manifest.util';+import { fromFlatViewGroupToViewGroupManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-group-to-view-group-manifest.util';+import { fromFlatViewSortToViewSortManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-sort-to-view-sort-manifest.util';+import {+ fromFlatViewToViewManifest,+ type ViewChildrenManifests,+} from 'src/engine/core-modules/application/application-manifest/converters/from-flat-view-to-view-manifest.util';+import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';+import { type ParentViewStatus } from 'src/engine/core-modules/application/application-manifest/types/view-export-classification.type';+import { buildExportedCoverageEntry } from 'src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util';+import { compareByUniversalIdentifier } from 'src/engine/core-modules/application/application-manifest/utils/compare-by-universal-identifier.util';+import { createViewChildDecider } from 'src/engine/core-modules/application/application-manifest/utils/create-view-child-decider.util';+import { getUnexportedViewFieldGroupReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unexported-view-field-group-reason.util';+import { getUnresolvableFieldReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-field-reason.util';+import { getUnsupportedViewFilterReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-filter-reason.util';+import { getUnsupportedViewReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unsupported-view-reason.util';+import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';+import { type SyncableFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-from.type';+import { type FlatView } from 'src/engine/metadata-modules/flat-view/types/flat-view.type';+import { type UniversalFlatEntityMaps } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-entity-maps.type';++type ViewChildren = Required<ViewChildrenManifests>;++const sortedFlatEntities = <TFlatEntity extends SyncableFlatEntity>(+ flatEntityMaps: UniversalFlatEntityMaps<TFlatEntity>,+): TFlatEntity[] =>+ Object.values(flatEntityMaps.byUniversalIdentifier)+ .filter(isDefined)+ .sort(compareByUniversalIdentifier);++export const reconstructViewsManifest = ({+ applicationAllFlatEntityMaps,+ allFlatEntityMaps,+ exportedObjectUniversalIdentifiers,+}: {+ applicationAllFlatEntityMaps: AllFlatEntityMaps;+ allFlatEntityMaps: AllFlatEntityMaps;+ exportedObjectUniversalIdentifiers: Set<string>;+}): {+ views: ViewManifest[];+ viewFields: StandaloneViewFieldManifest[];+ coverage: ApplicationExportCoverageEntry[];+} => {+ const coverage: ApplicationExportCoverageEntry[] = [];+ const applicationObjectUniversalIdentifiers = new Set(+ Object.values(+ applicationAllFlatEntityMaps.flatObjectMetadataMaps.byUniversalIdentifier,+ )+ .filter(isDefined)+ .map(({ universalIdentifier }) => universalIdentifier),+ );++ const parentViewStatusByUniversalIdentifier = new Map<+ string,+ ParentViewStatus+ >();+ const exportedFlatViews: FlatView[] = [];++ for (const flatView of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewMaps,+ )) {+ if (flatView.isSystemSideEffect) {+ coverage.push({+ metadataName: 'view',+ universalIdentifier: flatView.universalIdentifier,+ status: ApplicationExportCoverageStatus.ENGINE_DERIVED,+ });+ parentViewStatusByUniversalIdentifier.set(+ flatView.universalIdentifier,+ 'engineDerived',+ );+ continue;+ }++ const unsupportedReason = getUnsupportedViewReason({+ flatView,+ applicationObjectUniversalIdentifiers,+ exportedObjectUniversalIdentifiers,+ allFlatEntityMaps,+ });++ if (isDefined(unsupportedReason)) {+ coverage.push({+ metadataName: 'view',+ universalIdentifier: flatView.universalIdentifier,+ status: ApplicationExportCoverageStatus.UNSUPPORTED,+ reason: unsupportedReason,+ });+ parentViewStatusByUniversalIdentifier.set(+ flatView.universalIdentifier,+ 'unsupported',+ );+ continue;+ }++ exportedFlatViews.push(flatView);+ parentViewStatusByUniversalIdentifier.set(+ flatView.universalIdentifier,+ 'exported',+ );+ }++ const childrenByViewUniversalIdentifier = new Map<string, ViewChildren>(+ exportedFlatViews.map(({ universalIdentifier }) => [+ universalIdentifier,+ {+ fields: [],+ filters: [],+ filterGroups: [],+ groups: [],+ fieldGroups: [],+ sorts: [],+ },+ ]),+ );+ const viewFields: StandaloneViewFieldManifest[] = [];+ const decideViewChild = createViewChildDecider({+ coverage,+ parentViewStatusByUniversalIdentifier,+ });+ const childrenOf = (+ viewUniversalIdentifier: string,+ ): ViewChildren | undefined =>+ childrenByViewUniversalIdentifier.get(viewUniversalIdentifier);++ for (const flatViewField of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewFieldMaps,+ )) {+ const decision = decideViewChild({+ metadataName: 'viewField',+ flatEntity: flatViewField,+ isEngineDerived: flatViewField.isSystemSideEffect,+ unsupportedReason:+ getUnexportedViewFieldGroupReason({+ viewFieldGroupUniversalIdentifier:+ flatViewField.viewFieldGroupUniversalIdentifier,+ applicationAllFlatEntityMaps,+ parentViewStatusByUniversalIdentifier,+ }) ??+ getUnresolvableFieldReason({+ metadataName: 'viewField',+ fieldMetadataUniversalIdentifier:+ flatViewField.fieldMetadataUniversalIdentifier,+ allFlatEntityMaps,+ }),+ canStandAlone: true,+ });++ if (decision === 'nested') {+ childrenOf(flatViewField.viewUniversalIdentifier)?.fields.push(+ fromFlatViewFieldToViewFieldManifest({ flatViewField }),+ );+ } else if (decision === 'standalone') {+ viewFields.push(+ fromFlatViewFieldToStandaloneViewFieldManifest({ flatViewField }),+ );+ }+ }++ for (const flatViewFieldGroup of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewFieldGroupMaps,+ )) {+ if (+ decideViewChild({+ metadataName: 'viewFieldGroup',+ flatEntity: flatViewFieldGroup,+ isEngineDerived: flatViewFieldGroup.isSystemSideEffect,+ }) === 'nested'+ ) {+ childrenOf(flatViewFieldGroup.viewUniversalIdentifier)?.fieldGroups.push(+ fromFlatViewFieldGroupToViewFieldGroupManifest({ flatViewFieldGroup }),+ );+ }+ }++ for (const flatViewFilterGroup of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewFilterGroupMaps,+ )) {+ if (+ decideViewChild({+ metadataName: 'viewFilterGroup',+ flatEntity: flatViewFilterGroup,+ }) === 'nested'+ ) {+ childrenOf(+ flatViewFilterGroup.viewUniversalIdentifier,+ )?.filterGroups.push(+ fromFlatViewFilterGroupToViewFilterGroupManifest({+ flatViewFilterGroup,+ }),+ );+ }+ }++ for (const flatViewFilter of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewFilterMaps,+ )) {+ if (+ decideViewChild({+ metadataName: 'viewFilter',+ flatEntity: flatViewFilter,+ unsupportedReason: getUnsupportedViewFilterReason({+ flatViewFilter,+ allFlatEntityMaps,+ }),+ }) === 'nested'+ ) {+ childrenOf(flatViewFilter.viewUniversalIdentifier)?.filters.push(+ fromFlatViewFilterToViewFilterManifest({ flatViewFilter }),+ );+ }+ }++ for (const flatViewGroup of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewGroupMaps,+ )) {+ if (+ decideViewChild({+ metadataName: 'viewGroup',+ flatEntity: flatViewGroup,+ }) === 'nested'+ ) {+ childrenOf(flatViewGroup.viewUniversalIdentifier)?.groups.push(+ fromFlatViewGroupToViewGroupManifest({ flatViewGroup }),+ );+ }+ }++ for (const flatViewSort of sortedFlatEntities(+ applicationAllFlatEntityMaps.flatViewSortMaps,+ )) {+ if (+ decideViewChild({+ metadataName: 'viewSort',+ flatEntity: flatViewSort,+ unsupportedReason: getUnresolvableFieldReason({+ metadataName: 'viewSort',+ fieldMetadataUniversalIdentifier:+ flatViewSort.fieldMetadataUniversalIdentifier,+ allFlatEntityMaps,+ }),+ }) === 'nested'+ ) {+ childrenOf(flatViewSort.viewUniversalIdentifier)?.sorts.push(+ fromFlatViewSortToViewSortManifest({ flatViewSort }),+ );+ }+ }++ const views = exportedFlatViews.map((flatView) => {+ coverage.push(+ buildExportedCoverageEntry({+ metadataName: 'view',+ flatEntity: flatView,+ }),+ );++ return fromFlatViewToViewManifest({+ flatView,+ children: childrenOf(flatView.universalIdentifier),+ });+ });++ viewFields.sort(compareByUniversalIdentifier);++ return { views, viewFields, coverage };+};diff --git a/packages/twenty-server/test/integration/metadata/suites/application/__snapshots__/successful-export-application-data-model.integration-spec.ts.snap b/packages/twenty-server/test/integration/metadata/suites/application/__snapshots__/successful-export-application-data-model.integration-spec.ts.snapindex 2b9e70b9915..edc7f500525 100644--- a/packages/twenty-server/test/integration/metadata/suites/application/__snapshots__/successful-export-application-data-model.integration-spec.ts.snap+++ b/packages/twenty-server/test/integration/metadata/suites/application/__snapshots__/successful-export-application-data-model.integration-spec.ts.snap@@ -430,6 +430,12 @@ exports[`Application export - data model exports the whole application as a stab"status": "UNSUPPORTED","universalIdentifier": "<TEST_ROLE>",},+ {+ "metadataName": "view",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_VIEW>",+ },{"metadataName": "view","reason": null,@@ -454,6 +460,18 @@ exports[`Application export - data model exports the whole application as a stab"status": "ENGINE_DERIVED","universalIdentifier": "<TICKET_INDEX_ENGINE_VIEW>",},+ {+ "metadataName": "viewField",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_PROJECT_VIEW_FIELD>",+ },+ {+ "metadataName": "viewField",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_TITLE_VIEW_FIELD>",+ },{"metadataName": "viewField","reason": null,@@ -484,6 +502,12 @@ exports[`Application export - data model exports the whole application as a stab"status": "ENGINE_DERIVED","universalIdentifier": "<PROJECT_FIELDS_WIDGET_ENGINE_VIEW_FIELD_updatedBy>",},+ {+ "metadataName": "viewField",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<PROJECT_INDEX_DELETED_AT_VIEW_FIELD>",+ },{"metadataName": "viewField","reason": null,@@ -610,6 +634,36 @@ exports[`Application export - data model exports the whole application as a stab"status": "ENGINE_DERIVED","universalIdentifier": "<TICKET_INDEX_ENGINE_VIEW_FIELD_updatedBy>",},+ {+ "metadataName": "viewFieldGroup",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_TRIAGE_FIELD_GROUP>",+ },+ {+ "metadataName": "viewFilter",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_TITLE_FILTER>",+ },+ {+ "metadataName": "viewFilterGroup",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_NOT_FILTER_GROUP>",+ },+ {+ "metadataName": "viewGroup",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_OPEN_GROUP>",+ },+ {+ "metadataName": "viewSort",+ "reason": null,+ "status": "EXPORTED",+ "universalIdentifier": "<OPEN_TICKETS_TITLE_SORT>",+ },],"randomlyIdentifiedByKindAndStatus": {"index ENGINE_DERIVED": 8,@@ -666,49 +720,24 @@ exports[`Application export - data model exports the whole application as a stab"navigationMenuItems": [],"objects": [{- "color": null,- "description": "A project",+ "color": "blue",+ "description": "A ticket","fields": [{"defaultValue": null,- "isLabelSyncedWithName": false,+ "isLabelSyncedWithName": true,"isNullable": true,"isSearchable": false,"isUIEditable": true,"isUnique": false,- "label": "Tickets",- "name": "tickets",+ "label": "Title",+ "name": "title","options": null,- "relationTargetFieldMetadataUniversalIdentifier": "<TICKET_PROJECT_FIELD>",- "relationTargetObjectMetadataUniversalIdentifier": "<TICKET_OBJECT>",- "type": "RELATION",- "universalIdentifier": "<PROJECT_TICKETS_FIELD>",- "universalSettings": {- "relationType": "ONE_TO_MANY",- },+ "type": "TEXT",+ "universalIdentifier": "<TICKET_TITLE_FIELD>",+ "universalSettings": null,"writability": "OPEN",},- ],- "icon": "IconTicket",- "imageIdentifierFieldMetadataUniversalIdentifier": null,- "isLabelSyncedWithName": false,- "isSearchable": true,- "isUICreatable": true,- "isUIEditable": true,- "labelIdentifierFieldMetadataUniversalIdentifier": "<PROJECT_id_ENGINE_FIELD>",- "labelPlural": "Export Projects",- "labelSingular": "Export Project",- "namePlural": "exportProjects",- "nameSingular": "exportProject",- "openRecordIn": "USER_CHOICE",- "readability": "OPEN",- "universalIdentifier": "<PROJECT_OBJECT>",- "writability": "OPEN",- },- {- "color": "blue",- "description": "A ticket",- "fields": [{"defaultValue": null,"isLabelSyncedWithName": false,@@ -730,36 +759,61 @@ exports[`Application export - data model exports the whole application as a stab},"writability": "OPEN",},+ ],+ "icon": "IconTicket",+ "imageIdentifierFieldMetadataUniversalIdentifier": null,+ "isLabelSyncedWithName": true,+ "isSearchable": true,+ "isUICreatable": true,+ "isUIEditable": true,+ "labelIdentifierFieldMetadataUniversalIdentifier": "<TICKET_id_ENGINE_FIELD>",+ "labelPlural": "Export Tickets",+ "labelSingular": "Export Ticket",+ "namePlural": "exportTickets",+ "nameSingular": "exportTicket",+ "openRecordIn": "USER_CHOICE",+ "readability": "OPEN",+ "universalIdentifier": "<TICKET_OBJECT>",+ "writability": "OPEN",+ },+ {+ "color": null,+ "description": "A project",+ "fields": [{"defaultValue": null,- "isLabelSyncedWithName": true,+ "isLabelSyncedWithName": false,"isNullable": true,"isSearchable": false,"isUIEditable": true,"isUnique": false,- "label": "Title",- "name": "title",+ "label": "Tickets",+ "name": "tickets","options": null,- "type": "TEXT",- "universalIdentifier": "<TICKET_TITLE_FIELD>",- "universalSettings": null,+ "relationTargetFieldMetadataUniversalIdentifier": "<TICKET_PROJECT_FIELD>",+ "relationTargetObjectMetadataUniversalIdentifier": "<TICKET_OBJECT>",+ "type": "RELATION",+ "universalIdentifier": "<PROJECT_TICKETS_FIELD>",+ "universalSettings": {+ "relationType": "ONE_TO_MANY",+ },"writability": "OPEN",},],"icon": "IconTicket","imageIdentifierFieldMetadataUniversalIdentifier": null,- "isLabelSyncedWithName": true,+ "isLabelSyncedWithName": false,"isSearchable": true,"isUICreatable": true,"isUIEditable": true,- "labelIdentifierFieldMetadataUniversalIdentifier": "<TICKET_id_ENGINE_FIELD>",- "labelPlural": "Export Tickets",- "labelSingular": "Export Ticket",- "namePlural": "exportTickets",- "nameSingular": "exportTicket",+ "labelIdentifierFieldMetadataUniversalIdentifier": "<PROJECT_id_ENGINE_FIELD>",+ "labelPlural": "Export Projects",+ "labelSingular": "Export Project",+ "namePlural": "exportProjects",+ "nameSingular": "exportProject","openRecordIn": "USER_CHOICE","readability": "OPEN",- "universalIdentifier": "<TICKET_OBJECT>",+ "universalIdentifier": "<PROJECT_OBJECT>","writability": "OPEN",},],@@ -776,7 +830,86 @@ exports[`Application export - data model exports the whole application as a stab"export.ticket.title": "Titre du ticket",},},- "viewFields": [],- "views": [],+ "viewFields": [+ {+ "fieldMetadataUniversalIdentifier": "<PROJECT_deletedAt_ENGINE_FIELD>",+ "isVisible": true,+ "position": 10,+ "size": 180,+ "universalIdentifier": "<PROJECT_INDEX_DELETED_AT_VIEW_FIELD>",+ "viewUniversalIdentifier": "<PROJECT_INDEX_ENGINE_VIEW>",+ },+ ],+ "views": [+ {+ "anyFieldFilterValue": "urgent",+ "fieldGroups": [+ {+ "isVisible": true,+ "name": "Triage",+ "position": 0,+ "universalIdentifier": "<OPEN_TICKETS_TRIAGE_FIELD_GROUP>",+ },+ ],+ "fields": [+ {+ "aggregateOperation": "COUNT",+ "fieldMetadataUniversalIdentifier": "<TICKET_TITLE_FIELD>",+ "isVisible": true,+ "position": 0,+ "size": 240,+ "universalIdentifier": "<OPEN_TICKETS_TITLE_VIEW_FIELD>",+ },+ {+ "fieldMetadataUniversalIdentifier": "<TICKET_PROJECT_FIELD>",+ "isVisible": false,+ "position": 1,+ "size": 0,+ "universalIdentifier": "<OPEN_TICKETS_PROJECT_VIEW_FIELD>",+ },+ ],+ "filterGroups": [+ {+ "logicalOperator": "NOT",+ "universalIdentifier": "<OPEN_TICKETS_NOT_FILTER_GROUP>",+ },+ ],+ "filters": [+ {+ "fieldMetadataUniversalIdentifier": "<TICKET_TITLE_FIELD>",+ "operand": "CONTAINS",+ "positionInViewFilterGroup": 0,+ "universalIdentifier": "<OPEN_TICKETS_TITLE_FILTER>",+ "value": "bug",+ "viewFilterGroupUniversalIdentifier": "<OPEN_TICKETS_NOT_FILTER_GROUP>",+ },+ ],+ "groups": [+ {+ "fieldValue": "open",+ "isVisible": true,+ "position": 0,+ "universalIdentifier": "<OPEN_TICKETS_OPEN_GROUP>",+ },+ ],+ "icon": "IconTicket",+ "isCompact": true,+ "name": "Open tickets",+ "objectUniversalIdentifier": "<TICKET_OBJECT>",+ "openRecordIn": "SIDE_PANEL",+ "position": 1,+ "shouldHideEmptyGroups": false,+ "sorts": [+ {+ "direction": "DESC",+ "fieldMetadataUniversalIdentifier": "<TICKET_TITLE_FIELD>",+ "universalIdentifier": "<OPEN_TICKETS_TITLE_SORT>",+ },+ ],+ "type": "TABLE",+ "universalIdentifier": "<OPEN_TICKETS_VIEW>",+ "visibility": "WORKSPACE",+ },+ ],}`;diff --git a/packages/twenty-server/test/integration/metadata/suites/application/successful-export-application-data-model.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application/successful-export-application-data-model.integration-spec.tsindex 6e75f793956..fea1af9fe30 100644--- a/packages/twenty-server/test/integration/metadata/suites/application/successful-export-application-data-model.integration-spec.ts+++ b/packages/twenty-server/test/integration/metadata/suites/application/successful-export-application-data-model.integration-spec.ts@@ -5,6 +5,12 @@ import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/import { exportApplication } from 'test/integration/metadata/suites/application/utils/export-application.util';import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';+import { createOneViewFilter } from 'test/integration/metadata/suites/view-filter/utils/create-one-view-filter.util';+import { destroyOneViewFilter } from 'test/integration/metadata/suites/view-filter/utils/destroy-one-view-filter.util';+import { createOneView } from 'test/integration/metadata/suites/view/utils/create-one-view.util';+import { destroyOneView } from 'test/integration/metadata/suites/view/utils/destroy-one-view.util';+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';import {type FieldManifest,getFieldUniversalIdentifier,@@ -18,15 +24,22 @@ import {getSystemViewFieldUniversalIdentifier,getSystemViewUniversalIdentifier,type ObjectManifest,+ type StandaloneViewFieldManifest,SYSTEM_VIEW_KEYS,type TranslationsManifest,TWENTY_STANDARD_APPLICATION_UNIVERSAL_IDENTIFIER,+ type ViewManifest,} from 'twenty-shared/application';import { STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS } from 'twenty-shared/metadata';import {+ AggregateOperations,FieldMetadataType,RelationOnDeleteAction,RelationType,+ ViewFilterGroupLogicalOperator,+ ViewFilterOperand,+ ViewSortDirection,+ ViewType,} from 'twenty-shared/types';import { isDefined } from 'twenty-shared/utils';import { version as getUuidVersion } from 'uuid';@@ -47,6 +60,15 @@ const PROJECT_TICKETS_FIELD_ID = '7e3d1c2b-0006-4a7b-8c9d-0e1f2a3b4c5d';const COMPANY_TAGLINE_FIELD_ID = '7e3d1c2b-0007-4a7b-8c9d-0e1f2a3b4c5d';const INDEX_ID = '7e3d1c2b-0008-4a7b-8c9d-0e1f2a3b4c5d';const INDEX_FIELD_ID = '7e3d1c2b-0009-4a7b-8c9d-0e1f2a3b4c5d';+const OPEN_TICKETS_VIEW_ID = '7e3d1c2b-0010-4a7b-8c9d-0e1f2a3b4c5d';+const TITLE_VIEW_FIELD_ID = '7e3d1c2b-0011-4a7b-8c9d-0e1f2a3b4c5d';+const PROJECT_VIEW_FIELD_ID = '7e3d1c2b-0012-4a7b-8c9d-0e1f2a3b4c5d';+const VIEW_FIELD_GROUP_ID = '7e3d1c2b-0013-4a7b-8c9d-0e1f2a3b4c5d';+const VIEW_FILTER_GROUP_ID = '7e3d1c2b-0014-4a7b-8c9d-0e1f2a3b4c5d';+const VIEW_FILTER_ID = '7e3d1c2b-0015-4a7b-8c9d-0e1f2a3b4c5d';+const VIEW_SORT_ID = '7e3d1c2b-0016-4a7b-8c9d-0e1f2a3b4c5d';+const VIEW_GROUP_ID = '7e3d1c2b-0017-4a7b-8c9d-0e1f2a3b4c5d';+const PROJECT_INDEX_VIEW_FIELD_ID = '7e3d1c2b-0018-4a7b-8c9d-0e1f2a3b4c5d';const ENGINE_DERIVED_FIELD_NAMES = ['id',@@ -94,6 +116,15 @@ const buildIdentifierNames = (): Map<string, string> => {[PROJECT_TICKETS_FIELD_ID, 'PROJECT_TICKETS_FIELD'],[COMPANY_TAGLINE_FIELD_ID, 'COMPANY_TAGLINE_FIELD'],[INDEX_ID, 'TICKET_TITLE_INDEX'],+ [OPEN_TICKETS_VIEW_ID, 'OPEN_TICKETS_VIEW'],+ [TITLE_VIEW_FIELD_ID, 'OPEN_TICKETS_TITLE_VIEW_FIELD'],+ [PROJECT_VIEW_FIELD_ID, 'OPEN_TICKETS_PROJECT_VIEW_FIELD'],+ [VIEW_FIELD_GROUP_ID, 'OPEN_TICKETS_TRIAGE_FIELD_GROUP'],+ [VIEW_FILTER_GROUP_ID, 'OPEN_TICKETS_NOT_FILTER_GROUP'],+ [VIEW_FILTER_ID, 'OPEN_TICKETS_TITLE_FILTER'],+ [VIEW_SORT_ID, 'OPEN_TICKETS_TITLE_SORT'],+ [VIEW_GROUP_ID, 'OPEN_TICKETS_OPEN_GROUP'],+ [PROJECT_INDEX_VIEW_FIELD_ID, 'PROJECT_INDEX_DELETED_AT_VIEW_FIELD'],[getIndexFieldUniversalIdentifier({applicationUniversalIdentifier: TEST_APP_ID,@@ -416,6 +447,88 @@ const FIXTURE_TRANSLATIONS: TranslationsManifest = {},};+const openTicketsView: ViewManifest = {+ universalIdentifier: OPEN_TICKETS_VIEW_ID,+ name: 'Open tickets',+ objectUniversalIdentifier: ticketObject.universalIdentifier,+ type: ViewType.TABLE,+ icon: 'IconTicket',+ position: 1,+ isCompact: true,+ anyFieldFilterValue: 'urgent',+ fields: [+ {+ universalIdentifier: TITLE_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: TICKET_TITLE_FIELD_ID,+ position: 0,+ size: 240,+ aggregateOperation: AggregateOperations.COUNT,+ },+ {+ universalIdentifier: PROJECT_VIEW_FIELD_ID,+ fieldMetadataUniversalIdentifier: TICKET_PROJECT_FIELD_ID,+ position: 1,+ isVisible: false,+ },+ ],+ fieldGroups: [+ {+ universalIdentifier: VIEW_FIELD_GROUP_ID,+ name: 'Triage',+ position: 0,+ },+ ],+ filterGroups: [+ {+ universalIdentifier: VIEW_FILTER_GROUP_ID,+ logicalOperator: ViewFilterGroupLogicalOperator.NOT,+ },+ ],+ filters: [+ {+ universalIdentifier: VIEW_FILTER_ID,+ fieldMetadataUniversalIdentifier: TICKET_TITLE_FIELD_ID,+ operand: ViewFilterOperand.CONTAINS,+ value: 'bug',+ viewFilterGroupUniversalIdentifier: VIEW_FILTER_GROUP_ID,+ positionInViewFilterGroup: 0,+ },+ ],+ sorts: [+ {+ universalIdentifier: VIEW_SORT_ID,+ fieldMetadataUniversalIdentifier: TICKET_TITLE_FIELD_ID,+ direction: ViewSortDirection.DESC,+ },+ ],+ groups: [+ {+ universalIdentifier: VIEW_GROUP_ID,+ fieldValue: 'open',+ position: 0,+ },+ ],+};++const PROJECT_INDEX_VIEW_ID = getSystemViewUniversalIdentifier({+ objectMetadataApplicationUniversalIdentifier: TEST_APP_ID,+ objectUniversalIdentifier: PROJECT_OBJECT_ID,+ viewKey: SYSTEM_VIEW_KEYS.INDEX,+});++const projectIndexViewField: StandaloneViewFieldManifest = {+ universalIdentifier: PROJECT_INDEX_VIEW_FIELD_ID,+ viewUniversalIdentifier: PROJECT_INDEX_VIEW_ID,+ fieldMetadataUniversalIdentifier: getFieldUniversalIdentifier({+ applicationUniversalIdentifier: TEST_APP_ID,+ objectUniversalIdentifier: PROJECT_OBJECT_ID,+ name: 'deletedAt',+ }),+ position: 10,+ isVisible: true,+ size: 180,+};+const manifest = buildBaseManifest({appId: TEST_APP_ID,roleId: TEST_ROLE_ID,@@ -435,6 +548,8 @@ const manifest = buildBaseManifest({],},],+ views: [openTicketsView],+ viewFields: [projectIndexViewField],},});@@ -574,6 +689,12 @@ describe('Application export - data model', () => {}),),).toBe(ApplicationExportCoverageStatus.ENGINE_DERIVED);+ expect(statusOf(PROJECT_INDEX_VIEW_ID)).toBe(+ ApplicationExportCoverageStatus.ENGINE_DERIVED,+ );+ expect(statusOf(PROJECT_INDEX_VIEW_FIELD_ID)).toBe(+ ApplicationExportCoverageStatus.EXPORTED,+ );}, 60000);it('round-trips the raw export through an additive dry-run sync without any action', async () => {@@ -631,4 +752,101 @@ describe('Application export - data model', () => {expect(dryRun.errors).toBeUndefined();expect(dryRun.data.syncApplication.actions).toEqual([]);}, 60000);++ it('should round-trip a view with a filter created through the metadata API in the workspace Custom application without any action', async () => {+ const { objects } = await findManyObjectMetadata({+ expectToFail: false,+ input: { filter: {}, paging: { first: 1000 } },+ gqlFields: `+ id+ nameSingular+ fieldsList {+ id+ name+ }+ `,+ });+ const personObject = objects.find(+ ({ nameSingular }) => nameSingular === 'person',+ );++ jestExpectToBeDefined(personObject);++ const personJobTitleField = personObject.fieldsList?.find(+ ({ name }) => name === 'jobTitle',+ );++ jestExpectToBeDefined(personJobTitleField);++ const { data: applicationsData } = await findManyApplications({+ expectToFail: false,+ });+ const customApplication = applicationsData.findManyApplications.find(+ ({ name }) => name === WORKSPACE_CUSTOM_APPLICATION_NAME,+ );++ jestExpectToBeDefined(customApplication);++ const { data: createdViewData } = await createOneView({+ expectToFail: false,+ input: {+ name: 'Export Custom Application People',+ objectMetadataId: personObject.id,+ type: ViewType.TABLE,+ icon: 'IconUser',+ },+ });+ const createdViewId = createdViewData.createView.id;++ try {+ const { data: createdViewFilterData } = await createOneViewFilter({+ expectToFail: false,+ input: {+ viewId: createdViewId,+ fieldMetadataId: personJobTitleField.id,+ operand: ViewFilterOperand.CONTAINS,+ value: 'Engineer',+ },+ });+ const createdViewFilterId = createdViewFilterData.createViewFilter.id;++ try {+ const { data } = await exportApplication({+ universalIdentifier: customApplication.universalIdentifier,+ expectToFail: false,+ });++ expect(data.exportApplication.manifest.views).toContainEqual(+ expect.objectContaining({+ name: 'Export Custom Application People',+ objectUniversalIdentifier:+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.person,+ filters: [+ expect.objectContaining({+ operand: ViewFilterOperand.CONTAINS,+ value: 'Engineer',+ }),+ ],+ }),+ );++ const dryRun = await syncApplication({+ manifest: data.exportApplication.manifest,+ dryRun: true,+ inferDeletionFromMissingEntities: false,+ expectToFail: false,+ });++ expect(dryRun.errors).toBeUndefined();+ expect(dryRun.data.syncApplication.actions).toEqual([]);+ } finally {+ await destroyOneViewFilter({+ expectToFail: false,+ input: { id: createdViewFilterId },+ });+ }+ } finally {+ await destroyOneView({ expectToFail: false, viewId: createdViewId });+ }+ }, 60000);});diff --git a/packages/twenty-shared/src/application/viewManifestType.ts b/packages/twenty-shared/src/application/viewManifestType.tsindex adb9c0ce76e..22f822b4726 100644--- a/packages/twenty-shared/src/application/viewManifestType.ts+++ b/packages/twenty-shared/src/application/viewManifestType.ts@@ -36,6 +36,7 @@ export type ViewFilterManifest = SyncableEntityOptions & {operand: ViewFilterOperand;value: ViewManifestFilterValue;subFieldName?: string;+ relationTargetFieldMetadataUniversalIdentifier?: string;viewFilterGroupUniversalIdentifier?: string;positionInViewFilterGroup?: number;};