Skip to content

The open alternative to Salesforce, designed for AI.

Enforce blocklist scope and surface the workspace blocklist in settings (#25007)

neo77374f05e1f2869
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-links-by-slack-user-ids.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-links-by-slack-user-ids.ts
index 698b42dece8..e3c30229a5c 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-links-by-slack-user-ids.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-links-by-slack-user-ids.ts
@@ -18,8 +18,9 @@ export const findSlackUserLinksBySlackUserIds = async (
const linkBySlackUserId = new Map<string, SlackUserLinkSummary>();
const teamFilters = [...slackUserIdsBySlackTeamId.entries()]
- .filter(([slackTeamId, slackUserIds]) =>
- isNonEmptyString(slackTeamId) && slackUserIds.length > 0,
+ .filter(
+ ([slackTeamId, slackUserIds]) =>
+ isNonEmptyString(slackTeamId) && slackUserIds.length > 0,
)
.map(([slackTeamId, slackUserIds]) => ({
and: [
diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-connection.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-connection.test.ts
index 595f54082a5..332ad421668 100644
--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-connection.test.ts
+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-connection.test.ts
@@ -17,7 +17,11 @@ describe('getSlackConnection', () => {
it('should query connections for the slack provider', async () => {
listConnectionsMock.mockResolvedValue([
- { id: 'conn-ws', visibility: 'workspace', accessToken: 'workspace-token' },
+ {
+ id: 'conn-ws',
+ visibility: 'workspace',
+ accessToken: 'workspace-token',
+ },
]);
await getSlackConnection();
@@ -27,8 +31,16 @@ describe('getSlackConnection', () => {
it('should prefer a workspace-visibility connection over a personal one', async () => {
listConnectionsMock.mockResolvedValue([
- { id: 'conn-personal', visibility: 'personal', accessToken: 'personal-token' },
- { id: 'conn-ws', visibility: 'workspace', accessToken: 'workspace-token' },
+ {
+ id: 'conn-personal',
+ visibility: 'personal',
+ accessToken: 'personal-token',
+ },
+ {
+ id: 'conn-ws',
+ visibility: 'workspace',
+ accessToken: 'workspace-token',
+ },
]);
const result = await getSlackConnection();
@@ -43,7 +55,11 @@ describe('getSlackConnection', () => {
it('should fall back to the first connection when none are workspace-visible', async () => {
listConnectionsMock.mockResolvedValue([
{ id: 'conn-first', visibility: 'personal', accessToken: 'first-token' },
- { id: 'conn-second', visibility: 'personal', accessToken: 'second-token' },
+ {
+ id: 'conn-second',
+ visibility: 'personal',
+ accessToken: 'second-token',
+ },
]);
const result = await getSlackConnection();
diff --git a/packages/twenty-front/src/modules/accounts/types/BlocklistItem.ts b/packages/twenty-front/src/modules/accounts/types/BlocklistItem.ts
index 0b16357b709..3a7461e9d73 100644
--- a/packages/twenty-front/src/modules/accounts/types/BlocklistItem.ts
+++ b/packages/twenty-front/src/modules/accounts/types/BlocklistItem.ts
@@ -1,7 +1,10 @@
+import { type BlocklistScope } from 'twenty-shared/types';
+
export type BlocklistItem = {
id: string;
handle: string;
- workspaceMemberId: string;
+ scope: BlocklistScope;
+ workspaceMemberId: string | null;
createdAt: string;
__typename: 'BlocklistItem';
};
diff --git a/packages/twenty-front/src/modules/settings/accounts/components/SettingsAccountsBlocklistSection.tsx b/packages/twenty-front/src/modules/settings/accounts/components/SettingsAccountsBlocklistSection.tsx
index 62639488184..fdcd963b94f 100644
--- a/packages/twenty-front/src/modules/settings/accounts/components/SettingsAccountsBlocklistSection.tsx
+++ b/packages/twenty-front/src/modules/settings/accounts/components/SettingsAccountsBlocklistSection.tsx
@@ -8,7 +8,7 @@ import { SettingsAccountsBlocklistInput } from '@/settings/accounts/components/S
import { SettingsAccountsBlocklistTable } from '@/settings/accounts/components/SettingsAccountsBlocklistTable';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { useLingui } from '@lingui/react/macro';
-import { CoreObjectNameSingular } from 'twenty-shared/types';
+import { BlocklistScope, CoreObjectNameSingular } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { H2Title } from 'twenty-ui/typography';
import { Section } from 'twenty-ui/layout';
@@ -53,6 +53,7 @@ export const SettingsAccountsBlocklistSection = () => {
recordsToCreate: [...new Set(handles)].map((handle) => {
return {
handle,
+ scope: BlocklistScope.WORKSPACE_MEMBER,
workspaceMemberId: currentWorkspaceMember.id,
};
}),
diff --git a/packages/twenty-front/src/modules/settings/accounts/components/__stories__/mockedBlocklist.ts b/packages/twenty-front/src/modules/settings/accounts/components/__stories__/mockedBlocklist.ts
index ed85313d02b..d835d6881e7 100644
--- a/packages/twenty-front/src/modules/settings/accounts/components/__stories__/mockedBlocklist.ts
+++ b/packages/twenty-front/src/modules/settings/accounts/components/__stories__/mockedBlocklist.ts
@@ -1,11 +1,13 @@
import { formatISO, parseISO, subDays, subHours } from 'date-fns';
import { type BlocklistItem } from '@/accounts/types/BlocklistItem';
+import { BlocklistScope } from 'twenty-shared/types';
export const mockedBlocklist: BlocklistItem[] = [
{
id: '1',
handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
workspaceMemberId: '1',
createdAt:
formatISO(subHours(parseISO('2023-04-26T10:12:42.33625+00:00'), 2)) ?? '',
@@ -14,6 +16,7 @@ export const mockedBlocklist: BlocklistItem[] = [
{
id: '2',
handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
workspaceMemberId: '1',
createdAt:
formatISO(subDays(parseISO('2023-04-26T10:12:42.33625+00:00'), 2)) ?? '',
@@ -22,6 +25,7 @@ export const mockedBlocklist: BlocklistItem[] = [
{
id: '3',
handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
workspaceMemberId: '1',
createdAt:
formatISO(subDays(parseISO('2023-04-26T10:12:42.33625+00:00'), 3)) ?? '',
@@ -30,6 +34,7 @@ export const mockedBlocklist: BlocklistItem[] = [
{
id: '4',
handle: '@twenty.com',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
workspaceMemberId: '1',
createdAt:
formatISO(subDays(parseISO('2023-04-26T10:12:42.33625+00:00'), 4)) ?? '',
diff --git a/packages/twenty-front/src/modules/settings/security/components/SettingsSecuritySettings.tsx b/packages/twenty-front/src/modules/settings/security/components/SettingsSecuritySettings.tsx
index 304d00a4cc6..3efb95aaa25 100644
--- a/packages/twenty-front/src/modules/settings/security/components/SettingsSecuritySettings.tsx
+++ b/packages/twenty-front/src/modules/settings/security/components/SettingsSecuritySettings.tsx
@@ -6,11 +6,9 @@ import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
import { authProvidersState } from '@/client-config/states/authProvidersState';
import { isClickHouseConfiguredState } from '@/client-config/states/isClickHouseConfiguredState';
import { isMultiWorkspaceEnabledState } from '@/client-config/states/isMultiWorkspaceEnabledState';
-import { Separator } from '@/settings/components/Separator';
import { SettingsEnterpriseFeatureGateCard } from '@/settings/components/SettingsEnterpriseFeatureGateCard';
import { SettingsOptionCardContentButton } from '@/settings/components/SettingsOptions/SettingsOptionCardContentButton';
import { SettingsOptionCardContentCounter } from '@/settings/components/SettingsOptions/SettingsOptionCardContentCounter';
-import { SettingsOptionCardContentSwitch } from '@/settings/components/SettingsOptions/SettingsOptionCardContentSwitch';
import { SettingsRoleDefaultRole } from '@/settings/roles/components/SettingsRolesDefaultRole';
import { SettingsRolesQueryEffect } from '@/settings/roles/components/SettingsRolesQueryEffect';
import { useSettingsAllRoles } from '@/settings/roles/hooks/useSettingsAllRoles';
@@ -25,12 +23,7 @@ import { useAtomState } from '@/ui/utilities/state/jotai/hooks/useAtomState';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { CombinedGraphQLErrors } from '@apollo/client/errors';
import { useMutation } from '@apollo/client/react';
-import {
- IconClockHour8,
- IconHistory,
- IconMail,
- IconTrash,
-} from 'twenty-ui/icon';
+import { IconClockHour8, IconHistory, IconTrash } from 'twenty-ui/icon';
import { H2Title } from 'twenty-ui/typography';
import { Section } from 'twenty-ui/layout';
import { Card } from 'twenty-ui/surfaces';
@@ -117,33 +110,6 @@ export const SettingsSecuritySettings = () => {
saveTrashRetention(value);
};
- const handleSyncInternalEmailsChange = (value: boolean) => {
- if (!currentWorkspace) {
- return;
- }
-
- if (value === currentWorkspace.isInternalMessagesImportEnabled) {
- return;
- }
-
- setCurrentWorkspace({
- ...currentWorkspace,
- isInternalMessagesImportEnabled: value,
- });
-
- updateWorkspace({
- variables: {
- input: {
- isInternalMessagesImportEnabled: value,
- },
- },
- }).catch((err) => {
- enqueueErrorSnackBar({
- apolloError: CombinedGraphQLErrors.is(err) ? err : undefined,
- });
- });
- };
-
const handleEventLogRetentionDaysChange = (value: number) => {
if (!currentWorkspace) {
return;
@@ -282,17 +248,6 @@ export const SettingsSecuritySettings = () => {
minValue={0}
showButtons={false}
/>
- <Separator />
- <SettingsOptionCardContentSwitch
- Icon={IconMail}
- title={t`Sync Internal Emails`}
- description={t`Include emails where all participants share the same domain.`}
- checked={
- currentWorkspace?.isInternalMessagesImportEnabled ?? false
- }
- onChange={handleSyncInternalEmailsChange}
- advancedMode
- />
</Card>
</Section>
</StyledMainContent>
diff --git a/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceBlocklistSection.tsx b/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceBlocklistSection.tsx
new file mode 100644
index 00000000000..a17209cf2d7
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceBlocklistSection.tsx
@@ -0,0 +1,60 @@
+import { type BlocklistItem } from '@/accounts/types/BlocklistItem';
+import { useCreateManyRecords } from '@/object-record/hooks/useCreateManyRecords';
+import { useDeleteOneRecord } from '@/object-record/hooks/useDeleteOneRecord';
+import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
+import { SettingsAccountsBlocklistInput } from '@/settings/accounts/components/SettingsAccountsBlocklistInput';
+import { SettingsAccountsBlocklistTable } from '@/settings/accounts/components/SettingsAccountsBlocklistTable';
+import { useLingui } from '@lingui/react/macro';
+import { BlocklistScope, CoreObjectNameSingular } from 'twenty-shared/types';
+import { Section } from 'twenty-ui/layout';
+import { H2Title } from 'twenty-ui/typography';
+
+export const SettingsWorkspaceBlocklistSection = () => {
+ const { t } = useLingui();
+
+ const { records: workspaceBlocklist } = useFindManyRecords<BlocklistItem>({
+ objectNameSingular: CoreObjectNameSingular.Blocklist,
+ filter: {
+ scope: { eq: BlocklistScope.WORKSPACE },
+ },
+ });
+
+ const { createManyRecords: createBlocklistItems } =
+ useCreateManyRecords<BlocklistItem>({
+ objectNameSingular: CoreObjectNameSingular.Blocklist,
+ });
+
+ const { deleteOneRecord: deleteBlocklistItem } = useDeleteOneRecord({
+ objectNameSingular: CoreObjectNameSingular.Blocklist,
+ });
+
+ const handleBlockedEmailRemove = (id: string) => {
+ deleteBlocklistItem(id);
+ };
+
+ const updateBlockedEmailList = (handles: string[]) => {
+ createBlocklistItems({
+ recordsToCreate: [...new Set(handles)].map((handle) => ({
+ handle,
+ scope: BlocklistScope.WORKSPACE,
+ })),
+ });
+ };
+
+ return (
+ <Section>
+ <H2Title
+ title={t`Blocklist`}
+ description={t`Exclude the following people and domains from the email and calendar sync of every workspace member`}
+ />
+ <SettingsAccountsBlocklistInput
+ blockedEmailOrDomainList={workspaceBlocklist.map((item) => item.handle)}
+ updateBlockedEmailList={updateBlockedEmailList}
+ />
+ <SettingsAccountsBlocklistTable
+ blocklist={workspaceBlocklist}
+ handleBlockedEmailRemove={handleBlockedEmailRemove}
+ />
+ </Section>
+ );
+};
diff --git a/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceEmailSyncSection.tsx b/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceEmailSyncSection.tsx
new file mode 100644
index 00000000000..5866256cfca
--- /dev/null
+++ b/packages/twenty-front/src/modules/settings/workspace/components/SettingsWorkspaceEmailSyncSection.tsx
@@ -0,0 +1,69 @@
+import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
+import { SettingsOptionCardContentSwitch } from '@/settings/components/SettingsOptions/SettingsOptionCardContentSwitch';
+import { useSnackBar } from '@/ui/feedback/snack-bar-manager/hooks/useSnackBar';
+import { useAtomState } from '@/ui/utilities/state/jotai/hooks/useAtomState';
+import { CombinedGraphQLErrors } from '@apollo/client/errors';
+import { useMutation } from '@apollo/client/react';
+import { useLingui } from '@lingui/react/macro';
+import { isDefined } from 'twenty-shared/utils';
+import { IconMail } from 'twenty-ui/icon';
+import { Section } from 'twenty-ui/layout';
+import { Card } from 'twenty-ui/surfaces';
+import { H2Title } from 'twenty-ui/typography';
+import { UpdateWorkspaceDocument } from '~/generated-metadata/graphql';
+
+export const SettingsWorkspaceEmailSyncSection = () => {
+ const { t } = useLingui();
+
+ const [currentWorkspace, setCurrentWorkspace] = useAtomState(
+ currentWorkspaceState,
+ );
+ const { enqueueErrorSnackBar } = useSnackBar();
+ const [updateWorkspace] = useMutation(UpdateWorkspaceDocument);
+
+ const handleSyncInternalEmailsChange = (value: boolean) => {
+ if (!isDefined(currentWorkspace)) {
+ return;
+ }
+
+ if (value === currentWorkspace.isInternalMessagesImportEnabled) {
+ return;
+ }
+
+ setCurrentWorkspace({
+ ...currentWorkspace,
+ isInternalMessagesImportEnabled: value,
+ });
+
+ updateWorkspace({
+ variables: {
+ input: {
+ isInternalMessagesImportEnabled: value,
+ },
+ },
+ }).catch((err) => {
+ enqueueErrorSnackBar({
+ apolloError: CombinedGraphQLErrors.is(err) ? err : undefined,
+ });
+ });
+ };
+
+ return (
+ <Section>
+ <H2Title
+ title={t`Sync`}
+ description={t`Control what the workspace imports from connected mailboxes and calendars`}
+ />
+ <Card rounded>
+ <SettingsOptionCardContentSwitch
+ Icon={IconMail}
+ title={t`Sync Internal Emails`}
+ description={t`Include emails where all participants share the same domain.`}
+ checked={currentWorkspace?.isInternalMessagesImportEnabled ?? false}
+ onChange={handleSyncInternalEmailsChange}
+ advancedMode
+ />
+ </Card>
+ </Section>
+ );
+};
diff --git a/packages/twenty-front/src/pages/settings/communications/SettingsWorkspaceCommunications.tsx b/packages/twenty-front/src/pages/settings/communications/SettingsWorkspaceCommunications.tsx
index 18674c4a171..f5205c4fef8 100644
--- a/packages/twenty-front/src/pages/settings/communications/SettingsWorkspaceCommunications.tsx
+++ b/packages/twenty-front/src/pages/settings/communications/SettingsWorkspaceCommunications.tsx
@@ -3,7 +3,9 @@ import { useLingui } from '@lingui/react/macro';
import { SettingsPageContainer } from '@/settings/components/SettingsPageContainer';
import { SettingsDiscoveryHeroCard } from '@/settings/components/SettingsDiscoveryHeroCard';
+import { SettingsWorkspaceBlocklistSection } from '@/settings/workspace/components/SettingsWorkspaceBlocklistSection';
import { SettingsWorkspaceEmailGroupSection } from '@/settings/workspace/components/SettingsWorkspaceEmailGroupSection';
+import { SettingsWorkspaceEmailSyncSection } from '@/settings/workspace/components/SettingsWorkspaceEmailSyncSection';
import { SettingsPageLayout } from '@/settings/components/layout/SettingsPageLayout';
import { SettingsTabBar } from '@/settings/components/layout/SettingsTabBar';
import { useIsFeatureEnabled } from '@/workspace/hooks/useIsFeatureEnabled';
@@ -108,6 +110,8 @@ export const SettingsWorkspaceCommunications = () => {
</StyledCardsColumn>
</Section>
)}
+ <SettingsWorkspaceEmailSyncSection />
+ <SettingsWorkspaceBlocklistSection />
</SettingsPageContainer>
</SettingsPageLayout>
);
diff --git a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type.ts b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type.ts
index 0caafcd8f2f..aba11f3786e 100644
--- a/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type.ts
+++ b/packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-query-hook/types/workspace-query-hook.type.ts
@@ -11,6 +11,7 @@ import {
type GroupByResolverArgs,
type MergeManyResolverArgs,
type RestoreManyResolverArgs,
+ type RestoreOneResolverArgs,
type UpdateManyResolverArgs,
type UpdateOneResolverArgs,
} from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
@@ -40,12 +41,14 @@ export type WorkspacePreQueryHookPayload<T> = T extends 'createMany'
? FindDuplicatesResolverArgs
: T extends 'restoreMany'
? RestoreManyResolverArgs
- : T extends 'destroyMany'
- ? DestroyManyResolverArgs
- : T extends 'destroyOne'
- ? DestroyOneResolverArgs
- : T extends 'mergeMany'
- ? MergeManyResolverArgs
- : T extends 'groupBy'
- ? GroupByResolverArgs
- : never;
+ : T extends 'restoreOne'
+ ? RestoreOneResolverArgs
+ : T extends 'destroyMany'
+ ? DestroyManyResolverArgs
+ : T extends 'destroyOne'
+ ? DestroyOneResolverArgs
+ : T extends 'mergeMany'
+ ? MergeManyResolverArgs
+ : T extends 'groupBy'
+ ? GroupByResolverArgs
+ : never;
diff --git a/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module.ts b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module.ts
index b2482f11788..a60708fddbe 100644
--- a/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module.ts
+++ b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module.ts
@@ -1,11 +1,17 @@
import { Module } from '@nestjs/common';
+import { PermissionsModule } from 'src/engine/metadata-modules/permissions/permissions.module';
+import { BlocklistAccessService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-access.service';
import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
@Module({
- imports: [],
- providers: [BlocklistRepository, BlocklistValidationService],
+ imports: [PermissionsModule],
+ providers: [
+ BlocklistAccessService,
+ BlocklistRepository,
+ BlocklistValidationService,
+ ],
exports: [BlocklistValidationService],
})
export class BlocklistValidationManagerModule {}
diff --git a/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-access.service.ts b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-access.service.ts
new file mode 100644
index 00000000000..0fc2f01ed2e
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-access.service.ts
@@ -0,0 +1,82 @@
+import { Injectable } from '@nestjs/common';
+
+import { msg } from '@lingui/core/macro';
+import { PermissionFlagType } from 'twenty-shared/constants';
+import { BlocklistScope } from 'twenty-shared/types';
+
+import {
+ PermissionsException,
+ PermissionsExceptionCode,
+ PermissionsExceptionMessage,
+} from 'src/engine/metadata-modules/permissions/permissions.exception';
+import { PermissionsService } from 'src/engine/metadata-modules/permissions/permissions.service';
+import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { type BlocklistMutationContext } from 'src/modules/blocklist/types/blocklist-mutation-context.type';
+
+@Injectable()
+export class BlocklistAccessService {
+ constructor(private readonly permissionsService: PermissionsService) {}
+
+ async assertCanCreateBlocklistEntryOrThrow({
+ item,
+ context,
+ }: {
+ item: Partial<Pick<BlocklistItem, 'scope'>>;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const scope = item.scope ?? BlocklistScope.WORKSPACE_MEMBER;
+
+ if (scope === BlocklistScope.WORKSPACE_MEMBER) {
+ return;
+ }
+
+ if (await this.hasWorkspaceBlocklistPermission(context)) {
+ return;
+ }
+
+ this.throwWorkspacePermissionDenied();
+ }
+
+ async assertCanModifyBlocklistEntryOrThrow({
+ entry,
+ context,
+ }: {
+ entry: Pick<BlocklistWorkspaceEntity, 'scope' | 'workspaceMemberId'>;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const isOwnMemberScopedEntry =
+ entry.scope === BlocklistScope.WORKSPACE_MEMBER &&
+ entry.workspaceMemberId === context.workspaceMemberId;
+
+ if (isOwnMemberScopedEntry) {
+ return;
+ }
+
+ if (await this.hasWorkspaceBlocklistPermission(context)) {
+ return;
+ }
+
+ this.throwWorkspacePermissionDenied();
+ }
+
+ private async hasWorkspaceBlocklistPermission(
+ context: BlocklistMutationContext,
+ ): Promise<boolean> {
+ return this.permissionsService.userHasWorkspaceSettingPermission({
+ userWorkspaceId: context.userWorkspaceId,
+ setting: PermissionFlagType.WORKSPACE,
+ workspaceId: context.workspaceId,
+ });
+ }
+
+ private throwWorkspacePermissionDenied(): never {
+ throw new PermissionsException(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ {
+ userFriendlyMessage: msg`You do not have permission to manage the workspace blocklist.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service.ts b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service.ts
index 3a5dc500e13..da1015e0618 100644
--- a/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service.ts
+++ b/packages/twenty-server/src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service.ts
@@ -1,8 +1,8 @@
import { Injectable } from '@nestjs/common';
import { msg } from '@lingui/core/macro';
-import { isDefined } from 'twenty-shared/utils';
-import { z } from 'zod';
+import { BlocklistScope } from 'twenty-shared/types';
+import { assertUnreachable, isDefined } from 'twenty-shared/utils';
import {
type CreateManyResolverArgs,
@@ -13,65 +13,168 @@ import {
CommonQueryRunnerException,
CommonQueryRunnerExceptionCode,
} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
-import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
-import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
-import { isDomain } from 'src/engine/utils/is-domain';
+import { BlocklistAccessService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-access.service';
+import { groupBlocklistEntriesForUniqueness } from 'src/modules/blocklist/utils/group-blocklist-entries-for-uniqueness.util';
+import { BLOCKLIST_HANDLE_SCHEMA } from 'src/modules/blocklist/constants/blocklist-handle-schema.constant';
import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
-import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
-
-export type BlocklistItem = Omit<
- BlocklistWorkspaceEntity,
- 'createdAt' | 'updatedAt' | 'workspaceMember'
-> & {
- createdAt: string;
- updatedAt: string;
- workspaceMemberId: string;
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { type BlocklistMutationContext } from 'src/modules/blocklist/types/blocklist-mutation-context.type';
+
+type BlocklistCreateEntry = {
+ item: Partial<BlocklistItem>;
+ existingRecord: BlocklistWorkspaceEntity | null;
};
@Injectable()
export class BlocklistValidationService {
constructor(
private readonly blocklistRepository: BlocklistRepository,
- private readonly workspaceOrmManager: WorkspaceOrmManager,
+ private readonly blocklistAccessService: BlocklistAccessService,
) {}
- public async validateBlocklistForCreateMany(
- payload: CreateManyResolverArgs<BlocklistItem>,
- userId: string,
- workspaceId: string,
- ) {
- await this.validateSchema(payload.data);
- await this.validateUniquenessForCreateMany(payload, userId, workspaceId);
+ public async validateBlocklistForCreateMany({
+ payload,
+ context,
+ }: {
+ payload: CreateManyResolverArgs<Partial<BlocklistItem>>;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ this.validateHandleFormat(payload.data);
+
+ const existingRecords = await this.blocklistRepository.getByIds({
+ ids: payload.data.map((item) => item.id).filter(isDefined),
+ workspaceId: context.workspaceId,
+ });
+ const existingRecordById = new Map(
+ existingRecords.map((record) => [record.id, record]),
+ );
+
+ const entries: BlocklistCreateEntry[] = [];
+
+ for (const item of payload.data) {
+ const existingRecord = isDefined(item.id)
+ ? (existingRecordById.get(item.id) ?? null)
+ : null;
+
+ if (isDefined(existingRecord)) {
+ await this.blocklistAccessService.assertCanModifyBlocklistEntryOrThrow({
+ entry: existingRecord,
+ context,
+ });
+ this.validateScopeAndOwnerAreUnchanged({
+ data: item,
+ existingRecord,
+ });
+ } else {
+ this.validateScopeTarget({ item, context });
+ await this.blocklistAccessService.assertCanCreateBlocklistEntryOrThrow({
+ item,
+ context,
+ });
+ }
+
+ entries.push({ item, existingRecord });
+ }
+
+ await this.validateUniquenessForCreateMany({ entries, context });
}
- public async validateBlocklistForUpdateOne(
- payload: UpdateOneResolverArgs<BlocklistItem>,
- userId: string,
- workspaceId: string,
- ) {
- if (payload.data.handle) {
- await this.validateSchema([payload.data]);
+ public async validateBlocklistForUpdateOne({
+ payload,
+ context,
+ }: {
+ payload: UpdateOneResolverArgs<Partial<BlocklistItem>>;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const existingRecord = await this.getExistingRecordOrThrow({
+ id: payload.id,
+ context,
+ });
+
+ await this.blocklistAccessService.assertCanModifyBlocklistEntryOrThrow({
+ entry: existingRecord,
+ context,
+ });
+ this.validateScopeAndOwnerAreUnchanged({
+ data: payload.data,
+ existingRecord,
+ });
+
+ if (!isDefined(payload.data.handle)) {
+ return;
}
- await this.validateUniquenessForUpdateOne(payload, userId, workspaceId);
+
+ this.validateHandleFormat([payload.data]);
+
+ if (payload.data.handle === existingRecord.handle) {
+ return;
+ }
+
+ const siblingHandles = await this.getExistingHandlesForOwner({
+ scope: existingRecord.scope,
+ workspaceMemberId:
+ existingRecord.workspaceMemberId ?? context.workspaceMemberId,
+ context,
+ });
+
+ this.validateHandlesAreNew({
+ handles: [payload.data.handle],
+ existingHandles: siblingHandles.filter(
+ (handle) => handle !== existingRecord.handle,
+ ),
+ });
}
- public async validateSchema(blocklist: BlocklistItem[]) {
- const emailOrDomainSchema = z
- .string()
- .trim()
- .pipe(z.email({ error: 'Invalid email or domain' }))
- .or(
- z
- .string()
- .refine(
- (value) => value.startsWith('@') && isDomain(value.slice(1)),
- 'Invalid email or domain',
- ),
- );
+ public async validateBlocklistRecordIsManageable({
+ id,
+ context,
+ }: {
+ id: string;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const existingRecord = await this.getExistingRecordOrThrow({ id, context });
+
+ await this.blocklistAccessService.assertCanModifyBlocklistEntryOrThrow({
+ entry: existingRecord,
+ context,
+ });
+ }
+
+ public async validateBlocklistForRestoreOne({
+ id,
+ context,
+ }: {
+ id: string;
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const existingRecord = await this.getExistingRecordOrThrow({ id, context });
+
+ await this.blocklistAccessService.assertCanModifyBlocklistEntryOrThrow({
+ entry: existingRecord,
+ context,
+ });
+
+ if (!isDefined(existingRecord.handle)) {
+ return;
+ }
+
+ const liveHandles = await this.getExistingHandlesForOwner({
+ scope: existingRecord.scope,
+ workspaceMemberId:
+ existingRecord.workspaceMemberId ?? context.workspaceMemberId,
+ context,
+ });
+
+ this.validateHandlesAreNew({
+ handles: [existingRecord.handle],
+ existingHandles: liveHandles,
+ });
+ }
- for (const handle of blocklist.map((item) => item.handle)) {
- if (!handle) {
+ private validateHandleFormat(blocklist: Partial<BlocklistItem>[]): void {
+ for (const { handle } of blocklist) {
+ if (!isDefined(handle)) {
throw new CommonQueryRunnerException(
'Blocklist handle is required',
CommonQueryRunnerExceptionCode.BAD_REQUEST,
@@ -79,7 +182,7 @@ export class BlocklistValidationService {
);
}
- const result = emailOrDomainSchema.safeParse(handle);
+ const result = BLOCKLIST_HANDLE_SCHEMA.safeParse(handle);
if (!result.success) {
throw new CommonQueryRunnerException(
@@ -91,119 +194,163 @@ export class BlocklistValidationService {
}
}
- public async validateUniquenessForCreateMany(
- payload: CreateManyResolverArgs<BlocklistItem>,
- userId: string,
- workspaceId: string,
- ) {
- const authContext = buildSystemAuthContext(workspaceId);
-
- const currentWorkspaceMember =
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository(
- WorkspaceMemberWorkspaceEntity,
- { shouldBypassPermissionChecks: true },
+ private validateScopeTarget({
+ item,
+ context,
+ }: {
+ item: Partial<Pick<BlocklistItem, 'scope' | 'workspaceMemberId'>>;
+ context: BlocklistMutationContext;
+ }): void {
+ const scope = item.scope ?? BlocklistScope.WORKSPACE_MEMBER;
+
+ switch (scope) {
+ case BlocklistScope.WORKSPACE:
+ if (isDefined(item.workspaceMemberId)) {
+ throw new CommonQueryRunnerException(
+ 'A workspace-scoped blocklist entry cannot target a workspace member',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`A workspace-wide blocklist entry cannot target a workspace member.`,
+ },
);
+ }
- return workspaceMemberRepository.findOneByOrFail({
- userId,
- });
- }, authContext);
+ return;
+ case BlocklistScope.WORKSPACE_MEMBER:
+ if (item.workspaceMemberId !== context.workspaceMemberId) {
+ throw new CommonQueryRunnerException(
+ 'A workspace-member-scoped blocklist entry must target its own workspace member',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Cannot manage a blocklist entry of another workspace member.`,
+ },
+ );
+ }
- if (
- payload.data.some(
- (item) =>
- isDefined(item.workspaceMemberId) &&
- item.workspaceMemberId !== currentWorkspaceMember.id,
- )
- ) {
+ return;
+ default:
+ return assertUnreachable(
+ scope,
+ `Blocklist scope ${scope} is not implemented`,
+ );
+ }
+ }
+
+ private validateScopeAndOwnerAreUnchanged({
+ data,
+ existingRecord,
+ }: {
+ data: Partial<BlocklistItem>;
+ existingRecord: Pick<
+ BlocklistWorkspaceEntity,
+ 'scope' | 'workspaceMemberId'
+ >;
+ }): void {
+ if ('scope' in data && data.scope !== existingRecord.scope) {
throw new CommonQueryRunnerException(
- 'Cannot create blocklist entry for another workspace member',
+ 'Blocklist scope cannot be updated',
CommonQueryRunnerExceptionCode.BAD_REQUEST,
- {
- userFriendlyMessage: msg`Cannot create blocklist entry for another workspace member.`,
- },
+ { userFriendlyMessage: msg`Blocklist scope cannot be updated.` },
);
}
- const currentBlocklist =
- await this.blocklistRepository.getByWorkspaceMemberId(
- currentWorkspaceMember.id,
- workspaceId,
- );
-
- const currentBlocklistHandles = currentBlocklist.map(
- (blocklist) => blocklist.handle,
- );
-
if (
- payload.data.some((item) => currentBlocklistHandles.includes(item.handle))
+ 'workspaceMemberId' in data &&
+ data.workspaceMemberId !== existingRecord.workspaceMemberId
) {
throw new CommonQueryRunnerException(
- 'Blocklist handle already exists',
+ 'Workspace member cannot be updated',
CommonQueryRunnerExceptionCode.BAD_REQUEST,
- { userFriendlyMessage: msg`Blocklist handle already exists.` },
+ { userFriendlyMessage: msg`Workspace member cannot be updated.` },
);
}
}
- public async validateUniquenessForUpdateOne(
- payload: UpdateOneResolverArgs<BlocklistItem>,
- userId: string,
- workspaceId: string,
- ) {
- const existingRecord = await this.blocklistRepository.getById(
- payload.id,
- workspaceId,
- );
+ private async validateUniquenessForCreateMany({
+ entries,
+ context,
+ }: {
+ entries: BlocklistCreateEntry[];
+ context: BlocklistMutationContext;
+ }): Promise<void> {
+ const groups = groupBlocklistEntriesForUniqueness({ entries, context });
- if (!existingRecord) {
- throw new CommonQueryRunnerException(
- 'Blocklist item not found',
- CommonQueryRunnerExceptionCode.RECORD_NOT_FOUND,
- { userFriendlyMessage: msg`Blocklist item not found.` },
- );
- }
+ for (const {
+ scope,
+ workspaceMemberId,
+ handles,
+ retainedHandles,
+ } of groups) {
+ if (new Set(handles).size !== handles.length) {
+ throw new CommonQueryRunnerException(
+ 'Blocklist handle is duplicated in the payload',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ { userFriendlyMessage: msg`Blocklist handle already exists.` },
+ );
+ }
- if (existingRecord.workspaceMemberId !== payload.data.workspaceMemberId) {
- throw new CommonQueryRunnerException(
- 'Workspace member cannot be updated',
- CommonQueryRunnerExceptionCode.BAD_REQUEST,
- { userFriendlyMessage: msg`Workspace member cannot be updated.` },
- );
- }
+ const existingHandles = await this.getExistingHandlesForOwner({
+ scope,
+ workspaceMemberId,
+ context,
+ });
- if (existingRecord.handle === payload.data.handle) {
- return;
+ this.validateHandlesAreNew({
+ handles,
+ existingHandles: existingHandles.filter(
+ (handle) => !retainedHandles.includes(handle),
+ ),
+ });
}
+ }
- const authContext = buildSystemAuthContext(workspaceId);
-
- const currentWorkspaceMember =
- await this.workspaceOrmManager.executeInWorkspaceContext(async () => {
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository(
- WorkspaceMemberWorkspaceEntity,
- { shouldBypassPermissionChecks: true },
+ private async getExistingHandlesForOwner({
+ scope,
+ workspaceMemberId,
+ context,
+ }: {
+ scope: BlocklistScope;
+ workspaceMemberId: string;
+ context: BlocklistMutationContext;
+ }): Promise<string[]> {
+ switch (scope) {
+ case BlocklistScope.WORKSPACE: {
+ const workspaceBlocklist =
+ await this.blocklistRepository.getWorkspaceScopedEntries(
+ context.workspaceId,
);
- return workspaceMemberRepository.findOneByOrFail({
- userId,
- });
- }, authContext);
-
- const currentBlocklist =
- await this.blocklistRepository.getByWorkspaceMemberId(
- currentWorkspaceMember.id,
- workspaceId,
- );
+ return workspaceBlocklist
+ .map((blocklistItem) => blocklistItem.handle)
+ .filter(isDefined);
+ }
+ case BlocklistScope.WORKSPACE_MEMBER: {
+ const memberBlocklist =
+ await this.blocklistRepository.getMemberScopedEntries({
+ workspaceMemberId,
+ workspaceId: context.workspaceId,
+ });
- const currentBlocklistHandles = currentBlocklist
- .filter((blocklist) => blocklist.id !== payload.id)
- .map((blocklist) => blocklist.handle);
+ return memberBlocklist
+ .map((blocklistItem) => blocklistItem.handle)
+ .filter(isDefined);
+ }
+ default:
+ return assertUnreachable(
+ scope,
+ `Blocklist scope ${scope} is not implemented`,
+ );
+ }
+ }
- if (currentBlocklistHandles.includes(payload.data.handle)) {
+ private validateHandlesAreNew({
+ handles,
+ existingHandles,
+ }: {
+ handles: string[];
+ existingHandles: string[];
+ }): void {
+ if (handles.some((handle) => existingHandles.includes(handle))) {
throw new CommonQueryRunnerException(
'Blocklist handle already exists',
CommonQueryRunnerExceptionCode.BAD_REQUEST,
@@ -211,4 +358,27 @@ export class BlocklistValidationService {
);
}
}
+
+ private async getExistingRecordOrThrow({
+ id,
+ context,
+ }: {
+ id: string;
+ context: BlocklistMutationContext;
+ }): Promise<BlocklistWorkspaceEntity> {
+ const existingRecord = await this.blocklistRepository.getById({
+ id,
+ workspaceId: context.workspaceId,
+ });
+
+ if (!isDefined(existingRecord)) {
+ throw new CommonQueryRunnerException(
+ 'Blocklist item not found',
+ CommonQueryRunnerExceptionCode.RECORD_NOT_FOUND,
+ { userFriendlyMessage: msg`Blocklist item not found.` },
+ );
+ }
+
+ return existingRecord;
+ }
}
diff --git a/packages/twenty-server/src/modules/blocklist/constants/blocklist-handle-schema.constant.ts b/packages/twenty-server/src/modules/blocklist/constants/blocklist-handle-schema.constant.ts
new file mode 100644
index 00000000000..4485290b60c
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/constants/blocklist-handle-schema.constant.ts
@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+import { isDomain } from 'src/engine/utils/is-domain';
+
+export const BLOCKLIST_HANDLE_SCHEMA = z
+ .string()
+ .trim()
+ .pipe(z.email({ error: 'Invalid email or domain' }))
+ .or(
+ z
+ .string()
+ .refine(
+ (value) => value.startsWith('@') && isDomain(value.slice(1)),
+ 'Invalid email or domain',
+ ),
+ );
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-many.pre-query.hook.ts
index 77d3bf9eda3..487010bb165 100644
--- a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-many.pre-query.hook.ts
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-many.pre-query.hook.ts
@@ -1,19 +1,11 @@
-import { msg } from '@lingui/core/macro';
-
import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
import { type CreateManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
-import {
- CommonQueryRunnerException,
- CommonQueryRunnerExceptionCode,
-} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
-import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import {
- type BlocklistItem,
- BlocklistValidationService,
-} from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
@WorkspaceQueryHook(`blocklist.createMany`)
export class BlocklistCreateManyPreQueryHook implements WorkspacePreQueryHookInstance {
@@ -24,21 +16,12 @@ export class BlocklistCreateManyPreQueryHook implements WorkspacePreQueryHookIns
async execute(
authContext: WorkspaceAuthContext,
_objectName: string,
- payload: CreateManyResolverArgs<BlocklistItem>,
- ): Promise<CreateManyResolverArgs<BlocklistItem>> {
- if (!isUserAuthContext(authContext)) {
- throw new CommonQueryRunnerException(
- 'User id is required',
- CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT,
- { userFriendlyMessage: msg`User id is required.` },
- );
- }
-
- await this.blocklistValidationService.validateBlocklistForCreateMany(
+ payload: CreateManyResolverArgs<Partial<BlocklistItem>>,
+ ): Promise<CreateManyResolverArgs<Partial<BlocklistItem>>> {
+ await this.blocklistValidationService.validateBlocklistForCreateMany({
payload,
- authContext.user.id,
- authContext.workspace.id,
- );
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
return payload;
}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-one.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-one.pre-query.hook.ts
index 69c99479113..ea1810b3bca 100644
--- a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-one.pre-query.hook.ts
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-create-one.pre-query.hook.ts
@@ -1,19 +1,11 @@
-import { msg } from '@lingui/core/macro';
-
import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
import { type CreateOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
-import {
- CommonQueryRunnerException,
- CommonQueryRunnerExceptionCode,
-} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
-import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import {
- type BlocklistItem,
- BlocklistValidationService,
-} from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
@WorkspaceQueryHook(`blocklist.createOne`)
export class BlocklistCreateOnePreQueryHook implements WorkspacePreQueryHookInstance {
@@ -24,23 +16,12 @@ export class BlocklistCreateOnePreQueryHook implements WorkspacePreQueryHookInst
async execute(
authContext: WorkspaceAuthContext,
_objectName: string,
- payload: CreateOneResolverArgs<BlocklistItem>,
- ): Promise<CreateOneResolverArgs<BlocklistItem>> {
- if (!isUserAuthContext(authContext)) {
- throw new CommonQueryRunnerException(
- 'User id is required',
- CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT,
- {
- userFriendlyMessage: msg`You must be authenticated to manage blocklist.`,
- },
- );
- }
-
- await this.blocklistValidationService.validateBlocklistForCreateMany(
- { data: [payload.data] },
- authContext.user.id,
- authContext.workspace.id,
- );
+ payload: CreateOneResolverArgs<Partial<BlocklistItem>>,
+ ): Promise<CreateOneResolverArgs<Partial<BlocklistItem>>> {
+ await this.blocklistValidationService.validateBlocklistForCreateMany({
+ payload: { data: [payload.data] },
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
return payload;
}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-many.pre-query.hook.ts
new file mode 100644
index 00000000000..c8f95af3777
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-many.pre-query.hook.ts
@@ -0,0 +1,23 @@
+import { msg } from '@lingui/core/macro';
+
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type DeleteManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+
+@WorkspaceQueryHook(`blocklist.deleteMany`)
+export class BlocklistDeleteManyPreQueryHook implements WorkspacePreQueryHookInstance {
+ async execute(): Promise<DeleteManyResolverArgs> {
+ throw new CommonQueryRunnerException(
+ 'Method not allowed.',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Bulk deletion of blocklist entries is not allowed.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-one.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-one.pre-query.hook.ts
new file mode 100644
index 00000000000..05357b295de
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-delete-one.pre-query.hook.ts
@@ -0,0 +1,27 @@
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type DeleteOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
+
+@WorkspaceQueryHook(`blocklist.deleteOne`)
+export class BlocklistDeleteOnePreQueryHook implements WorkspacePreQueryHookInstance {
+ constructor(
+ private readonly blocklistValidationService: BlocklistValidationService,
+ ) {}
+
+ async execute(
+ authContext: WorkspaceAuthContext,
+ _objectName: string,
+ payload: DeleteOneResolverArgs,
+ ): Promise<DeleteOneResolverArgs> {
+ await this.blocklistValidationService.validateBlocklistRecordIsManageable({
+ id: payload.id,
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
+
+ return payload;
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-many.pre-query.hook.ts
new file mode 100644
index 00000000000..4686c13a817
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-many.pre-query.hook.ts
@@ -0,0 +1,23 @@
+import { msg } from '@lingui/core/macro';
+
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type DestroyManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+
+@WorkspaceQueryHook(`blocklist.destroyMany`)
+export class BlocklistDestroyManyPreQueryHook implements WorkspacePreQueryHookInstance {
+ async execute(): Promise<DestroyManyResolverArgs> {
+ throw new CommonQueryRunnerException(
+ 'Method not allowed.',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Bulk deletion of blocklist entries is not allowed.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-one.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-one.pre-query.hook.ts
new file mode 100644
index 00000000000..2cf6b894dbc
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-destroy-one.pre-query.hook.ts
@@ -0,0 +1,27 @@
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type DestroyOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
+
+@WorkspaceQueryHook(`blocklist.destroyOne`)
+export class BlocklistDestroyOnePreQueryHook implements WorkspacePreQueryHookInstance {
+ constructor(
+ private readonly blocklistValidationService: BlocklistValidationService,
+ ) {}
+
+ async execute(
+ authContext: WorkspaceAuthContext,
+ _objectName: string,
+ payload: DestroyOneResolverArgs,
+ ): Promise<DestroyOneResolverArgs> {
+ await this.blocklistValidationService.validateBlocklistRecordIsManageable({
+ id: payload.id,
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
+
+ return payload;
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-merge-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-merge-many.pre-query.hook.ts
new file mode 100644
index 00000000000..f556c5f1d13
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-merge-many.pre-query.hook.ts
@@ -0,0 +1,23 @@
+import { msg } from '@lingui/core/macro';
+
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type MergeManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+
+@WorkspaceQueryHook(`blocklist.mergeMany`)
+export class BlocklistMergeManyPreQueryHook implements WorkspacePreQueryHookInstance {
+ async execute(): Promise<MergeManyResolverArgs> {
+ throw new CommonQueryRunnerException(
+ 'Method not allowed.',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Merging blocklist entries is not allowed.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-query-hook.module.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-query-hook.module.ts
index d2a93bd7acd..c178e54f23f 100644
--- a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-query-hook.module.ts
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-query-hook.module.ts
@@ -3,6 +3,13 @@ import { Module } from '@nestjs/common';
import { BlocklistValidationManagerModule } from 'src/modules/blocklist/blocklist-validation-manager/blocklist-validation-manager.module';
import { BlocklistCreateManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-create-many.pre-query.hook';
import { BlocklistCreateOnePreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-create-one.pre-query.hook';
+import { BlocklistDeleteManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-delete-many.pre-query.hook';
+import { BlocklistDeleteOnePreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-delete-one.pre-query.hook';
+import { BlocklistDestroyManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-destroy-many.pre-query.hook';
+import { BlocklistDestroyOnePreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-destroy-one.pre-query.hook';
+import { BlocklistMergeManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-merge-many.pre-query.hook';
+import { BlocklistRestoreManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-restore-many.pre-query.hook';
+import { BlocklistRestoreOnePreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-restore-one.pre-query.hook';
import { BlocklistUpdateManyPreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-update-many.pre-query.hook';
import { BlocklistUpdateOnePreQueryHook } from 'src/modules/blocklist/query-hooks/blocklist-update-one.pre-query.hook';
@@ -11,6 +18,13 @@ import { BlocklistUpdateOnePreQueryHook } from 'src/modules/blocklist/query-hook
providers: [
BlocklistCreateManyPreQueryHook,
BlocklistCreateOnePreQueryHook,
+ BlocklistDeleteManyPreQueryHook,
+ BlocklistDeleteOnePreQueryHook,
+ BlocklistDestroyManyPreQueryHook,
+ BlocklistDestroyOnePreQueryHook,
+ BlocklistMergeManyPreQueryHook,
+ BlocklistRestoreManyPreQueryHook,
+ BlocklistRestoreOnePreQueryHook,
BlocklistUpdateManyPreQueryHook,
BlocklistUpdateOnePreQueryHook,
],
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-many.pre-query.hook.ts
new file mode 100644
index 00000000000..8c17114c657
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-many.pre-query.hook.ts
@@ -0,0 +1,23 @@
+import { msg } from '@lingui/core/macro';
+
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type RestoreManyResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+
+@WorkspaceQueryHook(`blocklist.restoreMany`)
+export class BlocklistRestoreManyPreQueryHook implements WorkspacePreQueryHookInstance {
+ async execute(): Promise<RestoreManyResolverArgs> {
+ throw new CommonQueryRunnerException(
+ 'Method not allowed.',
+ CommonQueryRunnerExceptionCode.BAD_REQUEST,
+ {
+ userFriendlyMessage: msg`Bulk restoration of blocklist entries is not allowed.`,
+ },
+ );
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-one.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-one.pre-query.hook.ts
new file mode 100644
index 00000000000..49930a7aa73
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-restore-one.pre-query.hook.ts
@@ -0,0 +1,27 @@
+import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
+import { type RestoreOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
+
+@WorkspaceQueryHook(`blocklist.restoreOne`)
+export class BlocklistRestoreOnePreQueryHook implements WorkspacePreQueryHookInstance {
+ constructor(
+ private readonly blocklistValidationService: BlocklistValidationService,
+ ) {}
+
+ async execute(
+ authContext: WorkspaceAuthContext,
+ _objectName: string,
+ payload: RestoreOneResolverArgs,
+ ): Promise<RestoreOneResolverArgs> {
+ await this.blocklistValidationService.validateBlocklistForRestoreOne({
+ id: payload.id,
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
+
+ return payload;
+ }
+}
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-many.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-many.pre-query.hook.ts
index fa4a4d3a849..d9825db9682 100644
--- a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-many.pre-query.hook.ts
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-many.pre-query.hook.ts
@@ -8,7 +8,7 @@ import {
CommonQueryRunnerExceptionCode,
} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
-import { type BlocklistItem } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
@WorkspaceQueryHook(`blocklist.updateMany`)
export class BlocklistUpdateManyPreQueryHook implements WorkspacePreQueryHookInstance {
diff --git a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-one.pre-query.hook.ts b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-one.pre-query.hook.ts
index 4887f007b7e..ad90c407539 100644
--- a/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-one.pre-query.hook.ts
+++ b/packages/twenty-server/src/modules/blocklist/query-hooks/blocklist-update-one.pre-query.hook.ts
@@ -1,19 +1,11 @@
-import { msg } from '@lingui/core/macro';
-
import { type WorkspacePreQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/interfaces/workspace-query-hook.interface';
import { type UpdateOneResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
-import {
- CommonQueryRunnerException,
- CommonQueryRunnerExceptionCode,
-} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
import { WorkspaceQueryHook } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-hook/decorators/workspace-query-hook.decorator';
-import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
-import {
- type BlocklistItem,
- BlocklistValidationService,
-} from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { BlocklistValidationService } from 'src/modules/blocklist/blocklist-validation-manager/services/blocklist-validation.service';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { buildBlocklistMutationContextOrThrow } from 'src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util';
@WorkspaceQueryHook(`blocklist.updateOne`)
export class BlocklistUpdateOnePreQueryHook implements WorkspacePreQueryHookInstance {
@@ -24,23 +16,12 @@ export class BlocklistUpdateOnePreQueryHook implements WorkspacePreQueryHookInst
async execute(
authContext: WorkspaceAuthContext,
_objectName: string,
- payload: UpdateOneResolverArgs<BlocklistItem>,
- ): Promise<UpdateOneResolverArgs<BlocklistItem>> {
- if (!isUserAuthContext(authContext)) {
- throw new CommonQueryRunnerException(
- 'User id is required',
- CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT,
- { userFriendlyMessage: msg`User id is required.` },
- );
- }
-
- const workspace = authContext.workspace;
-
- await this.blocklistValidationService.validateBlocklistForUpdateOne(
+ payload: UpdateOneResolverArgs<Partial<BlocklistItem>>,
+ ): Promise<UpdateOneResolverArgs<Partial<BlocklistItem>>> {
+ await this.blocklistValidationService.validateBlocklistForUpdateOne({
payload,
- authContext.user.id,
- workspace.id,
- );
+ context: buildBlocklistMutationContextOrThrow(authContext),
+ });
return payload;
}
diff --git a/packages/twenty-server/src/modules/blocklist/repositories/blocklist.repository.ts b/packages/twenty-server/src/modules/blocklist/repositories/blocklist.repository.ts
index d8203a8bcb2..7274fc2f22e 100644
--- a/packages/twenty-server/src/modules/blocklist/repositories/blocklist.repository.ts
+++ b/packages/twenty-server/src/modules/blocklist/repositories/blocklist.repository.ts
@@ -1,5 +1,9 @@
import { Injectable } from '@nestjs/common';
+import { BlocklistScope } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { type FindOptionsWhere, In } from 'typeorm';
+
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
@@ -8,10 +12,13 @@ import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects
export class BlocklistRepository {
constructor(private readonly workspaceOrmManager: WorkspaceOrmManager) {}
- public async getById(
- id: string,
- workspaceId: string,
- ): Promise<BlocklistWorkspaceEntity | null> {
+ public async getById({
+ id,
+ workspaceId,
+ }: {
+ id: string;
+ workspaceId: string;
+ }): Promise<BlocklistWorkspaceEntity | null> {
const authContext = buildSystemAuthContext(workspaceId);
return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
@@ -22,28 +29,103 @@ export class BlocklistRepository {
},
);
- return blockListRepository.findOneBy({
- id,
+ return blockListRepository.findOne({
+ where: { id },
+ withDeleted: true,
});
}, authContext);
}
- public async getByWorkspaceMemberId(
- workspaceMemberId: string,
- workspaceId: string,
- ): Promise<BlocklistWorkspaceEntity[]> {
+ public async getByIds({
+ ids,
+ workspaceId,
+ }: {
+ ids: string[];
+ workspaceId: string;
+ }): Promise<BlocklistWorkspaceEntity[]> {
+ if (ids.length === 0) {
+ return [];
+ }
+
const authContext = buildSystemAuthContext(workspaceId);
return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
const blockListRepository = this.workspaceOrmManager.getRepository(
BlocklistWorkspaceEntity,
+ {
+ shouldBypassPermissionChecks: true,
+ },
);
return blockListRepository.find({
- where: {
- workspaceMemberId,
- },
+ where: { id: In(ids) },
+ withDeleted: true,
});
}, authContext);
}
+
+ public async getMemberScopedEntries({
+ workspaceMemberId,
+ workspaceId,
+ }: {
+ workspaceMemberId: string;
+ workspaceId: string;
+ }): Promise<BlocklistWorkspaceEntity[]> {
+ return this.find({
+ workspaceId,
+ where: {
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId,
+ },
+ });
+ }
+
+ public async getWorkspaceScopedEntries(
+ workspaceId: string,
+ ): Promise<BlocklistWorkspaceEntity[]> {
+ return this.find({
+ workspaceId,
+ where: { scope: BlocklistScope.WORKSPACE },
+ });
+ }
+
+ public async getEntriesApplicableToWorkspaceMember({
+ workspaceMemberId,
+ workspaceId,
+ }: {
+ workspaceMemberId: string | null;
+ workspaceId: string;
+ }): Promise<BlocklistWorkspaceEntity[]> {
+ if (!isDefined(workspaceMemberId)) {
+ return this.getWorkspaceScopedEntries(workspaceId);
+ }
+
+ return this.find({
+ workspaceId,
+ where: [
+ { scope: BlocklistScope.WORKSPACE },
+ { scope: BlocklistScope.WORKSPACE_MEMBER, workspaceMemberId },
+ ],
+ });
+ }
+
+ private async find({
+ workspaceId,
+ where,
+ }: {
+ workspaceId: string;
+ where:
+ | FindOptionsWhere<BlocklistWorkspaceEntity>
+ | FindOptionsWhere<BlocklistWorkspaceEntity>[];
+ }): Promise<BlocklistWorkspaceEntity[]> {
+ const authContext = buildSystemAuthContext(workspaceId);
+
+ return this.workspaceOrmManager.executeInWorkspaceContext(async () => {
+ const blockListRepository = this.workspaceOrmManager.getRepository(
+ BlocklistWorkspaceEntity,
+ );
+
+ return blockListRepository.find({ where });
+ }, authContext);
+ }
}
diff --git a/packages/twenty-server/src/modules/blocklist/types/blocklist-item.type.ts b/packages/twenty-server/src/modules/blocklist/types/blocklist-item.type.ts
new file mode 100644
index 00000000000..7c2da74fcbd
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/types/blocklist-item.type.ts
@@ -0,0 +1,9 @@
+import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+
+export type BlocklistItem = Omit<
+ BlocklistWorkspaceEntity,
+ 'createdAt' | 'updatedAt' | 'workspaceMember'
+> & {
+ createdAt: string;
+ updatedAt: string;
+};
diff --git a/packages/twenty-server/src/modules/blocklist/types/blocklist-mutation-context.type.ts b/packages/twenty-server/src/modules/blocklist/types/blocklist-mutation-context.type.ts
new file mode 100644
index 00000000000..ed55cc9fd18
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/types/blocklist-mutation-context.type.ts
@@ -0,0 +1,5 @@
+export type BlocklistMutationContext = {
+ workspaceId: string;
+ userWorkspaceId: string;
+ workspaceMemberId: string;
+};
diff --git a/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-entries-for-uniqueness.util.spec.ts b/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-entries-for-uniqueness.util.spec.ts
new file mode 100644
index 00000000000..01b668265df
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-entries-for-uniqueness.util.spec.ts
@@ -0,0 +1,120 @@
+import { BlocklistScope } from 'twenty-shared/types';
+
+import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { type BlocklistMutationContext } from 'src/modules/blocklist/types/blocklist-mutation-context.type';
+import { groupBlocklistEntriesForUniqueness } from 'src/modules/blocklist/utils/group-blocklist-entries-for-uniqueness.util';
+
+const context: BlocklistMutationContext = {
+ workspaceId: 'workspace-id',
+ workspaceMemberId: 'caller-member-id',
+ userWorkspaceId: 'user-workspace-id',
+};
+
+type ExistingRecord = Pick<
+ BlocklistWorkspaceEntity,
+ 'handle' | 'scope' | 'workspaceMemberId'
+>;
+
+const existingRecord = (
+ overrides: Partial<ExistingRecord>,
+): ExistingRecord => ({
+ handle: null,
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'caller-member-id',
+ ...overrides,
+});
+
+describe('groupBlocklistEntriesForUniqueness', () => {
+ it('groups new member-scoped handles under the caller', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [
+ { item: { handle: '[email protected]' }, existingRecord: null },
+ { item: { handle: '[email protected]' }, existingRecord: null },
+ ],
+ context,
+ });
+
+ expect(groups).toEqual([
+ {
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'caller-member-id',
+ retainedHandles: [],
+ },
+ ]);
+ });
+
+ it('keeps workspace-scoped handles in their own group', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [
+ {
+ item: { handle: '@spam.com', scope: BlocklistScope.WORKSPACE },
+ existingRecord: null,
+ },
+ { item: { handle: '[email protected]' }, existingRecord: null },
+ ],
+ context,
+ });
+
+ expect(groups).toHaveLength(2);
+ expect(groups.map((group) => group.scope)).toEqual([
+ BlocklistScope.WORKSPACE,
+ BlocklistScope.WORKSPACE_MEMBER,
+ ]);
+ });
+
+ it('skips entries whose handle is unchanged', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [
+ {
+ item: { handle: '[email protected]' },
+ existingRecord: existingRecord({ handle: '[email protected]' }),
+ },
+ ],
+ context,
+ });
+
+ expect(groups).toEqual([]);
+ });
+
+ it('records the previous handle as retained when a handle is replaced', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [
+ {
+ item: { handle: '[email protected]' },
+ existingRecord: existingRecord({ handle: '[email protected]' }),
+ },
+ ],
+ context,
+ });
+
+ expect(groups[0].handles).toEqual(['[email protected]']);
+ expect(groups[0].retainedHandles).toEqual(['[email protected]']);
+ });
+
+ it('groups an existing record under its own owner, not the caller', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [
+ {
+ item: { handle: '[email protected]' },
+ existingRecord: existingRecord({
+ handle: '[email protected]',
+ workspaceMemberId: 'other-member-id',
+ }),
+ },
+ ],
+ context,
+ });
+
+ expect(groups[0].workspaceMemberId).toBe('other-member-id');
+ });
+
+ it('ignores entries without a handle', () => {
+ const groups = groupBlocklistEntriesForUniqueness({
+ entries: [{ item: {}, existingRecord: null }],
+ context,
+ });
+
+ expect(groups).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-handles-by-owner.util.spec.ts b/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-handles-by-owner.util.spec.ts
new file mode 100644
index 00000000000..121297798d8
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/utils/__tests__/group-blocklist-handles-by-owner.util.spec.ts
@@ -0,0 +1,89 @@
+import { BlocklistScope } from 'twenty-shared/types';
+
+import { groupBlocklistHandlesByOwner } from 'src/modules/blocklist/utils/group-blocklist-handles-by-owner.util';
+
+describe('groupBlocklistHandlesByOwner', () => {
+ it('groups member-scoped handles under their workspace member', () => {
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner([
+ {
+ handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'member-1',
+ },
+ {
+ handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'member-1',
+ },
+ {
+ handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'member-2',
+ },
+ ]);
+
+ expect(workspaceScopedHandles).toEqual([]);
+ expect(handlesByWorkspaceMemberId.get('member-1')).toEqual([
+ ]);
+ expect(handlesByWorkspaceMemberId.get('member-2')).toEqual([
+ ]);
+ });
+
+ it('collects workspace-scoped handles separately from member-scoped ones', () => {
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner([
+ {
+ handle: '@competitor.com',
+ scope: BlocklistScope.WORKSPACE,
+ workspaceMemberId: null,
+ },
+ {
+ handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'member-1',
+ },
+ ]);
+
+ expect(workspaceScopedHandles).toEqual(['@competitor.com']);
+ expect(handlesByWorkspaceMemberId.get('member-1')).toEqual([
+ ]);
+ });
+
+ it('drops a member-scoped handle whose workspace member was removed instead of applying it workspace-wide', () => {
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner([
+ {
+ handle: '[email protected]',
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: null,
+ },
+ ]);
+
+ expect(workspaceScopedHandles).toEqual([]);
+ expect(handlesByWorkspaceMemberId.size).toBe(0);
+ });
+
+ it('drops entries without a handle', () => {
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner([
+ {
+ handle: null,
+ scope: BlocklistScope.WORKSPACE,
+ workspaceMemberId: null,
+ },
+ {
+ handle: null,
+ scope: BlocklistScope.WORKSPACE_MEMBER,
+ workspaceMemberId: 'member-1',
+ },
+ ]);
+
+ expect(workspaceScopedHandles).toEqual([]);
+ expect(handlesByWorkspaceMemberId.size).toBe(0);
+ });
+});
diff --git a/packages/twenty-server/src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util.ts b/packages/twenty-server/src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util.ts
new file mode 100644
index 00000000000..c9644a444e6
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/utils/build-blocklist-mutation-context-or-throw.util.ts
@@ -0,0 +1,29 @@
+import { msg } from '@lingui/core/macro';
+
+import {
+ CommonQueryRunnerException,
+ CommonQueryRunnerExceptionCode,
+} from 'src/engine/api/common/common-query-runners/errors/common-query-runner.exception';
+import { isUserAuthContext } from 'src/engine/core-modules/auth/guards/is-user-auth-context.guard';
+import { type WorkspaceAuthContext } from 'src/engine/core-modules/auth/types/workspace-auth-context.type';
+import { type BlocklistMutationContext } from 'src/modules/blocklist/types/blocklist-mutation-context.type';
+
+export const buildBlocklistMutationContextOrThrow = (
+ authContext: WorkspaceAuthContext,
+): BlocklistMutationContext => {
+ if (!isUserAuthContext(authContext)) {
+ throw new CommonQueryRunnerException(
+ 'Blocklist entries can only be managed by an authenticated user',
+ CommonQueryRunnerExceptionCode.INVALID_AUTH_CONTEXT,
+ {
+ userFriendlyMessage: msg`You must be authenticated to manage the blocklist.`,
+ },
+ );
+ }
+
+ return {
+ workspaceId: authContext.workspace.id,
+ userWorkspaceId: authContext.userWorkspaceId,
+ workspaceMemberId: authContext.workspaceMemberId,
+ };
+};
diff --git a/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-entries-for-uniqueness.util.ts b/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-entries-for-uniqueness.util.ts
new file mode 100644
index 00000000000..3e43e553e98
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-entries-for-uniqueness.util.ts
@@ -0,0 +1,62 @@
+import { BlocklistScope } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { type BlocklistItem } from 'src/modules/blocklist/types/blocklist-item.type';
+import { type BlocklistMutationContext } from 'src/modules/blocklist/types/blocklist-mutation-context.type';
+
+export type BlocklistUniquenessGroup = {
+ scope: BlocklistScope;
+ workspaceMemberId: string;
+ handles: string[];
+ retainedHandles: string[];
+};
+
+export const groupBlocklistEntriesForUniqueness = ({
+ entries,
+ context,
+}: {
+ entries: {
+ item: Partial<Pick<BlocklistItem, 'handle' | 'scope'>>;
+ existingRecord: Pick<
+ BlocklistWorkspaceEntity,
+ 'handle' | 'scope' | 'workspaceMemberId'
+ > | null;
+ }[];
+ context: BlocklistMutationContext;
+}): BlocklistUniquenessGroup[] => {
+ const groups = new Map<string, BlocklistUniquenessGroup>();
+
+ for (const { item, existingRecord } of entries) {
+ if (!isDefined(item.handle)) {
+ continue;
+ }
+
+ if (existingRecord?.handle === item.handle) {
+ continue;
+ }
+
+ const scope =
+ existingRecord?.scope ?? item.scope ?? BlocklistScope.WORKSPACE_MEMBER;
+ const workspaceMemberId =
+ existingRecord?.workspaceMemberId ?? context.workspaceMemberId;
+
+ const groupKey = `${scope}:${workspaceMemberId}`;
+ const group = groups.get(groupKey) ?? {
+ scope,
+ workspaceMemberId,
+ handles: [],
+ retainedHandles: [],
+ };
+
+ group.handles.push(item.handle);
+
+ if (isDefined(existingRecord?.handle)) {
+ group.retainedHandles.push(existingRecord.handle);
+ }
+
+ groups.set(groupKey, group);
+ }
+
+ return [...groups.values()];
+};
diff --git a/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-handles-by-owner.util.ts b/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-handles-by-owner.util.ts
new file mode 100644
index 00000000000..a823ea17f14
--- /dev/null
+++ b/packages/twenty-server/src/modules/blocklist/utils/group-blocklist-handles-by-owner.util.ts
@@ -0,0 +1,41 @@
+import { BlocklistScope } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+
+type BlocklistHandlesByOwner = {
+ workspaceScopedHandles: string[];
+ handlesByWorkspaceMemberId: Map<string, string[]>;
+};
+
+export const groupBlocklistHandlesByOwner = (
+ blocklist: Pick<
+ BlocklistWorkspaceEntity,
+ 'handle' | 'scope' | 'workspaceMemberId'
+ >[],
+): BlocklistHandlesByOwner => {
+ const workspaceScopedHandles: string[] = [];
+ const handlesByWorkspaceMemberId = new Map<string, string[]>();
+
+ for (const { handle, scope, workspaceMemberId } of blocklist) {
+ if (!isDefined(handle)) {
+ continue;
+ }
+
+ if (scope === BlocklistScope.WORKSPACE) {
+ workspaceScopedHandles.push(handle);
+ continue;
+ }
+
+ if (!isDefined(workspaceMemberId)) {
+ continue;
+ }
+
+ const handles = handlesByWorkspaceMemberId.get(workspaceMemberId) ?? [];
+
+ handles.push(handle);
+ handlesByWorkspaceMemberId.set(workspaceMemberId, handles);
+ }
+
+ return { workspaceScopedHandles, handlesByWorkspaceMemberId };
+};
diff --git a/packages/twenty-server/src/modules/calendar/blocklist-manager/jobs/blocklist-reimport-calendar-events.job.ts b/packages/twenty-server/src/modules/calendar/blocklist-manager/jobs/blocklist-reimport-calendar-events.job.ts
index 00f3929d99b..5376efb1874 100644
--- a/packages/twenty-server/src/modules/calendar/blocklist-manager/jobs/blocklist-reimport-calendar-events.job.ts
+++ b/packages/twenty-server/src/modules/calendar/blocklist-manager/jobs/blocklist-reimport-calendar-events.job.ts
@@ -2,7 +2,9 @@ import { Scope } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { type ObjectRecordDeleteEvent } from 'twenty-shared/database-events';
-import { Not, type Repository } from 'typeorm';
+import { CalendarChannelSyncStage } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { type FindOptionsWhere, Not, type Repository } from 'typeorm';
import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
@@ -13,9 +15,9 @@ import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { groupBlocklistHandlesByOwner } from 'src/modules/blocklist/utils/group-blocklist-handles-by-owner.util';
import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
-import { CalendarChannelSyncStage } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
export type BlocklistReimportCalendarEventsJobData = WorkspaceEventBatch<
ObjectRecordDeleteEvent<BlocklistWorkspaceEntity>
@@ -43,51 +45,106 @@ export class BlocklistReimportCalendarEventsJob {
await this.workspaceOrmManager.executeInWorkspaceContext(
async () => {
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository('workspaceMember', {
- shouldBypassPermissionChecks: true,
- });
-
- for (const eventPayload of data.events) {
- const workspaceMemberId =
- eventPayload.properties.before.workspaceMemberId;
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner(
+ data.events.map((eventPayload) => eventPayload.properties.before),
+ );
- const workspaceMember = await workspaceMemberRepository.findOne({
- where: { id: workspaceMemberId },
- });
+ const calendarChannelIdsToReset = new Set<string>();
- if (!isDefined(workspaceMember)) {
- continue;
+ if (workspaceScopedHandles.length > 0) {
+ for (const calendarChannelId of await this.findCalendarChannelIdsToReset(
+ { workspaceId, userWorkspaceId: null },
+ )) {
+ calendarChannelIdsToReset.add(calendarChannelId);
}
+ }
- const userWorkspace = await this.userWorkspaceRepository.findOne({
- where: { userId: workspaceMember.userId, workspaceId },
- select: ['id'],
- });
+ for (const workspaceMemberId of handlesByWorkspaceMemberId.keys()) {
+ const userWorkspaceId = await this.findWorkspaceMemberUserWorkspaceId(
+ {
+ workspaceMemberId,
+ workspaceId,
+ },
+ );
- if (!isDefined(userWorkspace)) {
+ if (!isDefined(userWorkspaceId)) {
continue;
}
- const calendarChannels = await this.calendarChannelRepository.find({
- select: ['id'],
- where: {
- connectedAccount: { userWorkspaceId: userWorkspace.id },
- syncStage: Not(
- CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
- ),
- workspaceId,
- },
- });
+ for (const calendarChannelId of await this.findCalendarChannelIdsToReset(
+ { workspaceId, userWorkspaceId },
+ )) {
+ calendarChannelIdsToReset.add(calendarChannelId);
+ }
+ }
- await this.calendarChannelSyncStatusService.resetAndMarkAsCalendarEventListFetchPending(
- calendarChannels.map((calendarChannel) => calendarChannel.id),
- workspaceId,
- );
+ if (calendarChannelIdsToReset.size === 0) {
+ return;
}
+
+ await this.calendarChannelSyncStatusService.resetAndMarkAsCalendarEventListFetchPending(
+ [...calendarChannelIdsToReset],
+ workspaceId,
+ );
},
authContext,
{ lite: true },
);
}
+
+ private async findWorkspaceMemberUserWorkspaceId({
+ workspaceMemberId,
+ workspaceId,
+ }: {
+ workspaceMemberId: string;
+ workspaceId: string;
+ }): Promise<string | null> {
+ const workspaceMemberRepository =
+ this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+ 'workspaceMember',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const workspaceMember = await workspaceMemberRepository.findOne({
+ where: { id: workspaceMemberId },
+ });
+
+ if (!isDefined(workspaceMember)) {
+ return null;
+ }
+
+ const userWorkspace = await this.userWorkspaceRepository.findOne({
+ where: { userId: workspaceMember.userId, workspaceId },
+ select: ['id'],
+ });
+
+ return userWorkspace?.id ?? null;
+ }
+
+ private async findCalendarChannelIdsToReset({
+ workspaceId,
+ userWorkspaceId,
+ }: {
+ workspaceId: string;
+ userWorkspaceId: string | null;
+ }): Promise<string[]> {
+ const where: FindOptionsWhere<CalendarChannelEntity> = {
+ syncStage: Not(
+ CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+ ),
+ workspaceId,
+ };
+
+ if (isDefined(userWorkspaceId)) {
+ where.connectedAccount = { userWorkspaceId };
+ }
+
+ const calendarChannels = await this.calendarChannelRepository.find({
+ select: ['id'],
+ where,
+ });
+
+ return calendarChannels.map((calendarChannel) => calendarChannel.id);
+ }
}
diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service.ts b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service.ts
index 06e15c586f0..d68d22cff3b 100644
--- a/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service.ts
+++ b/packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service.ts
@@ -102,12 +102,13 @@ export class CalendarEventsImportService {
})
: null;
- const blocklist = workspaceMember
- ? await this.blocklistRepository.getByWorkspaceMemberId(
- workspaceMember.id,
+ const blocklist =
+ await this.blocklistRepository.getEntriesApplicableToWorkspaceMember(
+ {
+ workspaceMemberId: workspaceMember?.id ?? null,
workspaceId,
- )
- : [];
+ },
+ );
if (!isDefined(connectedAccount.handleAliases)) {
connectedAccount.handleAliases =
@@ -131,7 +132,9 @@ export class CalendarEventsImportService {
filterEventsAndReturnCancelledEvents(
[calendarChannel.handle, ...connectedAccount.handleAliases],
calendarEvents,
- blocklist.map((blocklist) => blocklist.handle ?? ''),
+ blocklist
+ .map((blocklistItem) => blocklistItem.handle)
+ .filter(isDefined),
);
const cancelledEventExternalIds = cancelledEvents.map(
diff --git a/packages/twenty-server/src/modules/messaging/blocklist-manager/constants/blocklisted-participant-roles.constant.ts b/packages/twenty-server/src/modules/messaging/blocklist-manager/constants/blocklisted-participant-roles.constant.ts
new file mode 100644
index 00000000000..7eec62ada99
--- /dev/null
+++ b/packages/twenty-server/src/modules/messaging/blocklist-manager/constants/blocklisted-participant-roles.constant.ts
@@ -0,0 +1,6 @@
+import { MessageParticipantRole } from 'twenty-shared/types';
+
+export const BLOCKLISTED_PARTICIPANT_ROLES = [
+ MessageParticipantRole.FROM,
+ MessageParticipantRole.TO,
+] as const;
diff --git a/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-item-delete-messages.job.ts b/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-item-delete-messages.job.ts
index 9d8374ac02b..d46bbeb79ac 100644
--- a/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-item-delete-messages.job.ts
+++ b/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-item-delete-messages.job.ts
@@ -2,7 +2,6 @@ import { Scope } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { type ObjectRecordCreateEvent } from 'twenty-shared/database-events';
-import { MessageParticipantRole } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { And, Any, ILike, In, Not, Or, Repository } from 'typeorm';
@@ -16,6 +15,8 @@ import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { groupBlocklistHandlesByOwner } from 'src/modules/blocklist/utils/group-blocklist-handles-by-owner.util';
+import { BLOCKLISTED_PARTICIPANT_ROLES } from 'src/modules/messaging/blocklist-manager/constants/blocklisted-participant-roles.constant';
import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
import { type MessageParticipantWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-participant.workspace-entity';
import { MessagingMessageCleanerService } from 'src/modules/messaging/message-cleaner/services/messaging-message-cleaner.service';
@@ -64,162 +65,25 @@ export class BlocklistItemDeleteMessagesJob {
},
});
- const handlesToDeleteByWorkspaceMemberIdMap = blocklist.reduce(
- (acc, blocklistItem) => {
- const { handle, workspaceMemberId } = blocklistItem;
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner(blocklist);
- if (!isDefined(workspaceMemberId)) {
- return acc;
- }
-
- if (!acc.has(workspaceMemberId)) {
- acc.set(workspaceMemberId, []);
- }
-
- if (!isDefined(handle)) {
- return acc;
- }
-
- acc.get(workspaceMemberId)?.push(handle);
-
- return acc;
- },
- new Map<string, string[]>(),
- );
-
- const messageChannelMessageAssociationRepository =
- this.workspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
- 'messageChannelMessageAssociation',
- );
-
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
- 'workspaceMember',
- { shouldBypassPermissionChecks: true },
- );
-
- const messageParticipantRepository =
- this.workspaceOrmManager.getRepository<MessageParticipantWorkspaceEntity>(
- 'messageParticipant',
- { shouldBypassPermissionChecks: true },
- );
-
- for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
- const handles =
- handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
-
- if (!handles) {
- continue;
- }
-
- const rolesToDelete = [
- MessageParticipantRole.FROM,
- MessageParticipantRole.TO,
- ] as const;
-
- const workspaceMember = await workspaceMemberRepository.findOne({
- where: { id: workspaceMemberId },
- });
-
- if (!workspaceMember) {
- continue;
- }
-
- const userWorkspace = await this.userWorkspaceRepository.findOne({
- where: { userId: workspaceMember.userId, workspaceId },
- });
-
- if (!userWorkspace) {
- continue;
- }
-
- const connectedAccounts = await this.connectedAccountRepository.find({
- where: { userWorkspaceId: userWorkspace.id, workspaceId },
+ if (workspaceScopedHandles.length > 0) {
+ await this.deleteMessagesForMessageChannels({
+ messageChannels:
+ await this.findWorkspaceMessageChannels(workspaceId),
+ handles: workspaceScopedHandles,
});
+ }
- const connectedAccountIds = connectedAccounts.map((ca) => ca.id);
-
- if (connectedAccountIds.length === 0) {
- continue;
- }
-
- const messageChannels = await this.messageChannelRepository.find({
- select: {
- id: true,
- handle: true,
- connectedAccount: {
- handleAliases: true,
- },
- },
- where: {
- connectedAccountId: In(connectedAccountIds),
+ for (const [workspaceMemberId, handles] of handlesByWorkspaceMemberId) {
+ await this.deleteMessagesForMessageChannels({
+ messageChannels: await this.findWorkspaceMemberMessageChannels({
+ workspaceMemberId,
workspaceId,
- },
- relations: { connectedAccount: true },
+ }),
+ handles,
});
-
- for (const messageChannel of messageChannels) {
- const messageChannelHandles = [messageChannel.handle];
-
- const handleAliases =
- messageChannel.connectedAccount?.handleAliases;
-
- if (isDefined(handleAliases)) {
- const aliasList: string[] = Array.isArray(handleAliases)
- ? handleAliases
- : (handleAliases as string).split(',');
-
- messageChannelHandles.push(...aliasList);
- }
-
- const handleConditions = handles.map((handle) => {
- const isHandleDomain = handle.startsWith('@');
-
- return isHandleDomain
- ? {
- handle: And(
- Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
- Not(In(messageChannelHandles)),
- ),
- role: In(rolesToDelete),
- }
- : { handle, role: In(rolesToDelete) };
- });
-
- const matchingParticipants =
- await messageParticipantRepository.find({
- where: handleConditions,
- select: { messageId: true },
- });
-
- const messageIds = [
- ...new Set(
- matchingParticipants.map(
- (participant) => participant.messageId,
- ),
- ),
- ];
-
- if (messageIds.length === 0) {
- continue;
- }
-
- const messageChannelMessageAssociationsToDelete =
- await messageChannelMessageAssociationRepository.find({
- where: {
- messageChannelId: messageChannel.id,
- messageId: In(messageIds),
- },
- });
-
- if (messageChannelMessageAssociationsToDelete.length === 0) {
- continue;
- }
-
- await messageChannelMessageAssociationRepository.delete(
- messageChannelMessageAssociationsToDelete.map(({ id }) => id),
- );
- }
}
await this.threadCleanerService.cleanOrphanMessagesAndThreads(
@@ -230,4 +94,146 @@ export class BlocklistItemDeleteMessagesJob {
{ lite: true },
);
}
+
+ private async findWorkspaceMessageChannels(
+ workspaceId: string,
+ ): Promise<MessageChannelEntity[]> {
+ return this.messageChannelRepository.find({
+ select: {
+ id: true,
+ handle: true,
+ connectedAccount: {
+ handleAliases: true,
+ },
+ },
+ where: { workspaceId },
+ relations: { connectedAccount: true },
+ });
+ }
+
+ private async findWorkspaceMemberMessageChannels({
+ workspaceMemberId,
+ workspaceId,
+ }: {
+ workspaceMemberId: string;
+ workspaceId: string;
+ }): Promise<MessageChannelEntity[]> {
+ const workspaceMemberRepository =
+ this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+ 'workspaceMember',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const workspaceMember = await workspaceMemberRepository.findOne({
+ where: { id: workspaceMemberId },
+ });
+
+ if (!isDefined(workspaceMember)) {
+ return [];
+ }
+
+ const userWorkspace = await this.userWorkspaceRepository.findOne({
+ where: { userId: workspaceMember.userId, workspaceId },
+ });
+
+ if (!isDefined(userWorkspace)) {
+ return [];
+ }
+
+ const connectedAccounts = await this.connectedAccountRepository.find({
+ where: { userWorkspaceId: userWorkspace.id, workspaceId },
+ });
+
+ if (connectedAccounts.length === 0) {
+ return [];
+ }
+
+ return this.messageChannelRepository.find({
+ select: {
+ id: true,
+ handle: true,
+ connectedAccount: {
+ handleAliases: true,
+ },
+ },
+ where: {
+ connectedAccountId: In(
+ connectedAccounts.map((connectedAccount) => connectedAccount.id),
+ ),
+ workspaceId,
+ },
+ relations: { connectedAccount: true },
+ });
+ }
+
+ private async deleteMessagesForMessageChannels({
+ messageChannels,
+ handles,
+ }: {
+ messageChannels: MessageChannelEntity[];
+ handles: string[];
+ }): Promise<void> {
+ const messageChannelMessageAssociationRepository =
+ this.workspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+ 'messageChannelMessageAssociation',
+ );
+
+ const messageParticipantRepository =
+ this.workspaceOrmManager.getRepository<MessageParticipantWorkspaceEntity>(
+ 'messageParticipant',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ for (const messageChannel of messageChannels) {
+ const messageChannelHandles = [
+ messageChannel.handle,
+ ...(messageChannel.connectedAccount?.handleAliases ?? []),
+ ];
+
+ const handleConditions = handles.map((handle) => {
+ const isHandleDomain = handle.startsWith('@');
+
+ return isHandleDomain
+ ? {
+ handle: And(
+ Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
+ Not(In(messageChannelHandles)),
+ ),
+ role: In(BLOCKLISTED_PARTICIPANT_ROLES),
+ }
+ : { handle, role: In(BLOCKLISTED_PARTICIPANT_ROLES) };
+ });
+
+ const matchingParticipants = await messageParticipantRepository.find({
+ where: handleConditions,
+ select: { messageId: true },
+ });
+
+ const messageIds = [
+ ...new Set(
+ matchingParticipants.map((participant) => participant.messageId),
+ ),
+ ];
+
+ if (messageIds.length === 0) {
+ continue;
+ }
+
+ const messageChannelMessageAssociationsToDelete =
+ await messageChannelMessageAssociationRepository.find({
+ where: {
+ messageChannelId: messageChannel.id,
+ messageId: In(messageIds),
+ },
+ });
+
+ if (messageChannelMessageAssociationsToDelete.length === 0) {
+ continue;
+ }
+
+ await messageChannelMessageAssociationRepository.delete(
+ messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+ );
+ }
+ }
}
diff --git a/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-reimport-messages.job.ts b/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-reimport-messages.job.ts
index 87d43fef3f2..026efad8fb2 100644
--- a/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-reimport-messages.job.ts
+++ b/packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-reimport-messages.job.ts
@@ -2,7 +2,9 @@ import { Scope } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { type ObjectRecordDeleteEvent } from 'twenty-shared/database-events';
-import { In, Not, Repository } from 'typeorm';
+import { MessageChannelSyncStage } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
+import { type FindOptionsWhere, In, Not, Repository } from 'typeorm';
import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
@@ -14,9 +16,9 @@ import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager
import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
+import { groupBlocklistHandlesByOwner } from 'src/modules/blocklist/utils/group-blocklist-handles-by-owner.util';
import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
import { type WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/standard-objects/workspace-member.workspace-entity';
-import { MessageChannelSyncStage } from 'twenty-shared/types';
export type BlocklistReimportMessagesJobData = WorkspaceEventBatch<
ObjectRecordDeleteEvent<BlocklistWorkspaceEntity>
@@ -46,60 +48,111 @@ export class BlocklistReimportMessagesJob {
await this.workspaceOrmManager.executeInWorkspaceContext(
async () => {
- const workspaceMemberRepository =
- this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
- 'workspaceMember',
- { shouldBypassPermissionChecks: true },
+ const { workspaceScopedHandles, handlesByWorkspaceMemberId } =
+ groupBlocklistHandlesByOwner(
+ data.events.map((eventPayload) => eventPayload.properties.before),
);
- for (const eventPayload of data.events) {
- const workspaceMemberId =
- eventPayload.properties.before.workspaceMemberId;
-
- const workspaceMember = await workspaceMemberRepository.findOne({
- where: { id: workspaceMemberId },
- });
-
- if (!workspaceMember) {
- continue;
- }
-
- const userWorkspace = await this.userWorkspaceRepository.findOne({
- where: { userId: workspaceMember.userId, workspaceId },
- });
+ const messageChannelIdsToReset = new Set<string>();
- if (!userWorkspace) {
- continue;
+ if (workspaceScopedHandles.length > 0) {
+ for (const messageChannelId of await this.findMessageChannelIdsToReset(
+ { workspaceId, connectedAccountIds: null },
+ )) {
+ messageChannelIdsToReset.add(messageChannelId);
}
+ }
- const connectedAccounts = await this.connectedAccountRepository.find({
- where: { userWorkspaceId: userWorkspace.id, workspaceId },
- });
-
- const connectedAccountIds = connectedAccounts.map((ca) => ca.id);
+ for (const workspaceMemberId of handlesByWorkspaceMemberId.keys()) {
+ const connectedAccountIds =
+ await this.findWorkspaceMemberConnectedAccountIds({
+ workspaceMemberId,
+ workspaceId,
+ });
if (connectedAccountIds.length === 0) {
continue;
}
- const messageChannels = await this.messageChannelRepository.find({
- where: {
- connectedAccountId: In(connectedAccountIds),
- syncStage: Not(
- MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
- ),
- workspaceId,
- },
- });
+ for (const messageChannelId of await this.findMessageChannelIdsToReset(
+ { workspaceId, connectedAccountIds },
+ )) {
+ messageChannelIdsToReset.add(messageChannelId);
+ }
+ }
- await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
- messageChannels.map((messageChannel) => messageChannel.id),
- workspaceId,
- );
+ if (messageChannelIdsToReset.size === 0) {
+ return;
}
+
+ await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
+ [...messageChannelIdsToReset],
+ workspaceId,
+ );
},
authContext,
{ lite: true },
);
}
+
+ private async findWorkspaceMemberConnectedAccountIds({
+ workspaceMemberId,
+ workspaceId,
+ }: {
+ workspaceMemberId: string;
+ workspaceId: string;
+ }): Promise<string[]> {
+ const workspaceMemberRepository =
+ this.workspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+ 'workspaceMember',
+ { shouldBypassPermissionChecks: true },
+ );
+
+ const workspaceMember = await workspaceMemberRepository.findOne({
+ where: { id: workspaceMemberId },
+ });
+
+ if (!isDefined(workspaceMember)) {
+ return [];
+ }
+
+ const userWorkspace = await this.userWorkspaceRepository.findOne({
+ where: { userId: workspaceMember.userId, workspaceId },
+ });
+
+ if (!isDefined(userWorkspace)) {
+ return [];
+ }
+
+ const connectedAccounts = await this.connectedAccountRepository.find({
+ select: ['id'],
+ where: { userWorkspaceId: userWorkspace.id, workspaceId },
+ });
+
+ return connectedAccounts.map((connectedAccount) => connectedAccount.id);
+ }
+
+ private async findMessageChannelIdsToReset({
+ workspaceId,
+ connectedAccountIds,
+ }: {
+ workspaceId: string;
+ connectedAccountIds: string[] | null;
+ }): Promise<string[]> {
+ const where: FindOptionsWhere<MessageChannelEntity> = {
+ syncStage: Not(MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING),
+ workspaceId,
+ };
+
+ if (isDefined(connectedAccountIds)) {
+ where.connectedAccountId = In(connectedAccountIds);
+ }
+
+ const messageChannels = await this.messageChannelRepository.find({
+ select: ['id'],
+ where,
+ });
+
+ return messageChannels.map((messageChannel) => messageChannel.id);
+ }
}
diff --git a/packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-messages-import.service.ts b/packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-messages-import.service.ts
index c0090e2f7a1..60f369b1bb4 100644
--- a/packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-messages-import.service.ts
+++ b/packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-messages-import.service.ts
@@ -163,12 +163,13 @@ export class MessagingMessagesImportService {
})
: null;
- const blocklist = workspaceMember
- ? await this.blocklistRepository.getByWorkspaceMemberId(
- workspaceMember.id,
+ const blocklist =
+ await this.blocklistRepository.getEntriesApplicableToWorkspaceMember(
+ {
+ workspaceMemberId: workspaceMember?.id ?? null,
workspaceId,
- )
- : [];
+ },
+ );
if (!isDefined(messageChannel.handle)) {
throw new MessageImportDriverException(
diff --git a/packages/twenty-server/test/integration/google/messaging/blocklist-cleanup.integration-spec.ts b/packages/twenty-server/test/integration/google/messaging/blocklist-cleanup.integration-spec.ts
index 32481be653d..c680c16af5a 100644
--- a/packages/twenty-server/test/integration/google/messaging/blocklist-cleanup.integration-spec.ts
+++ b/packages/twenty-server/test/integration/google/messaging/blocklist-cleanup.integration-spec.ts
@@ -1,10 +1,11 @@
import { randomUUID } from 'node:crypto';
-import { ConnectedAccountProvider } from 'twenty-shared/types';
+import { BlocklistScope, ConnectedAccountProvider } from 'twenty-shared/types';
import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
+import { destroyOneOperationFactory } from 'test/integration/graphql/utils/destroy-one-operation-factory.util';
import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
import { googleCalendarEvent } from 'test/integration/google/mocks/google-calendar-event.util';
import { getGmailMessageSubject } from 'test/integration/google/mocks/gmail-message-subject.util';
@@ -17,29 +18,39 @@ import {
} from 'test/integration/utils/find-imported-records.util';
import { runCalendarChannelEventsImport } from 'test/integration/utils/run-calendar-channel-events-import.util';
import { runCalendarChannelListFetch } from 'test/integration/utils/run-calendar-channel-list-fetch.util';
+import { resetMessageChannelSyncState } from 'test/integration/utils/reset-channel-sync-state.util';
import { runMessageChannelSync } from 'test/integration/utils/run-message-channel-sync.util';
import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
const HANDLE = '[email protected]';
const BLOCKED_HANDLE = `blocked-${randomUUID()}@acme.com`;
+const WORKSPACE_BLOCKED_HANDLE = `workspace-blocked-${randomUUID()}@acme.com`;
describe('Blocklist cleanup (integration)', () => {
const blockedMessage = gmailMessage({ from: BLOCKED_HANDLE, to: HANDLE });
+ const workspaceBlockedMessage = gmailMessage({
+ from: WORKSPACE_BLOCKED_HANDLE,
+ to: HANDLE,
+ });
const keptMessage = gmailMessage({
from: `kept-${randomUUID()}@acme.com`,
to: HANDLE,
});
const blockedSubject = getGmailMessageSubject(blockedMessage);
+ const workspaceBlockedSubject = getGmailMessageSubject(
+ workspaceBlockedMessage,
+ );
const keptSubject = getGmailMessageSubject(keptMessage);
const blockedEventTitle = `Blocked event ${randomUUID()}`;
const keptEventTitle = `Kept event ${randomUUID()}`;
- const gmail = setupGoogleMock({
- handle: HANDLE,
- inbox: [blockedMessage, keptMessage],
- });
+ const inbox = [blockedMessage, workspaceBlockedMessage, keptMessage];
+
+ const gmail = setupGoogleMock({ handle: HANDLE, inbox });
+
+ const blocklistIds: string[] = [];
let channel: Awaited<ReturnType<typeof connectMessagingAccount>>;
@@ -67,13 +78,27 @@ describe('Blocklist cleanup (integration)', () => {
}, 180000);
afterAll(async () => {
+ for (const blocklistId of blocklistIds) {
+ await makeGraphqlAPIRequest(
+ destroyOneOperationFactory({
+ objectMetadataSingularName: 'blocklist',
+ gqlFields: 'id',
+ recordId: blocklistId,
+ }),
+ ).catch(() => undefined);
+ }
+
await channel?.cleanup().catch(() => undefined);
});
- it('imports both the message and the calendar event before anything is blocked', async () => {
+ it('imports every message and the calendar event before anything is blocked', async () => {
expect(
- await findImportedMessageSubjects([blockedSubject, keptSubject]),
- ).toEqual([blockedSubject, keptSubject].sort());
+ await findImportedMessageSubjects([
+ blockedSubject,
+ workspaceBlockedSubject,
+ keptSubject,
+ ]),
+ ).toEqual([blockedSubject, workspaceBlockedSubject, keptSubject].sort());
expect(
await findImportedCalendarEventTitles([
@@ -83,10 +108,7 @@ describe('Blocklist cleanup (integration)', () => {
).toEqual([blockedEventTitle, keptEventTitle].sort());
}, 60000);
- // Blocking a handle deletes their messages but deliberately leaves calendar
- // events alone: an event the blocked handle merely attended is still the
- // workspace's own meeting, so it is not swept up with them.
- it('deletes the blocked handle messages and keeps every calendar event', async () => {
+ it('deletes the blocked handle messages and keeps the calendar events imported before the block', async () => {
const response = await makeGraphqlAPIRequest(
createOneOperationFactory({
objectMetadataSingularName: 'blocklist',
@@ -100,6 +122,8 @@ describe('Blocklist cleanup (integration)', () => {
expect(response.body.errors).toBeUndefined();
+ blocklistIds.push(response.body.data.createBlocklist.id);
+
await waitForAllJobsToFinish();
expect(
@@ -113,4 +137,85 @@ describe('Blocklist cleanup (integration)', () => {
]),
).toEqual([blockedEventTitle, keptEventTitle].sort());
}, 120000);
+
+ it('deletes the messages of a handle blocked for the whole workspace', async () => {
+ const response = await makeGraphqlAPIRequest(
+ createOneOperationFactory({
+ objectMetadataSingularName: 'blocklist',
+ gqlFields: 'id handle scope workspaceMemberId',
+ data: {
+ handle: WORKSPACE_BLOCKED_HANDLE,
+ scope: BlocklistScope.WORKSPACE,
+ },
+ }),
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.createBlocklist.workspaceMemberId).toBeNull();
+
+ blocklistIds.push(response.body.data.createBlocklist.id);
+
+ await waitForAllJobsToFinish();
+
+ expect(
+ await findImportedMessageSubjects([workspaceBlockedSubject, keptSubject]),
+ ).toEqual([keptSubject]);
+ }, 120000);
+
+ it('never imports new messages or calendar events involving a workspace-blocked handle', async () => {
+ const resyncBlockedMessage = gmailMessage({
+ from: WORKSPACE_BLOCKED_HANDLE,
+ to: HANDLE,
+ });
+ const resyncKeptMessage = gmailMessage({
+ from: `resync-kept-${randomUUID()}@acme.com`,
+ to: HANDLE,
+ });
+ const resyncBlockedSubject = getGmailMessageSubject(resyncBlockedMessage);
+ const resyncKeptSubject = getGmailMessageSubject(resyncKeptMessage);
+
+ inbox.push(resyncBlockedMessage, resyncKeptMessage);
+ gmail.serveMessageList([resyncBlockedMessage, resyncKeptMessage]);
+
+ await resetMessageChannelSyncState(channel.channelId, '');
+ await runMessageChannelSync(channel.channelId);
+ await waitForAllJobsToFinish();
+
+ expect(
+ await findImportedMessageSubjects([
+ resyncBlockedSubject,
+ resyncKeptSubject,
+ ]),
+ ).toEqual([resyncKeptSubject]);
+
+ const blockedAttendeeEventTitle = `Workspace blocked event ${randomUUID()}`;
+ const importedEventTitle = `Workspace kept event ${randomUUID()}`;
+
+ gmail.serveCalendarEvents(
+ [
+ googleCalendarEvent({
+ summary: blockedAttendeeEventTitle,
+ attendees: [{ email: WORKSPACE_BLOCKED_HANDLE }],
+ }),
+ googleCalendarEvent({
+ summary: importedEventTitle,
+ attendees: [
+ { email: `workspace-kept-attendee-${randomUUID()}@acme.com` },
+ ],
+ }),
+ ],
+ { nextSyncToken: 'mock-calendar-sync-token-workspace-blocklist' },
+ );
+
+ await runCalendarChannelListFetch(channel.calendarChannelId);
+ await runCalendarChannelEventsImport(channel.calendarChannelId);
+ await waitForAllJobsToFinish();
+
+ expect(
+ await findImportedCalendarEventTitles([
+ blockedAttendeeEventTitle,
+ importedEventTitle,
+ ]),
+ ).toEqual([importedEventTitle]);
+ }, 180000);
});
diff --git a/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap b/packages/twenty-server/test/integration/graphql/suites/hooks/__snapshots__/blocklist-scope-hooks.integration-spec.ts.snap
new file mode 100644
index 00000000000..5bc6def1d22
--- /dev/null
+++ b/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",
+}
+`;
diff --git a/packages/twenty-server/test/integration/graphql/suites/hooks/blocklist-scope-hooks.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/hooks/blocklist-scope-hooks.integration-spec.ts
new file mode 100644
index 00000000000..a6035273fbb
--- /dev/null
+++ b/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 });
+ });
+});
diff --git a/packages/twenty-server/test/integration/graphql/suites/object-generated/blocklists.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-generated/blocklists.integration-spec.ts
index 50bd5bd7a22..429f63f862d 100644
--- a/packages/twenty-server/test/integration/graphql/suites/object-generated/blocklists.integration-spec.ts
+++ b/packages/twenty-server/test/integration/graphql/suites/object-generated/blocklists.integration-spec.ts
@@ -15,6 +15,7 @@ describe('blocklistsResolver (e2e)', () => {
createdAt
updatedAt
deletedAt
+ scope
workspaceMemberId
}
}
@@ -48,6 +49,7 @@ describe('blocklistsResolver (e2e)', () => {
expect(blocklists).toHaveProperty('createdAt');
expect(blocklists).toHaveProperty('updatedAt');
expect(blocklists).toHaveProperty('deletedAt');
+ expect(blocklists).toHaveProperty('scope');
expect(blocklists).toHaveProperty('workspaceMemberId');
}
});
diff --git a/packages/twenty-utils/crowdin-normalizer/rules/__tests__/escaped-unicode.rule.spec.ts b/packages/twenty-utils/crowdin-normalizer/rules/__tests__/escaped-unicode.rule.spec.ts
index eb896febb97..0c04700b75c 100644
--- a/packages/twenty-utils/crowdin-normalizer/rules/__tests__/escaped-unicode.rule.spec.ts
+++ b/packages/twenty-utils/crowdin-normalizer/rules/__tests__/escaped-unicode.rule.spec.ts
@@ -16,7 +16,8 @@ describe('ESCAPED_UNICODE_RULE', () => {
it('keeps an escape the source writes itself, such as a code sample', () => {
const sourceText = 'Escape the accent as \\u00e9 in the config';
- const translationText = "Echappez l'accent en \\u00e9 dans la configuration";
+ const translationText =
+ "Echappez l'accent en \\u00e9 dans la configuration";
expect(detect(translationText, sourceText)).toBe(false);
expect(fix(translationText, sourceText)).toBe(translationText);
diff --git a/packages/twenty-utils/crowdin-normalizer/rules/__tests__/invented-argument.rule.spec.ts b/packages/twenty-utils/crowdin-normalizer/rules/__tests__/invented-argument.rule.spec.ts
index 7dde649830d..20d43a7e4ab 100644
--- a/packages/twenty-utils/crowdin-normalizer/rules/__tests__/invented-argument.rule.spec.ts
+++ b/packages/twenty-utils/crowdin-normalizer/rules/__tests__/invented-argument.rule.spec.ts
@@ -26,8 +26,7 @@ describe('INVENTED_ARGUMENT_RULE', () => {
it('deletes a translation that adds an argument nothing will supply', () => {
const sourceText = 'We keep your data for {dataRetentionDays} days.';
- const translationText =
- 'Чувамо податке {dataRetentionDays} {dayOrDays}.';
+ const translationText = 'Чувамо податке {dataRetentionDays} {dayOrDays}.';
expect(fix(translationText, sourceText)).toBe('');
});
@@ -58,7 +57,10 @@ describe('INVENTED_ARGUMENT_RULE', () => {
it('is idempotent', () => {
const sourceText = 'Found for {conflictingFieldsValues}.';
- const once = fix('{ConflictingFieldsValues} で見つかりました。', sourceText);
+ const once = fix(
+ '{ConflictingFieldsValues} で見つかりました。',
+ sourceText,
+ );
expect(detect(once, sourceText)).toBe(false);
expect(fix(once, sourceText)).toBe(once);
diff --git a/packages/twenty-utils/crowdin-normalizer/rules/escaped-unicode.rule.ts b/packages/twenty-utils/crowdin-normalizer/rules/escaped-unicode.rule.ts
index 10021116de3..eef6dd5d344 100644
--- a/packages/twenty-utils/crowdin-normalizer/rules/escaped-unicode.rule.ts
+++ b/packages/twenty-utils/crowdin-normalizer/rules/escaped-unicode.rule.ts
@@ -20,7 +20,9 @@ function unescapeUnicode(text: string, sourceText?: string): string {
if (sourceText === undefined) return text;
return text.replace(ESCAPED_UNICODE_REGEX, (escape, hex) =>
- sourceText.includes(escape) ? escape : String.fromCharCode(parseInt(hex, 16)),
+ sourceText.includes(escape)
+ ? escape
+ : String.fromCharCode(parseInt(hex, 16)),
);
}
diff --git a/packages/twenty-utils/crowdin-normalizer/rules/invented-argument.rule.ts b/packages/twenty-utils/crowdin-normalizer/rules/invented-argument.rule.ts
index 54e421db582..5e1059557a5 100644
--- a/packages/twenty-utils/crowdin-normalizer/rules/invented-argument.rule.ts
+++ b/packages/twenty-utils/crowdin-normalizer/rules/invented-argument.rule.ts
@@ -38,15 +38,13 @@ function inventedArgumentNames(text: string, sourceText: string): string[] {
}
function renameArgument(text: string, from: string, to: string): string {
- return text.replace(
- new RegExp(`\\{\\s*${from}\\s*(?=[,}])`, 'g'),
- `{${to}`,
- );
+ return text.replace(new RegExp(`\\{\\s*${from}\\s*(?=[,}])`, 'g'), `{${to}`);
}
function hasInventedArgument(text: string, sourceText?: string): boolean {
return (
- sourceText !== undefined && inventedArgumentNames(text, sourceText).length > 0
+ sourceText !== undefined &&
+ inventedArgumentNames(text, sourceText).length > 0
);
}
diff --git a/packages/twenty-utils/crowdin-normalizer/utils/__tests__/is-translation-already-present-error.util.spec.ts b/packages/twenty-utils/crowdin-normalizer/utils/__tests__/is-translation-already-present-error.util.spec.ts
index 7e697143882..80e36190574 100644
--- a/packages/twenty-utils/crowdin-normalizer/utils/__tests__/is-translation-already-present-error.util.spec.ts
+++ b/packages/twenty-utils/crowdin-normalizer/utils/__tests__/is-translation-already-present-error.util.spec.ts
@@ -27,7 +27,8 @@ describe('isTranslationAlreadyPresentError', () => {
isTranslationAlreadyPresentError(
buildDetailError({
code: 'validationError',
- message: 'Duplicate translation. Please vote or approve the original.',
+ message:
+ 'Duplicate translation. Please vote or approve the original.',
}),
),
).toBe(true);
@@ -59,6 +60,8 @@ describe('isTranslationAlreadyPresentError', () => {
expect(
isTranslationAlreadyPresentError(buildError('<html>502</html>')),
).toBe(false);
- expect(isTranslationAlreadyPresentError(new Error('identical'))).toBe(false);
+ expect(isTranslationAlreadyPresentError(new Error('identical'))).toBe(
+ false,
+ );
});
});