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

packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap

@@ -0,0 +1,166 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`blocklist scope hooks refuses a member-scoped entry targeting another workspace member 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Cannot manage a blocklist entry of another workspace member.",
+  },
+  "message": "A workspace-member-scoped blocklist entry must target its own workspace member",
+}
+`;
+
+exports[`blocklist scope hooks refuses a member-scoped entry with no workspace member 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Cannot manage a blocklist entry of another workspace member.",
+  },
+  "message": "A workspace-member-scoped blocklist entry must target its own workspace member",
+}
+`;
+
+exports[`blocklist scope hooks refuses a scope change on an existing entry 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Blocklist scope cannot be updated.",
+  },
+  "message": "Blocklist scope cannot be updated",
+}
+`;
+
+exports[`blocklist scope hooks refuses a second workspace-scoped entry with the same handle 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Blocklist handle already exists.",
+  },
+  "message": "Blocklist handle already exists",
+}
+`;
+
+exports[`blocklist scope hooks refuses a workspace-scoped entry created without the workspace permission 1`] = `
+{
+  "extensions": {
+    "code": "FORBIDDEN",
+    "subCode": "PERMISSION_DENIED",
+    "userFriendlyMessage": "User does not have permission.",
+  },
+  "message": "Entity performing the request does not have permission",
+}
+`;
+
+exports[`blocklist scope hooks refuses a workspace-scoped entry that also targets a workspace member 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "A workspace-wide blocklist entry cannot target a workspace member.",
+  },
+  "message": "A workspace-scoped blocklist entry cannot target a workspace member",
+}
+`;
+
+exports[`blocklist scope hooks refuses deletion and restoration of a workspace-scoped entry without the workspace permission 1`] = `
+{
+  "extensions": {
+    "code": "FORBIDDEN",
+    "subCode": "PERMISSION_DENIED",
+    "userFriendlyMessage": "User does not have permission.",
+  },
+  "message": "Entity performing the request does not have permission",
+}
+`;
+
+exports[`blocklist scope hooks refuses deletion and restoration of a workspace-scoped entry without the workspace permission 2`] = `
+{
+  "extensions": {
+    "code": "FORBIDDEN",
+    "subCode": "PERMISSION_DENIED",
+    "userFriendlyMessage": "User does not have permission.",
+  },
+  "message": "Entity performing the request does not have permission",
+}
+`;
+
+exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Bulk deletion of blocklist entries is not allowed.",
+  },
+  "message": "Method not allowed.",
+}
+`;
+
+exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries 2`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Bulk deletion of blocklist entries is not allowed.",
+  },
+  "message": "Method not allowed.",
+}
+`;
+
+exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries 3`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Bulk restoration of blocklist entries is not allowed.",
+  },
+  "message": "Method not allowed.",
+}
+`;
+
+exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries 4`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Bulk update of blocklist entries is not allowed.",
+  },
+  "message": "Method not allowed.",
+}
+`;
+
+exports[`blocklist scope hooks refuses every bulk mutation of blocklist entries 5`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "INVALID_QUERY_INPUT",
+    "userFriendlyMessage": "This type of record cannot be merged.",
+  },
+  "message": "Merge is only available for objects with duplicate criteria. Object 'blocklist' does not have duplicate criteria defined.",
+}
+`;
+
+exports[`blocklist scope hooks refuses to null out the workspace member of a member-scoped entry 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "BAD_REQUEST",
+    "userFriendlyMessage": "Workspace member cannot be updated.",
+  },
+  "message": "Workspace member cannot be updated",
+}
+`;
+
+exports[`blocklist scope hooks refuses to overwrite a workspace-scoped entry through an upsert create 1`] = `
+{
+  "extensions": {
+    "code": "FORBIDDEN",
+    "subCode": "PERMISSION_DENIED",
+    "userFriendlyMessage": "User does not have permission.",
+  },
+  "message": "Entity performing the request does not have permission",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/hooks/blocklist-scope-hooks.integration-spec.ts

@@ -0,0 +1,423 @@
+import { randomUUID } from 'node:crypto';
+
+import gql from 'graphql-tag';
+import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { createOneOperation } from 'test/integration/graphql/utils/create-one-operation.util';
+import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
+import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { makeGraphqlAPIRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
+import { restoreOneOperationFactory } from 'test/integration/graphql/utils/restore-one-operation-factory.util';
+import { updateManyOperationFactory } from 'test/integration/graphql/utils/update-many-operation-factory.util';
+import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';
+import { BlocklistScope } from 'twenty-shared/types';
+
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const BLOCKLIST_GQL_FIELDS = `
+  id
+  handle
+  scope
+  workspaceMemberId
+  deletedAt
+`;
+
+const CREATE_BLOCKLISTS_WITH_UPSERT = gql`
+  mutation CreateBlocklists($data: [BlocklistCreateInput!]!, $upsert: Boolean) {
+    createBlocklists(data: $data, upsert: $upsert) {
+      id
+      handle
+      scope
+      workspaceMemberId
+    }
+  }
+`;
+
+const MERGE_BLOCKLISTS = gql`
+  mutation MergeBlocklists($ids: [UUID!]!, $conflictPriorityIndex: Int!) {
+    mergeBlocklists(ids: $ids, conflictPriorityIndex: $conflictPriorityIndex) {
+      id
+    }
+  }
+`;
+
+const uniqueEmailHandle = (prefix: string) =>
+  `${prefix}-${randomUUID()}@blocklist.test`;
+
+const uniqueDomainHandle = () => `@${randomUUID()}.test`;
+
+describe('blocklist scope hooks', () => {
+  const blocklistIds: string[] = [];
+
+  const trackedId = () => {
+    const id = randomUUID();
+
+    blocklistIds.push(id);
+
+    return id;
+  };
+
+  const createAsAdmin = (input: Record<string, unknown>) =>
+    createOneOperation({
+      objectMetadataSingularName: 'blocklist',
+      gqlFields: BLOCKLIST_GQL_FIELDS,
+      input,
+    });
+
+  const createAsMember = (input: Record<string, unknown>) =>
+    makeGraphqlAPIRequestWithMemberRole(
+      createOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        data: input,
+      }),
+    );
+
+  const upsertAsMember = (data: Record<string, unknown>) =>
+    makeGraphqlAPIRequestWithMemberRole({
+      query: CREATE_BLOCKLISTS_WITH_UPSERT,
+      variables: { data: [data], upsert: true },
+    });
+
+  const upsertAsAdmin = (data: Record<string, unknown>) =>
+    makeGraphqlAPIRequest({
+      query: CREATE_BLOCKLISTS_WITH_UPSERT,
+      variables: { data: [data], upsert: true },
+    });
+
+  const deleteAsAdmin = (recordId: string) =>
+    makeGraphqlAPIRequest(
+      deleteOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        recordId,
+      }),
+    );
+
+  const restoreOne = (
+    recordId: string,
+    request: typeof makeGraphqlAPIRequest = makeGraphqlAPIRequest,
+  ) =>
+    request(
+      restoreOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        recordId,
+      }),
+    );
+
+  afterAll(async () => {
+    for (const blocklistId of blocklistIds) {
+      await makeGraphqlAPIRequest(
+        destroyOneOperationFactory({
+          objectMetadataSingularName: 'blocklist',
+          gqlFields: 'id',
+          recordId: blocklistId,
+        }),
+      );
+    }
+  });
+
+  it('lets an admin create a workspace-scoped entry with no workspace member', async () => {
+    const { data, errors } = await createAsAdmin({
+      id: trackedId(),
+      handle: uniqueDomainHandle(),
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expect(errors).toBeUndefined();
+    expect(data.createOneResponse.scope).toBe(BlocklistScope.WORKSPACE);
+    expect(data.createOneResponse.workspaceMemberId).toBeNull();
+  });
+
+  it('lets a member create their own member-scoped entry', async () => {
+    const response = await createAsMember({
+      id: trackedId(),
+      handle: uniqueEmailHandle('my-own-entry'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+    });
+
+    expect(response.body.errors).toBeUndefined();
+    expect(response.body.data.createBlocklist.scope).toBe(
+      BlocklistScope.WORKSPACE_MEMBER,
+    );
+  });
+
+  it('refuses a workspace-scoped entry that also targets a workspace member', async () => {
+    const { errors } = await createAsAdmin({
+      id: randomUUID(),
+      handle: uniqueDomainHandle(),
+      scope: BlocklistScope.WORKSPACE,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+
+  it('refuses a workspace-scoped entry created without the workspace permission', async () => {
+    const response = await createAsMember({
+      id: randomUUID(),
+      handle: uniqueDomainHandle(),
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors: response.body.errors });
+  });
+
+  it('refuses a member-scoped entry targeting another workspace member', async () => {
+    const response = await createAsMember({
+      id: randomUUID(),
+      handle: uniqueEmailHandle('someone-elses-entry'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors: response.body.errors });
+  });
+
+  it('refuses a member-scoped entry with no workspace member', async () => {
+    const response = await createAsMember({
+      id: randomUUID(),
+      handle: uniqueEmailHandle('ownerless'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors: response.body.errors });
+  });
+
+  it('refuses to overwrite a workspace-scoped entry through an upsert create', async () => {
+    const id = trackedId();
+
+    await createAsAdmin({
+      id,
+      handle: uniqueDomainHandle(),
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    const hijackResponse = await upsertAsMember({
+      id,
+      handle: uniqueEmailHandle('hijacked'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors: hijackResponse.body.errors,
+    });
+
+    const renamedHandle = uniqueDomainHandle();
+
+    const adminResponse = await upsertAsAdmin({
+      id,
+      handle: renamedHandle,
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expect(adminResponse.body.errors).toBeUndefined();
+    expect(adminResponse.body.data.createBlocklists[0].handle).toBe(
+      renamedHandle,
+    );
+
+    const idempotentResponse = await upsertAsAdmin({
+      id,
+      handle: renamedHandle,
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expect(idempotentResponse.body.errors).toBeUndefined();
+    expect(idempotentResponse.body.data.createBlocklists[0].handle).toBe(
+      renamedHandle,
+    );
+  });
+
+  it('refuses a scope change on an existing entry', async () => {
+    const id = trackedId();
+
+    await createAsAdmin({
+      id,
+      handle: uniqueEmailHandle('immutable-scope'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+    });
+
+    const response = await makeGraphqlAPIRequest(
+      updateOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        recordId: id,
+        data: { scope: BlocklistScope.WORKSPACE },
+      }),
+    );
+
+    expectOneNotInternalServerErrorSnapshot({ errors: response.body.errors });
+  });
+
+  it('refuses to null out the workspace member of a member-scoped entry', async () => {
+    const id = trackedId();
+
+    await createAsAdmin({
+      id,
+      handle: uniqueEmailHandle('immutable-owner'),
+      scope: BlocklistScope.WORKSPACE_MEMBER,
+      workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+    });
+
+    const response = await makeGraphqlAPIRequest(
+      updateOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        recordId: id,
+        data: { workspaceMemberId: null },
+      }),
+    );
+
+    expectOneNotInternalServerErrorSnapshot({ errors: response.body.errors });
+  });
+
+  it('refuses deletion and restoration of a workspace-scoped entry without the workspace permission', async () => {
+    const id = trackedId();
+
+    await createAsAdmin({
+      id,
+      handle: uniqueDomainHandle(),
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    const deleteAsMemberResponse = await makeGraphqlAPIRequestWithMemberRole(
+      deleteOneOperationFactory({
+        objectMetadataSingularName: 'blocklist',
+        gqlFields: BLOCKLIST_GQL_FIELDS,
+        recordId: id,
+      }),
+    );
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors: deleteAsMemberResponse.body.errors,
+    });
+
+    const deleteAsAdminResponse = await deleteAsAdmin(id);
+
+    expect(deleteAsAdminResponse.body.errors).toBeUndefined();
+    expect(
+      deleteAsAdminResponse.body.data.deleteBlocklist.deletedAt,
+    ).not.toBeNull();
+
+    const restoreAsMemberResponse = await restoreOne(
+      id,
+      makeGraphqlAPIRequestWithMemberRole,
+    );
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors: restoreAsMemberResponse.body.errors,
+    });
+  });
+
+  it('refuses to restore an entry whose handle was taken again while it was deleted', async () => {
+    const id = trackedId();
+    const handle = uniqueDomainHandle();
+
+    await createAsAdmin({ id, handle, scope: BlocklistScope.WORKSPACE });
+
+    const deleteResponse = await deleteAsAdmin(id);
+
+    expect(deleteResponse.body.errors).toBeUndefined();
+
+    const { errors: recreateErrors } = await createAsAdmin({
+      id: trackedId(),
+      handle,
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expect(recreateErrors).toBeUndefined();
+
+    const restoreResponse = await restoreOne(id);
+
+    expect(restoreResponse.body.errors).toBeDefined();
+    expect(restoreResponse.body.errors[0].message).toMatch(/already exists/i);
+  });
+
+  it('refuses every bulk mutation of blocklist entries', async () => {
+    const filter = { scope: { eq: BlocklistScope.WORKSPACE } };
+
+    const mergeSourceIds = [trackedId(), trackedId()];
+
+    for (const mergeSourceId of mergeSourceIds) {
+      const { errors: mergeSourceErrors } = await createAsAdmin({
+        id: mergeSourceId,
+        handle: uniqueDomainHandle(),
+        scope: BlocklistScope.WORKSPACE,
+      });
+
+      expect(mergeSourceErrors).toBeUndefined();
+    }
+
+    const bulkResponses = [
+      await makeGraphqlAPIRequest(
+        deleteManyOperationFactory({
+          objectMetadataSingularName: 'blocklist',
+          objectMetadataPluralName: 'blocklists',
+          gqlFields: BLOCKLIST_GQL_FIELDS,
+          filter,
+        }),
+      ),
+      await makeGraphqlAPIRequest(
+        destroyManyOperationFactory({
+          objectMetadataSingularName: 'blocklist',
+          objectMetadataPluralName: 'blocklists',
+          gqlFields: BLOCKLIST_GQL_FIELDS,
+          filter,
+        }),
+      ),
+      await makeGraphqlAPIRequest(
+        restoreManyOperationFactory({
+          objectMetadataSingularName: 'blocklist',
+          objectMetadataPluralName: 'blocklists',
+          gqlFields: BLOCKLIST_GQL_FIELDS,
+          filter,
+        }),
+      ),
+      await makeGraphqlAPIRequest(
+        updateManyOperationFactory({
+          objectMetadataSingularName: 'blocklist',
+          objectMetadataPluralName: 'blocklists',
+          gqlFields: BLOCKLIST_GQL_FIELDS,
+          filter,
+          data: { handle: uniqueDomainHandle() },
+        }),
+      ),
+      await makeGraphqlAPIRequest({
+        query: MERGE_BLOCKLISTS,
+        variables: { ids: mergeSourceIds, conflictPriorityIndex: 0 },
+      }),
+    ];
+
+    for (const bulkResponse of bulkResponses) {
+      expectOneNotInternalServerErrorSnapshot({
+        errors: bulkResponse.body.errors,
+      });
+    }
+  });
+
+  it('refuses a second workspace-scoped entry with the same handle', async () => {
+    const handle = uniqueDomainHandle();
+
+    await createAsAdmin({
+      id: trackedId(),
+      handle,
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    const { errors } = await createAsAdmin({
+      id: randomUUID(),
+      handle,
+      scope: BlocklistScope.WORKSPACE,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+});

packages/twenty-server/test/integration/graphql/suites/hooks/note-target-hooks.integration-spec.ts

@@ -0,0 +1,477 @@
+import { randomUUID } from 'crypto';
+
+import { createOneOperation } from 'test/integration/graphql/utils/create-one-operation.util';
+import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
+import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
+import { restoreOneOperationFactory } from 'test/integration/graphql/utils/restore-one-operation-factory.util';
+
+const NOTE_GQL_FIELDS = `
+  id
+  title
+  deletedAt
+`;
+
+const NOTE_TARGET_GQL_FIELDS = `
+  id
+  noteId
+  deletedAt
+`;
+
+describe('noteTargets hooks on note actions', () => {
+  const noteIds: string[] = [];
+  const noteTargetIds: string[] = [];
+
+  afterAll(async () => {
+    if (noteIds.length > 0) {
+      const destroyNotesOperation = destroyManyOperationFactory({
+        objectMetadataSingularName: 'note',
+        objectMetadataPluralName: 'notes',
+        gqlFields: 'id',
+        filter: { id: { in: noteIds } },
+      });
+
+      await makeGraphqlAPIRequest(destroyNotesOperation);
+    }
+
+    if (noteTargetIds.length > 0) {
+      const destroyNoteTargetsOperation = destroyManyOperationFactory({
+        objectMetadataSingularName: 'noteTarget',
+        objectMetadataPluralName: 'noteTargets',
+        gqlFields: 'id',
+        filter: { id: { in: noteTargetIds } },
+      });
+
+      await makeGraphqlAPIRequest(destroyNoteTargetsOperation);
+    }
+  });
+
+  it('deleteOne note should soft delete related noteTargets', async () => {
+    const noteId = randomUUID();
+    const noteTargetId = randomUUID();
+
+    noteIds.push(noteId);
+    noteTargetIds.push(noteTargetId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      input: { id: noteId, title: 'Test Note for DeleteOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'noteTarget',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      input: { id: noteTargetId, noteId },
+    });
+
+    const deleteNoteOperation = deleteOneOperationFactory({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      recordId: noteId,
+    });
+
+    const deleteResponse = await makeGraphqlAPIRequest(deleteNoteOperation);
+
+    expect(deleteResponse.body.data.deleteNote).toBeDefined();
+    expect(deleteResponse.body.data.deleteNote.deletedAt).not.toBeNull();
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: {
+        id: { eq: noteTargetId },
+        not: { deletedAt: { is: 'NULL' } },
+      },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(1);
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[0].node.deletedAt,
+    ).not.toBeNull();
+  });
+
+  it('deleteOne note should leave a noteTarget detached earlier at its own deletion time', async () => {
+    const noteId = randomUUID();
+    const detachedNoteTargetId = randomUUID();
+    const attachedNoteTargetId = randomUUID();
+
+    noteIds.push(noteId);
+    noteTargetIds.push(detachedNoteTargetId, attachedNoteTargetId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      input: { id: noteId, title: 'Test Note with a detached target' },
+    });
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: detachedNoteTargetId, noteId },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: attachedNoteTargetId, noteId },
+      }),
+    ]);
+
+    const detachResponse = await makeGraphqlAPIRequest(
+      deleteOneOperationFactory({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        recordId: detachedNoteTargetId,
+      }),
+    );
+    const detachedAt = detachResponse.body.data.deleteNoteTarget.deletedAt;
+
+    expect(detachedAt).not.toBeNull();
+
+    const deleteResponse = await makeGraphqlAPIRequest(
+      deleteOneOperationFactory({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        recordId: noteId,
+      }),
+    );
+
+    expect(deleteResponse.body.data.deleteNote.deletedAt).not.toBeNull();
+
+    const noteTargetsResponse = await makeGraphqlAPIRequest(
+      findManyOperationFactory({
+        objectMetadataSingularName: 'noteTarget',
+        objectMetadataPluralName: 'noteTargets',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        filter: {
+          id: { in: [detachedNoteTargetId, attachedNoteTargetId] },
+          not: { deletedAt: { is: 'NULL' } },
+        },
+      }),
+    );
+    const deletedAtByNoteTargetId = Object.fromEntries(
+      noteTargetsResponse.body.data.noteTargets.edges.map(
+        ({ node }: { node: { id: string; deletedAt: string } }) => [
+          node.id,
+          node.deletedAt,
+        ],
+      ),
+    );
+
+    expect(deletedAtByNoteTargetId[detachedNoteTargetId]).toBe(detachedAt);
+    expect(deletedAtByNoteTargetId[attachedNoteTargetId]).not.toBeNull();
+    expect(
+      new Date(deletedAtByNoteTargetId[attachedNoteTargetId]).getTime(),
+    ).toBeGreaterThan(new Date(detachedAt).getTime());
+  });
+
+  it('deleteMany notes should soft delete related noteTargets', async () => {
+    const noteId1 = randomUUID();
+    const noteId2 = randomUUID();
+    const noteTargetId1 = randomUUID();
+    const noteTargetId2 = randomUUID();
+
+    noteIds.push(noteId1, noteId2);
+    noteTargetIds.push(noteTargetId1, noteTargetId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId1, title: 'Test Note 1 for DeleteMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId2, title: 'Test Note 2 for DeleteMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId1, noteId: noteId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId2, noteId: noteId2 },
+      }),
+    ]);
+
+    const deleteNotesOperation = deleteManyOperationFactory({
+      objectMetadataSingularName: 'note',
+      objectMetadataPluralName: 'notes',
+      gqlFields: NOTE_GQL_FIELDS,
+      filter: { id: { in: [noteId1, noteId2] } },
+    });
+
+    const deleteResponse = await makeGraphqlAPIRequest(deleteNotesOperation);
+
+    expect(deleteResponse.body.data.deleteNotes).toHaveLength(2);
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: {
+        id: { in: [noteTargetId1, noteTargetId2] },
+        not: { deletedAt: { is: 'NULL' } },
+      },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(2);
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[0].node.deletedAt,
+    ).not.toBeNull();
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[1].node.deletedAt,
+    ).not.toBeNull();
+  });
+
+  it('restoreOne note should restore related noteTargets', async () => {
+    const noteId = randomUUID();
+    const noteTargetId = randomUUID();
+
+    noteIds.push(noteId);
+    noteTargetIds.push(noteTargetId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      input: { id: noteId, title: 'Test Note for RestoreOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'noteTarget',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      input: { id: noteTargetId, noteId },
+    });
+
+    const deleteNoteOperation = deleteOneOperationFactory({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      recordId: noteId,
+    });
+
+    await makeGraphqlAPIRequest(deleteNoteOperation);
+
+    const restoreNoteOperation = restoreOneOperationFactory({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      recordId: noteId,
+    });
+
+    const restoreResponse = await makeGraphqlAPIRequest(restoreNoteOperation);
+
+    expect(restoreResponse.body.data.restoreNote).toBeDefined();
+    expect(restoreResponse.body.data.restoreNote.deletedAt).toBeNull();
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: { id: { eq: noteTargetId } },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(1);
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[0].node.deletedAt,
+    ).toBeNull();
+  });
+
+  it('restoreMany notes should restore related noteTargets', async () => {
+    const noteId1 = randomUUID();
+    const noteId2 = randomUUID();
+    const noteTargetId1 = randomUUID();
+    const noteTargetId2 = randomUUID();
+
+    noteIds.push(noteId1, noteId2);
+    noteTargetIds.push(noteTargetId1, noteTargetId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId1, title: 'Test Note 1 for RestoreMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId2, title: 'Test Note 2 for RestoreMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId1, noteId: noteId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId2, noteId: noteId2 },
+      }),
+    ]);
+
+    const deleteNotesOperation = deleteManyOperationFactory({
+      objectMetadataSingularName: 'note',
+      objectMetadataPluralName: 'notes',
+      gqlFields: NOTE_GQL_FIELDS,
+      filter: { id: { in: [noteId1, noteId2] } },
+    });
+
+    await makeGraphqlAPIRequest(deleteNotesOperation);
+
+    const restoreNotesOperation = restoreManyOperationFactory({
+      objectMetadataSingularName: 'note',
+      objectMetadataPluralName: 'notes',
+      gqlFields: NOTE_GQL_FIELDS,
+      filter: { id: { in: [noteId1, noteId2] } },
+    });
+
+    const restoreResponse = await makeGraphqlAPIRequest(restoreNotesOperation);
+
+    expect(restoreResponse.body.data.restoreNotes).toHaveLength(2);
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: { id: { in: [noteTargetId1, noteTargetId2] } },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(2);
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[0].node.deletedAt,
+    ).toBeNull();
+    expect(
+      noteTargetResponse.body.data.noteTargets.edges[1].node.deletedAt,
+    ).toBeNull();
+  });
+
+  it('destroyOne note should destroy related noteTargets', async () => {
+    const noteId = randomUUID();
+    const noteTargetId = randomUUID();
+
+    noteIds.push(noteId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'note',
+      gqlFields: NOTE_GQL_FIELDS,
+      input: { id: noteId, title: 'Test Note for DestroyOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'noteTarget',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      input: { id: noteTargetId, noteId },
+    });
+
+    const destroyNoteOperation = destroyOneOperationFactory({
+      objectMetadataSingularName: 'note',
+      gqlFields: 'id',
+      recordId: noteId,
+    });
+
+    const destroyResponse = await makeGraphqlAPIRequest(destroyNoteOperation);
+
+    expect(destroyResponse.body.data.destroyNote).toBeDefined();
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: { id: { eq: noteTargetId } },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(0);
+  });
+
+  it('destroyMany notes should destroy related noteTargets', async () => {
+    const noteId1 = randomUUID();
+    const noteId2 = randomUUID();
+    const noteTargetId1 = randomUUID();
+    const noteTargetId2 = randomUUID();
+
+    noteIds.push(noteId1, noteId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId1, title: 'Test Note 1 for DestroyMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'note',
+        gqlFields: NOTE_GQL_FIELDS,
+        input: { id: noteId2, title: 'Test Note 2 for DestroyMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId1, noteId: noteId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'noteTarget',
+        gqlFields: NOTE_TARGET_GQL_FIELDS,
+        input: { id: noteTargetId2, noteId: noteId2 },
+      }),
+    ]);
+
+    const destroyNotesOperation = destroyManyOperationFactory({
+      objectMetadataSingularName: 'note',
+      objectMetadataPluralName: 'notes',
+      gqlFields: 'id',
+      filter: { id: { in: [noteId1, noteId2] } },
+    });
+
+    const destroyResponse = await makeGraphqlAPIRequest(destroyNotesOperation);
+
+    expect(destroyResponse.body.data.destroyNotes).toHaveLength(2);
+
+    const findNoteTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'noteTarget',
+      objectMetadataPluralName: 'noteTargets',
+      gqlFields: NOTE_TARGET_GQL_FIELDS,
+      filter: { id: { in: [noteTargetId1, noteTargetId2] } },
+    });
+
+    const noteTargetResponse = await makeGraphqlAPIRequest(
+      findNoteTargetsOperation,
+    );
+
+    expect(noteTargetResponse.body.data.noteTargets.edges).toHaveLength(0);
+  });
+});

packages/twenty-server/test/integration/graphql/suites/hooks/task-target-hooks.integration-spec.ts

@@ -0,0 +1,402 @@
+import { randomUUID } from 'crypto';
+
+import { createOneOperation } from 'test/integration/graphql/utils/create-one-operation.util';
+import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';
+import { deleteOneOperationFactory } from 'test/integration/graphql/utils/delete-one-operation-factory.util';
+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';
+import { restoreOneOperationFactory } from 'test/integration/graphql/utils/restore-one-operation-factory.util';
+
+const TASK_GQL_FIELDS = `
+  id
+  title
+  deletedAt
+`;
+
+const TASK_TARGET_GQL_FIELDS = `
+  id
+  taskId
+  deletedAt
+`;
+
+describe('taskTargets hooks on task actions', () => {
+  const taskIds: string[] = [];
+  const taskTargetIds: string[] = [];
+
+  afterAll(async () => {
+    if (taskIds.length > 0) {
+      const destroyTasksOperation = destroyManyOperationFactory({
+        objectMetadataSingularName: 'task',
+        objectMetadataPluralName: 'tasks',
+        gqlFields: 'id',
+        filter: { id: { in: taskIds } },
+      });
+
+      await makeGraphqlAPIRequest(destroyTasksOperation);
+    }
+
+    if (taskTargetIds.length > 0) {
+      const destroyTaskTargetsOperation = destroyManyOperationFactory({
+        objectMetadataSingularName: 'taskTarget',
+        objectMetadataPluralName: 'taskTargets',
+        gqlFields: 'id',
+        filter: { id: { in: taskTargetIds } },
+      });
+
+      await makeGraphqlAPIRequest(destroyTaskTargetsOperation);
+    }
+  });
+
+  it('deleteOne task should soft delete related taskTargets', async () => {
+    const taskId = randomUUID();
+    const taskTargetId = randomUUID();
+
+    taskIds.push(taskId);
+    taskTargetIds.push(taskTargetId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      input: { id: taskId, title: 'Test Task for DeleteOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'taskTarget',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      input: { id: taskTargetId, taskId },
+    });
+
+    const deleteTaskOperation = deleteOneOperationFactory({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      recordId: taskId,
+    });
+
+    const deleteResponse = await makeGraphqlAPIRequest(deleteTaskOperation);
+
+    expect(deleteResponse.body.data.deleteTask).toBeDefined();
+    expect(deleteResponse.body.data.deleteTask.deletedAt).not.toBeNull();
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: {
+        id: { eq: taskTargetId },
+        not: { deletedAt: { is: 'NULL' } },
+      },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(1);
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[0].node.deletedAt,
+    ).not.toBeNull();
+  });
+
+  it('deleteMany tasks should soft delete related taskTargets', async () => {
+    const taskId1 = randomUUID();
+    const taskId2 = randomUUID();
+    const taskTargetId1 = randomUUID();
+    const taskTargetId2 = randomUUID();
+
+    taskIds.push(taskId1, taskId2);
+    taskTargetIds.push(taskTargetId1, taskTargetId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId1, title: 'Test Task 1 for DeleteMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId2, title: 'Test Task 2 for DeleteMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId1, taskId: taskId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId2, taskId: taskId2 },
+      }),
+    ]);
+
+    const deleteTasksOperation = deleteManyOperationFactory({
+      objectMetadataSingularName: 'task',
+      objectMetadataPluralName: 'tasks',
+      gqlFields: TASK_GQL_FIELDS,
+      filter: { id: { in: [taskId1, taskId2] } },
+    });
+
+    const deleteResponse = await makeGraphqlAPIRequest(deleteTasksOperation);
+
+    expect(deleteResponse.body.data.deleteTasks).toHaveLength(2);
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: {
+        id: { in: [taskTargetId1, taskTargetId2] },
+        not: { deletedAt: { is: 'NULL' } },
+      },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(2);
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[0].node.deletedAt,
+    ).not.toBeNull();
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[1].node.deletedAt,
+    ).not.toBeNull();
+  });
+
+  it('restoreOne task should restore related taskTargets', async () => {
+    const taskId = randomUUID();
+    const taskTargetId = randomUUID();
+
+    taskIds.push(taskId);
+    taskTargetIds.push(taskTargetId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      input: { id: taskId, title: 'Test Task for RestoreOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'taskTarget',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      input: { id: taskTargetId, taskId },
+    });
+
+    const deleteTaskOperation = deleteOneOperationFactory({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      recordId: taskId,
+    });
+
+    await makeGraphqlAPIRequest(deleteTaskOperation);
+
+    const restoreTaskOperation = restoreOneOperationFactory({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      recordId: taskId,
+    });
+
+    const restoreResponse = await makeGraphqlAPIRequest(restoreTaskOperation);
+
+    expect(restoreResponse.body.data.restoreTask).toBeDefined();
+    expect(restoreResponse.body.data.restoreTask.deletedAt).toBeNull();
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: { id: { eq: taskTargetId } },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(1);
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[0].node.deletedAt,
+    ).toBeNull();
+  });
+
+  it('restoreMany tasks should restore related taskTargets', async () => {
+    const taskId1 = randomUUID();
+    const taskId2 = randomUUID();
+    const taskTargetId1 = randomUUID();
+    const taskTargetId2 = randomUUID();
+
+    taskIds.push(taskId1, taskId2);
+    taskTargetIds.push(taskTargetId1, taskTargetId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId1, title: 'Test Task 1 for RestoreMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId2, title: 'Test Task 2 for RestoreMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId1, taskId: taskId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId2, taskId: taskId2 },
+      }),
+    ]);
+
+    const deleteTasksOperation = deleteManyOperationFactory({
+      objectMetadataSingularName: 'task',
+      objectMetadataPluralName: 'tasks',
+      gqlFields: TASK_GQL_FIELDS,
+      filter: { id: { in: [taskId1, taskId2] } },
+    });
+
+    await makeGraphqlAPIRequest(deleteTasksOperation);
+
+    const restoreTasksOperation = restoreManyOperationFactory({
+      objectMetadataSingularName: 'task',
+      objectMetadataPluralName: 'tasks',
+      gqlFields: TASK_GQL_FIELDS,
+      filter: { id: { in: [taskId1, taskId2] } },
+    });
+
+    const restoreResponse = await makeGraphqlAPIRequest(restoreTasksOperation);
+
+    expect(restoreResponse.body.data.restoreTasks).toHaveLength(2);
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: { id: { in: [taskTargetId1, taskTargetId2] } },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(2);
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[0].node.deletedAt,
+    ).toBeNull();
+    expect(
+      taskTargetResponse.body.data.taskTargets.edges[1].node.deletedAt,
+    ).toBeNull();
+  });
+
+  it('destroyOne task should destroy related taskTargets', async () => {
+    const taskId = randomUUID();
+    const taskTargetId = randomUUID();
+
+    taskIds.push(taskId);
+
+    await createOneOperation({
+      objectMetadataSingularName: 'task',
+      gqlFields: TASK_GQL_FIELDS,
+      input: { id: taskId, title: 'Test Task for DestroyOne' },
+    });
+
+    await createOneOperation({
+      objectMetadataSingularName: 'taskTarget',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      input: { id: taskTargetId, taskId },
+    });
+
+    const destroyTaskOperation = destroyOneOperationFactory({
+      objectMetadataSingularName: 'task',
+      gqlFields: 'id',
+      recordId: taskId,
+    });
+
+    const destroyResponse = await makeGraphqlAPIRequest(destroyTaskOperation);
+
+    expect(destroyResponse.body.data.destroyTask).toBeDefined();
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: { id: { eq: taskTargetId } },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(0);
+  });
+
+  it('destroyMany tasks should destroy related taskTargets', async () => {
+    const taskId1 = randomUUID();
+    const taskId2 = randomUUID();
+    const taskTargetId1 = randomUUID();
+    const taskTargetId2 = randomUUID();
+
+    taskIds.push(taskId1, taskId2);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId1, title: 'Test Task 1 for DestroyMany' },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'task',
+        gqlFields: TASK_GQL_FIELDS,
+        input: { id: taskId2, title: 'Test Task 2 for DestroyMany' },
+      }),
+    ]);
+
+    await Promise.all([
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId1, taskId: taskId1 },
+      }),
+      createOneOperation({
+        objectMetadataSingularName: 'taskTarget',
+        gqlFields: TASK_TARGET_GQL_FIELDS,
+        input: { id: taskTargetId2, taskId: taskId2 },
+      }),
+    ]);
+
+    const destroyTasksOperation = destroyManyOperationFactory({
+      objectMetadataSingularName: 'task',
+      objectMetadataPluralName: 'tasks',
+      gqlFields: 'id',
+      filter: { id: { in: [taskId1, taskId2] } },
+    });
+
+    const destroyResponse = await makeGraphqlAPIRequest(destroyTasksOperation);
+
+    expect(destroyResponse.body.data.destroyTasks).toHaveLength(2);
+
+    const findTaskTargetsOperation = findManyOperationFactory({
+      objectMetadataSingularName: 'taskTarget',
+      objectMetadataPluralName: 'taskTargets',
+      gqlFields: TASK_TARGET_GQL_FIELDS,
+      filter: { id: { in: [taskTargetId1, taskTargetId2] } },
+    });
+
+    const taskTargetResponse = await makeGraphqlAPIRequest(
+      findTaskTargetsOperation,
+    );
+
+    expect(taskTargetResponse.body.data.taskTargets.edges).toHaveLength(0);
+  });
+});