snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-batch-creation.integration-spec.ts.snap

@@ -0,0 +1,59 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`NavigationMenuItem batch creation should fail when batch contains item with invalid folderId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem batch creation should fail when batch contains item with invalid targetObjectMetadataId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem batch creation should fail when batch contains item with invalid targetRecordId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem batch creation should fail when batch contains item with missing targetRecordId 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "RELATION_UNIVERSAL_IDENTIFIER_NOT_FOUND",
+    "userFriendlyMessage": "An error occurred.",
+  },
+  "message": "Could not find objectMetadata for given targetObjectMetadataId",
+  "name": "NotFoundError",
+}
+`;
+

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-batch-deletion.integration-spec.ts.snap

@@ -0,0 +1,25 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`NavigationMenuItem batch deletion should fail when batch contains a non-existent id among valid ones 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;
+
+exports[`NavigationMenuItem batch deletion should fail when deleting with non-existent id 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-batch-update.integration-spec.ts.snap

@@ -0,0 +1,40 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`NavigationMenuItem batch update should fail when batch contains an update for non-existent item 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;
+
+exports[`NavigationMenuItem batch update should fail when updating with invalid folderId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem batch update should fail when updating with non-existent id 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-creation.integration-spec.ts.snap

@@ -0,0 +1,140 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`NavigationMenuItem creation should fail when creating with empty targetObjectMetadataId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "",
+  },
+  "message": "Invalid UUID: ''",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with empty targetRecordId 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "",
+  },
+  "message": "Invalid UUID: ''",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with invalid folderId (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with invalid targetObjectMetadataId (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with invalid targetRecordId (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with invalid userWorkspaceId (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with missing targetObjectMetadataId 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "navigationMenuItem": [
+        {
+          "errors": [
+            {
+              "code": "INVALID_NAVIGATION_MENU_ITEM_INPUT",
+              "message": "A valid targetObjectMetadataUniversalIdentifier is required for RECORD type",
+              "userFriendlyMessage": "A valid targetObjectMetadataUniversalIdentifier is required for RECORD type",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": null,
+            "type": "RECORD",
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "navigationMenuItem",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 navigationMenuItem",
+    "summary": {
+      "navigationMenuItem": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "A valid targetObjectMetadataUniversalIdentifier is required for RECORD type",
+  },
+  "message": "Multiple validation errors occurred while creating navigation menu items",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`NavigationMenuItem creation should fail when creating with missing targetRecordId 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "RELATION_UNIVERSAL_IDENTIFIER_NOT_FOUND",
+    "userFriendlyMessage": "An error occurred.",
+  },
+  "message": "Could not find objectMetadata for given targetObjectMetadataId",
+  "name": "NotFoundError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-deletion.integration-spec.ts.snap

@@ -0,0 +1,57 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`NavigationMenuItem deletion should fail when deleting a non-existent navigation menu item 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;
+
+exports[`NavigationMenuItem deletion should fail when deleting with empty id 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "",
+  },
+  "message": "Invalid UUID: ''",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem deletion should fail when deleting with invalid id (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem deletion should fail when deleting with missing id 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+  },
+  "message": "Variable "$id" of required type "UUID!" was not provided.",
+  "name": "GraphQLError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-update-circular-dependency.integration-spec.ts.snap

@@ -0,0 +1,75 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Navigation Menu Item update should fail with circular dependency when folderId equals id (self-reference) 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "navigationMenuItem": [
+        {
+          "errors": [
+            {
+              "code": "CIRCULAR_DEPENDENCY",
+              "message": "Navigation menu item cannot be its own parent",
+              "userFriendlyMessage": "Navigation menu item cannot be its own parent",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "Standalone Folder",
+            "type": "FOLDER",
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "navigationMenuItem",
+          "status": "fail",
+          "type": "update",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 navigationMenuItem",
+    "summary": {
+      "navigationMenuItem": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "Navigation menu item cannot be its own parent",
+  },
+  "message": "Multiple validation errors occurred while updating navigation menu items",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`Navigation Menu Item update should fail with circular dependency when update creates a circular dependency chain 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "navigationMenuItem": [
+        {
+          "errors": [
+            {
+              "code": "CIRCULAR_DEPENDENCY",
+              "message": "Circular dependency detected in navigation menu item hierarchy",
+              "userFriendlyMessage": "Circular dependency detected in navigation menu item hierarchy",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "Parent Folder",
+            "type": "FOLDER",
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "navigationMenuItem",
+          "status": "fail",
+          "type": "update",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 navigationMenuItem",
+    "summary": {
+      "navigationMenuItem": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "Circular dependency detected in navigation menu item hierarchy",
+  },
+  "message": "Multiple validation errors occurred while updating navigation menu items",
+  "name": "GraphQLError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/__snapshots__/failing-navigation-menu-item-update.integration-spec.ts.snap

@@ -0,0 +1,73 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`NavigationMenuItem update should fail when updating a non-existent navigation menu item 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "NAVIGATION_MENU_ITEM_NOT_FOUND",
+    "userFriendlyMessage": "Navigation menu item not found.",
+  },
+  "message": "Navigation menu item not found",
+  "name": "NotFoundError",
+}
+`;
+
+exports[`NavigationMenuItem update should fail when updating with empty id 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "",
+  },
+  "message": "Invalid UUID: ''",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem update should fail when updating with invalid folderId (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem update should fail when updating with invalid id (not a UUID) 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "not-a-valid-uuid",
+  },
+  "message": "Invalid UUID: 'not-a-valid-uuid'",
+  "name": "ValidationError",
+}
+`;
+
+exports[`NavigationMenuItem update should fail when updating with missing id 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "",
+  },
+  "message": "Invalid UUID: ''",
+  "name": "ValidationError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-batch-creation.integration-spec.ts

@@ -0,0 +1,81 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items.util';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+
+import { type CreateNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/create-navigation-menu-item.input';
+
+type TestContext = {
+  inputs: CreateNavigationMenuItemInput[];
+};
+
+const failingBatchCreationTestCases: EachTestingContext<TestContext>[] = [
+  {
+    title: 'when batch contains item with missing targetRecordId',
+    context: {
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetObjectMetadataId: faker.string.uuid(),
+        } as CreateNavigationMenuItemInput,
+      ],
+    },
+  },
+  {
+    title: 'when batch contains item with invalid targetRecordId',
+    context: {
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: 'not-a-valid-uuid',
+          targetObjectMetadataId: faker.string.uuid(),
+        },
+      ],
+    },
+  },
+  {
+    title: 'when batch contains item with invalid targetObjectMetadataId',
+    context: {
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: 'not-a-valid-uuid',
+        },
+      ],
+    },
+  },
+  {
+    title: 'when batch contains item with invalid folderId',
+    context: {
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: faker.string.uuid(),
+          folderId: 'not-a-valid-uuid',
+        },
+      ],
+    },
+  },
+];
+
+describe('NavigationMenuItem batch creation should fail', () => {
+  it.each(eachTestingContextFilter(failingBatchCreationTestCases))(
+    '$title',
+    async ({ context }) => {
+      const { errors } = await createManyNavigationMenuItems({
+        expectToFail: true,
+        inputs: context.inputs,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-batch-deletion.integration-spec.ts

@@ -0,0 +1,100 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { deleteManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+type TestContext = {
+  buildIds: (realItemId: string) => string[];
+};
+
+const failingBatchDeletionTestCases: EachTestingContext<TestContext>[] = [
+  {
+    title: 'when deleting with non-existent id',
+    context: {
+      buildIds: () => [faker.string.uuid()],
+    },
+  },
+  {
+    title: 'when batch contains a non-existent id among valid ones',
+    context: {
+      buildIds: (realItemId: string) => [realItemId, faker.string.uuid()],
+    },
+  },
+];
+
+describe('NavigationMenuItem batch deletion should fail', () => {
+  let createdNavigationMenuItemId: string;
+  let personObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  beforeEach(async () => {
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: faker.string.uuid(),
+        targetObjectMetadataId: personObjectMetadataId,
+        position: 1,
+      },
+    });
+
+    createdNavigationMenuItemId = data.createNavigationMenuItem.id;
+  });
+
+  afterEach(async () => {
+    if (createdNavigationMenuItemId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdNavigationMenuItemId },
+      });
+      createdNavigationMenuItemId = undefined as unknown as string;
+    }
+  });
+
+  it.each(eachTestingContextFilter(failingBatchDeletionTestCases))(
+    '$title',
+    async ({ context }) => {
+      const ids = context.buildIds(createdNavigationMenuItemId);
+
+      const { errors } = await deleteManyNavigationMenuItems({
+        expectToFail: true,
+        ids,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-batch-update.integration-spec.ts

@@ -0,0 +1,127 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { updateManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-many-navigation-menu-items.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+import { type UpdateOneNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/update-navigation-menu-item.input';
+
+type TestContext = {
+  buildInputs: (itemId: string) => UpdateOneNavigationMenuItemInput[];
+};
+
+const failingBatchUpdateTestCases: EachTestingContext<TestContext>[] = [
+  {
+    title: 'when updating with non-existent id',
+    context: {
+      buildInputs: () => [
+        {
+          id: faker.string.uuid(),
+          update: { position: 5 },
+        },
+      ],
+    },
+  },
+  {
+    title: 'when updating with invalid folderId',
+    context: {
+      buildInputs: (itemId: string) => [
+        {
+          id: itemId,
+          update: { folderId: 'not-a-valid-uuid' },
+        },
+      ],
+    },
+  },
+  {
+    title: 'when batch contains an update for non-existent item',
+    context: {
+      buildInputs: (itemId: string) => [
+        {
+          id: itemId,
+          update: { position: 10 },
+        },
+        {
+          id: faker.string.uuid(),
+          update: { position: 20 },
+        },
+      ],
+    },
+  },
+];
+
+describe('NavigationMenuItem batch update should fail', () => {
+  let createdNavigationMenuItemId: string;
+  let personObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  beforeEach(async () => {
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: faker.string.uuid(),
+        targetObjectMetadataId: personObjectMetadataId,
+        position: 1,
+      },
+    });
+
+    createdNavigationMenuItemId = data.createNavigationMenuItem.id;
+  });
+
+  afterEach(async () => {
+    if (createdNavigationMenuItemId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdNavigationMenuItemId },
+      });
+      createdNavigationMenuItemId = undefined as unknown as string;
+    }
+  });
+
+  it.each(eachTestingContextFilter(failingBatchUpdateTestCases))(
+    '$title',
+    async ({ context }) => {
+      const inputs = context.buildInputs(createdNavigationMenuItemId);
+
+      const { errors } = await updateManyNavigationMenuItems({
+        expectToFail: true,
+        inputs,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-creation.integration-spec.ts

@@ -0,0 +1,114 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+
+import { type CreateNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/create-navigation-menu-item.input';
+
+type TestContext = {
+  input: CreateNavigationMenuItemInput;
+};
+
+const failingNavigationMenuItemCreationTestCases: EachTestingContext<TestContext>[] =
+  [
+    {
+      title: 'when creating with missing targetRecordId',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetObjectMetadataId: faker.string.uuid(),
+        } as CreateNavigationMenuItemInput,
+      },
+    },
+    {
+      title: 'when creating with empty targetRecordId',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: '',
+          targetObjectMetadataId: faker.string.uuid(),
+        },
+      },
+    },
+    {
+      title: 'when creating with invalid targetRecordId (not a UUID)',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: 'not-a-valid-uuid',
+          targetObjectMetadataId: faker.string.uuid(),
+        },
+      },
+    },
+    {
+      title: 'when creating with missing targetObjectMetadataId',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+        } as CreateNavigationMenuItemInput,
+      },
+    },
+    {
+      title: 'when creating with empty targetObjectMetadataId',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: '',
+        },
+      },
+    },
+    {
+      title: 'when creating with invalid targetObjectMetadataId (not a UUID)',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: 'not-a-valid-uuid',
+        },
+      },
+    },
+    {
+      title: 'when creating with invalid userWorkspaceId (not a UUID)',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: faker.string.uuid(),
+          userWorkspaceId: 'not-a-valid-uuid',
+        },
+      },
+    },
+    {
+      title: 'when creating with invalid folderId (not a UUID)',
+      context: {
+        input: {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: faker.string.uuid(),
+          folderId: 'not-a-valid-uuid',
+        },
+      },
+    },
+  ];
+
+describe('NavigationMenuItem creation should fail', () => {
+  it.each(eachTestingContextFilter(failingNavigationMenuItemCreationTestCases))(
+    '$title',
+    async ({ context }) => {
+      const { errors } = await createNavigationMenuItem({
+        expectToFail: true,
+        input: context.input,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-deletion.integration-spec.ts

@@ -0,0 +1,62 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { type DeleteNavigationMenuItemFactoryInput } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item-query-factory.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+
+type TestContext = {
+  input: DeleteNavigationMenuItemFactoryInput;
+};
+
+const failingNavigationMenuItemDeletionTestCases: EachTestingContext<TestContext>[] =
+  [
+    {
+      title: 'when deleting a non-existent navigation menu item',
+      context: {
+        input: {
+          id: faker.string.uuid(),
+        },
+      },
+    },
+    {
+      title: 'when deleting with missing id',
+      context: {
+        input: {} as DeleteNavigationMenuItemFactoryInput,
+      },
+    },
+    {
+      title: 'when deleting with empty id',
+      context: {
+        input: {
+          id: '',
+        },
+      },
+    },
+    {
+      title: 'when deleting with invalid id (not a UUID)',
+      context: {
+        input: {
+          id: 'not-a-valid-uuid',
+        },
+      },
+    },
+  ];
+
+describe('NavigationMenuItem deletion should fail', () => {
+  it.each(eachTestingContextFilter(failingNavigationMenuItemDeletionTestCases))(
+    '$title',
+    async ({ context }) => {
+      const { errors } = await deleteNavigationMenuItem({
+        expectToFail: true,
+        input: context.input,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-update-circular-dependency.integration-spec.ts

@@ -0,0 +1,103 @@
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { updateNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('Navigation Menu Item update should fail with circular dependency', () => {
+  let folderId: string;
+  let parentFolderId: string;
+  let childFolderId: string;
+
+  beforeAll(async () => {
+    const { data: folderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.FOLDER,
+        name: 'Standalone Folder',
+      },
+    });
+
+    folderId = folderData?.createNavigationMenuItem?.id;
+    jestExpectToBeDefined(folderId);
+
+    const { data: parentFolderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.FOLDER,
+        name: 'Parent Folder',
+      },
+    });
+
+    parentFolderId = parentFolderData?.createNavigationMenuItem?.id;
+    jestExpectToBeDefined(parentFolderId);
+
+    const { data: childFolderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.FOLDER,
+        name: 'Child Folder',
+        folderId: parentFolderId,
+      },
+    });
+
+    childFolderId = childFolderData?.createNavigationMenuItem?.id;
+    jestExpectToBeDefined(childFolderId);
+  });
+
+  afterAll(async () => {
+    if (childFolderId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: childFolderId },
+      });
+    }
+
+    if (parentFolderId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: parentFolderId },
+      });
+    }
+
+    if (folderId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: folderId },
+      });
+    }
+  });
+
+  it('when folderId equals id (self-reference)', async () => {
+    const { errors } = await updateNavigationMenuItem({
+      expectToFail: true,
+      input: {
+        id: folderId,
+        update: {
+          folderId: folderId,
+        },
+      },
+    });
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors,
+    });
+  });
+
+  it('when update creates a circular dependency chain', async () => {
+    const { errors } = await updateNavigationMenuItem({
+      expectToFail: true,
+      input: {
+        id: parentFolderId,
+        update: {
+          folderId: childFolderId,
+        },
+      },
+    });
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors,
+    });
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/failing-navigation-menu-item-update.integration-spec.ts

@@ -0,0 +1,156 @@
+import { faker } from '@faker-js/faker';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { updateNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+
+import { type UpdateOneNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/update-navigation-menu-item.input';
+
+type TestContext = {
+  input: (testSetup: TestSetup) => UpdateOneNavigationMenuItemInput;
+};
+
+type TestSetup = {
+  testNavigationMenuItemId: string;
+};
+
+describe('NavigationMenuItem update should fail', () => {
+  let testNavigationMenuItemId: string;
+  let personObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  beforeEach(async () => {
+    const targetRecordId = faker.string.uuid();
+
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+        position: 1,
+      },
+    });
+
+    testNavigationMenuItemId = data.createNavigationMenuItem.id;
+  });
+
+  afterEach(async () => {
+    if (testNavigationMenuItemId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: testNavigationMenuItemId },
+      });
+    }
+  });
+
+  const failingNavigationMenuItemUpdateTestCases: EachTestingContext<TestContext>[] =
+    [
+      {
+        title: 'when updating with missing id',
+        context: {
+          input: () =>
+            ({
+              id: '',
+              update: {
+                position: 10,
+              },
+            }) as UpdateOneNavigationMenuItemInput,
+        },
+      },
+      {
+        title: 'when updating with empty id',
+        context: {
+          input: () => ({
+            id: '',
+            update: {
+              position: 10,
+            },
+          }),
+        },
+      },
+      {
+        title: 'when updating with invalid id (not a UUID)',
+        context: {
+          input: () => ({
+            id: 'not-a-valid-uuid',
+            update: {
+              position: 10,
+            },
+          }),
+        },
+      },
+      {
+        title: 'when updating a non-existent navigation menu item',
+        context: {
+          input: () => ({
+            id: faker.string.uuid(),
+            update: {
+              position: 10,
+            },
+          }),
+        },
+      },
+      {
+        title: 'when updating with invalid folderId (not a UUID)',
+        context: {
+          input: (testSetup) => ({
+            id: testSetup.testNavigationMenuItemId,
+            update: {
+              folderId: 'not-a-valid-uuid',
+            },
+          }),
+        },
+      },
+    ];
+
+  it.each(eachTestingContextFilter(failingNavigationMenuItemUpdateTestCases))(
+    '$title',
+    async ({ context }) => {
+      const testSetup: TestSetup = {
+        testNavigationMenuItemId,
+      };
+
+      const input = context.input(testSetup);
+
+      const { errors } = await updateNavigationMenuItem({
+        expectToFail: true,
+        input,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-batch-creation.integration-spec.ts

@@ -0,0 +1,218 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { createManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items.util';
+import { deleteManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items.util';
+import { findNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem batch creation should succeed', () => {
+  let personObjectMetadataId: string;
+  let companyObjectMetadataId: string;
+  let createdIds: string[] = [];
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+    const companyObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'company',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+    jestExpectToBeDefined(companyObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+    companyObjectMetadataId = companyObjectMetadata.id;
+  });
+
+  afterEach(async () => {
+    if (createdIds.length > 0) {
+      await deleteManyNavigationMenuItems({
+        ids: createdIds,
+        expectToFail: false,
+      });
+      createdIds = [];
+    }
+  });
+
+  it('should create multiple navigation menu items in a single batch', async () => {
+    const targetRecordId1 = faker.string.uuid();
+    const targetRecordId2 = faker.string.uuid();
+
+    const { data } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: targetRecordId1,
+          targetObjectMetadataId: personObjectMetadataId,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: targetRecordId2,
+          targetObjectMetadataId: companyObjectMetadataId,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(data?.createManyNavigationMenuItems);
+
+    const items = data.createManyNavigationMenuItems;
+
+    createdIds = items.map((item) => item.id);
+
+    expect(items).toHaveLength(2);
+
+    expect(items[0]).toMatchObject({
+      id: expect.any(String),
+      targetRecordId: targetRecordId1,
+      targetObjectMetadataId: personObjectMetadataId,
+    });
+
+    expect(items[1]).toMatchObject({
+      id: expect.any(String),
+      targetRecordId: targetRecordId2,
+      targetObjectMetadataId: companyObjectMetadataId,
+    });
+  });
+
+  it('should create a folder and a child item in a single batch', async () => {
+    const folderId = faker.string.uuid();
+    const targetRecordId = faker.string.uuid();
+
+    const { data } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          id: folderId,
+          type: NavigationMenuItemType.FOLDER,
+          name: 'Test Folder',
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId,
+          targetObjectMetadataId: personObjectMetadataId,
+          folderId,
+          position: 1,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(data?.createManyNavigationMenuItems);
+
+    const items = data.createManyNavigationMenuItems;
+
+    createdIds = items.map((item) => item.id);
+
+    expect(items).toHaveLength(2);
+
+    expect(items[0]).toMatchObject({
+      id: folderId,
+      type: NavigationMenuItemType.FOLDER,
+      name: 'Test Folder',
+    });
+
+    expect(items[1]).toMatchObject({
+      targetRecordId,
+      folderId,
+    });
+  });
+
+  it('should preserve input order in the response', async () => {
+    const targetRecordId1 = faker.string.uuid();
+    const targetRecordId2 = faker.string.uuid();
+    const targetRecordId3 = faker.string.uuid();
+
+    const { data } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: targetRecordId1,
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 3,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: targetRecordId2,
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: targetRecordId3,
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 2,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(data?.createManyNavigationMenuItems);
+
+    const items = data.createManyNavigationMenuItems;
+
+    createdIds = items.map((item) => item.id);
+
+    expect(items).toHaveLength(3);
+    expect(items[0].targetRecordId).toBe(targetRecordId1);
+    expect(items[1].targetRecordId).toBe(targetRecordId2);
+    expect(items[2].targetRecordId).toBe(targetRecordId3);
+  });
+
+  it('should return empty array for empty inputs', async () => {
+    const { data } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [],
+    });
+
+    jestExpectToBeDefined(data?.createManyNavigationMenuItems);
+    expect(data.createManyNavigationMenuItems).toHaveLength(0);
+  });
+
+  it('should create items visible in findAll', async () => {
+    const targetRecordId = faker.string.uuid();
+
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId,
+          targetObjectMetadataId: personObjectMetadataId,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    createdIds = createData.createManyNavigationMenuItems.map(
+      (item) => item.id,
+    );
+
+    const { data: findData } = await findNavigationMenuItems({
+      expectToFail: false,
+      input: undefined,
+    });
+
+    const foundItem = findData.navigationMenuItems.find(
+      (item) => item.id === createdIds[0],
+    );
+
+    expect(foundItem).toBeDefined();
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-batch-deletion.integration-spec.ts

@@ -0,0 +1,182 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { createManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items.util';
+import { deleteManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items.util';
+import { findNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem batch deletion should succeed', () => {
+  let personObjectMetadataId: string;
+  let pendingCleanupIds: string[] = [];
+
+  afterEach(async () => {
+    if (pendingCleanupIds.length > 0) {
+      await deleteManyNavigationMenuItems({
+        ids: pendingCleanupIds,
+        expectToFail: false,
+      });
+      pendingCleanupIds = [];
+    }
+  });
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  it('should delete multiple items in a single batch', async () => {
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    const items = createData.createManyNavigationMenuItems;
+    const idsToDelete = items.map((item) => item.id);
+
+    pendingCleanupIds = [...idsToDelete];
+
+    const { data: deleteData } = await deleteManyNavigationMenuItems({
+      ids: idsToDelete,
+      expectToFail: false,
+    });
+
+    pendingCleanupIds = [];
+
+    jestExpectToBeDefined(deleteData?.deleteManyNavigationMenuItems);
+    expect(deleteData.deleteManyNavigationMenuItems).toHaveLength(2);
+
+    const { data: findData } = await findNavigationMenuItems({
+      expectToFail: false,
+      input: undefined,
+    });
+
+    for (const deletedId of idsToDelete) {
+      const foundItem = findData.navigationMenuItems.find(
+        (item) => item.id === deletedId,
+      );
+      expect(foundItem).toBeUndefined();
+    }
+  });
+
+  it('should delete a folder and cascade to its children', async () => {
+    const folderId = faker.string.uuid();
+
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          id: folderId,
+          type: NavigationMenuItemType.FOLDER,
+          name: 'Cascade Folder',
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+          folderId,
+          position: 1,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    const items = createData.createManyNavigationMenuItems;
+    const childId = items[1].id;
+
+    pendingCleanupIds = items.map((item) => item.id);
+
+    const { data: deleteData } = await deleteManyNavigationMenuItems({
+      ids: [folderId],
+      expectToFail: false,
+    });
+
+    pendingCleanupIds = [];
+
+    jestExpectToBeDefined(deleteData?.deleteManyNavigationMenuItems);
+    expect(deleteData.deleteManyNavigationMenuItems).toHaveLength(1);
+
+    const { data: findData } = await findNavigationMenuItems({
+      expectToFail: false,
+      input: undefined,
+    });
+
+    expect(
+      findData.navigationMenuItems.find((item) => item.id === folderId),
+    ).toBeUndefined();
+
+    expect(
+      findData.navigationMenuItems.find((item) => item.id === childId),
+    ).toBeUndefined();
+  });
+
+  it('should handle deduplication of ids', async () => {
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    const itemId = createData.createManyNavigationMenuItems[0].id;
+
+    pendingCleanupIds = [itemId];
+
+    const { data: deleteData } = await deleteManyNavigationMenuItems({
+      ids: [itemId, itemId],
+      expectToFail: false,
+    });
+
+    pendingCleanupIds = [];
+
+    jestExpectToBeDefined(deleteData?.deleteManyNavigationMenuItems);
+    expect(deleteData.deleteManyNavigationMenuItems).toHaveLength(1);
+  });
+
+  it('should return empty array for empty ids', async () => {
+    const { data } = await deleteManyNavigationMenuItems({
+      ids: [],
+      expectToFail: false,
+    });
+
+    jestExpectToBeDefined(data?.deleteManyNavigationMenuItems);
+    expect(data.deleteManyNavigationMenuItems).toHaveLength(0);
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-batch-update.integration-spec.ts

@@ -0,0 +1,150 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { createManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items.util';
+import { deleteManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items.util';
+import { updateManyNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-many-navigation-menu-items.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem batch update should succeed', () => {
+  let personObjectMetadataId: string;
+  let createdIds: string[] = [];
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  afterEach(async () => {
+    if (createdIds.length > 0) {
+      await deleteManyNavigationMenuItems({
+        ids: createdIds,
+        expectToFail: false,
+      });
+      createdIds = [];
+    }
+  });
+
+  it('should update positions of multiple items at once', async () => {
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 2,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    const items = createData.createManyNavigationMenuItems;
+    createdIds = items.map((item) => item.id);
+
+    const { data: updateData } = await updateManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        { id: items[0].id, update: { position: 10 } },
+        { id: items[1].id, update: { position: 20 } },
+      ],
+    });
+
+    jestExpectToBeDefined(updateData?.updateManyNavigationMenuItems);
+
+    const updatedItems = updateData.updateManyNavigationMenuItems;
+
+    expect(updatedItems).toHaveLength(2);
+    expect(updatedItems[0]).toMatchObject({
+      id: items[0].id,
+      position: 10,
+    });
+    expect(updatedItems[1]).toMatchObject({
+      id: items[1].id,
+      position: 20,
+    });
+  });
+
+  it('should update folderIds of multiple items at once', async () => {
+    const folderId = faker.string.uuid();
+
+    const { data: createData } = await createManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        {
+          id: folderId,
+          type: NavigationMenuItemType.FOLDER,
+          name: 'Batch Folder',
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 1,
+        },
+        {
+          type: NavigationMenuItemType.RECORD,
+          targetRecordId: faker.string.uuid(),
+          targetObjectMetadataId: personObjectMetadataId,
+          position: 2,
+        },
+      ],
+    });
+
+    jestExpectToBeDefined(createData?.createManyNavigationMenuItems);
+    const items = createData.createManyNavigationMenuItems;
+    createdIds = items.map((item) => item.id);
+
+    const { data: updateData } = await updateManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [
+        { id: items[1].id, update: { folderId } },
+        { id: items[2].id, update: { folderId } },
+      ],
+    });
+
+    jestExpectToBeDefined(updateData?.updateManyNavigationMenuItems);
+
+    const updatedItems = updateData.updateManyNavigationMenuItems;
+
+    expect(updatedItems).toHaveLength(2);
+    expect(updatedItems[0]).toMatchObject({ id: items[1].id, folderId });
+    expect(updatedItems[1]).toMatchObject({ id: items[2].id, folderId });
+  });
+
+  it('should return empty array for empty inputs', async () => {
+    const { data } = await updateManyNavigationMenuItems({
+      expectToFail: false,
+      inputs: [],
+    });
+
+    jestExpectToBeDefined(data?.updateManyNavigationMenuItems);
+    expect(data.updateManyNavigationMenuItems).toHaveLength(0);
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-creation.integration-spec.ts

@@ -0,0 +1,175 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { getCurrentUser } from 'test/integration/graphql/utils/get-current-user.util';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem creation should succeed', () => {
+  let createdNavigationMenuItemId: string;
+  let companyObjectMetadataId: string;
+  let personObjectMetadataId: string;
+  let validUserWorkspaceId: string | null;
+  let createdFolderId: string | undefined;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const companyObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'company',
+    );
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(companyObjectMetadata);
+    jestExpectToBeDefined(personObjectMetadata);
+
+    companyObjectMetadataId = companyObjectMetadata.id;
+    personObjectMetadataId = personObjectMetadata.id;
+
+    const { data: currentUserData } = await getCurrentUser({
+      accessToken: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+      expectToFail: false,
+    });
+
+    jestExpectToBeDefined(currentUserData?.currentUser?.currentUserWorkspace);
+
+    validUserWorkspaceId =
+      currentUserData?.currentUser?.currentUserWorkspace?.id ?? null;
+  });
+
+  afterEach(async () => {
+    if (createdNavigationMenuItemId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdNavigationMenuItemId },
+      });
+      createdNavigationMenuItemId = undefined as unknown as string;
+    }
+    if (createdFolderId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdFolderId },
+      });
+      createdFolderId = undefined;
+    }
+  });
+
+  it('should create a basic navigation menu item with minimal input', async () => {
+    const targetRecordId = faker.string.uuid();
+
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    createdNavigationMenuItemId = data?.createNavigationMenuItem?.id;
+
+    expect(data.createNavigationMenuItem).toMatchObject({
+      id: expect.any(String),
+      targetRecordId,
+      targetObjectMetadataId: personObjectMetadataId,
+      userWorkspaceId: null,
+      folderId: null,
+      position: expect.any(Number),
+    });
+  });
+
+  it('should create navigation menu item with all optional fields', async () => {
+    const targetRecordId = faker.string.uuid();
+    const folderTargetRecordId = faker.string.uuid();
+
+    const { data: folderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: folderTargetRecordId,
+        targetObjectMetadataId: companyObjectMetadataId,
+        userWorkspaceId: validUserWorkspaceId ?? undefined,
+      },
+    });
+
+    const folderId = folderData?.createNavigationMenuItem?.id;
+
+    jestExpectToBeDefined(folderId);
+    createdFolderId = folderId;
+
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId,
+        targetObjectMetadataId: companyObjectMetadataId,
+        userWorkspaceId: validUserWorkspaceId ?? undefined,
+        folderId,
+        position: 5,
+      },
+    });
+
+    createdNavigationMenuItemId = data?.createNavigationMenuItem?.id;
+
+    expect(data.createNavigationMenuItem).toMatchObject({
+      id: expect.any(String),
+      targetRecordId,
+      targetObjectMetadataId: companyObjectMetadataId,
+      userWorkspaceId: validUserWorkspaceId,
+      folderId,
+      position: 5,
+    });
+  });
+
+  it('should auto-calculate position when not provided', async () => {
+    const targetRecordId1 = faker.string.uuid();
+    const targetRecordId2 = faker.string.uuid();
+
+    const { data: data1 } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: targetRecordId1,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    const firstItemId = data1.createNavigationMenuItem.id;
+    const firstPosition = data1.createNavigationMenuItem.position;
+
+    const { data: data2 } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: targetRecordId2,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    createdNavigationMenuItemId = data2.createNavigationMenuItem.id;
+
+    expect(data2.createNavigationMenuItem.position).toBeGreaterThan(
+      firstPosition,
+    );
+
+    await deleteNavigationMenuItem({
+      expectToFail: false,
+      input: { id: firstItemId },
+    });
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-deletion.integration-spec.ts

@@ -0,0 +1,71 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { findNavigationMenuItems } from 'test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem deletion should succeed', () => {
+  let personObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  it('should delete an existing navigation menu item', async () => {
+    const targetRecordId = faker.string.uuid();
+
+    const { data: createData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    const createdId = createData.createNavigationMenuItem.id;
+
+    const { data: deleteData } = await deleteNavigationMenuItem({
+      expectToFail: false,
+      input: { id: createdId },
+    });
+
+    expect(deleteData.deleteNavigationMenuItem).toMatchObject({
+      id: createdId,
+      targetRecordId,
+    });
+
+    const { data: findData } = await findNavigationMenuItems({
+      expectToFail: false,
+      input: undefined,
+    });
+
+    const deletedItem = findData.navigationMenuItems.find(
+      (item) => item.id === createdId,
+    );
+
+    expect(deletedItem).toBeUndefined();
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/successful-navigation-menu-item-update.integration-spec.ts

@@ -0,0 +1,198 @@
+import { faker } from '@faker-js/faker';
+import { NavigationMenuItemType } from 'twenty-shared/types';
+import { createNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util';
+import { deleteNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util';
+import { updateNavigationMenuItem } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+
+describe('NavigationMenuItem update should succeed', () => {
+  let createdNavigationMenuItemId: string;
+  let personObjectMetadataId: string;
+  let createdFolderId: string | undefined;
+
+  beforeAll(async () => {
+    const { objects } = await findManyObjectMetadata({
+      expectToFail: false,
+      input: {
+        filter: {},
+        paging: { first: 1000 },
+      },
+      gqlFields: `
+        id
+        nameSingular
+      `,
+    });
+
+    jestExpectToBeDefined(objects);
+
+    const personObjectMetadata = objects.find(
+      (object: { nameSingular: string }) => object.nameSingular === 'person',
+    );
+
+    jestExpectToBeDefined(personObjectMetadata);
+
+    personObjectMetadataId = personObjectMetadata.id;
+  });
+
+  beforeEach(async () => {
+    const targetRecordId = faker.string.uuid();
+
+    const { data } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+        position: 1,
+      },
+    });
+
+    createdNavigationMenuItemId = data.createNavigationMenuItem.id;
+  });
+
+  afterEach(async () => {
+    if (createdNavigationMenuItemId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdNavigationMenuItemId },
+      });
+      createdNavigationMenuItemId = undefined as unknown as string;
+    }
+    if (createdFolderId) {
+      await deleteNavigationMenuItem({
+        expectToFail: false,
+        input: { id: createdFolderId },
+      });
+      createdFolderId = undefined;
+    }
+  });
+
+  it('should update the position', async () => {
+    const { data } = await updateNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        id: createdNavigationMenuItemId,
+        update: {
+          position: 10,
+        },
+      },
+    });
+
+    expect(data.updateNavigationMenuItem).toMatchObject({
+      id: createdNavigationMenuItemId,
+      position: 10,
+    });
+  });
+
+  it('should update the folderId', async () => {
+    const folderTargetRecordId = faker.string.uuid();
+
+    const { data: folderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: folderTargetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    const folderId = folderData?.createNavigationMenuItem?.id;
+
+    jestExpectToBeDefined(folderId);
+    createdFolderId = folderId;
+
+    const { data } = await updateNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        id: createdNavigationMenuItemId,
+        update: {
+          folderId,
+        },
+      },
+    });
+
+    expect(data.updateNavigationMenuItem).toMatchObject({
+      id: createdNavigationMenuItemId,
+      folderId,
+    });
+  });
+
+  it('should update folderId to null', async () => {
+    const folderTargetRecordId = faker.string.uuid();
+
+    const { data: folderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: folderTargetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    const folderId = folderData?.createNavigationMenuItem?.id;
+
+    jestExpectToBeDefined(folderId);
+    createdFolderId = folderId;
+
+    await updateNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        id: createdNavigationMenuItemId,
+        update: {
+          folderId,
+        },
+      },
+    });
+
+    const { data } = await updateNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        id: createdNavigationMenuItemId,
+        update: {
+          folderId: null,
+        },
+      },
+    });
+
+    expect(data.updateNavigationMenuItem).toMatchObject({
+      id: createdNavigationMenuItemId,
+      folderId: null,
+    });
+  });
+
+  it('should update multiple fields at once', async () => {
+    const folderTargetRecordId = faker.string.uuid();
+
+    const { data: folderData } = await createNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        type: NavigationMenuItemType.RECORD,
+        targetRecordId: folderTargetRecordId,
+        targetObjectMetadataId: personObjectMetadataId,
+      },
+    });
+
+    const folderId = folderData?.createNavigationMenuItem?.id;
+
+    jestExpectToBeDefined(folderId);
+    createdFolderId = folderId;
+
+    const { data } = await updateNavigationMenuItem({
+      expectToFail: false,
+      input: {
+        id: createdNavigationMenuItemId,
+        update: {
+          folderId,
+          position: 99,
+        },
+      },
+    });
+
+    expect(data.updateNavigationMenuItem).toMatchObject({
+      id: createdNavigationMenuItemId,
+      folderId,
+      position: 99,
+    });
+  });
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items-query-factory.util.ts

@@ -0,0 +1,42 @@
+import gql from 'graphql-tag';
+
+import { type CreateNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/create-navigation-menu-item.input';
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  type
+  userWorkspaceId
+  targetRecordId
+  targetObjectMetadataId
+  viewId
+  folderId
+  position
+  name
+  link
+  icon
+  color
+  applicationId
+  createdAt
+  updatedAt
+`;
+
+export const createManyNavigationMenuItemsQueryFactory = ({
+  inputs,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: {
+  inputs: CreateNavigationMenuItemInput[];
+  gqlFields?: string;
+}) => ({
+  query: gql`
+    mutation CreateManyNavigationMenuItems(
+      $inputs: [CreateNavigationMenuItemInput!]!
+    ) {
+      createManyNavigationMenuItems(inputs: $inputs) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    inputs,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items.util.ts

@@ -0,0 +1,47 @@
+import { createManyNavigationMenuItemsQueryFactory } from 'test/integration/metadata/suites/navigation-menu-item/utils/create-many-navigation-menu-items-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type CreateNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/create-navigation-menu-item.input';
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const createManyNavigationMenuItems = async ({
+  inputs,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: {
+  inputs: CreateNavigationMenuItemInput[];
+  gqlFields?: string;
+  expectToFail?: boolean;
+  token?: string;
+}): CommonResponseBody<{
+  createManyNavigationMenuItems: NavigationMenuItemDTO[];
+}> => {
+  const graphqlOperation = createManyNavigationMenuItemsQueryFactory({
+    inputs,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch creation has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item-query-factory.util.ts

@@ -0,0 +1,35 @@
+import gql from 'graphql-tag';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type CreateNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/create-navigation-menu-item.input';
+
+export type CreateNavigationMenuItemFactoryInput =
+  CreateNavigationMenuItemInput;
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  userWorkspaceId
+  targetRecordId
+  targetObjectMetadataId
+  folderId
+  position
+  applicationId
+  createdAt
+  updatedAt
+`;
+
+export const createNavigationMenuItemQueryFactory = ({
+  input,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: PerformMetadataQueryParams<CreateNavigationMenuItemFactoryInput>) => ({
+  query: gql`
+    mutation CreateNavigationMenuItem($input: CreateNavigationMenuItemInput!) {
+      createNavigationMenuItem(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item.util.ts

@@ -0,0 +1,44 @@
+import {
+  type CreateNavigationMenuItemFactoryInput,
+  createNavigationMenuItemQueryFactory,
+} from 'test/integration/metadata/suites/navigation-menu-item/utils/create-navigation-menu-item-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const createNavigationMenuItem = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<CreateNavigationMenuItemFactoryInput>): CommonResponseBody<{
+  createNavigationMenuItem: NavigationMenuItemDTO;
+}> => {
+  const graphqlOperation = createNavigationMenuItemQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItem creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItem creation has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items-query-factory.util.ts

@@ -0,0 +1,28 @@
+import gql from 'graphql-tag';
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  type
+  targetRecordId
+  targetObjectMetadataId
+  position
+`;
+
+export const deleteManyNavigationMenuItemsQueryFactory = ({
+  ids,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: {
+  ids: string[];
+  gqlFields?: string;
+}) => ({
+  query: gql`
+    mutation DeleteManyNavigationMenuItems($ids: [UUID!]!) {
+      deleteManyNavigationMenuItems(ids: $ids) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    ids,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items.util.ts

@@ -0,0 +1,46 @@
+import { deleteManyNavigationMenuItemsQueryFactory } from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-many-navigation-menu-items-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const deleteManyNavigationMenuItems = async ({
+  ids,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: {
+  ids: string[];
+  gqlFields?: string;
+  expectToFail?: boolean;
+  token?: string;
+}): CommonResponseBody<{
+  deleteManyNavigationMenuItems: NavigationMenuItemDTO[];
+}> => {
+  const graphqlOperation = deleteManyNavigationMenuItemsQueryFactory({
+    ids,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch deletion should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch deletion has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item-query-factory.util.ts

@@ -0,0 +1,28 @@
+import gql from 'graphql-tag';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+export type DeleteNavigationMenuItemFactoryInput = {
+  id: string;
+};
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  targetRecordId
+  position
+`;
+
+export const deleteNavigationMenuItemQueryFactory = ({
+  input,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: PerformMetadataQueryParams<DeleteNavigationMenuItemFactoryInput>) => ({
+  query: gql`
+    mutation DeleteNavigationMenuItem($id: UUID!) {
+      deleteNavigationMenuItem(id: $id) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    id: input.id,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item.util.ts

@@ -0,0 +1,44 @@
+import {
+  type DeleteNavigationMenuItemFactoryInput,
+  deleteNavigationMenuItemQueryFactory,
+} from 'test/integration/metadata/suites/navigation-menu-item/utils/delete-navigation-menu-item-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const deleteNavigationMenuItem = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<DeleteNavigationMenuItemFactoryInput>): CommonResponseBody<{
+  deleteNavigationMenuItem: NavigationMenuItemDTO;
+}> => {
+  const graphqlOperation = deleteNavigationMenuItemQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItem deletion should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItem deletion has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items-query-factory.util.ts

@@ -0,0 +1,26 @@
+import gql from 'graphql-tag';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  userWorkspaceId
+  targetRecordId
+  targetObjectMetadataId
+  folderId
+  position
+  applicationId
+  createdAt
+  updatedAt
+`;
+
+export const findNavigationMenuItemsQueryFactory = ({
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: PerformMetadataQueryParams<void>) => ({
+  query: gql`
+    query NavigationMenuItems {
+      navigationMenuItems {
+        ${gqlFields}
+      }
+    }
+  `,
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items.util.ts

@@ -0,0 +1,39 @@
+import { findNavigationMenuItemsQueryFactory } from 'test/integration/metadata/suites/navigation-menu-item/utils/find-navigation-menu-items-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const findNavigationMenuItems = async ({
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<void>): CommonResponseBody<{
+  navigationMenuItems: NavigationMenuItemDTO[];
+}> => {
+  const graphqlOperation = findNavigationMenuItemsQueryFactory({
+    input: undefined,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItems query should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItems query has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/update-many-navigation-menu-items-query-factory.util.ts

@@ -0,0 +1,37 @@
+import gql from 'graphql-tag';
+
+import { type UpdateOneNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/update-navigation-menu-item.input';
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  type
+  userWorkspaceId
+  targetRecordId
+  targetObjectMetadataId
+  folderId
+  position
+  applicationId
+  createdAt
+  updatedAt
+`;
+
+export const updateManyNavigationMenuItemsQueryFactory = ({
+  inputs,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: {
+  inputs: UpdateOneNavigationMenuItemInput[];
+  gqlFields?: string;
+}) => ({
+  query: gql`
+    mutation UpdateManyNavigationMenuItems(
+      $inputs: [UpdateOneNavigationMenuItemInput!]!
+    ) {
+      updateManyNavigationMenuItems(inputs: $inputs) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    inputs,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/update-many-navigation-menu-items.util.ts

@@ -0,0 +1,47 @@
+import { updateManyNavigationMenuItemsQueryFactory } from 'test/integration/metadata/suites/navigation-menu-item/utils/update-many-navigation-menu-items-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+import { type UpdateOneNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/update-navigation-menu-item.input';
+
+export const updateManyNavigationMenuItems = async ({
+  inputs,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: {
+  inputs: UpdateOneNavigationMenuItemInput[];
+  gqlFields?: string;
+  expectToFail?: boolean;
+  token?: string;
+}): CommonResponseBody<{
+  updateManyNavigationMenuItems: NavigationMenuItemDTO[];
+}> => {
+  const graphqlOperation = updateManyNavigationMenuItemsQueryFactory({
+    inputs,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch update should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage:
+        'NavigationMenuItems batch update has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item-query-factory.util.ts

@@ -0,0 +1,35 @@
+import gql from 'graphql-tag';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type UpdateOneNavigationMenuItemInput } from 'src/engine/metadata-modules/navigation-menu-item/dtos/update-navigation-menu-item.input';
+
+export type UpdateNavigationMenuItemFactoryInput =
+  UpdateOneNavigationMenuItemInput;
+
+const DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS = `
+  id
+  userWorkspaceId
+  targetRecordId
+  targetObjectMetadataId
+  folderId
+  position
+  applicationId
+  createdAt
+  updatedAt
+`;
+
+export const updateNavigationMenuItemQueryFactory = ({
+  input,
+  gqlFields = DEFAULT_NAVIGATION_MENU_ITEM_GQL_FIELDS,
+}: PerformMetadataQueryParams<UpdateNavigationMenuItemFactoryInput>) => ({
+  query: gql`
+    mutation UpdateNavigationMenuItem($input: UpdateOneNavigationMenuItemInput!) {
+      updateNavigationMenuItem(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item.util.ts

@@ -0,0 +1,43 @@
+import {
+  type UpdateNavigationMenuItemFactoryInput,
+  updateNavigationMenuItemQueryFactory,
+} from 'test/integration/metadata/suites/navigation-menu-item/utils/update-navigation-menu-item-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type NavigationMenuItemDTO } from 'src/engine/metadata-modules/navigation-menu-item/dtos/navigation-menu-item.dto';
+
+export const updateNavigationMenuItem = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<UpdateNavigationMenuItemFactoryInput>): CommonResponseBody<{
+  updateNavigationMenuItem: NavigationMenuItemDTO;
+}> => {
+  const graphqlOperation = updateNavigationMenuItemQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItem update should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'NavigationMenuItem update has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};