Skip to content

The open alternative to Salesforce, designed for AI.

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.mdx
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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/appli
import { 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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-m
import { 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.ts
new file mode 100644
index 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.snap
index 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.ts
index 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.ts
index 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;
};