Skip to content

The open alternative to Salesforce, designed for AI.

Export an application's navigation menu items (#25687)

Weikoea401a1d3d40
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.spec.ts
new file mode 100644
index 00000000000..e460f40a45a
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.spec.ts
@@ -0,0 +1,93 @@
+import { type NavigationMenuItemManifest } from 'twenty-shared/application';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+
+import { fromFlatNavigationMenuItemToNavigationMenuItemManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util';
+import { fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem } from 'src/engine/core-modules/application/application-manifest/converters/from-navigation-menu-item-manifest-to-universal-flat-navigation-menu-item.util';
+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 NAVIGATION_MENU_ITEM_UID = '22222222-2222-4222-8222-222222222222';
+const FOLDER_UID = '33333333-3333-4333-8333-333333333333';
+const OBJECT_UID = '44444444-4444-4444-8444-444444444444';
+const VIEW_UID = '55555555-5555-4555-8555-555555555555';
+const PAGE_LAYOUT_UID = '66666666-6666-4666-8666-666666666666';
+const NOW = '2026-09-09T10:00:00.000Z';
+
+const NAVIGATION_MENU_ITEM_MANIFEST: Required<NavigationMenuItemManifest> = {
+ universalIdentifier: NAVIGATION_MENU_ITEM_UID,
+ type: NavigationMenuItemType.VIEW,
+ name: 'All pets',
+ icon: 'IconPaw',
+ color: 'green',
+ position: 12.5,
+ link: 'https://example.com/pets',
+ folderUniversalIdentifier: FOLDER_UID,
+ viewUniversalIdentifier: VIEW_UID,
+ targetObjectUniversalIdentifier: OBJECT_UID,
+ pageLayoutUniversalIdentifier: PAGE_LAYOUT_UID,
+};
+
+const MINIMAL_NAVIGATION_MENU_ITEM_MANIFEST: NavigationMenuItemManifest = {
+ universalIdentifier: NAVIGATION_MENU_ITEM_UID,
+ type: NavigationMenuItemType.OBJECT,
+ position: 7,
+ targetObjectUniversalIdentifier: OBJECT_UID,
+};
+
+const forward = (navigationMenuItemManifest: NavigationMenuItemManifest) =>
+ fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem({
+ navigationMenuItemManifest,
+ applicationUniversalIdentifier: APP_UID,
+ now: NOW,
+ });
+
+describe('fromFlatNavigationMenuItemToNavigationMenuItemManifest', () => {
+ it('should reproduce the manifest after a forward then an inverse conversion', () => {
+ expect(
+ fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem: forward(NAVIGATION_MENU_ITEM_MANIFEST),
+ }),
+ ).toEqual(NAVIGATION_MENU_ITEM_MANIFEST);
+ });
+
+ it('should omit the null slots of a minimal manifest rather than emit them as null', () => {
+ const navigationMenuItemManifest =
+ fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem: forward(MINIMAL_NAVIGATION_MENU_ITEM_MANIFEST),
+ });
+
+ expect(navigationMenuItemManifest).toEqual(
+ MINIMAL_NAVIGATION_MENU_ITEM_MANIFEST,
+ );
+ expect(Object.values(navigationMenuItemManifest)).not.toContain(null);
+ });
+
+ it('should keep a name the workspace stored as an empty string, which a folder is allowed to have', () => {
+ expect(
+ fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem: forward({
+ universalIdentifier: FOLDER_UID,
+ type: NavigationMenuItemType.FOLDER,
+ position: 0,
+ name: '',
+ }),
+ }).name,
+ ).toBe('');
+ });
+
+ it('should reproduce the flat entity after an inverse then a forward conversion', () => {
+ const flatNavigationMenuItem = forward(NAVIGATION_MENU_ITEM_MANIFEST);
+
+ expect(
+ compareTwoFlatEntity({
+ fromUniversalFlatEntity: flatNavigationMenuItem,
+ toUniversalFlatEntity: forward(
+ fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem,
+ }),
+ ),
+ metadataName: 'navigationMenuItem',
+ }),
+ ).toBeUndefined();
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.ts
new file mode 100644
index 00000000000..32b30d3e403
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util.ts
@@ -0,0 +1,49 @@
+import { type NavigationMenuItemManifest } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type UniversalFlatNavigationMenuItem } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-navigation-menu-item.type';
+
+export const fromFlatNavigationMenuItemToNavigationMenuItemManifest = ({
+ flatNavigationMenuItem,
+}: {
+ flatNavigationMenuItem: UniversalFlatNavigationMenuItem;
+}): NavigationMenuItemManifest => ({
+ universalIdentifier: flatNavigationMenuItem.universalIdentifier,
+ type: flatNavigationMenuItem.type,
+ position: flatNavigationMenuItem.position,
+ ...(isDefined(flatNavigationMenuItem.name)
+ ? { name: flatNavigationMenuItem.name }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.icon)
+ ? { icon: flatNavigationMenuItem.icon }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.color)
+ ? { color: flatNavigationMenuItem.color }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.link)
+ ? { link: flatNavigationMenuItem.link }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.folderUniversalIdentifier)
+ ? {
+ folderUniversalIdentifier:
+ flatNavigationMenuItem.folderUniversalIdentifier,
+ }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.viewUniversalIdentifier)
+ ? {
+ viewUniversalIdentifier: flatNavigationMenuItem.viewUniversalIdentifier,
+ }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.targetObjectMetadataUniversalIdentifier)
+ ? {
+ targetObjectUniversalIdentifier:
+ flatNavigationMenuItem.targetObjectMetadataUniversalIdentifier,
+ }
+ : {}),
+ ...(isDefined(flatNavigationMenuItem.pageLayoutUniversalIdentifier)
+ ? {
+ pageLayoutUniversalIdentifier:
+ flatNavigationMenuItem.pageLayoutUniversalIdentifier,
+ }
+ : {}),
+});
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 72535468227..43e111a0196 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,8 @@ 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 { getResolvableReferenceUniversalIdentifiers } from 'src/engine/core-modules/application/application-manifest/utils/get-resolvable-reference-universal-identifiers.util';
+import { reconstructNavigationMenuItemsManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-navigation-menu-items-manifest.util';
import { reconstructPageLayoutsManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-page-layouts-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';
@@ -101,6 +103,22 @@ export class ApplicationManifestExportService {
allFlatEntityMaps,
exportedObjectUniversalIdentifiers,
});
+ const { navigationMenuItems, coverage: navigationMenuItemsCoverage } =
+ reconstructNavigationMenuItemsManifest({
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ exportedObjectUniversalIdentifiers,
+ resolvableViewUniversalIdentifiers:
+ getResolvableReferenceUniversalIdentifiers({
+ coverage: viewsCoverage,
+ metadataName: 'view',
+ }),
+ resolvablePageLayoutUniversalIdentifiers:
+ getResolvableReferenceUniversalIdentifiers({
+ coverage: pageLayoutsCoverage,
+ metadataName: 'pageLayout',
+ }),
+ });
const translations = isDefined(flatApplication.applicationRegistrationId)
? await this.applicationTranslationCacheService.getCatalogsByLocale(
flatApplication.applicationRegistrationId,
@@ -128,7 +146,7 @@ export class ApplicationManifestExportService {
publicAssets: [],
views,
viewFields,
- navigationMenuItems: [],
+ navigationMenuItems,
pageLayouts,
pageLayoutWidgets,
pageLayoutTabs,
@@ -152,6 +170,7 @@ export class ApplicationManifestExportService {
...dataModelCoverage,
...viewsCoverage,
...pageLayoutsCoverage,
+ ...navigationMenuItemsCoverage,
],
}),
files: [],
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 b8bfb54d244..3629042404d 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,4 +1,5 @@
import {
+ type NavigationMenuItemManifest,
type PageLayoutManifest,
type PageLayoutTabManifest,
type PageLayoutWidgetManifest,
@@ -16,6 +17,7 @@ import {
FieldMetadataType,
PageLayoutTabLayoutMode,
PageLayoutType,
+ NavigationMenuItemType,
ViewCalendarLayout,
ViewFilterGroupLogicalOperator,
ViewFilterOperand,
@@ -27,10 +29,12 @@ import {
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 { fromFlatNavigationMenuItemToNavigationMenuItemManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util';
import { fromFlatObjectMetadataToObjectManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-object-metadata-to-object-manifest.util';
import { fromFlatPageLayoutTabToPageLayoutTabManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-page-layout-tab-to-page-layout-tab-manifest.util';
import { fromFlatPageLayoutToPageLayoutManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-page-layout-to-page-layout-manifest.util';
import { fromFlatPageLayoutWidgetToStandalonePageLayoutWidgetManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-page-layout-widget-to-standalone-page-layout-widget-manifest.util';
+import { fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem } from 'src/engine/core-modules/application/application-manifest/converters/from-navigation-menu-item-manifest-to-universal-flat-navigation-menu-item.util';
import { fromPageLayoutManifestToUniversalFlatPageLayout } from 'src/engine/core-modules/application/application-manifest/converters/from-page-layout-manifest-to-universal-flat-page-layout.util';
import { fromPageLayoutTabManifestToUniversalFlatPageLayoutTab } from 'src/engine/core-modules/application/application-manifest/converters/from-page-layout-tab-manifest-to-universal-flat-page-layout-tab.util';
import { fromPageLayoutWidgetManifestToUniversalFlatPageLayoutWidget } from 'src/engine/core-modules/application/application-manifest/converters/from-page-layout-widget-manifest-to-universal-flat-page-layout-widget.util';
@@ -184,6 +188,20 @@ const PAGE_LAYOUT_MANIFEST: PageLayoutManifest = {
tabs: [PAGE_LAYOUT_TAB_MANIFEST],
};
+const NAVIGATION_MENU_ITEM_MANIFEST: Required<NavigationMenuItemManifest> = {
+ universalIdentifier: '77777777-7777-4777-8777-777777777777',
+ type: NavigationMenuItemType.VIEW,
+ name: 'All pets',
+ icon: 'IconPaw',
+ color: 'green',
+ position: 12,
+ link: 'https://example.com/pets',
+ folderUniversalIdentifier: '88888888-8888-4888-8888-888888888888',
+ viewUniversalIdentifier: VIEW_UID,
+ targetObjectUniversalIdentifier: OBJECT_UID,
+ pageLayoutUniversalIdentifier: '99999999-9999-4999-8999-999999999999',
+};
+
const PAGE_LAYOUT_KIND_GAPS = {
deletedAt:
'page layouts, tabs and widgets are never soft-deleted; the column is scheduled for removal',
@@ -387,6 +405,22 @@ const EXPORTED_KINDS: ExportedKind[] = [
workspaceLocalProperties: [],
knownGaps: NESTED_VIEW_CHILD_GAPS,
},
+ {
+ metadataName: 'navigationMenuItem',
+ emittedProperties: Object.keys(
+ fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem:
+ fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem({
+ navigationMenuItemManifest: NAVIGATION_MENU_ITEM_MANIFEST,
+ applicationUniversalIdentifier: APP_UID,
+ now: NOW,
+ }),
+ }),
+ ),
+ renamedProperties: {},
+ workspaceLocalProperties: [],
+ knownGaps: {},
+ },
{
metadataName: 'pageLayout',
emittedProperties: Object.keys(
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-navigation-menu-items-manifest.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-navigation-menu-items-manifest.util.spec.ts
new file mode 100644
index 00000000000..3c59a6a1b08
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/__tests__/reconstruct-navigation-menu-items-manifest.util.spec.ts
@@ -0,0 +1,394 @@
+import { NavigationMenuItemType } from 'twenty-shared/types';
+
+import { fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem } from 'src/engine/core-modules/application/application-manifest/converters/from-navigation-menu-item-manifest-to-universal-flat-navigation-menu-item.util';
+import { addAllFlatEntitiesToFlatEntityMaps } from 'src/engine/core-modules/application/application-manifest/utils/__tests__/add-all-flat-entities-to-flat-entity-maps.test-util';
+import { reconstructNavigationMenuItemsManifest } from 'src/engine/core-modules/application/application-manifest/utils/reconstruct-navigation-menu-items-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 FlatNavigationMenuItem } from 'src/engine/metadata-modules/flat-navigation-menu-item/types/flat-navigation-menu-item.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 FlatPageLayout } from 'src/engine/metadata-modules/flat-page-layout/types/flat-page-layout.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-09T10:00:00.000Z';
+const APP_UID = '11111111-1111-4111-8111-111111111111';
+const PET_UID = '22222222-2222-4222-8222-222222222222';
+const UNSUPPORTED_OBJECT_UID = '33333333-3333-4333-8333-333333333333';
+const MISSING_UID = '44444444-4444-4444-8444-444444444444';
+const VIEW_UID = '55555555-5555-4555-8555-555555555555';
+const PAGE_LAYOUT_UID = '66666666-6666-4666-8666-666666666666';
+const UNSUPPORTED_VIEW_UID = '77777777-7777-4777-8777-777777777777';
+const UNSUPPORTED_PAGE_LAYOUT_UID = '88888888-8888-4888-8888-888888888888';
+const ENGINE_VIEW_UID = '99999999-9999-4999-8999-999999999999';
+const FOLDER_UID = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
+const NESTED_FOLDER_UID = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
+const FOREIGN_FOLDER_UID = 'dddddddd-dddd-4ddd-8ddd-dddddddddddd';
+const EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS = new Set([PET_UID]);
+
+const petObject = getFlatObjectMetadataMock({
+ universalIdentifier: PET_UID,
+ applicationId: APP_ID,
+ applicationUniversalIdentifier: APP_UID,
+ nameSingular: 'pet',
+ namePlural: 'pets',
+});
+
+const unsupportedObject = getFlatObjectMetadataMock({
+ universalIdentifier: UNSUPPORTED_OBJECT_UID,
+ applicationId: APP_ID,
+ applicationUniversalIdentifier: APP_UID,
+ nameSingular: 'toy',
+ namePlural: 'toys',
+});
+
+const buildFlatNavigationMenuItem = ({
+ universalIdentifier,
+ type = NavigationMenuItemType.OBJECT,
+ position = 0,
+ ...flatNavigationMenuItemProperties
+}: {
+ universalIdentifier: string;
+ type?: NavigationMenuItemType;
+ position?: number;
+} & Partial<FlatNavigationMenuItem>): FlatNavigationMenuItem => ({
+ ...fromNavigationMenuItemManifestToUniversalFlatNavigationMenuItem({
+ navigationMenuItemManifest: { universalIdentifier, type, position },
+ applicationUniversalIdentifier: APP_UID,
+ now: NOW,
+ }),
+ id: `${universalIdentifier}-id`,
+ workspaceId: WORKSPACE_ID,
+ applicationId: APP_ID,
+ viewId: null,
+ folderId: null,
+ targetObjectMetadataId: null,
+ pageLayoutId: null,
+ ...flatNavigationMenuItemProperties,
+});
+
+const buildMaps = ({
+ objects = [],
+ views = [],
+ pageLayouts = [],
+ navigationMenuItems = [],
+}: {
+ objects?: FlatObjectMetadata[];
+ views?: FlatView[];
+ pageLayouts?: FlatPageLayout[];
+ navigationMenuItems?: FlatNavigationMenuItem[];
+}): AllFlatEntityMaps => {
+ const maps = createEmptyAllFlatEntityMaps();
+
+ return {
+ ...maps,
+ flatObjectMetadataMaps: addAllFlatEntitiesToFlatEntityMaps({
+ flatEntities: objects,
+ flatEntityMaps: maps.flatObjectMetadataMaps,
+ }),
+ flatViewMaps: addAllFlatEntitiesToFlatEntityMaps({
+ flatEntities: views,
+ flatEntityMaps: maps.flatViewMaps,
+ }),
+ flatPageLayoutMaps: addAllFlatEntitiesToFlatEntityMaps({
+ flatEntities: pageLayouts,
+ flatEntityMaps: maps.flatPageLayoutMaps,
+ }),
+ flatNavigationMenuItemMaps: addAllFlatEntitiesToFlatEntityMaps({
+ flatEntities: navigationMenuItems,
+ flatEntityMaps: maps.flatNavigationMenuItemMaps,
+ }),
+ };
+};
+
+const allFlatEntityMaps = buildMaps({
+ objects: [petObject, unsupportedObject],
+ views: [
+ { universalIdentifier: VIEW_UID } as FlatView,
+ { universalIdentifier: UNSUPPORTED_VIEW_UID } as FlatView,
+ { universalIdentifier: ENGINE_VIEW_UID } as FlatView,
+ ],
+ pageLayouts: [
+ { universalIdentifier: PAGE_LAYOUT_UID } as FlatPageLayout,
+ { universalIdentifier: UNSUPPORTED_PAGE_LAYOUT_UID } as FlatPageLayout,
+ ],
+ navigationMenuItems: [
+ buildFlatNavigationMenuItem({
+ universalIdentifier: FOREIGN_FOLDER_UID,
+ type: NavigationMenuItemType.FOLDER,
+ name: 'Shared',
+ applicationId: 'other-application-id',
+ }),
+ ],
+});
+
+const reconstruct = (
+ navigationMenuItems: FlatNavigationMenuItem[],
+ {
+ applicationViews = [],
+ applicationPageLayouts = [],
+ resolvableViewUniversalIdentifiers = new Set([VIEW_UID]),
+ resolvablePageLayoutUniversalIdentifiers = new Set([PAGE_LAYOUT_UID]),
+ }: {
+ applicationViews?: FlatView[];
+ applicationPageLayouts?: FlatPageLayout[];
+ resolvableViewUniversalIdentifiers?: ReadonlySet<string>;
+ resolvablePageLayoutUniversalIdentifiers?: ReadonlySet<string>;
+ } = {},
+) =>
+ reconstructNavigationMenuItemsManifest({
+ applicationAllFlatEntityMaps: buildMaps({
+ objects: [petObject, unsupportedObject],
+ views: applicationViews,
+ pageLayouts: applicationPageLayouts,
+ navigationMenuItems,
+ }),
+ allFlatEntityMaps,
+ exportedObjectUniversalIdentifiers: EXPORTED_OBJECT_UNIVERSAL_IDENTIFIERS,
+ resolvableViewUniversalIdentifiers,
+ resolvablePageLayoutUniversalIdentifiers,
+ });
+
+const statusOf = (
+ coverage: ReturnType<
+ typeof reconstructNavigationMenuItemsManifest
+ >['coverage'],
+ universalIdentifier: string,
+) =>
+ coverage.find((entry) => entry.universalIdentifier === universalIdentifier);
+
+describe('reconstructNavigationMenuItemsManifest', () => {
+ it('should export an item with only the properties the workspace set, ordered by universal identifier', () => {
+ const { navigationMenuItems, coverage } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'zzzzzzzz-zzzz-4zzz-8zzz-zzzzzzzzzzzz',
+ position: 1,
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+ type: NavigationMenuItemType.VIEW,
+ position: 2,
+ name: 'All pets',
+ icon: 'IconPaw',
+ viewUniversalIdentifier: VIEW_UID,
+ }),
+ ]);
+
+ expect(navigationMenuItems).toEqual([
+ {
+ universalIdentifier: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+ type: NavigationMenuItemType.VIEW,
+ position: 2,
+ name: 'All pets',
+ icon: 'IconPaw',
+ viewUniversalIdentifier: VIEW_UID,
+ },
+ {
+ universalIdentifier: 'zzzzzzzz-zzzz-4zzz-8zzz-zzzzzzzzzzzz',
+ type: NavigationMenuItemType.OBJECT,
+ position: 1,
+ targetObjectUniversalIdentifier: PET_UID,
+ },
+ ]);
+ expect(
+ coverage.every(
+ ({ status }) => status === ApplicationExportCoverageStatus.EXPORTED,
+ ),
+ ).toBe(true);
+ });
+
+ it('should exclude a personal favourite and an item pinned to a record', () => {
+ const { navigationMenuItems, coverage } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'personal-item',
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ userWorkspaceId: 'user-workspace-id',
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'record-item',
+ type: NavigationMenuItemType.RECORD,
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ targetRecordId: 'record-id',
+ }),
+ ]);
+
+ expect(navigationMenuItems).toEqual([]);
+ expect(statusOf(coverage, 'personal-item')).toEqual({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier: 'personal-item',
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'personal navigation item',
+ });
+ expect(statusOf(coverage, 'record-item')).toEqual({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier: 'record-item',
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'navigation item pinned to a record',
+ });
+ });
+
+ it('should refuse an item whose target cannot be resolved', () => {
+ const { navigationMenuItems, coverage } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'unsupported-object-item',
+ targetObjectMetadataUniversalIdentifier: UNSUPPORTED_OBJECT_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'missing-object-item',
+ targetObjectMetadataUniversalIdentifier: MISSING_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'missing-view-item',
+ type: NavigationMenuItemType.VIEW,
+ viewUniversalIdentifier: MISSING_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'missing-page-layout-item',
+ type: NavigationMenuItemType.PAGE_LAYOUT,
+ pageLayoutUniversalIdentifier: MISSING_UID,
+ }),
+ ]);
+
+ expect(navigationMenuItems).toEqual([]);
+ expect(statusOf(coverage, 'unsupported-object-item')?.reason).toBe(
+ 'navigation menu item on an unsupported object',
+ );
+ expect(statusOf(coverage, 'missing-object-item')?.reason).toBe(
+ 'navigation menu item on an object that does not exist',
+ );
+ expect(statusOf(coverage, 'missing-view-item')?.reason).toBe(
+ 'navigation menu item on a view that does not exist',
+ );
+ expect(statusOf(coverage, 'missing-page-layout-item')?.reason).toBe(
+ 'navigation menu item on a page layout that does not exist',
+ );
+ });
+
+ it('should refuse an item pointing at a view or a page layout the application did not export, and keep one pointing at an engine-derived view or at a target it does not own', () => {
+ const { navigationMenuItems, coverage } = reconstruct(
+ [
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'unsupported-view-item',
+ type: NavigationMenuItemType.VIEW,
+ viewUniversalIdentifier: UNSUPPORTED_VIEW_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'unsupported-page-layout-item',
+ type: NavigationMenuItemType.PAGE_LAYOUT,
+ pageLayoutUniversalIdentifier: UNSUPPORTED_PAGE_LAYOUT_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'engine-derived-view-item',
+ type: NavigationMenuItemType.VIEW,
+ viewUniversalIdentifier: ENGINE_VIEW_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'foreign-view-item',
+ type: NavigationMenuItemType.VIEW,
+ viewUniversalIdentifier: VIEW_UID,
+ }),
+ ],
+ {
+ applicationViews: [
+ { universalIdentifier: UNSUPPORTED_VIEW_UID } as FlatView,
+ { universalIdentifier: ENGINE_VIEW_UID } as FlatView,
+ ],
+ applicationPageLayouts: [
+ {
+ universalIdentifier: UNSUPPORTED_PAGE_LAYOUT_UID,
+ } as FlatPageLayout,
+ ],
+ resolvableViewUniversalIdentifiers: new Set([ENGINE_VIEW_UID]),
+ resolvablePageLayoutUniversalIdentifiers: new Set([]),
+ },
+ );
+
+ expect(statusOf(coverage, 'unsupported-view-item')?.reason).toBe(
+ 'navigation menu item on an unsupported view',
+ );
+ expect(statusOf(coverage, 'unsupported-page-layout-item')?.reason).toBe(
+ 'navigation menu item on an unsupported page layout',
+ );
+ expect(
+ navigationMenuItems.map(({ universalIdentifier }) => universalIdentifier),
+ ).toEqual(['engine-derived-view-item', 'foreign-view-item']);
+ });
+
+ it('should export a folder with the items it holds', () => {
+ const { navigationMenuItems } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: FOLDER_UID,
+ type: NavigationMenuItemType.FOLDER,
+ name: 'Pets',
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'folded-item',
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ folderUniversalIdentifier: FOLDER_UID,
+ }),
+ ]);
+
+ expect(
+ navigationMenuItems.map(({ universalIdentifier }) => universalIdentifier),
+ ).toEqual([FOLDER_UID, 'folded-item']);
+ });
+
+ it('should keep an item held by a folder of another application and drop one held by a folder that does not exist', () => {
+ const { navigationMenuItems, coverage } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'foreign-folder-item',
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ folderUniversalIdentifier: FOREIGN_FOLDER_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'missing-folder-item',
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ folderUniversalIdentifier: MISSING_UID,
+ }),
+ ]);
+
+ expect(
+ navigationMenuItems.map(({ universalIdentifier }) => universalIdentifier),
+ ).toEqual(['foreign-folder-item']);
+ expect(statusOf(coverage, 'missing-folder-item')?.reason).toBe(
+ 'navigation menu item in a folder that is not exported',
+ );
+ });
+
+ it('should drop the items of a folder that is not exported, down the nesting', () => {
+ const { navigationMenuItems, coverage } = reconstruct([
+ buildFlatNavigationMenuItem({
+ universalIdentifier: FOLDER_UID,
+ type: NavigationMenuItemType.FOLDER,
+ name: 'Toys',
+ targetObjectMetadataUniversalIdentifier: UNSUPPORTED_OBJECT_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: NESTED_FOLDER_UID,
+ type: NavigationMenuItemType.FOLDER,
+ name: 'Soft toys',
+ folderUniversalIdentifier: FOLDER_UID,
+ }),
+ buildFlatNavigationMenuItem({
+ universalIdentifier: 'nested-item',
+ targetObjectMetadataUniversalIdentifier: PET_UID,
+ folderUniversalIdentifier: NESTED_FOLDER_UID,
+ }),
+ ]);
+
+ expect(navigationMenuItems).toEqual([]);
+ expect(statusOf(coverage, FOLDER_UID)?.reason).toBe(
+ 'navigation menu item on an unsupported object',
+ );
+ expect(statusOf(coverage, NESTED_FOLDER_UID)?.reason).toBe(
+ 'navigation menu item in a folder that is not exported',
+ );
+ expect(statusOf(coverage, 'nested-item')?.reason).toBe(
+ 'navigation menu item in a folder that is not exported',
+ );
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
index 85e852a3e60..4cdfbc9d2f1 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/classify-application-flat-entities.util.ts
@@ -78,15 +78,6 @@ const classifyFlatEntity = ({
reason: 'member or API key role assignment',
}
: { status: ApplicationExportCoverageStatus.UNSUPPORTED };
- case 'navigationMenuItem':
- return ('userWorkspaceId' in flatEntity &&
- isDefined(flatEntity.userWorkspaceId)) ||
- ('targetRecordId' in flatEntity && isDefined(flatEntity.targetRecordId))
- ? {
- status: ApplicationExportCoverageStatus.EXCLUDED,
- reason: 'personal navigation item',
- }
- : { status: ApplicationExportCoverageStatus.UNSUPPORTED };
case 'commandMenuItem':
if (
'workflowVersionId' in flatEntity &&
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-resolvable-reference-universal-identifiers.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-resolvable-reference-universal-identifiers.util.ts
new file mode 100644
index 00000000000..7406c7975c8
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-resolvable-reference-universal-identifiers.util.ts
@@ -0,0 +1,26 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+
+import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';
+import { ApplicationExportCoverageStatus } from 'src/engine/core-modules/application/enums/application-export-coverage-status.enum';
+
+const RESOLVABLE_ON_INSTALL_STATUSES = [
+ ApplicationExportCoverageStatus.EXPORTED,
+ ApplicationExportCoverageStatus.ENGINE_DERIVED,
+];
+
+export const getResolvableReferenceUniversalIdentifiers = ({
+ coverage,
+ metadataName,
+}: {
+ coverage: ApplicationExportCoverageEntry[];
+ metadataName: AllMetadataName;
+}): ReadonlySet<string> =>
+ new Set(
+ coverage
+ .filter(
+ (coverageEntry) =>
+ coverageEntry.metadataName === metadataName &&
+ RESOLVABLE_ON_INSTALL_STATUSES.includes(coverageEntry.status),
+ )
+ .map(({ universalIdentifier }) => universalIdentifier),
+ );
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util.ts
deleted file mode 100644
index a5c034d0990..00000000000
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { type AllMetadataName } from 'twenty-shared/metadata';
-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 AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
-
-export const getUnresolvableObjectReason = ({
- metadataName,
- objectUniversalIdentifier,
- applicationAllFlatEntityMaps,
- allFlatEntityMaps,
- exportedObjectUniversalIdentifiers,
-}: {
- metadataName: AllMetadataName;
- objectUniversalIdentifier: string | null;
- applicationAllFlatEntityMaps: AllFlatEntityMaps;
- allFlatEntityMaps: AllFlatEntityMaps;
- exportedObjectUniversalIdentifiers: ReadonlySet<string>;
-}): string | undefined => {
- if (!isDefined(objectUniversalIdentifier)) {
- return undefined;
- }
-
- const label = MANIFEST_ENTITY_REGISTRY[metadataName].entityKind;
-
- if (
- isDefined(
- applicationAllFlatEntityMaps.flatObjectMetadataMaps.byUniversalIdentifier[
- objectUniversalIdentifier
- ],
- ) &&
- !exportedObjectUniversalIdentifiers.has(objectUniversalIdentifier)
- ) {
- return `${label} on an unsupported object`;
- }
-
- if (
- !isDefined(
- allFlatEntityMaps.flatObjectMetadataMaps.byUniversalIdentifier[
- objectUniversalIdentifier
- ],
- )
- ) {
- return `${label} on an object that does not exist`;
- }
-
- return undefined;
-};
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util.ts
new file mode 100644
index 00000000000..48f7b8efc21
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util.ts
@@ -0,0 +1,57 @@
+import { type AllMetadataName } from 'twenty-shared/metadata';
+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 AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
+
+const withArticle = (label: string) =>
+ `${/^[aeiou]/.test(label) ? 'an' : 'a'} ${label}`;
+
+export const getUnresolvableReferenceReason = ({
+ metadataName,
+ referenceMetadataName,
+ referenceUniversalIdentifier,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ resolvableReferenceUniversalIdentifiers,
+}: {
+ metadataName: AllMetadataName;
+ referenceMetadataName: AllMetadataName;
+ referenceUniversalIdentifier: string | null;
+ applicationAllFlatEntityMaps: AllFlatEntityMaps;
+ allFlatEntityMaps: AllFlatEntityMaps;
+ resolvableReferenceUniversalIdentifiers: ReadonlySet<string>;
+}): string | undefined => {
+ if (!isDefined(referenceUniversalIdentifier)) {
+ return undefined;
+ }
+
+ const label = MANIFEST_ENTITY_REGISTRY[metadataName].entityKind;
+ const referenceLabel =
+ MANIFEST_ENTITY_REGISTRY[referenceMetadataName].entityKind;
+ const flatEntityMapsKey = getMetadataFlatEntityMapsKey(referenceMetadataName);
+
+ if (
+ isDefined(
+ applicationAllFlatEntityMaps[flatEntityMapsKey].byUniversalIdentifier[
+ referenceUniversalIdentifier
+ ],
+ ) &&
+ !resolvableReferenceUniversalIdentifiers.has(referenceUniversalIdentifier)
+ ) {
+ return `${label} on an unsupported ${referenceLabel}`;
+ }
+
+ if (
+ !isDefined(
+ allFlatEntityMaps[flatEntityMapsKey].byUniversalIdentifier[
+ referenceUniversalIdentifier
+ ],
+ )
+ ) {
+ return `${label} on ${withArticle(referenceLabel)} that does not exist`;
+ }
+
+ return undefined;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-navigation-menu-item-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-navigation-menu-item-reason.util.ts
new file mode 100644
index 00000000000..579596df4b8
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-navigation-menu-item-reason.util.ts
@@ -0,0 +1,47 @@
+import { getUnresolvableReferenceReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util';
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { type FlatNavigationMenuItem } from 'src/engine/metadata-modules/flat-navigation-menu-item/types/flat-navigation-menu-item.type';
+
+export const getUnsupportedNavigationMenuItemReason = ({
+ flatNavigationMenuItem,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ exportedObjectUniversalIdentifiers,
+ resolvableViewUniversalIdentifiers,
+ resolvablePageLayoutUniversalIdentifiers,
+}: {
+ flatNavigationMenuItem: FlatNavigationMenuItem;
+ applicationAllFlatEntityMaps: AllFlatEntityMaps;
+ allFlatEntityMaps: AllFlatEntityMaps;
+ exportedObjectUniversalIdentifiers: ReadonlySet<string>;
+ resolvableViewUniversalIdentifiers: ReadonlySet<string>;
+ resolvablePageLayoutUniversalIdentifiers: ReadonlySet<string>;
+}): string | undefined =>
+ getUnresolvableReferenceReason({
+ metadataName: 'navigationMenuItem',
+ referenceMetadataName: 'objectMetadata',
+ referenceUniversalIdentifier:
+ flatNavigationMenuItem.targetObjectMetadataUniversalIdentifier,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ resolvableReferenceUniversalIdentifiers: exportedObjectUniversalIdentifiers,
+ }) ??
+ getUnresolvableReferenceReason({
+ metadataName: 'navigationMenuItem',
+ referenceMetadataName: 'view',
+ referenceUniversalIdentifier:
+ flatNavigationMenuItem.viewUniversalIdentifier,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ resolvableReferenceUniversalIdentifiers: resolvableViewUniversalIdentifiers,
+ }) ??
+ getUnresolvableReferenceReason({
+ metadataName: 'navigationMenuItem',
+ referenceMetadataName: 'pageLayout',
+ referenceUniversalIdentifier:
+ flatNavigationMenuItem.pageLayoutUniversalIdentifier,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ resolvableReferenceUniversalIdentifiers:
+ resolvablePageLayoutUniversalIdentifiers,
+ });
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-reason.util.ts
index 04d4f604d37..0093c36f497 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-reason.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-reason.util.ts
@@ -1,7 +1,7 @@
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
-import { getUnresolvableObjectReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util';
+import { getUnresolvableReferenceReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util';
import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
import { type FlatPageLayout } from 'src/engine/metadata-modules/flat-page-layout/types/flat-page-layout.type';
@@ -20,12 +20,14 @@ export const getUnsupportedPageLayoutReason = ({
return 'page layout without a name';
}
- const unresolvableObjectReason = getUnresolvableObjectReason({
+ const unresolvableObjectReason = getUnresolvableReferenceReason({
metadataName: 'pageLayout',
- objectUniversalIdentifier: flatPageLayout.objectMetadataUniversalIdentifier,
+ referenceMetadataName: 'objectMetadata',
+ referenceUniversalIdentifier:
+ flatPageLayout.objectMetadataUniversalIdentifier,
applicationAllFlatEntityMaps,
allFlatEntityMaps,
- exportedObjectUniversalIdentifiers,
+ resolvableReferenceUniversalIdentifiers: exportedObjectUniversalIdentifiers,
});
if (isDefined(unresolvableObjectReason)) {
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-widget-reason.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-widget-reason.util.ts
index f775ddea33d..3c6468fefc4 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-widget-reason.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/get-unsupported-page-layout-widget-reason.util.ts
@@ -2,7 +2,7 @@ import { WidgetType } from 'twenty-shared/types';
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 { getUnresolvableObjectReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util';
+import { getUnresolvableReferenceReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util';
import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
import { type FlatPageLayoutTab } from 'src/engine/metadata-modules/flat-page-layout-tab/types/flat-page-layout-tab.type';
import { type FlatPageLayoutWidget } from 'src/engine/metadata-modules/flat-page-layout-widget/types/flat-page-layout-widget.type';
@@ -74,7 +74,7 @@ const getFlatEntityMaps = ({
}
};
-const getUnresolvableReferenceReason = ({
+const getUnresolvableConfigurationKeyReason = ({
key,
metadataName,
universalIdentifier,
@@ -154,7 +154,7 @@ const findUnresolvableReferenceReason = ({
}
for (const universalIdentifier of Array.isArray(child) ? child : [child]) {
- const reason = getUnresolvableReferenceReason({
+ const reason = getUnresolvableConfigurationKeyReason({
key,
metadataName,
universalIdentifier,
@@ -202,13 +202,14 @@ export const getUnsupportedPageLayoutWidgetReason = ({
return 'page layout widget with a conditional availability expression';
}
- const unresolvableObjectReason = getUnresolvableObjectReason({
+ const unresolvableObjectReason = getUnresolvableReferenceReason({
metadataName: 'pageLayoutWidget',
- objectUniversalIdentifier:
+ referenceMetadataName: 'objectMetadata',
+ referenceUniversalIdentifier:
flatPageLayoutWidget.objectMetadataUniversalIdentifier,
applicationAllFlatEntityMaps,
allFlatEntityMaps,
- exportedObjectUniversalIdentifiers,
+ resolvableReferenceUniversalIdentifiers: exportedObjectUniversalIdentifiers,
});
if (isDefined(unresolvableObjectReason)) {
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
index 8cf652827ed..2f0c13d9acc 100644
--- 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
@@ -1,7 +1,7 @@
import { isNonEmptyString } from '@sniptt/guards';
import { isDefined } from 'twenty-shared/utils';
-import { getUnresolvableObjectReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-object-reason.util';
+import { getUnresolvableReferenceReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unresolvable-reference-reason.util';
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';
@@ -27,12 +27,13 @@ export const getUnsupportedViewReason = ({
return 'view without a name';
}
- const unresolvableObjectReason = getUnresolvableObjectReason({
+ const unresolvableObjectReason = getUnresolvableReferenceReason({
metadataName: 'view',
- objectUniversalIdentifier: flatView.objectMetadataUniversalIdentifier,
+ referenceMetadataName: 'objectMetadata',
+ referenceUniversalIdentifier: flatView.objectMetadataUniversalIdentifier,
applicationAllFlatEntityMaps,
allFlatEntityMaps,
- exportedObjectUniversalIdentifiers,
+ resolvableReferenceUniversalIdentifiers: exportedObjectUniversalIdentifiers,
});
if (isDefined(unresolvableObjectReason)) {
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-navigation-menu-items-manifest.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-navigation-menu-items-manifest.util.ts
new file mode 100644
index 00000000000..b43aedf16af
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/utils/reconstruct-navigation-menu-items-manifest.util.ts
@@ -0,0 +1,154 @@
+import { type NavigationMenuItemManifest } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+
+import { fromFlatNavigationMenuItemToNavigationMenuItemManifest } from 'src/engine/core-modules/application/application-manifest/converters/from-flat-navigation-menu-item-to-navigation-menu-item-manifest.util';
+import { type ApplicationExportCoverageEntry } from 'src/engine/core-modules/application/application-manifest/types/application-export.type';
+import { buildExportedCoverageEntry } from 'src/engine/core-modules/application/application-manifest/utils/build-exported-coverage-entry.util';
+import { getUnsupportedNavigationMenuItemReason } from 'src/engine/core-modules/application/application-manifest/utils/get-unsupported-navigation-menu-item-reason.util';
+import { MANIFEST_ENTITY_REGISTRY } from 'src/engine/core-modules/application/application-manifest/utils/find-manifest-entity-descriptor-by-universal-identifier.util';
+import { sortFlatEntitiesByUniversalIdentifier } from 'src/engine/core-modules/application/application-manifest/utils/sort-flat-entities-by-universal-identifier.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 FlatNavigationMenuItem } from 'src/engine/metadata-modules/flat-navigation-menu-item/types/flat-navigation-menu-item.type';
+
+const NAVIGATION_MENU_ITEM_LABEL =
+ MANIFEST_ENTITY_REGISTRY.navigationMenuItem.entityKind;
+
+export const reconstructNavigationMenuItemsManifest = ({
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ exportedObjectUniversalIdentifiers,
+ resolvableViewUniversalIdentifiers,
+ resolvablePageLayoutUniversalIdentifiers,
+}: {
+ applicationAllFlatEntityMaps: AllFlatEntityMaps;
+ allFlatEntityMaps: AllFlatEntityMaps;
+ exportedObjectUniversalIdentifiers: ReadonlySet<string>;
+ resolvableViewUniversalIdentifiers: ReadonlySet<string>;
+ resolvablePageLayoutUniversalIdentifiers: ReadonlySet<string>;
+}): {
+ navigationMenuItems: NavigationMenuItemManifest[];
+ coverage: ApplicationExportCoverageEntry[];
+} => {
+ const coverage: ApplicationExportCoverageEntry[] = [];
+ const exportableFlatNavigationMenuItems: FlatNavigationMenuItem[] = [];
+
+ for (const flatNavigationMenuItem of sortFlatEntitiesByUniversalIdentifier(
+ applicationAllFlatEntityMaps.flatNavigationMenuItemMaps,
+ )) {
+ const { universalIdentifier, userWorkspaceId, targetRecordId } =
+ flatNavigationMenuItem;
+
+ if (isDefined(userWorkspaceId)) {
+ coverage.push({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier,
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'personal navigation item',
+ });
+ continue;
+ }
+
+ if (isDefined(targetRecordId)) {
+ coverage.push({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier,
+ status: ApplicationExportCoverageStatus.EXCLUDED,
+ reason: 'navigation item pinned to a record',
+ });
+ continue;
+ }
+
+ const unsupportedReason = getUnsupportedNavigationMenuItemReason({
+ flatNavigationMenuItem,
+ applicationAllFlatEntityMaps,
+ allFlatEntityMaps,
+ exportedObjectUniversalIdentifiers,
+ resolvableViewUniversalIdentifiers,
+ resolvablePageLayoutUniversalIdentifiers,
+ });
+
+ if (isDefined(unsupportedReason)) {
+ coverage.push({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier,
+ status: ApplicationExportCoverageStatus.UNSUPPORTED,
+ reason: unsupportedReason,
+ });
+ continue;
+ }
+
+ exportableFlatNavigationMenuItems.push(flatNavigationMenuItem);
+ }
+
+ const exportedUniversalIdentifiers = new Set(
+ exportableFlatNavigationMenuItems.map(
+ ({ universalIdentifier }) => universalIdentifier,
+ ),
+ );
+ const isFolderResolvable = ({
+ folderUniversalIdentifier,
+ }: FlatNavigationMenuItem) => {
+ if (!isDefined(folderUniversalIdentifier)) {
+ return true;
+ }
+
+ if (
+ isDefined(
+ applicationAllFlatEntityMaps.flatNavigationMenuItemMaps
+ .byUniversalIdentifier[folderUniversalIdentifier],
+ )
+ ) {
+ return exportedUniversalIdentifiers.has(folderUniversalIdentifier);
+ }
+
+ return isDefined(
+ allFlatEntityMaps.flatNavigationMenuItemMaps.byUniversalIdentifier[
+ folderUniversalIdentifier
+ ],
+ );
+ };
+
+ let orphanedFlatNavigationMenuItems =
+ exportableFlatNavigationMenuItems.filter(
+ (flatNavigationMenuItem) => !isFolderResolvable(flatNavigationMenuItem),
+ );
+
+ while (orphanedFlatNavigationMenuItems.length > 0) {
+ for (const { universalIdentifier } of orphanedFlatNavigationMenuItems) {
+ exportedUniversalIdentifiers.delete(universalIdentifier);
+ coverage.push({
+ metadataName: 'navigationMenuItem',
+ universalIdentifier,
+ status: ApplicationExportCoverageStatus.UNSUPPORTED,
+ reason: `${NAVIGATION_MENU_ITEM_LABEL} in a folder that is not exported`,
+ });
+ }
+
+ orphanedFlatNavigationMenuItems = exportableFlatNavigationMenuItems.filter(
+ (flatNavigationMenuItem) =>
+ exportedUniversalIdentifiers.has(
+ flatNavigationMenuItem.universalIdentifier,
+ ) && !isFolderResolvable(flatNavigationMenuItem),
+ );
+ }
+
+ const navigationMenuItems = exportableFlatNavigationMenuItems
+ .filter(({ universalIdentifier }) =>
+ exportedUniversalIdentifiers.has(universalIdentifier),
+ )
+ .map((flatNavigationMenuItem) => {
+ coverage.push(
+ buildExportedCoverageEntry({
+ metadataName: 'navigationMenuItem',
+ flatEntity: flatNavigationMenuItem,
+ }),
+ );
+
+ return fromFlatNavigationMenuItemToNavigationMenuItemManifest({
+ flatNavigationMenuItem,
+ });
+ });
+
+ return { navigationMenuItems, 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 6dbd9d3b10a..53f2f40d99a 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
@@ -238,6 +238,24 @@ exports[`Application export - data model exports the whole application as a stab
"status": "EXPORTED",
"universalIdentifier": "<TICKET_TITLE_INDEX>",
},
+ {
+ "metadataName": "navigationMenuItem",
+ "reason": null,
+ "status": "EXPORTED",
+ "universalIdentifier": "<TICKETS_INDEX_VIEW_NAVIGATION_ITEM>",
+ },
+ {
+ "metadataName": "navigationMenuItem",
+ "reason": null,
+ "status": "EXPORTED",
+ "universalIdentifier": "<TICKETS_NAVIGATION_FOLDER>",
+ },
+ {
+ "metadataName": "navigationMenuItem",
+ "reason": null,
+ "status": "EXPORTED",
+ "universalIdentifier": "<TICKETS_NAVIGATION_ITEM>",
+ },
{
"metadataName": "objectMetadata",
"reason": null,
@@ -778,7 +796,31 @@ exports[`Application export - data model exports the whole application as a stab
},
],
"logicFunctions": [],
- "navigationMenuItems": [],
+ "navigationMenuItems": [
+ {
+ "name": "Support",
+ "position": 40,
+ "type": "FOLDER",
+ "universalIdentifier": "<TICKETS_NAVIGATION_FOLDER>",
+ },
+ {
+ "folderUniversalIdentifier": "<TICKETS_NAVIGATION_FOLDER>",
+ "icon": "IconTicket",
+ "position": 41,
+ "targetObjectUniversalIdentifier": "<TICKET_OBJECT>",
+ "type": "OBJECT",
+ "universalIdentifier": "<TICKETS_NAVIGATION_ITEM>",
+ },
+ {
+ "folderUniversalIdentifier": "<TICKETS_NAVIGATION_FOLDER>",
+ "icon": "IconList",
+ "name": "All tickets",
+ "position": 42,
+ "type": "VIEW",
+ "universalIdentifier": "<TICKETS_INDEX_VIEW_NAVIGATION_ITEM>",
+ "viewUniversalIdentifier": "<TICKET_INDEX_ENGINE_VIEW>",
+ },
+ ],
"objects": [
{
"color": "blue",
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 a5eb4ea52a8..ea8facd7548 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
@@ -23,6 +23,7 @@ import {
getSystemRelationFieldUniversalIdentifier,
getSystemViewFieldUniversalIdentifier,
getSystemViewUniversalIdentifier,
+ type NavigationMenuItemManifest,
type ObjectManifest,
type PageLayoutManifest,
type PageLayoutTabManifest,
@@ -37,6 +38,7 @@ import { STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS } from 'twenty-shared/metadata';
import {
AggregateOperations,
FieldMetadataType,
+ NavigationMenuItemType,
PageLayoutTabLayoutMode,
RelationOnDeleteAction,
RelationType,
@@ -82,6 +84,10 @@ const TICKET_BOARD_DOCS_WIDGET_ID = '7e3d1c2b-0024-4a7b-8c9d-0e1f2a3b4c5d';
const TICKET_RECORD_PAGE_EXTRA_TAB_ID = '7e3d1c2b-0025-4a7b-8c9d-0e1f2a3b4c5d';
const TICKET_RECORD_PAGE_EXTRA_NOTES_WIDGET_ID =
'7e3d1c2b-0026-4a7b-8c9d-0e1f2a3b4c5d';
+const TICKETS_NAVIGATION_FOLDER_ID = '7e3d1c2b-0029-4a7b-8c9d-0e1f2a3b4c5d';
+const TICKETS_NAVIGATION_ITEM_ID = '7e3d1c2b-0030-4a7b-8c9d-0e1f2a3b4c5d';
+const TICKETS_INDEX_VIEW_NAVIGATION_ITEM_ID =
+ '7e3d1c2b-0031-4a7b-8c9d-0e1f2a3b4c5d';
const COMPANY_RECORD_PAGE_TAGLINE_TAB_ID =
'7e3d1c2b-0027-4a7b-8c9d-0e1f2a3b4c5d';
const TICKET_RECORD_PAGE_HOME_DOCS_WIDGET_ID =
@@ -157,6 +163,12 @@ const buildIdentifierNames = (): Map<string, string> => {
COMPANY_RECORD_PAGE_TAGLINE_TAB_ID,
'STANDARD_COMPANY_RECORD_PAGE_TAGLINE_TAB',
],
+ [TICKETS_NAVIGATION_FOLDER_ID, 'TICKETS_NAVIGATION_FOLDER'],
+ [TICKETS_NAVIGATION_ITEM_ID, 'TICKETS_NAVIGATION_ITEM'],
+ [
+ TICKETS_INDEX_VIEW_NAVIGATION_ITEM_ID,
+ 'TICKETS_INDEX_VIEW_NAVIGATION_ITEM',
+ ],
[
TICKET_RECORD_PAGE_HOME_DOCS_WIDGET_ID,
'TICKET_RECORD_PAGE_HOME_DOCS_WIDGET',
@@ -552,6 +564,12 @@ const PROJECT_INDEX_VIEW_ID = getSystemViewUniversalIdentifier({
viewKey: SYSTEM_VIEW_KEYS.INDEX,
});
+const TICKET_INDEX_VIEW_ID = getSystemViewUniversalIdentifier({
+ objectMetadataApplicationUniversalIdentifier: TEST_APP_ID,
+ objectUniversalIdentifier: TICKET_OBJECT_ID,
+ viewKey: SYSTEM_VIEW_KEYS.INDEX,
+});
+
const projectIndexViewField: StandaloneViewFieldManifest = {
universalIdentifier: PROJECT_INDEX_VIEW_FIELD_ID,
viewUniversalIdentifier: PROJECT_INDEX_VIEW_ID,
@@ -684,6 +702,32 @@ const ticketRecordPageHomeDocsWidget: StandalonePageLayoutWidgetManifest = {
},
};
+const ticketsNavigationFolder: NavigationMenuItemManifest = {
+ universalIdentifier: TICKETS_NAVIGATION_FOLDER_ID,
+ type: NavigationMenuItemType.FOLDER,
+ name: 'Support',
+ position: 40,
+};
+
+const ticketsNavigationItem: NavigationMenuItemManifest = {
+ universalIdentifier: TICKETS_NAVIGATION_ITEM_ID,
+ type: NavigationMenuItemType.OBJECT,
+ position: 41,
+ icon: 'IconTicket',
+ folderUniversalIdentifier: TICKETS_NAVIGATION_FOLDER_ID,
+ targetObjectUniversalIdentifier: TICKET_OBJECT_ID,
+};
+
+const ticketsIndexViewNavigationItem: NavigationMenuItemManifest = {
+ universalIdentifier: TICKETS_INDEX_VIEW_NAVIGATION_ITEM_ID,
+ type: NavigationMenuItemType.VIEW,
+ position: 42,
+ name: 'All tickets',
+ icon: 'IconList',
+ folderUniversalIdentifier: TICKETS_NAVIGATION_FOLDER_ID,
+ viewUniversalIdentifier: TICKET_INDEX_VIEW_ID,
+};
+
const manifest = buildBaseManifest({
appId: TEST_APP_ID,
roleId: TEST_ROLE_ID,
@@ -708,6 +752,11 @@ const manifest = buildBaseManifest({
pageLayouts: [ticketPageLayout, ticketBoardLayout],
pageLayoutTabs: [ticketRecordPageExtraTab, companyRecordPageTaglineTab],
pageLayoutWidgets: [ticketRecordPageHomeDocsWidget],
+ navigationMenuItems: [
+ ticketsNavigationFolder,
+ ticketsNavigationItem,
+ ticketsIndexViewNavigationItem,
+ ],
},
});
@@ -838,15 +887,9 @@ describe('Application export - data model', () => {
expect(statusOf(TEST_ROLE_ID)).toBe(
ApplicationExportCoverageStatus.UNSUPPORTED,
);
- expect(
- statusOf(
- getSystemViewUniversalIdentifier({
- objectMetadataApplicationUniversalIdentifier: TEST_APP_ID,
- objectUniversalIdentifier: TICKET_OBJECT_ID,
- viewKey: SYSTEM_VIEW_KEYS.INDEX,
- }),
- ),
- ).toBe(ApplicationExportCoverageStatus.ENGINE_DERIVED);
+ expect(statusOf(TICKET_INDEX_VIEW_ID)).toBe(
+ ApplicationExportCoverageStatus.ENGINE_DERIVED,
+ );
expect(statusOf(PROJECT_INDEX_VIEW_ID)).toBe(
ApplicationExportCoverageStatus.ENGINE_DERIVED,
);
@@ -862,6 +905,15 @@ describe('Application export - data model', () => {
expect(statusOf(TICKET_RECORD_PAGE_HOME_DOCS_WIDGET_ID)).toBe(
ApplicationExportCoverageStatus.EXPORTED,
);
+ expect(statusOf(TICKETS_NAVIGATION_FOLDER_ID)).toBe(
+ ApplicationExportCoverageStatus.EXPORTED,
+ );
+ expect(statusOf(TICKETS_NAVIGATION_ITEM_ID)).toBe(
+ ApplicationExportCoverageStatus.EXPORTED,
+ );
+ expect(statusOf(TICKETS_INDEX_VIEW_NAVIGATION_ITEM_ID)).toBe(
+ ApplicationExportCoverageStatus.EXPORTED,
+ );
}, 60000);
it('round-trips the raw export through an additive dry-run sync without any action', async () => {