The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(slack): match the Slack roster by email and list unlinked users (#25151)
Abdul Rahmanc19c1fec8700
diff --git a/packages/twenty-apps/public/slack/README.md b/packages/twenty-apps/public/slack/README.mdindex 52a0d8e9355..39c63819f67 100644--- a/packages/twenty-apps/public/slack/README.md+++ b/packages/twenty-apps/public/slack/README.md@@ -14,12 +14,14 @@ Mention the bot in a channel or DM it. It replies in the thread with your CRM daOut of the box the bot runs with the **Slack Assistant** role, which can read, create, update and soft-delete people, companies, opportunities, notes and tasks. Workspace members stay read-only and hard delete is off. Tighten the role in **Settings → Roles** if you want a narrower bot.-**It acts as whoever tagged it.** The first time someone mentions the bot, their Slack profile email is matched against workspace members and the pair is stored as a **Slack User Link** record. The person who connects the Slack workspace is matched the same way right at connection time, so the installer is linked before anyone messages the bot. From then on the bot runs with that member's own permissions, so it can never do more than the person asking. Someone with no link gets the **Slack Assistant** role instead, exactly as before.+**It acts as whoever tagged it.** The first time someone mentions the bot, their Slack profile email is matched against workspace members and the pair is stored as a **Slack User Link** record. The person who connects the Slack workspace is matched the same way right at connection time, and the rest of the Slack roster is swept for matching emails in the same pass, so most people are linked before anyone messages the bot. From then on the bot runs with that member's own permissions, so it can never do more than the person asking. Someone with no link gets the **Slack Assistant** role instead, exactly as before.A link matched on email is re-verified on every request: the bot rechecks that the Slack account's current verified email still points at the same member, and follows the live match rather than the stored record if they disagree. The record is an audit trail, not the source of truth.Only members of the Slack workspace that installed the app are matched automatically. Guests and Slack Connect users from another Slack workspace are not, because their email is vouched for by someone other than your admin. For those cases a member with the roles permission can link them by hand from the **Slack user links** section of the app's **Settings** tab, or by asking the assistant to link a Slack user to a workspace member; either way the pair is stored with its source set to manual. The Settings section searches members by name so there is no need to paste a member ID, searches the Slack workspace by name or email the same way to pick the Slack account, and spells out next to the save button whether saving activates the link immediately or sends an approval request, so you never link or message the wrong account. It lists the existing links with their status, lets a member with the permission remove a link or resend a pending consent request, and shows a read-only view to anyone without the permission. A guest or Slack Connect user whose email is not in your workspace is linked by their Slack user ID instead; for a Slack Connect user, include their own Slack workspace's team ID so the link matches the messages they send.+The same section lists Slack users who have no link yet, so an admin can see who the automatic match skipped and finish the job in place: each row has its own member picker, spells out whether linking activates immediately or asks the person first, and saves without leaving the list. An **Auto-link by email** button reruns the roster sweep on demand, which covers workspaces that connected the app before the sweep existed and new hires who joined Slack after connection. The sweep only trusts a confirmed email on a full member of the installed workspace and never touches an existing link, so a declined or hand-made link is left alone.+**A matching email needs no approval.** Linking a Slack account to the workspace member with the same email is just the automatic match set up ahead of the person's first message, so it is stored as an email-matched link and is active immediately, with the same live re-verification automatic links get.**Any other manual link asks the person first.** When you link someone who is in the installed Slack workspace to a member with a different email, the app sends them a direct message explaining that an admin wants the assistant to act with a workspace member's access, with **Approve** and **Decline** buttons. The link stays inactive (shown as _Awaiting consent_) until they approve, so the assistant never borrows someone's permissions without their say-so; a decline keeps it off. Guests and Slack Connect users from another workspace cannot be messaged this way, so their link is admin-set and active on save, labelled as such. A consented or admin-set manual link wins over email matching. Slack User Link records can only be written by the app itself, never directly through the API or the UI, so a manual link always reflects both an admin's decision and, where possible, the person's consent. Sending the consent request needs the `im:write` scope, so reconnect the Slack app after upgrading to grant it.diff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.jsonindex bac98c8f5ba..39566578e93 100644--- a/packages/twenty-apps/public/slack/package.json+++ b/packages/twenty-apps/public/slack/package.json@@ -1,6 +1,6 @@{"name": "@twentyhq/slack",- "version": "0.5.0",+ "version": "0.6.0","description": "Slack assistant and workflow steps for Twenty","license": "MIT","engines": {diff --git a/packages/twenty-apps/public/slack/src/application.config.ts b/packages/twenty-apps/public/slack/src/application.config.tsindex 5e253396009..4b4e618b93c 100644--- a/packages/twenty-apps/public/slack/src/application.config.ts+++ b/packages/twenty-apps/public/slack/src/application.config.ts@@ -14,6 +14,7 @@ export default defineApplication({termsUrl: 'https://www.twenty.com/terms',emailSupport: '[email protected]',issueReportUrl: 'https://github.com/twentyhq/twenty/issues',+ galleryImages: [],serverVariables: {SLACK_CLIENT_ID: {description:diff --git a/packages/twenty-apps/public/slack/src/constants/slack-user-links-route-path.constant.ts b/packages/twenty-apps/public/slack/src/constants/slack-user-links-route-path.constant.tsindex f46eb04e5ea..503c527f473 100644--- a/packages/twenty-apps/public/slack/src/constants/slack-user-links-route-path.constant.ts+++ b/packages/twenty-apps/public/slack/src/constants/slack-user-links-route-path.constant.ts@@ -8,3 +8,11 @@ export const SLACK_USER_LINKS_REMOVE_ROUTE_PATH = '/slack-user-links/remove';export const SLACK_USER_LINKS_RESEND_CONSENT_ROUTE_PATH ='/slack-user-links/resend-consent';++export const SLACK_USER_LINKS_MATCH_ROUTE_PATH = '/slack-user-links/match';++export const SLACK_USER_LINKS_UNLINKED_ROUTE_PATH =+ '/slack-user-links/unlinked';++export const SLACK_USER_LINKS_CONNECTION_STATUS_ROUTE_PATH =+ '/slack-user-links/connection-status';diff --git a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.tsindex 9b6166b0ee7..3844a083c61 100644--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts@@ -73,6 +73,12 @@ export const SLACK_REMOVE_USER_LINK_UNIVERSAL_IDENTIFIER =export const SLACK_RESEND_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER ='52f08a8e-d97e-4fb6-8707-328423b06a3d';+export const SLACK_MATCH_USER_LINKS_UNIVERSAL_IDENTIFIER =+ 'eb2d7285-87fd-46d2-88b6-813ba3318d9a';++export const SLACK_LIST_UNLINKED_USERS_UNIVERSAL_IDENTIFIER =+ '7cd303b1-da18-4f68-895a-b01bca2f0381';+export const SLACK_TEAM_RELEASE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER ='4470aba8-5ff5-4800-88db-2a427cd8677c';@@ -171,3 +177,6 @@ export const SLACK_ASSISTANT_REQUESTS_ON_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIexport const SLACK_USER_LINKS_SETTINGS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER ='20beb6d2-804f-40a5-ad7d-8d523e401651';++export const SLACK_CONNECTION_STATUS_UNIVERSAL_IDENTIFIER =+ 'ca8af663-5229-486a-b81b-1ac9bf8e1e8f';diff --git a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsxnew file mode 100644index 00000000000..bac7178fd7b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPicker.tsx@@ -0,0 +1,125 @@+import styled from '@emotion/styled';+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { Avatar } from 'twenty-ui/data-display';+import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { InlineWorkspaceMemberPickerPanel } from 'src/front-components/components/InlineWorkspaceMemberPickerPanel';+import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';++const StyledContainer = styled.div`+ flex: 1;+ min-width: 0;+ position: relative;+`;++const StyledSelectTrigger = styled.button`+ align-items: center;+ background-color: ${() => themeCssVariables.background.transparent.lighter};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.md};+ box-sizing: border-box;+ cursor: pointer;+ display: grid;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ gap: ${() => themeCssVariables.spacing[1]};+ grid-template-columns: 1fr auto;+ height: ${() => themeCssVariables.spacing[6]};+ padding: 0 ${() => themeCssVariables.spacing[2]};+ text-align: left;+ width: 100%;++ &:hover:enabled {+ background-color: ${() => themeCssVariables.background.transparent.light};+ }++ &:disabled {+ cursor: not-allowed;+ }+`;++const StyledSelectedValue = styled.div`+ align-items: center;+ display: flex;+ gap: ${() => themeCssVariables.spacing[1]};+ min-width: 0;+`;++const StyledValueName = styled.div`+ color: ${() => themeCssVariables.font.color.primary};+ min-width: 0;+`;++const StyledPlaceholder = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+`;++const StyledChevron = styled.div`+ border-bottom: 1px solid ${() => themeCssVariables.font.color.tertiary};+ border-right: 1px solid ${() => themeCssVariables.font.color.tertiary};+ height: 5px;+ margin-top: -3px;+ transform: rotate(45deg);+ width: 5px;+`;++type InlineWorkspaceMemberPickerProps = {+ selectedMember: WorkspaceMemberOption | null;+ onSelect: (member: WorkspaceMemberOption) => void;+ disabled?: boolean;+};++export const InlineWorkspaceMemberPicker = ({+ selectedMember,+ onSelect,+ disabled,+}: InlineWorkspaceMemberPickerProps) => {+ const [isOpen, setIsOpen] = useState(false);++ return (+ <StyledContainer>+ <StyledSelectTrigger+ type="button"+ disabled={disabled}+ onClick={() => setIsOpen(true)}+ aria-label="Select the workspace member"+ aria-haspopup="listbox"+ aria-expanded={isOpen}+ >+ {isDefined(selectedMember) ? (+ <StyledSelectedValue>+ <Avatar+ placeholder={getMemberDisplayName(selectedMember)}+ placeholderColorSeed={selectedMember.id}+ type="rounded"+ size="sm"+ />+ <StyledValueName>+ <OverflowingTextWithTooltip+ text={getMemberDisplayName(selectedMember)}+ />+ </StyledValueName>+ </StyledSelectedValue>+ ) : (+ <StyledPlaceholder>Select member</StyledPlaceholder>+ )}+ <StyledChevron />+ </StyledSelectTrigger>+ {isOpen && (+ <InlineWorkspaceMemberPickerPanel+ onSelect={(member) => {+ setIsOpen(false);+ onSelect(member);+ }}+ onClose={() => setIsOpen(false)}+ />+ )}+ </StyledContainer>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsx b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsxnew file mode 100644index 00000000000..12ebba98294--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/InlineWorkspaceMemberPickerPanel.tsx@@ -0,0 +1,141 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { MenuItem, MenuItemAvatar } from 'twenty-ui/navigation';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { useWorkspaceMemberSearch } from 'src/front-components/hooks/use-workspace-member-search';+import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';++const StyledBackdrop = styled.div`+ inset: 0;+ position: fixed;+ z-index: 1;+`;++const StyledDropdownPanel = styled.div`+ background: ${() => themeCssVariables.background.primary};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.md};+ box-shadow: ${() => themeCssVariables.boxShadow.light};+ box-sizing: border-box;+ left: 0;+ margin-top: ${() => themeCssVariables.spacing[1]};+ min-width: 240px;+ position: absolute;+ top: 100%;+ width: 100%;+ z-index: 2;+`;++const StyledSearchInput = styled.input`+ background: transparent;+ border: none;+ border-bottom: 1px solid ${() => themeCssVariables.border.color.light};+ box-sizing: border-box;+ color: ${() => themeCssVariables.font.color.primary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ height: ${() => themeCssVariables.spacing[8]};+ outline: none;+ padding: 0 ${() => themeCssVariables.spacing[2]};+ width: 100%;++ &::placeholder {+ color: ${() => themeCssVariables.font.color.light};+ }+`;++const StyledOptions = styled.div`+ max-height: 240px;+ overflow-y: auto;+ padding: ${() => themeCssVariables.spacing[1]};+`;++const getEmptyStateText = ({+ isSearching,+ searchErrorMessage,+}: {+ isSearching: boolean;+ searchErrorMessage: string | undefined;+}): string => {+ if (isSearching) {+ return 'Searching…';+ }++ if (isNonEmptyString(searchErrorMessage)) {+ return searchErrorMessage;+ }++ return 'No results';+};++type InlineWorkspaceMemberPickerPanelProps = {+ onSelect: (member: WorkspaceMemberOption) => void;+ onClose: () => void;+};++export const InlineWorkspaceMemberPickerPanel = ({+ onSelect,+ onClose,+}: InlineWorkspaceMemberPickerPanelProps) => {+ const [searchTerm, setSearchTerm] = useState('');+ const { options, isSearching, searchErrorMessage } = useWorkspaceMemberSearch(+ { searchTerm, shouldListWithoutSearchTerm: true },+ );++ return (+ <>+ <StyledBackdrop onClick={onClose} />+ <StyledDropdownPanel>+ <StyledSearchInput+ value={searchTerm}+ onChange={(event) => setSearchTerm(event.target.value)}+ onKeyDown={(event) => {+ if (event.key === 'Escape') {+ event.preventDefault();+ onClose();++ return;+ }++ if (event.key === 'Enter') {+ event.preventDefault();++ if (options.length > 0) {+ onSelect(options[0]);+ }+ }+ }}+ placeholder="Search members"+ aria-label="Search workspace members"+ autoFocus+ />+ <StyledOptions role="listbox" aria-label="Workspace members">+ {options.map((member) => (+ <div key={member.id} role="option" aria-selected={false}>+ <MenuItemAvatar+ avatar={{+ type: 'rounded',+ size: 'md',+ placeholder: getMemberDisplayName(member),+ placeholderColorSeed: member.id,+ }}+ text={getMemberDisplayName(member)}+ contextualText={member.userEmail ?? undefined}+ onClick={() => onSelect(member)}+ />+ </div>+ ))}+ {options.length === 0 && (+ <MenuItem+ disabled+ text={getEmptyStateText({ isSearching, searchErrorMessage })}+ />+ )}+ </StyledOptions>+ </StyledDropdownPanel>+ </>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackSettingsTable.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackSettingsTable.tsxnew file mode 100644index 00000000000..37e5c8179a5--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackSettingsTable.tsx@@ -0,0 +1,51 @@+import styled from '@emotion/styled';+import { themeCssVariables } from 'twenty-ui/theme-constants';++export const SlackTable = styled.div`+ display: flex;+ flex-direction: column;+ width: 100%;+`;++export const SlackTableRow = styled.div<{ gridTemplateColumns: string }>`+ align-items: center;+ border-radius: ${() => themeCssVariables.border.radius.md};+ display: grid;+ grid-template-columns: ${({ gridTemplateColumns }) => gridTemplateColumns};+ width: 100%;+`;++export const SlackTableHeader = styled.div<{ align?: 'left' | 'right' }>`+ align-items: center;+ border-bottom: 1px solid ${() => themeCssVariables.border.color.light};+ color: ${() => themeCssVariables.font.color.tertiary};+ display: flex;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ font-weight: ${() => themeCssVariables.font.weight.medium};+ height: ${() => themeCssVariables.spacing[8]};+ justify-content: ${({ align }) =>+ align === 'right' ? 'flex-end' : 'flex-start'};+ padding: 0 ${() => themeCssVariables.spacing[2]};+`;++export const SlackTableCell = styled.div<{ align?: 'left' | 'right' }>`+ align-items: center;+ color: ${() => themeCssVariables.font.color.secondary};+ display: flex;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ gap: ${() => themeCssVariables.spacing[2]};+ justify-content: ${({ align }) =>+ align === 'right' ? 'flex-end' : 'flex-start'};+ min-height: ${() => themeCssVariables.spacing[8]};+ min-width: 0;+ padding: 0 ${() => themeCssVariables.spacing[2]};+`;++export const SlackTableBody = styled.div`+ display: flex;+ flex-direction: column;+ gap: 2px;+ padding: ${() => themeCssVariables.spacing[2]} 0;+`;diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsxindex 9a9d68ae40a..56ff63860ea 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx@@ -33,15 +33,8 @@ const StyledResolveError = styled.span`font-size: ${() => themeCssVariables.font.size.xs};`;-const StyledDisclosureButton = styled.button`+const StyledDisclosure = styled.div`align-self: flex-start;- background: transparent;- border: none;- color: ${() => themeCssVariables.color.blue};- cursor: pointer;- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.sm};- padding: 0;`;const StyledActions = styled.div`@@ -200,12 +193,15 @@ export const SlackUserLinkForm = ({disabled={isSubmitting}/>) : (- <StyledDisclosureButton- type="button"- onClick={() => setIsConnectUser(true)}- >- Guest or Slack Connect user? Link by Slack ID instead- </StyledDisclosureButton>+ <StyledDisclosure>+ <Button+ type="button"+ title="Guest or Slack Connect user? Link by Slack ID instead"+ size="small"+ variant="tertiary"+ onClick={() => setIsConnectUser(true)}+ />+ </StyledDisclosure>)}{isResolving ? (<SlackUserLinkFormHint>diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsxindex 5d8b887e887..5517f2215cb 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx@@ -1,84 +1,54 @@import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';-import { useState } from 'react';+import { useEffect, useState } from 'react';import { isDefined } from 'twenty-sdk/utils';-import { Tag } from 'twenty-ui/data-display';+import { Avatar, Tag } from 'twenty-ui/data-display';+import { Button } from 'twenty-ui/input';+import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';import { themeCssVariables } from 'twenty-ui/theme-constants';+import {+ SlackTable,+ SlackTableBody,+ SlackTableCell,+ SlackTableHeader,+ SlackTableRow,+} from 'src/front-components/components/SlackSettingsTable';import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';import { SLACK_USER_LINK_SOURCE } from 'src/logic-functions/constants/slack-user-link-source';import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';import { isSlackUserLinkConsentState } from 'src/logic-functions/utils/is-slack-user-link-consent-state';import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';-const StyledList = styled.div`- display: flex;- flex-direction: column;- gap: ${() => themeCssVariables.spacing[2]};-`;+const LINKS_GRID_TEMPLATE_COLUMNS = 'minmax(0, 2fr) minmax(0, 2fr) 252px 156px';+const REMOVAL_CONFIRM_TIMEOUT_MS = 4000;-const StyledRow = styled.div`+const StyledIdentity = styled.div`align-items: center;- border: 1px solid ${() => themeCssVariables.border.color.light};- border-radius: ${() => themeCssVariables.border.radius.sm};- box-sizing: border-box;display: flex;- gap: ${() => themeCssVariables.spacing[4]};- justify-content: space-between;- padding: ${() => themeCssVariables.spacing[3]};-`;--const StyledDetails = styled.div`- display: flex;- flex-direction: column;- gap: ${() => themeCssVariables.spacing[1]};+ gap: ${() => themeCssVariables.spacing[2]};min-width: 0;`;-const StyledName = styled.span`+const StyledName = styled.div`color: ${() => themeCssVariables.font.color.primary};- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.sm};- font-weight: ${() => themeCssVariables.font.weight.medium};-`;--const StyledMeta = styled.span`- color: ${() => themeCssVariables.font.color.tertiary};- font-family: ${() => themeCssVariables.font.family};- font-size: ${() => themeCssVariables.font.size.xs};+ min-width: 0;`;-const StyledRight = styled.div`- align-items: flex-end;+const StyledDetails = styled.div`display: flex;flex-direction: column;- gap: ${() => themeCssVariables.spacing[2]};-`;--const StyledBadges = styled.div`- align-items: center;- display: flex;- gap: ${() => themeCssVariables.spacing[1]};-`;--const StyledActions = styled.div`- display: flex;- gap: ${() => themeCssVariables.spacing[2]};+ min-width: 0;+ padding: ${() => themeCssVariables.spacing[1]} 0;`;-const StyledActionButton = styled.button`- background: transparent;- border: none;- color: ${() => themeCssVariables.color.blue};- cursor: pointer;- font-family: ${() => themeCssVariables.font.family};+const StyledMeta = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};font-size: ${() => themeCssVariables.font.size.xs};- padding: 0;-- &:disabled {- color: ${() => themeCssVariables.font.color.tertiary};- cursor: default;- }+ min-width: 0;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;`;const StyledEmptyState = styled.div`@@ -147,6 +117,19 @@ export const SlackUserLinksList = ({null,);+ useEffect(() => {+ if (removalArmedLinkId === null) {+ return undefined;+ }++ const disarmTimer = setTimeout(+ () => setRemovalArmedLinkId(null),+ REMOVAL_CONFIRM_TIMEOUT_MS,+ );++ return () => clearTimeout(disarmTimer);+ }, [removalArmedLinkId]);+const isActionInFlight =isDefined(removingLinkId) || isDefined(resendingLinkId);@@ -155,38 +138,55 @@ export const SlackUserLinksList = ({}return (- <StyledList>- {hasMore && (- <StyledEmptyState>- Showing {slackUserLinks.length} links; more exist than can be shown- here.- </StyledEmptyState>- )}- {slackUserLinks.map((slackUserLink) => {- const consentState = toDisplayedConsentState(- slackUserLink.consentState,- );- const isPending =- consentState === SLACK_USER_LINK_CONSENT_STATE.PENDING;-- return (- <StyledRow key={slackUserLink.id}>- <StyledDetails>- <StyledName>- {slackUserLink.name ??- slackUserLink.slackUserId ??- 'Unnamed link'}- </StyledName>- <StyledMeta>- {slackUserLink.workspaceMemberName ?? 'No workspace member'}- </StyledMeta>- <StyledMeta>- Slack user {slackUserLink.slackUserId ?? 'unknown'} · Team{' '}- {slackUserLink.slackTeamId ?? 'unknown'}- </StyledMeta>- </StyledDetails>- <StyledRight>- <StyledBadges>+ <SlackTable>+ <SlackTableRow gridTemplateColumns={LINKS_GRID_TEMPLATE_COLUMNS}>+ <SlackTableHeader>Slack account</SlackTableHeader>+ <SlackTableHeader>Workspace member</SlackTableHeader>+ <SlackTableHeader>Status</SlackTableHeader>+ <SlackTableHeader align="right" />+ </SlackTableRow>+ <SlackTableBody>+ {slackUserLinks.map((slackUserLink) => {+ const consentState = toDisplayedConsentState(+ slackUserLink.consentState,+ );+ const isPending =+ consentState === SLACK_USER_LINK_CONSENT_STATE.PENDING;+ const displayedName =+ slackUserLink.name ?? slackUserLink.slackUserId ?? 'Unnamed link';++ return (+ <SlackTableRow+ key={slackUserLink.id}+ gridTemplateColumns={LINKS_GRID_TEMPLATE_COLUMNS}+ >+ <SlackTableCell>+ <StyledIdentity>+ <Avatar+ placeholder={displayedName}+ placeholderColorSeed={slackUserLink.id}+ type="rounded"+ size="md"+ />+ <StyledDetails>+ <StyledName>+ <OverflowingTextWithTooltip text={displayedName} />+ </StyledName>+ <StyledMeta>+ {slackUserLink.slackUserId ?? 'unknown'} ·{' '}+ {slackUserLink.slackTeamId ?? 'unknown'}+ </StyledMeta>+ </StyledDetails>+ </StyledIdentity>+ </SlackTableCell>+ <SlackTableCell>+ <OverflowingTextWithTooltip+ text={+ slackUserLink.workspaceMemberName ?? 'No workspace member'+ }+ />+ </SlackTableCell>+ <SlackTableCell>{isDefined(consentState) && (<Tagcolor={CONSENT_COLORS[consentState]}@@ -197,46 +197,64 @@ export const SlackUserLinksList = ({color={getSourceColor(slackUserLink.source)}text={getSourceLabel(slackUserLink.source)}/>- </StyledBadges>- {canManage && (- <StyledActions>- {isPending && (- <StyledActionButton- type="button"- onClick={() => onResend(slackUserLink)}- disabled={isActionInFlight}- >- {resendingLinkId === slackUserLink.id- ? 'Resending…'- : 'Resend request'}- </StyledActionButton>- )}- <StyledActionButton- type="button"- onClick={() => {- if (removalArmedLinkId !== slackUserLink.id) {- setRemovalArmedLinkId(slackUserLink.id);- return;- }-- setRemovalArmedLinkId(null);- onRemove(slackUserLink);- }}- onBlur={() => setRemovalArmedLinkId(null)}- disabled={isActionInFlight}- >- {removingLinkId === slackUserLink.id- ? 'Removing…'- : removalArmedLinkId === slackUserLink.id- ? 'Confirm removal'- : 'Remove'}- </StyledActionButton>- </StyledActions>- )}- </StyledRight>- </StyledRow>- );- })}- </StyledList>+ </SlackTableCell>+ <SlackTableCell align="right">+ {canManage && (+ <>+ {isPending && removalArmedLinkId !== slackUserLink.id && (+ <Button+ type="button"+ title={+ resendingLinkId === slackUserLink.id+ ? 'Resending…'+ : 'Resend'+ }+ size="small"+ variant="secondary"+ disabled={isActionInFlight}+ onClick={() => onResend(slackUserLink)}+ />+ )}+ {removalArmedLinkId === slackUserLink.id ? (+ <Button+ type="button"+ title={+ removingLinkId === slackUserLink.id+ ? 'Removing…'+ : 'Confirm removal'+ }+ size="small"+ variant="secondary"+ accent="danger"+ disabled={isActionInFlight}+ onClick={() => {+ setRemovalArmedLinkId(null);+ onRemove(slackUserLink);+ }}+ />+ ) : (+ <Button+ type="button"+ title="Remove"+ size="small"+ variant="secondary"+ disabled={isActionInFlight}+ onClick={() => setRemovalArmedLinkId(slackUserLink.id)}+ />+ )}+ </>+ )}+ </SlackTableCell>+ </SlackTableRow>+ );+ })}+ {hasMore && (+ <StyledEmptyState>+ Showing {slackUserLinks.length} links; more exist than can be shown+ here.+ </StyledEmptyState>+ )}+ </SlackTableBody>+ </SlackTable>);};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsxindex 26d37cd7b01..f80932b3a7f 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx@@ -2,19 +2,25 @@ import 'twenty-ui/style.css';import styled from '@emotion/styled';import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';import { enqueueSnackbar } from 'twenty-sdk/front-component';import { isDefined } from 'twenty-sdk/utils';import { Callout } from 'twenty-ui/feedback';+import { Button } from 'twenty-ui/input';import { Section } from 'twenty-ui/layout';import { themeCssVariables } from 'twenty-ui/theme-constants';import { H2Title } from 'twenty-ui/typography';import { SlackUserLinkForm } from 'src/front-components/components/SlackUserLinkForm';import { SlackUserLinksList } from 'src/front-components/components/SlackUserLinksList';+import { UnlinkedSlackUsersList } from 'src/front-components/components/UnlinkedSlackUsersList';import { useCanManageSlackUserLinks } from 'src/front-components/hooks/use-can-manage-slack-user-links';+import { useMatchSlackUserLinks } from 'src/front-components/hooks/use-match-slack-user-links';+import { useSlackConnectionStatus } from 'src/front-components/hooks/use-slack-connection-status';import { useRemoveSlackUserLink } from 'src/front-components/hooks/use-remove-slack-user-link';import { useResendSlackUserLinkConsent } from 'src/front-components/hooks/use-resend-slack-user-link-consent';import { useSlackUserLinks } from 'src/front-components/hooks/use-slack-user-links';+import { useUnlinkedSlackUsers } from 'src/front-components/hooks/use-unlinked-slack-users';import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';const StyledContainer = styled.div`@@ -25,6 +31,24 @@ const StyledContainer = styled.div`width: 100%;`;+const StyledMatchAction = styled.div`+ align-items: center;+ display: flex;+ gap: ${() => themeCssVariables.spacing[3]};+ justify-content: flex-end;+ padding-top: ${() => themeCssVariables.spacing[2]};+`;++const StyledMatchSummary = styled.span`+ color: ${() => themeCssVariables.font.color.secondary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+`;++const StyledDisclosure = styled.div`+ align-self: flex-start;+`;+const StyledCenteredState = styled.div`align-items: center;box-sizing: border-box;@@ -40,6 +64,8 @@ const StyledCenteredState = styled.div`export const SlackUserLinksSettings = () => {const { canManage, isPermissionLoading } = useCanManageSlackUserLinks();+ const { isSlackConnected, isConnectionStatusLoading } =+ useSlackConnectionStatus();const {slackUserLinks,isSlackUserLinksLoading,@@ -49,6 +75,44 @@ export const SlackUserLinksSettings = () => {} = useSlackUserLinks();const { removeSlackUserLink, removingLinkId } = useRemoveSlackUserLink();const { resendConsent, resendingLinkId } = useResendSlackUserLinkConsent();+ const {+ unlinkedSlackUsers,+ hasMoreUnlinkedSlackUsers,+ isUnlinkedSlackUsersLoading,+ unlinkedErrorMessage,+ refetchUnlinkedSlackUsers,+ } = useUnlinkedSlackUsers({ isEnabled: canManage && isSlackConnected });+ const { matchSlackUserLinks, isMatching } = useMatchSlackUserLinks();+ const [matchSummary, setMatchSummary] = useState<string | undefined>(+ undefined,+ );+ const [isManualFormOpen, setIsManualFormOpen] = useState(false);++ const handleLinkSaved = async () => {+ await Promise.all([refetchSlackUserLinks(), refetchUnlinkedSlackUsers()]);+ };++ const handleManualLinkSaved = async () => {+ setIsManualFormOpen(false);+ await handleLinkSaved();+ };++ const handleMatchByEmail = async () => {+ const result = await matchSlackUserLinks();++ if (!result.success) {+ setMatchSummary(undefined);+ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: 'error',+ });++ return;+ }++ setMatchSummary(result.message);+ await handleLinkSaved();+ };const handleRemove = async (slackUserLink: SlackUserLinkRecord) => {const result = await removeSlackUserLink(slackUserLink.id);@@ -59,7 +123,7 @@ export const SlackUserLinksSettings = () => {});if (result.success) {- await refetchSlackUserLinks();+ await handleLinkSaved();}};@@ -93,6 +157,10 @@ export const SlackUserLinksSettings = () => {}};+ if (isConnectionStatusLoading || !isSlackConnected) {+ return null;+ }+if (isPermissionLoading) {return <StyledCenteredState>Loading Slack user links…</StyledCenteredState>;}@@ -107,10 +175,38 @@ export const SlackUserLinksSettings = () => {/>)}{canManage && (- <SlackUserLinkForm- existingLinks={slackUserLinks}- onLinkSaved={refetchSlackUserLinks}- />+ <Section>+ <H2Title+ title="Unlinked Slack users"+ description="These Slack users talk to the assistant with its default role. Pick a workspace member on a row to link them in place, or auto-link everyone whose Slack email matches a workspace member."+ />+ {isUnlinkedSlackUsersLoading && unlinkedSlackUsers.length === 0 ? (+ <StyledCenteredState>+ Loading unlinked Slack users…+ </StyledCenteredState>+ ) : isDefined(unlinkedErrorMessage) ? (+ <StyledCenteredState>{unlinkedErrorMessage}</StyledCenteredState>+ ) : (+ <UnlinkedSlackUsersList+ unlinkedSlackUsers={unlinkedSlackUsers}+ hasMore={hasMoreUnlinkedSlackUsers}+ onLinkSaved={handleLinkSaved}+ />+ )}+ <StyledMatchAction>+ {isDefined(matchSummary) && (+ <StyledMatchSummary>{matchSummary}</StyledMatchSummary>+ )}+ <Button+ type="button"+ title={isMatching ? 'Auto-linking…' : 'Auto-link by email'}+ size="small"+ variant="secondary"+ disabled={isMatching}+ onClick={handleMatchByEmail}+ />+ </StyledMatchAction>+ </Section>)}<Section><H2Title@@ -133,6 +229,23 @@ export const SlackUserLinksSettings = () => {/>)}</Section>+ {canManage &&+ (isManualFormOpen ? (+ <SlackUserLinkForm+ existingLinks={slackUserLinks}+ onLinkSaved={handleManualLinkSaved}+ />+ ) : (+ <StyledDisclosure>+ <Button+ type="button"+ title="Link someone not listed above"+ size="small"+ variant="secondary"+ onClick={() => setIsManualFormOpen(true)}+ />+ </StyledDisclosure>+ ))}</StyledContainer>);};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUserRow.tsx b/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUserRow.tsxnew file mode 100644index 00000000000..ede079c2981--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUserRow.tsx@@ -0,0 +1,140 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { enqueueSnackbar } from 'twenty-sdk/front-component';+import { isDefined } from 'twenty-sdk/utils';+import { Avatar } from 'twenty-ui/data-display';+import { Button } from 'twenty-ui/input';+import { OverflowingTextWithTooltip } from 'twenty-ui/surfaces';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { InlineWorkspaceMemberPicker } from 'src/front-components/components/InlineWorkspaceMemberPicker';+import {+ SlackTableCell,+ SlackTableRow,+} from 'src/front-components/components/SlackSettingsTable';+import { useSetSlackUserLink } from 'src/front-components/hooks/use-set-slack-user-link';+import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++const StyledIdentity = styled.div`+ align-items: center;+ display: flex;+ gap: ${() => themeCssVariables.spacing[2]};+ min-width: 0;+`;++const StyledName = styled.div`+ color: ${() => themeCssVariables.font.color.primary};+ min-width: 0;+`;++const StyledNoEmail = styled.span`+ color: ${() => themeCssVariables.font.color.tertiary};+`;++const StyledMemberCell = styled.div`+ align-items: center;+ display: flex;+ flex: 1;+ gap: ${() => themeCssVariables.spacing[2]};+ justify-content: space-between;+ min-width: 0;+`;++const StyledLinkControls = styled.div`+ align-items: center;+ display: flex;+ flex-shrink: 0;+ gap: ${() => themeCssVariables.spacing[2]};+`;++type UnlinkedSlackUserRowProps = {+ slackUser: SlackResolvedUser;+ gridTemplateColumns: string;+ onLinkSaved: () => void;+};++export const UnlinkedSlackUserRow = ({+ slackUser,+ gridTemplateColumns,+ onLinkSaved,+}: UnlinkedSlackUserRowProps) => {+ const [selectedMember, setSelectedMember] =+ useState<WorkspaceMemberOption | null>(null);+ const { setSlackUserLink, isSubmitting } = useSetSlackUserLink();++ const displayedName = isNonEmptyString(slackUser.displayName)+ ? slackUser.displayName+ : slackUser.slackUserId;++ const handleLink = async () => {+ if (!isDefined(selectedMember)) {+ return;+ }++ const result = await setSlackUserLink({+ workspaceMemberId: selectedMember.id,+ slackUserId: slackUser.slackUserId,+ slackTeamId: isNonEmptyString(slackUser.slackTeamId)+ ? slackUser.slackTeamId+ : undefined,+ name: slackUser.displayName,+ });++ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: result.success ? 'success' : 'error',+ });++ if (result.success) {+ setSelectedMember(null);+ onLinkSaved();+ }+ };++ return (+ <SlackTableRow gridTemplateColumns={gridTemplateColumns}>+ <SlackTableCell>+ <StyledIdentity>+ <Avatar+ placeholder={displayedName}+ placeholderColorSeed={slackUser.slackUserId}+ type="rounded"+ size="md"+ />+ <StyledName>+ <OverflowingTextWithTooltip text={displayedName} />+ </StyledName>+ </StyledIdentity>+ </SlackTableCell>+ <SlackTableCell>+ {isNonEmptyString(slackUser.email) ? (+ <OverflowingTextWithTooltip text={slackUser.email} />+ ) : (+ <StyledNoEmail>No confirmed email</StyledNoEmail>+ )}+ </SlackTableCell>+ <SlackTableCell>+ <StyledMemberCell>+ <InlineWorkspaceMemberPicker+ selectedMember={selectedMember}+ onSelect={setSelectedMember}+ disabled={isSubmitting}+ />+ <StyledLinkControls>+ <Button+ type="button"+ title={isSubmitting ? 'Linking…' : 'Link'}+ size="small"+ variant="secondary"+ accent="blue"+ disabled={!isDefined(selectedMember) || isSubmitting}+ onClick={handleLink}+ />+ </StyledLinkControls>+ </StyledMemberCell>+ </SlackTableCell>+ </SlackTableRow>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUsersList.tsx b/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUsersList.tsxnew file mode 100644index 00000000000..ea13299edff--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/UnlinkedSlackUsersList.tsx@@ -0,0 +1,76 @@+import styled from '@emotion/styled';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import {+ SlackTable,+ SlackTableBody,+ SlackTableHeader,+ SlackTableRow,+} from 'src/front-components/components/SlackSettingsTable';+import { UnlinkedSlackUserRow } from 'src/front-components/components/UnlinkedSlackUserRow';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++const UNLINKED_GRID_TEMPLATE_COLUMNS = '2fr 2fr 3fr';++const StyledEmptyState = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ padding: ${() => themeCssVariables.spacing[2]};+`;++const StyledTruncationNote = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+ padding: ${() => themeCssVariables.spacing[1]}+ ${() => themeCssVariables.spacing[2]};+`;++type UnlinkedSlackUsersListProps = {+ unlinkedSlackUsers: SlackResolvedUser[];+ hasMore: boolean;+ onLinkSaved: () => void;+};++export const UnlinkedSlackUsersList = ({+ unlinkedSlackUsers,+ hasMore,+ onLinkSaved,+}: UnlinkedSlackUsersListProps) => {+ if (unlinkedSlackUsers.length === 0) {+ return (+ <StyledEmptyState>+ {hasMore+ ? 'The Slack roster is too large to scan in one pass. Find a specific person with the search below.'+ : 'Everyone in the Slack workspace is linked.'}+ </StyledEmptyState>+ );+ }++ return (+ <SlackTable>+ <SlackTableRow gridTemplateColumns={UNLINKED_GRID_TEMPLATE_COLUMNS}>+ <SlackTableHeader>Slack user</SlackTableHeader>+ <SlackTableHeader>Email</SlackTableHeader>+ <SlackTableHeader>Workspace member</SlackTableHeader>+ </SlackTableRow>+ <SlackTableBody>+ {unlinkedSlackUsers.map((slackUser) => (+ <UnlinkedSlackUserRow+ key={slackUser.slackUserId}+ slackUser={slackUser}+ gridTemplateColumns={UNLINKED_GRID_TEMPLATE_COLUMNS}+ onLinkSaved={onLinkSaved}+ />+ ))}+ {hasMore && (+ <StyledTruncationNote>+ There may be more unlinked users. Link some of these first, or find+ a specific person with the search below.+ </StyledTruncationNote>+ )}+ </SlackTableBody>+ </SlackTable>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsxindex 09d1430622d..4783f2a6c50 100644--- a/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx+++ b/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx@@ -6,6 +6,7 @@ import { SearchDropdownPicker } from 'src/front-components/components/SearchDropimport { SlackPickedEntityButton } from 'src/front-components/components/SlackPickedEntityButton';import { useWorkspaceMemberSearch } from 'src/front-components/hooks/use-workspace-member-search';import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';type WorkspaceMemberPickerProps = {selectedMember: WorkspaceMemberOption | null;@@ -22,17 +23,14 @@ export const WorkspaceMemberPicker = ({}: WorkspaceMemberPickerProps) => {const [searchTerm, setSearchTerm] = useState('');const [isReopening, setIsReopening] = useState(false);- const { options, isSearching, searchErrorMessage } =- useWorkspaceMemberSearch(searchTerm);+ const { options, isSearching, searchErrorMessage } = useWorkspaceMemberSearch(+ { searchTerm },+ );if (isDefined(selectedMember)) {return (<SlackPickedEntityButton- name={- isNonEmptyString(selectedMember.name)- ? selectedMember.name- : (selectedMember.userEmail ?? selectedMember.id)- }+ name={getMemberDisplayName(selectedMember)}changeLabel="Change the workspace member"onChangeRequest={() => {setIsReopening(true);diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-match-slack-user-links.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-match-slack-user-links.tsnew file mode 100644index 00000000000..7c7d8bb972e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-match-slack-user-links.ts@@ -0,0 +1,50 @@+import { useRef, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { SLACK_USER_LINKS_MATCH_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { type SlackRosterMatchOutcome } from 'src/front-components/types/slack-roster-match-outcome.type';+import { parseSlackRosterMatchResult } from 'src/front-components/utils/parse-slack-roster-match-result.util';++const FALLBACK_MATCH_ERROR_MESSAGE =+ 'Could not match Slack users. Please try again.';++const buildFailureOutcome = (error: string): SlackRosterMatchOutcome => ({+ success: false,+ message: FALLBACK_MATCH_ERROR_MESSAGE,+ error,+ linkedCount: 0,+ unmatchedCount: 0,+});++export const useMatchSlackUserLinks = () => {+ const isMatchingRef = useRef(false);+ const [isMatching, setIsMatching] = useState(false);++ const matchSlackUserLinks = async (): Promise<SlackRosterMatchOutcome> => {+ if (isMatchingRef.current) {+ return buildFailureOutcome('A match is already running.');+ }++ isMatchingRef.current = true;+ setIsMatching(true);++ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_MATCH_ROUTE_PATH}`,+ {},+ );++ return parseSlackRosterMatchResult({+ value: result,+ fallbackMessage: FALLBACK_MATCH_ERROR_MESSAGE,+ });+ } catch {+ return buildFailureOutcome(FALLBACK_MATCH_ERROR_MESSAGE);+ } finally {+ isMatchingRef.current = false;+ setIsMatching(false);+ }+ };++ return { matchSlackUserLinks, isMatching };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-connection-status.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-connection-status.tsnew file mode 100644index 00000000000..1624ff4be76--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-connection-status.ts@@ -0,0 +1,50 @@+import { useEffect, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { SLACK_USER_LINKS_CONNECTION_STATUS_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { asRecord } from 'src/logic-functions/utils/as-record.util';++type SlackConnectionStatusState = {+ isSlackConnected: boolean;+ isConnectionStatusLoading: boolean;+};++const LOADING_STATE: SlackConnectionStatusState = {+ isSlackConnected: false,+ isConnectionStatusLoading: true,+};++export const useSlackConnectionStatus = (): SlackConnectionStatusState => {+ const [state, setState] = useState<SlackConnectionStatusState>(LOADING_STATE);++ useEffect(() => {+ let cancelled = false;++ const fetchConnectionStatus = async () => {+ let isSlackConnected = false;++ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_CONNECTION_STATUS_ROUTE_PATH}`,+ {},+ );++ isSlackConnected = asRecord(result)?.isConnected === true;+ } catch {+ isSlackConnected = false;+ }++ if (!cancelled) {+ setState({ isSlackConnected, isConnectionStatusLoading: false });+ }+ };++ fetchConnectionStatus();++ return () => {+ cancelled = true;+ };+ }, []);++ return state;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-unlinked-slack-users.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-unlinked-slack-users.tsnew file mode 100644index 00000000000..0d8fda3a971--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-unlinked-slack-users.ts@@ -0,0 +1,93 @@+import { useCallback, useEffect, useRef, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_USER_LINKS_UNLINKED_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { parseSlackUserSearchResponse } from 'src/front-components/utils/parse-slack-user-search-response.util';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';++const UNLINKED_USERS_ERROR_MESSAGE =+ 'Could not load unlinked Slack users. Please try again later.';++type UnlinkedSlackUsersState = {+ unlinkedSlackUsers: SlackResolvedUser[];+ hasMoreUnlinkedSlackUsers: boolean;+ isUnlinkedSlackUsersLoading: boolean;+ unlinkedErrorMessage: string | undefined;+ refetchUnlinkedSlackUsers: () => Promise<void>;+};++export const useUnlinkedSlackUsers = ({+ isEnabled,+}: {+ isEnabled: boolean;+}): UnlinkedSlackUsersState => {+ const [unlinkedSlackUsers, setUnlinkedSlackUsers] = useState<+ SlackResolvedUser[]+ >([]);+ const [hasMoreUnlinkedSlackUsers, setHasMoreUnlinkedSlackUsers] =+ useState(false);+ const [isUnlinkedSlackUsersLoading, setIsUnlinkedSlackUsersLoading] =+ useState(true);+ const [unlinkedErrorMessage, setUnlinkedErrorMessage] = useState<+ string | undefined+ >(undefined);+ const fetchIdRef = useRef(0);++ const refetchUnlinkedSlackUsers = useCallback(async () => {+ fetchIdRef.current += 1;+ const fetchId = fetchIdRef.current;++ setIsUnlinkedSlackUsersLoading(true);+ setUnlinkedErrorMessage(undefined);++ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_UNLINKED_ROUTE_PATH}`,+ {},+ );++ if (fetchId !== fetchIdRef.current) {+ return;+ }++ const { options, errorMessage } = parseSlackUserSearchResponse(result);++ if (isDefined(errorMessage)) {+ setUnlinkedErrorMessage(errorMessage);+ setUnlinkedSlackUsers([]);+ setHasMoreUnlinkedSlackUsers(false);++ return;+ }++ setUnlinkedSlackUsers(options);+ setHasMoreUnlinkedSlackUsers(asRecord(result)?.hasMore === true);+ } catch {+ if (fetchId === fetchIdRef.current) {+ setUnlinkedErrorMessage(UNLINKED_USERS_ERROR_MESSAGE);+ }+ } finally {+ if (fetchId === fetchIdRef.current) {+ setIsUnlinkedSlackUsersLoading(false);+ }+ }+ }, []);++ useEffect(() => {+ if (!isEnabled) {+ return;+ }++ refetchUnlinkedSlackUsers();+ }, [isEnabled, refetchUnlinkedSlackUsers]);++ return {+ unlinkedSlackUsers,+ hasMoreUnlinkedSlackUsers,+ isUnlinkedSlackUsersLoading,+ unlinkedErrorMessage,+ refetchUnlinkedSlackUsers,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-workspace-member-search.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-workspace-member-search.tsindex 3d0087366a7..05d8626f754 100644--- a/packages/twenty-apps/public/slack/src/front-components/hooks/use-workspace-member-search.ts+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-workspace-member-search.ts@@ -28,9 +28,13 @@ type WorkspaceMemberSearchState = {searchErrorMessage: string | undefined;};-export const useWorkspaceMemberSearch = (- searchTerm: string,-): WorkspaceMemberSearchState => {+export const useWorkspaceMemberSearch = ({+ searchTerm,+ shouldListWithoutSearchTerm = false,+}: {+ searchTerm: string;+ shouldListWithoutSearchTerm?: boolean;+}): WorkspaceMemberSearchState => {const [options, setOptions] = useState<WorkspaceMemberOption[]>([]);const [isSearching, setIsSearching] = useState(false);const [searchErrorMessage, setSearchErrorMessage] = useState<@@ -43,7 +47,10 @@ export const useWorkspaceMemberSearch = (setOptions([]);setSearchErrorMessage(undefined);- if (!isNonEmptyString(filter)) {+ if (+ !isNonEmptyString(filter) &&+ (!shouldListWithoutSearchTerm || isNonEmptyString(searchTerm))+ ) {setIsSearching(false);return;@@ -60,7 +67,7 @@ export const useWorkspaceMemberSearch = ('/rest/workspaceMembers',{query: {- filter,+ ...(isNonEmptyString(filter) ? { filter } : {}),limit: String(WORKSPACE_MEMBER_SEARCH_PAGE_SIZE),},},@@ -101,7 +108,7 @@ export const useWorkspaceMemberSearch = (cancelled = true;clearTimeout(timeoutId);};- }, [searchTerm]);+ }, [searchTerm, shouldListWithoutSearchTerm]);return { options, isSearching, searchErrorMessage };};diff --git a/packages/twenty-apps/public/slack/src/front-components/types/slack-roster-match-outcome.type.ts b/packages/twenty-apps/public/slack/src/front-components/types/slack-roster-match-outcome.type.tsnew file mode 100644index 00000000000..3af040e50ca--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/types/slack-roster-match-outcome.type.ts@@ -0,0 +1,7 @@+export type SlackRosterMatchOutcome = {+ success: boolean;+ message: string;+ error?: string;+ linkedCount: number;+ unmatchedCount: number;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/get-member-display-name.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/get-member-display-name.util.test.tsnew file mode 100644index 00000000000..500ec1ab60e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/get-member-display-name.util.test.ts@@ -0,0 +1,31 @@+import { describe, expect, it } from 'vitest';++import { getMemberDisplayName } from 'src/front-components/utils/get-member-display-name.util';++describe('getMemberDisplayName', () => {+ it('should prefer the name', () => {+ expect(+ getMemberDisplayName({+ id: 'member-1',+ name: 'Ada Lovelace',+ userEmail: '[email protected]',+ }),+ ).toBe('Ada Lovelace');+ });++ it('should fall back to the email when the name is empty', () => {+ expect(+ getMemberDisplayName({+ id: 'member-1',+ name: '',+ userEmail: '[email protected]',+ }),+ ).toBe('[email protected]');+ });++ it('should fall back to the id when name and email are empty', () => {+ expect(+ getMemberDisplayName({ id: 'member-1', name: '', userEmail: null }),+ ).toBe('member-1');+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-roster-match-result.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-roster-match-result.util.test.tsnew file mode 100644index 00000000000..399932712bd--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-roster-match-result.util.test.ts@@ -0,0 +1,62 @@+import { describe, expect, it } from 'vitest';++import { parseSlackRosterMatchResult } from 'src/front-components/utils/parse-slack-roster-match-result.util';++const FALLBACK_MESSAGE = 'Could not match Slack users. Please try again.';++describe('parseSlackRosterMatchResult', () => {+ it('should parse a successful match summary', () => {+ const result = parseSlackRosterMatchResult({+ value: {+ success: true,+ message: 'Matched 2 Slack users by email.',+ linkedCount: 2,+ alreadyLinkedCount: 1,+ unmatchedCount: 3,+ },+ fallbackMessage: FALLBACK_MESSAGE,+ });++ expect(result.success).toBe(true);+ expect(result.message).toBe('Matched 2 Slack users by email.');+ expect(result.linkedCount).toBe(2);+ expect(result.unmatchedCount).toBe(3);+ });++ it('should default counts to zero when missing', () => {+ const result = parseSlackRosterMatchResult({+ value: { success: true, message: 'ok' },+ fallbackMessage: FALLBACK_MESSAGE,+ });++ expect(result.linkedCount).toBe(0);+ expect(result.unmatchedCount).toBe(0);+ });++ it('should ignore non-numeric counts', () => {+ const result = parseSlackRosterMatchResult({+ value: {+ success: true,+ message: 'ok',+ linkedCount: 'two',+ unmatchedCount: null,+ },+ fallbackMessage: FALLBACK_MESSAGE,+ });++ expect(result.linkedCount).toBe(0);+ expect(result.unmatchedCount).toBe(0);+ });++ it('should fall back on a malformed payload', () => {+ const result = parseSlackRosterMatchResult({+ value: undefined,+ fallbackMessage: FALLBACK_MESSAGE,+ });++ expect(result.success).toBe(false);+ expect(result.message).toBe(FALLBACK_MESSAGE);+ expect(result.linkedCount).toBe(0);+ expect(result.unmatchedCount).toBe(0);+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/get-member-display-name.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/get-member-display-name.util.tsnew file mode 100644index 00000000000..7bf6c83d094--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/get-member-display-name.util.ts@@ -0,0 +1,15 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';++export const getMemberDisplayName = (member: WorkspaceMemberOption): string => {+ if (isNonEmptyString(member.name)) {+ return member.name;+ }++ if (isNonEmptyString(member.userEmail)) {+ return member.userEmail;+ }++ return member.id;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-roster-match-result.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-roster-match-result.util.tsnew file mode 100644index 00000000000..387cd3a4663--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-roster-match-result.util.ts@@ -0,0 +1,24 @@+import { isNumber } from '@sniptt/guards';++import { type SlackRosterMatchOutcome } from 'src/front-components/types/slack-roster-match-outcome.type';+import { parseSlackToolResult } from 'src/front-components/utils/parse-slack-tool-result.util';+import { asRecord } from 'src/logic-functions/utils/as-record.util';++export const parseSlackRosterMatchResult = ({+ value,+ fallbackMessage,+}: {+ value: unknown;+ fallbackMessage: string;+}): SlackRosterMatchOutcome => {+ const base = parseSlackToolResult({ value, fallbackMessage });+ const record = asRecord(value);++ return {+ ...base,+ linkedCount: isNumber(record?.linkedCount) ? record.linkedCount : 0,+ unmatchedCount: isNumber(record?.unmatchedCount)+ ? record.unmatchedCount+ : 0,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-deleted-slack-user-link-ids.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-deleted-slack-user-link-ids.test.tsnew file mode 100644index 00000000000..00e6f63d85d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-deleted-slack-user-link-ids.test.ts@@ -0,0 +1,84 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { describe, expect, it, vi } from 'vitest';++import { findDeletedSlackUserLinkIds } from 'src/logic-functions/data/find-deleted-slack-user-link-ids';++const SLACK_TEAM_ID = 'T-installed';++const buildClient = (pages: { ids: string[]; endCursor?: string }[]) => {+ const queryMock = vi.fn();++ for (const page of pages) {+ queryMock.mockResolvedValueOnce({+ slackUserLinks: {+ edges: page.ids.map((id) => ({ node: { id } })),+ pageInfo: {+ hasNextPage: page.endCursor !== undefined,+ endCursor: page.endCursor ?? null,+ },+ },+ });+ }++ return {+ client: { query: queryMock } as unknown as CoreApiClient,+ queryMock,+ };+};++describe('findDeletedSlackUserLinkIds', () => {+ it('should ask only for soft-deleted links of the given Slack users', async () => {+ const { client, queryMock } = buildClient([{ ids: [] }]);++ await findDeletedSlackUserLinkIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1', 'U2'],+ });++ expect(queryMock.mock.calls[0][0].slackUserLinks.__args.filter).toEqual({+ slackTeamId: { eq: SLACK_TEAM_ID },+ slackUserId: { in: ['U1', 'U2'] },+ deletedAt: { is: 'NOT_NULL' },+ });+ });++ it('should return every matching link id', async () => {+ const { client } = buildClient([{ ids: ['link-1', 'link-2'] }]);++ const deletedLinkIds = await findDeletedSlackUserLinkIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1', 'U2'],+ });++ expect(deletedLinkIds).toEqual(['link-1', 'link-2']);+ });++ it('should follow pagination', async () => {+ const { client, queryMock } = buildClient([+ { ids: ['link-1'], endCursor: 'cursor-2' },+ { ids: ['link-2'] },+ ]);++ const deletedLinkIds = await findDeletedSlackUserLinkIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1'],+ });++ expect(deletedLinkIds).toEqual(['link-1', 'link-2']);+ expect(queryMock.mock.calls[1][0].slackUserLinks.__args.after).toBe(+ 'cursor-2',+ );+ });++ it('should not query when there is no Slack user to check', async () => {+ const { client, queryMock } = buildClient([]);++ const deletedLinkIds = await findDeletedSlackUserLinkIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: [],+ });++ expect(queryMock).not.toHaveBeenCalled();+ expect(deletedLinkIds).toEqual([]);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-workspace-member-ids-by-emails.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-workspace-member-ids-by-emails.test.tsnew file mode 100644index 00000000000..6aad8c984f2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-workspace-member-ids-by-emails.test.ts@@ -0,0 +1,134 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { describe, expect, it, vi } from 'vitest';++import { findWorkspaceMemberIdsByEmails } from 'src/logic-functions/data/find-workspace-member-ids-by-emails';++const buildClient = (+ pages: {+ edges: { node: { id: string; userEmail: string } }[];+ endCursor?: string;+ }[],+) => {+ const queryMock = vi.fn();++ for (const page of pages) {+ queryMock.mockResolvedValueOnce({+ workspaceMembers: {+ edges: page.edges,+ pageInfo: {+ hasNextPage: page.endCursor !== undefined,+ endCursor: page.endCursor ?? null,+ },+ },+ });+ }++ return {+ client: { query: queryMock } as unknown as CoreApiClient,+ queryMock,+ };+};++describe('findWorkspaceMemberIdsByEmails', () => {+ it('should map lowercased emails to member ids', async () => {+ const { client } = buildClient([+ {+ edges: [+ { node: { id: 'member-ada', userEmail: '[email protected]' } },+ { node: { id: 'member-bob', userEmail: '[email protected]' } },+ ],+ },+ ]);++ const { workspaceMemberIdByEmail, ambiguousEmailCount } =+ await findWorkspaceMemberIdsByEmails(client, {+ emails: ['[email protected]', '[email protected]'],+ });++ expect(workspaceMemberIdByEmail.get('[email protected]')).toBe('member-ada');+ expect(workspaceMemberIdByEmail.get('[email protected]')).toBe('member-bob');+ expect(ambiguousEmailCount).toBe(0);+ });++ it('should ask only for the roster emails through case-insensitive matches', async () => {+ const { client, queryMock } = buildClient([{ edges: [] }]);++ await findWorkspaceMemberIdsByEmails(client, {+ emails: ['[email protected]', '[email protected]'],+ });++ expect(queryMock).toHaveBeenCalledTimes(1);+ expect(queryMock.mock.calls[0][0].workspaceMembers.__args.filter).toEqual({+ or: [+ { userEmail: { ilike: '[email protected]' } },+ { userEmail: { ilike: '[email protected]' } },+ ],+ });+ });++ it('should escape like wildcards inside the looked up emails', async () => {+ const { client, queryMock } = buildClient([{ edges: [] }]);++ await findWorkspaceMemberIdsByEmails(client, {+ emails: ['[email protected]'],+ });++ expect(queryMock.mock.calls[0][0].workspaceMembers.__args.filter).toEqual({+ or: [{ userEmail: { ilike: 'john\\[email protected]' } }],+ });+ });++ it('should not query at all when the roster has no vouched email', async () => {+ const { client, queryMock } = buildClient([]);++ const { workspaceMemberIdByEmail, ambiguousEmailCount } =+ await findWorkspaceMemberIdsByEmails(client, { emails: [] });++ expect(queryMock).not.toHaveBeenCalled();+ expect(workspaceMemberIdByEmail.size).toBe(0);+ expect(ambiguousEmailCount).toBe(0);+ });++ it('should drop an email shared by two members and report it', async () => {+ const { client } = buildClient([+ {+ edges: [+ { node: { id: 'member-ada', userEmail: '[email protected]' } },+ { node: { id: 'member-bob', userEmail: '[email protected]' } },+ { node: { id: 'member-carol', userEmail: '[email protected]' } },+ ],+ },+ ]);++ const { workspaceMemberIdByEmail, ambiguousEmailCount } =+ await findWorkspaceMemberIdsByEmails(client, {+ emails: ['[email protected]', '[email protected]'],+ });++ expect(workspaceMemberIdByEmail.has('[email protected]')).toBe(false);+ expect(workspaceMemberIdByEmail.get('[email protected]')).toBe(+ 'member-carol',+ );+ expect(ambiguousEmailCount).toBe(1);+ });++ it('should follow pagination within one batch of emails', async () => {+ const { client, queryMock } = buildClient([+ {+ edges: [{ node: { id: 'member-ada', userEmail: '[email protected]' } }],+ endCursor: 'cursor-2',+ },+ { edges: [{ node: { id: 'member-bob', userEmail: '[email protected]' } }] },+ ]);++ const { workspaceMemberIdByEmail } = await findWorkspaceMemberIdsByEmails(+ client,+ { emails: ['[email protected]', '[email protected]'] },+ );++ expect(workspaceMemberIdByEmail.size).toBe(2);+ expect(queryMock.mock.calls[1][0].workspaceMembers.__args.after).toBe(+ 'cursor-2',+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/list-linked-slack-user-ids.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/list-linked-slack-user-ids.test.tsnew file mode 100644index 00000000000..ee6e8d51747--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/list-linked-slack-user-ids.test.ts@@ -0,0 +1,80 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { describe, expect, it, vi } from 'vitest';++import { listLinkedSlackUserIds } from 'src/logic-functions/data/list-linked-slack-user-ids';++const SLACK_TEAM_ID = 'T-installed';++const buildClient = (+ pages: { slackUserIds: string[]; endCursor?: string }[],+) => {+ const queryMock = vi.fn();++ for (const page of pages) {+ queryMock.mockResolvedValueOnce({+ slackUserLinks: {+ edges: page.slackUserIds.map((slackUserId) => ({+ node: { slackUserId },+ })),+ pageInfo: {+ hasNextPage: page.endCursor !== undefined,+ endCursor: page.endCursor ?? null,+ },+ },+ });+ }++ return {+ client: { query: queryMock } as unknown as CoreApiClient,+ queryMock,+ };+};++const filterOfCall = (queryMock: ReturnType<typeof vi.fn>, call: number) =>+ queryMock.mock.calls[call][0].slackUserLinks.__args.filter;++describe('listLinkedSlackUserIds', () => {+ it('should ask for every link of the team when no Slack user is given', async () => {+ const { client, queryMock } = buildClient([{ slackUserIds: ['U1', 'U2'] }]);++ const linkedSlackUserIds = await listLinkedSlackUserIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(filterOfCall(queryMock, 0)).toEqual({+ slackTeamId: { eq: SLACK_TEAM_ID },+ });+ expect([...linkedSlackUserIds]).toEqual(['U1', 'U2']);+ });++ it('should narrow the query to the given Slack users', async () => {+ const { client, queryMock } = buildClient([{ slackUserIds: ['U1'] }]);++ const linkedSlackUserIds = await listLinkedSlackUserIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1', 'U2'],+ });++ expect(filterOfCall(queryMock, 0)).toEqual({+ slackTeamId: { eq: SLACK_TEAM_ID },+ slackUserId: { in: ['U1', 'U2'] },+ });+ expect([...linkedSlackUserIds]).toEqual(['U1']);+ });++ it('should follow pagination', async () => {+ const { client, queryMock } = buildClient([+ { slackUserIds: ['U1'], endCursor: 'cursor-2' },+ { slackUserIds: ['U2'] },+ ]);++ const linkedSlackUserIds = await listLinkedSlackUserIds(client, {+ slackTeamId: SLACK_TEAM_ID,+ });++ expect([...linkedSlackUserIds]).toEqual(['U1', 'U2']);+ expect(queryMock.mock.calls[1][0].slackUserLinks.__args.after).toBe(+ 'cursor-2',+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-link.tsindex 69be98dcdd7..fdb87390317 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-link.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-link.ts@@ -1,39 +1,15 @@import { isNonEmptyString } from '@sniptt/guards';import { type CoreApiClient } from 'twenty-client-sdk/core';-import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';-import { type SlackUserLinkSource } from 'src/logic-functions/types/slack-user-link-source.type';+import { type SlackUserLinkDraft } from 'src/logic-functions/types/slack-user-link-draft.type';export const createSlackUserLink = async (client: CoreApiClient,- {- slackTeamId,- slackUserId,- workspaceMemberId,- name,- source,- consentState,- }: {- slackTeamId: string;- slackUserId: string;- workspaceMemberId: string;- name: string;- source: SlackUserLinkSource;- consentState: SlackUserLinkConsentState;- },+ draft: SlackUserLinkDraft,): Promise<string> => {const result = await client.mutation({createSlackUserLink: {- __args: {- data: {- slackTeamId,- slackUserId,- workspaceMemberId,- name,- source,- consentState,- },- },+ __args: { data: draft },id: true,},});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-links.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-links.tsnew file mode 100644index 00000000000..ecf29ba829d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/create-slack-user-links.ts@@ -0,0 +1,15 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { type SlackUserLinkDraft } from 'src/logic-functions/types/slack-user-link-draft.type';++export const createSlackUserLinks = async (+ client: CoreApiClient,+ { drafts }: { drafts: SlackUserLinkDraft[] },+): Promise<void> => {+ await client.mutation({+ createSlackUserLinks: {+ __args: { data: drafts },+ id: true,+ },+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-links.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-links.tsnew file mode 100644index 00000000000..5ba0b1388e6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-links.ts@@ -0,0 +1,27 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++const IDS_PER_MUTATION = 200;++export const destroySlackUserLinks = async (+ client: CoreApiClient,+ { ids }: { ids: string[] },+): Promise<void> => {+ for (+ let mutationStart = 0;+ mutationStart < ids.length;+ mutationStart += IDS_PER_MUTATION+ ) {+ await client.mutation({+ destroySlackUserLinks: {+ __args: {+ filter: {+ id: {+ in: ids.slice(mutationStart, mutationStart + IDS_PER_MUTATION),+ },+ },+ },+ id: true,+ },+ });+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-id.tsdeleted file mode 100644index 295fa140e93..00000000000--- a/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-id.ts+++ /dev/null@@ -1,29 +0,0 @@-import { isNonEmptyString } from '@sniptt/guards';-import { type CoreApiClient } from 'twenty-client-sdk/core';--export const findDeletedSlackUserLinkId = async (- client: CoreApiClient,- { slackTeamId, slackUserId }: { slackTeamId: string; slackUserId: string },-): Promise<string | undefined> => {- const queryResult = await client.query({- slackUserLinks: {- __args: {- filter: {- slackTeamId: { eq: slackTeamId },- slackUserId: { eq: slackUserId },- deletedAt: { is: 'NOT_NULL' },- },- first: 1,- },- edges: {- node: {- id: true,- },- },- },- });-- const id = queryResult.slackUserLinks?.edges?.[0]?.node?.id;-- return isNonEmptyString(id) ? id : undefined;-};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-ids.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-ids.tsnew file mode 100644index 00000000000..7f4538aeb00--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-deleted-slack-user-link-ids.ts@@ -0,0 +1,69 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++const SLACK_USER_IDS_PER_QUERY = 200;+const LINKS_PER_PAGE = 200;+const MAX_PAGES_PER_QUERY = 5;++export const findDeletedSlackUserLinkIds = async (+ client: CoreApiClient,+ {+ slackTeamId,+ slackUserIds,+ }: { slackTeamId: string; slackUserIds: string[] },+): Promise<string[]> => {+ const deletedLinkIds: string[] = [];++ for (+ let queryStart = 0;+ queryStart < slackUserIds.length;+ queryStart += SLACK_USER_IDS_PER_QUERY+ ) {+ const queriedSlackUserIds = slackUserIds.slice(+ queryStart,+ queryStart + SLACK_USER_IDS_PER_QUERY,+ );++ let after: string | undefined;++ for (let page = 0; page < MAX_PAGES_PER_QUERY; page += 1) {+ const queryResult = await client.query({+ slackUserLinks: {+ __args: {+ filter: {+ slackTeamId: { eq: slackTeamId },+ slackUserId: { in: queriedSlackUserIds },+ deletedAt: { is: 'NOT_NULL' },+ },+ first: LINKS_PER_PAGE,+ ...(isDefined(after) ? { after } : {}),+ },+ edges: { node: { id: true } },+ pageInfo: { hasNextPage: true, endCursor: true },+ },+ });++ for (const edge of queryResult.slackUserLinks?.edges ?? []) {+ const id = edge?.node?.id;++ if (isNonEmptyString(id)) {+ deletedLinkIds.push(id);+ }+ }++ const pageInfo = queryResult.slackUserLinks?.pageInfo;++ if (+ pageInfo?.hasNextPage !== true ||+ !isNonEmptyString(pageInfo.endCursor)+ ) {+ break;+ }++ after = pageInfo.endCursor;+ }+ }++ return deletedLinkIds;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-id-by-email.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-id-by-email.tsindex 16203edda35..d7e1105767c 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-id-by-email.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-id-by-email.ts@@ -2,12 +2,11 @@ import { isNonEmptyString } from '@sniptt/guards';import { isDefined } from 'twenty-sdk/utils';import { type CoreApiClient } from 'twenty-client-sdk/core';+import { escapeSqlLikePattern } from 'src/logic-functions/utils/escape-sql-like-pattern.util';+const CANDIDATES_PER_PAGE = 100;const MAX_PAGES = 10;-const escapeIlikePattern = (value: string): string =>- value.replace(/[\\%_]/g, '\\$&');-export const findWorkspaceMemberIdByEmail = async (client: CoreApiClient,email: string,@@ -21,7 +20,7 @@ export const findWorkspaceMemberIdByEmail = async (const queryResult = await client.query({workspaceMembers: {__args: {- filter: { userEmail: { ilike: escapeIlikePattern(email) } },+ filter: { userEmail: { ilike: escapeSqlLikePattern(email) } },first: CANDIDATES_PER_PAGE,...(isDefined(after) ? { after } : {}),},diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-ids-by-emails.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-ids-by-emails.tsnew file mode 100644index 00000000000..c01e89eb88a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-ids-by-emails.ts@@ -0,0 +1,97 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { escapeSqlLikePattern } from 'src/logic-functions/utils/escape-sql-like-pattern.util';++const EMAILS_PER_QUERY = 50;+const MEMBERS_PER_PAGE = 200;+const MAX_PAGES_PER_QUERY = 5;++type WorkspaceMemberEmailLookup = {+ workspaceMemberIdByEmail: Map<string, string>;+ ambiguousEmailCount: number;+};++export const findWorkspaceMemberIdsByEmails = async (+ client: CoreApiClient,+ { emails }: { emails: string[] },+): Promise<WorkspaceMemberEmailLookup> => {+ const lookedUpEmails = [+ ...new Set(emails.map((email) => email.toLowerCase())),+ ];+ const workspaceMemberIdByEmail = new Map<string, string>();+ const ambiguousEmails = new Set<string>();++ for (+ let queryStart = 0;+ queryStart < lookedUpEmails.length;+ queryStart += EMAILS_PER_QUERY+ ) {+ const queriedEmails = lookedUpEmails.slice(+ queryStart,+ queryStart + EMAILS_PER_QUERY,+ );++ let after: string | undefined;++ for (let page = 0; page < MAX_PAGES_PER_QUERY; page += 1) {+ const queryResult = await client.query({+ workspaceMembers: {+ __args: {+ filter: {+ or: queriedEmails.map((email) => ({+ userEmail: { ilike: escapeSqlLikePattern(email) },+ })),+ },+ first: MEMBERS_PER_PAGE,+ ...(isDefined(after) ? { after } : {}),+ },+ edges: { node: { id: true, userEmail: true } },+ pageInfo: { hasNextPage: true, endCursor: true },+ },+ });++ for (const edge of queryResult.workspaceMembers?.edges ?? []) {+ const node = edge?.node;++ if (!isNonEmptyString(node?.id) || !isNonEmptyString(node.userEmail)) {+ continue;+ }++ const email = node.userEmail.toLowerCase();+ const alreadyMappedMemberId = workspaceMemberIdByEmail.get(email);++ if (+ isDefined(alreadyMappedMemberId) &&+ alreadyMappedMemberId !== node.id+ ) {+ ambiguousEmails.add(email);+ continue;+ }++ workspaceMemberIdByEmail.set(email, node.id);+ }++ const pageInfo = queryResult.workspaceMembers?.pageInfo;++ if (+ pageInfo?.hasNextPage !== true ||+ !isNonEmptyString(pageInfo.endCursor)+ ) {+ break;+ }++ after = pageInfo.endCursor;+ }+ }++ for (const ambiguousEmail of ambiguousEmails) {+ workspaceMemberIdByEmail.delete(ambiguousEmail);+ }++ return {+ workspaceMemberIdByEmail,+ ambiguousEmailCount: ambiguousEmails.size,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/list-linked-slack-user-ids.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/list-linked-slack-user-ids.tsnew file mode 100644index 00000000000..e0367e5dd43--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/list-linked-slack-user-ids.ts@@ -0,0 +1,60 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++const LINKS_PER_PAGE = 200;+const MAX_PAGES = 25;++export const listLinkedSlackUserIds = async (+ client: CoreApiClient,+ {+ slackTeamId,+ slackUserIds,+ }: { slackTeamId: string; slackUserIds?: string[] },+): Promise<Set<string>> => {+ const linkedSlackUserIds = new Set<string>();++ let after: string | undefined;++ for (let page = 0; page < MAX_PAGES; page += 1) {+ const queryResult = await client.query({+ slackUserLinks: {+ __args: {+ filter: {+ slackTeamId: { eq: slackTeamId },+ ...(isDefined(slackUserIds)+ ? { slackUserId: { in: slackUserIds } }+ : {}),+ },+ first: LINKS_PER_PAGE,+ ...(isDefined(after) ? { after } : {}),+ },+ edges: { node: { slackUserId: true } },+ pageInfo: { hasNextPage: true, endCursor: true },+ },+ });++ const edges = queryResult.slackUserLinks?.edges ?? [];++ for (const edge of edges) {+ const slackUserId = edge?.node?.slackUserId;++ if (isNonEmptyString(slackUserId)) {+ linkedSlackUserIds.add(slackUserId);+ }+ }++ const pageInfo = queryResult.slackUserLinks?.pageInfo;++ if (+ pageInfo?.hasNextPage !== true ||+ !isNonEmptyString(pageInfo.endCursor)+ ) {+ break;+ }++ after = pageInfo.endCursor;+ }++ return linkedSlackUserIds;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-connection-status-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-connection-status-handler.test.tsnew file mode 100644index 00000000000..2453d074725--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-connection-status-handler.test.ts@@ -0,0 +1,34 @@+import { describe, expect, it, vi } from 'vitest';++import { slackConnectionStatusHandler } from 'src/logic-functions/handlers/slack-connection-status-handler';+import { getSlackConnection } from 'src/logic-functions/utils/get-slack-connection';++vi.mock('src/logic-functions/utils/get-slack-connection', () => ({+ getSlackConnection: vi.fn(),+}));++describe('slackConnectionStatusHandler', () => {+ it('should report a connected workspace', async () => {+ vi.mocked(getSlackConnection).mockResolvedValueOnce({+ success: true,+ accessToken: 'xoxb-token',+ });++ await expect(slackConnectionStatusHandler()).resolves.toEqual({+ success: true,+ isConnected: true,+ });+ });++ it('should report a missing connection without failing', async () => {+ vi.mocked(getSlackConnection).mockResolvedValueOnce({+ success: false,+ error: 'Slack is not connected.',+ });++ await expect(slackConnectionStatusHandler()).resolves.toEqual({+ success: true,+ isConnected: false,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-list-unlinked-users-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-list-unlinked-users-handler.test.tsnew file mode 100644index 00000000000..2a0a7487324--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-list-unlinked-users-handler.test.ts@@ -0,0 +1,184 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackListUnlinkedUsersHandler } from 'src/logic-functions/handlers/slack-list-unlinked-users-handler';++const {+ currentUserHasRolesPermissionMock,+ getSlackClientMock,+ authTestMock,+ usersListMock,+ coreApiClientMock,+ listLinkedSlackUserIdsMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ authTestMock: vi.fn(),+ usersListMock: vi.fn(),+ coreApiClientMock: vi.fn(),+ listLinkedSlackUserIdsMock: vi.fn(),+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('src/logic-functions/utils/get-slack-client', () => ({+ getSlackClient: getSlackClientMock,+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/list-linked-slack-user-ids', () => ({+ listLinkedSlackUserIds: listLinkedSlackUserIdsMock,+}));++const INSTALLED_TEAM_ID = 'T0INSTALLED';++const ADA = {+ id: 'U0ADA',+ team_id: INSTALLED_TEAM_ID,+ real_name: 'Ada Lovelace',+ is_email_confirmed: true,+ profile: { display_name: 'ada', email: '[email protected]' },+};++const BOB = {+ id: 'U0BOB',+ team_id: INSTALLED_TEAM_ID,+ real_name: 'Bob Builder',+ is_email_confirmed: true,+ profile: { display_name: 'bob', email: '[email protected]' },+};++describe('slackListUnlinkedUsersHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ getSlackClientMock.mockResolvedValue({+ success: true,+ client: {+ auth: { test: authTestMock },+ users: { list: usersListMock },+ },+ });+ authTestMock.mockResolvedValue({ team_id: INSTALLED_TEAM_ID });+ usersListMock.mockResolvedValue({ members: [ADA, BOB] });+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set());+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(false);+ expect(usersListMock).not.toHaveBeenCalled();+ });++ it('should fail closed when the installed workspace cannot be confirmed', async () => {+ authTestMock.mockRejectedValue(new Error('network'));++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(false);+ expect(usersListMock).not.toHaveBeenCalled();+ });++ it('should list roster members without a link', async () => {+ const result = await slackListUnlinkedUsersHandler();++ expect(result).toEqual({+ success: true,+ hasMore: false,+ slackUsers: [+ {+ slackUserId: 'U0ADA',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'ada',+ email: '[email protected]',+ },+ {+ slackUserId: 'U0BOB',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'bob',+ email: '[email protected]',+ },+ ],+ });+ });++ it('should leave out members that already have a link of any state', async () => {+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set(['U0ADA']));++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers.map((user) => user.slackUserId)).toEqual([+ 'U0BOB',+ ]);+ }+ });++ it('should list a guest but leave their email out of the option', async () => {+ usersListMock.mockResolvedValue({+ members: [{ ...ADA, is_restricted: true }],+ });++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers[0]?.email).toBeUndefined();+ }+ });++ it('should not report more results when exactly the cap is unlinked', async () => {+ usersListMock.mockResolvedValue({+ members: Array.from({ length: 20 }, (_, index) => ({+ id: `U${index}`,+ is_email_confirmed: true,+ real_name: `User ${index}`,+ })),+ });++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers).toHaveLength(20);+ expect(result.hasMore).toBe(false);+ }+ });++ it('should stop early and report more results past the cap', async () => {+ usersListMock.mockResolvedValue({+ members: Array.from({ length: 30 }, (_, index) => ({+ id: `U${index}`,+ is_email_confirmed: true,+ real_name: `User ${index}`,+ })),+ });++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers).toHaveLength(20);+ expect(result.hasMore).toBe(true);+ }+ });++ it('should fail with a structured error when the roster read throws', async () => {+ usersListMock.mockRejectedValue(new Error('ratelimited'));++ const result = await slackListUnlinkedUsersHandler();++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toBe('ratelimited');+ }+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-users-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-users-handler.test.tsindex d01d0a2c8ed..71928c23ce7 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-users-handler.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-users-handler.test.ts@@ -26,6 +26,7 @@ const INSTALLED_TEAM_ID = 'T0INSTALLED';const ADA = {id: 'U0ADA',+ team_id: INSTALLED_TEAM_ID,real_name: 'Ada Lovelace',is_email_confirmed: true,profile: { display_name: 'ada', email: '[email protected]' },@@ -33,6 +34,7 @@ const ADA = {const BOB = {id: 'U0BOB',+ team_id: INSTALLED_TEAM_ID,real_name: 'Bob Builder',is_email_confirmed: true,profile: { display_name: 'bob', email: '[email protected]' },@@ -115,6 +117,26 @@ describe('slackSearchUsersHandler', () => {});});+ it('should leave a Slack Connect account email out of the option', async () => {+ usersListMock.mockResolvedValue({+ members: [{ ...ADA, team_id: 'T0OTHER' }],+ });++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ expect(result).toEqual({+ success: true,+ slackUsers: [+ {+ slackUserId: 'U0ADA',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'ada',+ email: undefined,+ },+ ],+ });+ });+it('should leave an unconfirmed profile email out of the option', async () => {usersListMock.mockResolvedValue({members: [{ ...ADA, is_email_confirmed: false }],diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-user-link-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-user-link-handler.test.tsindex 54c958a2de3..62363483ee1 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-user-link-handler.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-user-link-handler.test.ts@@ -9,7 +9,7 @@ const {authTestMock,doesWorkspaceMemberExistMock,findSlackUserLinkMock,- findDeletedSlackUserLinkIdMock,+ findDeletedSlackUserLinkIdsMock,createSlackUserLinkMock,updateSlackUserLinkMock,destroySlackUserLinkMock,@@ -25,7 +25,7 @@ const {authTestMock: vi.fn(),doesWorkspaceMemberExistMock: vi.fn(),findSlackUserLinkMock: vi.fn(),- findDeletedSlackUserLinkIdMock: vi.fn(),+ findDeletedSlackUserLinkIdsMock: vi.fn(),createSlackUserLinkMock: vi.fn(),updateSlackUserLinkMock: vi.fn(),destroySlackUserLinkMock: vi.fn(),@@ -64,8 +64,8 @@ vi.mock('src/logic-functions/data/find-slack-user-link', () => ({findSlackUserLink: findSlackUserLinkMock,}));-vi.mock('src/logic-functions/data/find-deleted-slack-user-link-id', () => ({- findDeletedSlackUserLinkId: findDeletedSlackUserLinkIdMock,+vi.mock('src/logic-functions/data/find-deleted-slack-user-link-ids', () => ({+ findDeletedSlackUserLinkIds: findDeletedSlackUserLinkIdsMock,}));vi.mock('src/logic-functions/data/create-slack-user-link', () => ({@@ -110,7 +110,7 @@ describe('slackSetUserLinkHandler', () => {authTestMock.mockResolvedValue({ team_id: INSTALLED_TEAM_ID });doesWorkspaceMemberExistMock.mockResolvedValue(true);findSlackUserLinkMock.mockResolvedValue(undefined);- findDeletedSlackUserLinkIdMock.mockResolvedValue(undefined);+ findDeletedSlackUserLinkIdsMock.mockResolvedValue([]);createSlackUserLinkMock.mockResolvedValue('link-new');fetchSlackUserIdentityMock.mockResolvedValue({slackUserId: INPUT.slackUserId,@@ -133,7 +133,7 @@ describe('slackSetUserLinkHandler', () => {});it('should destroy a soft-deleted ghost link before creating the same tuple', async () => {- findDeletedSlackUserLinkIdMock.mockResolvedValue('link-ghost');+ findDeletedSlackUserLinkIdsMock.mockResolvedValue(['link-ghost']);const result = await slackSetUserLinkHandler(INPUT);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-connection-status-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-connection-status-handler.tsnew file mode 100644index 00000000000..cd40e8884be--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-connection-status-handler.ts@@ -0,0 +1,13 @@+import { getSlackConnection } from 'src/logic-functions/utils/get-slack-connection';++type SlackConnectionStatusResult = {+ success: true;+ isConnected: boolean;+};++export const slackConnectionStatusHandler =+ async (): Promise<SlackConnectionStatusResult> => {+ const connection = await getSlackConnection();++ return { success: true, isConnected: connection.success };+ };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-list-unlinked-users-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-list-unlinked-users-handler.tsnew file mode 100644index 00000000000..744da796b1b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-list-unlinked-users-handler.ts@@ -0,0 +1,80 @@+import { CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { listLinkedSlackUserIds } from 'src/logic-functions/data/list-linked-slack-user-ids';+import { type SlackUnlinkedUsersResult } from 'src/logic-functions/types/slack-unlinked-users.type';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { collectSlackRosterMembers } from 'src/logic-functions/utils/collect-slack-roster-members';+import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';+import { toSlackUserSearchOption } from 'src/logic-functions/utils/to-slack-user-search-option';++const MAX_UNLINKED_RESULTS = 20;++export const slackListUnlinkedUsersHandler =+ async (): Promise<SlackUnlinkedUsersResult> => {+ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error:+ 'Only members with the roles permission can list unlinked Slack users.',+ };+ }++ const slackClientResult = await getSlackClient();++ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }++ const slackClient = slackClientResult.client;++ const installedTeamId = await getInstalledSlackTeamId(slackClient);++ if (!isDefined(installedTeamId)) {+ return {+ success: false,+ message: 'Could not verify the installed Slack workspace',+ error:+ 'Slack did not confirm the installed workspace. Please try again.',+ };+ }++ try {+ const linkedSlackUserIds = await listLinkedSlackUserIds(+ new CoreApiClient({ runAs: 'application' }),+ { slackTeamId: installedTeamId },+ );++ const { members, isTruncated } = await collectSlackRosterMembers({+ slackClient,+ shouldCollectMember: (member) => !linkedSlackUserIds.has(member.id),+ maxMembers: MAX_UNLINKED_RESULTS,+ });++ return {+ success: true,+ slackUsers: members.map((member) =>+ toSlackUserSearchOption({+ member,+ installedSlackTeamId: installedTeamId,+ }),+ ),+ hasMore: isTruncated,+ };+ } catch (error) {+ return {+ success: false,+ message: 'Could not list unlinked Slack users',+ error: toErrorMessage(error),+ };+ }+ };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-match-user-links-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-match-user-links-handler.tsnew file mode 100644index 00000000000..c7c50f3e3ff--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-match-user-links-handler.ts@@ -0,0 +1,65 @@+import { isDefined } from 'twenty-sdk/utils';++import { type SlackRosterMatchResult } from 'src/logic-functions/types/slack-roster-match.type';+import { buildSlackRosterMatchMessage } from 'src/logic-functions/utils/build-slack-roster-match-message';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { matchSlackRosterByEmail } from 'src/logic-functions/utils/match-slack-roster-by-email';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++export const slackMatchUserLinksHandler =+ async (): Promise<SlackRosterMatchResult> => {+ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error:+ 'Only members with the roles permission can match Slack users to workspace members.',+ };+ }++ const slackClientResult = await getSlackClient();++ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }++ const slackClient = slackClientResult.client;++ const installedTeamId = await getInstalledSlackTeamId(slackClient);++ if (!isDefined(installedTeamId)) {+ return {+ success: false,+ message: 'Could not verify the installed Slack workspace',+ error:+ 'Slack did not confirm the installed workspace. Please try again.',+ };+ }++ try {+ const summary = await matchSlackRosterByEmail({+ slackClient,+ slackTeamId: installedTeamId,+ });++ return {+ success: true,+ message: buildSlackRosterMatchMessage(summary),+ ...summary,+ };+ } catch (error) {+ return {+ success: false,+ message: 'Could not match Slack users',+ error: toErrorMessage(error),+ };+ }+ };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-users-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-users-handler.tsindex 1936e14eee9..73e47bca49d 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-users-handler.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-users-handler.ts@@ -1,42 +1,25 @@-import { type WebClient } from '@slack/web-api';import { isNonEmptyString } from '@sniptt/guards';import { isDefined } from 'twenty-sdk/utils';import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';-import {- type SlackUserSearchOption,- type SlackUserSearchResult,-} from 'src/logic-functions/types/slack-user-search.type';+import { type LinkableSlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { type SlackUserSearchResult } from 'src/logic-functions/types/slack-user-search.type';import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { collectSlackRosterMembers } from 'src/logic-functions/utils/collect-slack-roster-members';import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';+import { toSlackUserSearchOption } from 'src/logic-functions/utils/to-slack-user-search-option';-const SLACKBOT_USER_ID = 'USLACKBOT';const MAX_RESULTS = 10;-const PAGE_SIZE = 200;const MAX_PAGES = 3;-type SlackRosterMember = {- id?: string;- is_bot?: boolean;- deleted?: boolean;- is_restricted?: boolean;- is_ultra_restricted?: boolean;- is_email_confirmed?: boolean;- real_name?: string;- profile?: { display_name?: string; email?: string };-};--const isLinkableRosterMember = (member: SlackRosterMember): boolean =>- isNonEmptyString(member.id) &&- member.id !== SLACKBOT_USER_ID &&- member.is_bot !== true &&- member.deleted !== true;--const matchesQuery = (member: SlackRosterMember, query: string): boolean =>+const matchesQuery = (+ member: LinkableSlackRosterMember,+ query: string,+): boolean =>[member.real_name,member.profile?.display_name,@@ -46,60 +29,6 @@ const matchesQuery = (member: SlackRosterMember, query: string): boolean =>(value) => isNonEmptyString(value) && value.toLowerCase().includes(query),);-const isEmailVouchedForOwner = (member: SlackRosterMember): boolean =>- member.is_restricted !== true &&- member.is_ultra_restricted !== true &&- member.is_email_confirmed === true;--const toSearchOption = (- member: SlackRosterMember,- slackTeamId: string,-): SlackUserSearchOption => ({- slackUserId: member.id ?? '',- slackTeamId,- displayName: [member.profile?.display_name, member.real_name].find(- isNonEmptyString,- ),- email:- isEmailVouchedForOwner(member) && isNonEmptyString(member.profile?.email)- ? member.profile.email- : undefined,-});--const collectMatches = async (- slackClient: WebClient,- query: string,- slackTeamId: string,-): Promise<SlackUserSearchOption[]> => {- const matches: SlackUserSearchOption[] = [];- let cursor: string | undefined;-- for (let page = 0; page < MAX_PAGES; page += 1) {- const response = await slackClient.users.list({- limit: PAGE_SIZE,- cursor,- });-- for (const member of response.members ?? []) {- if (isLinkableRosterMember(member) && matchesQuery(member, query)) {- matches.push(toSearchOption(member, slackTeamId));-- if (matches.length >= MAX_RESULTS) {- return matches;- }- }- }-- cursor = response.response_metadata?.next_cursor;-- if (!isNonEmptyString(cursor)) {- break;- }- }-- return matches;-};-export const slackSearchUsersHandler = async (payload: SlackRouteBody,): Promise<SlackUserSearchResult> => {@@ -143,9 +72,21 @@ export const slackSearchUsersHandler = async (}try {+ const { members } = await collectSlackRosterMembers({+ slackClient,+ shouldCollectMember: (member) => matchesQuery(member, query),+ maxMembers: MAX_RESULTS,+ maxPages: MAX_PAGES,+ });+return {success: true,- slackUsers: await collectMatches(slackClient, query, installedTeamId),+ slackUsers: members.map((member) =>+ toSlackUserSearchOption({+ member,+ installedSlackTeamId: installedTeamId,+ }),+ ),};} catch (error) {return {diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-connection-status.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-connection-status.tsnew file mode 100644index 00000000000..99dae59e9cb--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-connection-status.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_CONNECTION_STATUS_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_CONNECTION_STATUS_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackConnectionStatusHandler } from 'src/logic-functions/handlers/slack-connection-status-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_CONNECTION_STATUS_UNIVERSAL_IDENTIFIER,+ name: 'slack-connection-status',+ description:+ 'Tells the settings tab whether a Slack workspace connection exists, so it can hide the link management tools until Slack is connected.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_CONNECTION_STATUS_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackConnectionStatusHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-list-unlinked-users.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-list-unlinked-users.tsnew file mode 100644index 00000000000..bdb1a7685d2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-list-unlinked-users.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_UNLINKED_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_LIST_UNLINKED_USERS_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackListUnlinkedUsersHandler } from 'src/logic-functions/handlers/slack-list-unlinked-users-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_LIST_UNLINKED_USERS_UNIVERSAL_IDENTIFIER,+ name: 'slack-list-unlinked-users',+ description:+ 'Lists Slack workspace users that have no Slack user link yet so an admin can link them manually. Restricted to members with the roles permission.',+ timeoutSeconds: 60,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_UNLINKED_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackListUnlinkedUsersHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-match-user-links.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-match-user-links.tsnew file mode 100644index 00000000000..edb821d8aa6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-match-user-links.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_MATCH_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_MATCH_USER_LINKS_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackMatchUserLinksHandler } from 'src/logic-functions/handlers/slack-match-user-links-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_MATCH_USER_LINKS_UNIVERSAL_IDENTIFIER,+ name: 'slack-match-user-links',+ description:+ 'Matches every Slack workspace user against workspace members by verified email and stores the resulting links. Restricted to members with the roles permission.',+ timeoutSeconds: 120,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_MATCH_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackMatchUserLinksHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-register-connection.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-register-connection.tsindex e88a9801b4a..c2b4aba6056 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/slack-register-connection.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-register-connection.ts@@ -7,7 +7,7 @@ export default defineLogicFunction({universalIdentifier: SLACK_REGISTER_CONNECTION_UNIVERSAL_IDENTIFIER,name: 'slack-register-connection',description:- 'Runs when a Slack connection is established (via the connection provider onConnect hook). Resolves the Slack team_id for the just-created connection via auth.test and stores this workspace id under the server-scoped slack-team:<team_id> key so inbound Slack events route here. Records the same team under slack-connected-account-team:<connected_account_id> so the disconnect hook can release the claim once the connection is gone. Caches the bot user id from the same auth.test under slack-bot-user-id so the channel welcome can recognise the bot without calling Slack on every join event.',- timeoutSeconds: 30,+ 'Runs when a Slack connection is established (via the connection provider onConnect hook). Resolves the Slack team_id for the just-created connection via auth.test and stores this workspace id under the server-scoped slack-team:<team_id> key so inbound Slack events route here. Records the same team under slack-connected-account-team:<connected_account_id> so the disconnect hook can release the claim once the connection is gone. Caches the bot user id from the same auth.test under slack-bot-user-id so the channel welcome can recognise the bot without calling Slack on every join event. Links the installer and then sweeps the Slack roster for members whose confirmed email matches a workspace member, which is why this hook needs the same budget as the on-demand match route.',+ timeoutSeconds: 120,handler: slackRegisterConnectionHandler,});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-match.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-match.type.tsnew file mode 100644index 00000000000..ef574509ced--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-match.type.ts@@ -0,0 +1,24 @@+export type SlackRosterMatchCandidate = {+ slackUserId: string;+ workspaceMemberId: string;+ displayName: string | undefined;+};++export type SlackRosterMatchPlan = {+ candidates: SlackRosterMatchCandidate[];+ alreadyLinkedCount: number;+ unmatchedCount: number;+};++export type SlackRosterMatchSummary = {+ linkedCount: number;+ alreadyLinkedCount: number;+ unmatchedCount: number;+ ambiguousEmailCount: number;+ failedCount: number;+ isRosterTruncated: boolean;+};++export type SlackRosterMatchResult =+ | ({ success: true; message: string } & SlackRosterMatchSummary)+ | { success: false; message: string; error: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-member.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-member.type.tsnew file mode 100644index 00000000000..5b3a152256f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-roster-member.type.ts@@ -0,0 +1,14 @@+export type SlackRosterMember = {+ id?: string;+ team_id?: string;+ is_bot?: boolean;+ deleted?: boolean;+ is_restricted?: boolean;+ is_ultra_restricted?: boolean;+ is_stranger?: boolean;+ is_email_confirmed?: boolean;+ real_name?: string;+ profile?: { display_name?: string; email?: string };+};++export type LinkableSlackRosterMember = SlackRosterMember & { id: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-unlinked-users.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-unlinked-users.type.tsnew file mode 100644index 00000000000..0e24a68fd5f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-unlinked-users.type.ts@@ -0,0 +1,5 @@+import { type SlackUserSearchOption } from 'src/logic-functions/types/slack-user-search.type';++export type SlackUnlinkedUsersResult =+ | { success: true; slackUsers: SlackUserSearchOption[]; hasMore: boolean }+ | { success: false; message: string; error: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-draft.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-draft.type.tsnew file mode 100644index 00000000000..c73d9ac2d0c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-draft.type.ts@@ -0,0 +1,11 @@+import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';+import { type SlackUserLinkSource } from 'src/logic-functions/types/slack-user-link-source.type';++export type SlackUserLinkDraft = {+ slackTeamId: string;+ slackUserId: string;+ workspaceMemberId: string;+ name: string;+ source: SlackUserLinkSource;+ consentState: SlackUserLinkConsentState;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-roster-match-message.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-roster-match-message.test.tsnew file mode 100644index 00000000000..9c970512b91--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-roster-match-message.test.ts@@ -0,0 +1,54 @@+import { describe, expect, it } from 'vitest';++import { type SlackRosterMatchSummary } from 'src/logic-functions/types/slack-roster-match.type';+import { buildSlackRosterMatchMessage } from 'src/logic-functions/utils/build-slack-roster-match-message';++const buildSummary = (+ summary: Partial<SlackRosterMatchSummary>,+): SlackRosterMatchSummary => ({+ linkedCount: 0,+ alreadyLinkedCount: 0,+ unmatchedCount: 0,+ ambiguousEmailCount: 0,+ failedCount: 0,+ isRosterTruncated: false,+ ...summary,+});++describe('buildSlackRosterMatchMessage', () => {+ it('should report a clean run with nothing else to say', () => {+ expect(buildSlackRosterMatchMessage(buildSummary({ linkedCount: 2 }))).toBe(+ 'Matched 2 Slack users by email.',+ );+ });++ it('should keep the count singular for a single match', () => {+ expect(buildSlackRosterMatchMessage(buildSummary({ linkedCount: 1 }))).toBe(+ 'Matched 1 Slack user by email.',+ );+ });++ it('should mention every non-zero tally', () => {+ expect(+ buildSlackRosterMatchMessage(+ buildSummary({+ linkedCount: 3,+ alreadyLinkedCount: 4,+ unmatchedCount: 5,+ ambiguousEmailCount: 2,+ failedCount: 1,+ }),+ ),+ ).toBe(+ 'Matched 3 Slack users by email. 4 already linked. 5 without a matching member email. 2 skipped because their email belongs to more than one workspace member. 1 could not be linked; try the match again.',+ );+ });++ it('should warn that the roster was only partly scanned', () => {+ expect(+ buildSlackRosterMatchMessage(buildSummary({ isRosterTruncated: true })),+ ).toBe(+ 'Matched 0 Slack users by email. The Slack roster is too large to scan in one pass, so some users were not checked.',+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/collect-slack-roster-members.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/collect-slack-roster-members.test.tsnew file mode 100644index 00000000000..1f1e5bcd1d5--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/collect-slack-roster-members.test.ts@@ -0,0 +1,133 @@+import { type WebClient } from '@slack/web-api';+import { describe, expect, it, vi } from 'vitest';++import { type SlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { collectSlackRosterMembers } from 'src/logic-functions/utils/collect-slack-roster-members';++const buildSlackClient = (+ pages: { members: SlackRosterMember[]; nextCursor?: string }[],+) => {+ const usersListMock = vi.fn();++ for (const page of pages) {+ usersListMock.mockResolvedValueOnce({+ members: page.members,+ response_metadata: { next_cursor: page.nextCursor },+ });+ }++ return {+ slackClient: { users: { list: usersListMock } } as unknown as WebClient,+ usersListMock,+ };+};++describe('collectSlackRosterMembers', () => {+ it('should collect only linkable members', async () => {+ const { slackClient } = buildSlackClient([+ {+ members: [+ { id: 'U1' },+ { id: 'U-bot', is_bot: true },+ { id: 'USLACKBOT' },+ { id: 'U2' },+ ],+ },+ ]);++ const { members, isTruncated } = await collectSlackRosterMembers({+ slackClient,+ });++ expect(members.map((member) => member.id)).toEqual(['U1', 'U2']);+ expect(isTruncated).toBe(false);+ });++ it('should keep only the members the caller asks for', async () => {+ const { slackClient } = buildSlackClient([+ { members: [{ id: 'U1' }, { id: 'U2' }, { id: 'U3' }] },+ ]);++ const { members } = await collectSlackRosterMembers({+ slackClient,+ shouldCollectMember: (member) => member.id !== 'U2',+ });++ expect(members.map((member) => member.id)).toEqual(['U1', 'U3']);+ });++ it('should keep a member Slack repeats across pages only once', async () => {+ const { slackClient } = buildSlackClient([+ { members: [{ id: 'U1' }, { id: 'U2' }], nextCursor: 'cursor-2' },+ { members: [{ id: 'U2' }, { id: 'U3' }] },+ ]);++ const { members } = await collectSlackRosterMembers({ slackClient });++ expect(members.map((member) => member.id)).toEqual(['U1', 'U2', 'U3']);+ });++ it('should follow pagination cursors', async () => {+ const { slackClient, usersListMock } = buildSlackClient([+ { members: [{ id: 'U1' }], nextCursor: 'cursor-2' },+ { members: [{ id: 'U2' }] },+ ]);++ const { members, isTruncated } = await collectSlackRosterMembers({+ slackClient,+ });++ expect(members.map((member) => member.id)).toEqual(['U1', 'U2']);+ expect(isTruncated).toBe(false);+ expect(usersListMock).toHaveBeenNthCalledWith(2, {+ limit: 200,+ cursor: 'cursor-2',+ });+ });++ it('should stop paging and report truncation once the member cap is reached', async () => {+ const { slackClient, usersListMock } = buildSlackClient([+ { members: [{ id: 'U1' }, { id: 'U2' }], nextCursor: 'cursor-2' },+ ]);++ const { members, isTruncated } = await collectSlackRosterMembers({+ slackClient,+ maxMembers: 1,+ });++ expect(members.map((member) => member.id)).toEqual(['U1']);+ expect(isTruncated).toBe(true);+ expect(usersListMock).toHaveBeenCalledTimes(1);+ });++ it('should report truncation when the page cap is reached', async () => {+ const { slackClient, usersListMock } = buildSlackClient(+ Array.from({ length: 6 }, (_, index) => ({+ members: [{ id: `U${index}` }],+ nextCursor: `cursor-${index + 1}`,+ })),+ );++ const { isTruncated } = await collectSlackRosterMembers({ slackClient });++ expect(isTruncated).toBe(true);+ expect(usersListMock).toHaveBeenCalledTimes(5);+ });++ it('should honor a lower page cap', async () => {+ const { slackClient, usersListMock } = buildSlackClient(+ Array.from({ length: 4 }, (_, index) => ({+ members: [{ id: `U${index}` }],+ nextCursor: `cursor-${index + 1}`,+ })),+ );++ const { isTruncated } = await collectSlackRosterMembers({+ slackClient,+ maxPages: 2,+ });++ expect(isTruncated).toBe(true);+ expect(usersListMock).toHaveBeenCalledTimes(2);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/escape-sql-like-pattern.util.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/escape-sql-like-pattern.util.test.tsnew file mode 100644index 00000000000..aa5974f40b9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/escape-sql-like-pattern.util.test.ts@@ -0,0 +1,19 @@+import { describe, expect, it } from 'vitest';++import { escapeSqlLikePattern } from 'src/logic-functions/utils/escape-sql-like-pattern.util';++describe('escapeSqlLikePattern', () => {+ it('should leave a plain email untouched', () => {+ expect(escapeSqlLikePattern('[email protected]')).toBe('[email protected]');+ });++ it('should escape underscores', () => {+ expect(escapeSqlLikePattern('[email protected]')).toBe(+ 'john\\[email protected]',+ );+ });++ it('should escape percent signs and backslashes', () => {+ expect(escapeSqlLikePattern('a%b\\c')).toBe('a\\%b\\\\c');+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-roster-member-display-name.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-roster-member-display-name.test.tsnew file mode 100644index 00000000000..d52c3a6ee2d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-slack-roster-member-display-name.test.ts@@ -0,0 +1,27 @@+import { describe, expect, it } from 'vitest';++import { getSlackRosterMemberDisplayName } from 'src/logic-functions/utils/get-slack-roster-member-display-name';++describe('getSlackRosterMemberDisplayName', () => {+ it('should prefer the profile display name', () => {+ expect(+ getSlackRosterMemberDisplayName({+ real_name: 'Ada Lovelace',+ profile: { display_name: 'ada' },+ }),+ ).toBe('ada');+ });++ it('should fall back to the real name', () => {+ expect(+ getSlackRosterMemberDisplayName({+ real_name: 'Ada Lovelace',+ profile: { display_name: '' },+ }),+ ).toBe('Ada Lovelace');+ });++ it('should return undefined when no name is set', () => {+ expect(getSlackRosterMemberDisplayName({})).toBeUndefined();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-vouched-slack-roster-email.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-vouched-slack-roster-email.test.tsnew file mode 100644index 00000000000..243ed9411fb--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/get-vouched-slack-roster-email.test.ts@@ -0,0 +1,60 @@+import { describe, expect, it } from 'vitest';++import { type SlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { getVouchedSlackRosterEmail } from 'src/logic-functions/utils/get-vouched-slack-roster-email';++const INSTALLED_TEAM_ID = 'T-installed';++const vouchedMember: SlackRosterMember = {+ team_id: INSTALLED_TEAM_ID,+ is_email_confirmed: true,+ profile: { email: '[email protected]' },+};++const getEmail = (member: SlackRosterMember) =>+ getVouchedSlackRosterEmail({+ member,+ installedSlackTeamId: INSTALLED_TEAM_ID,+ });++describe('getVouchedSlackRosterEmail', () => {+ it('should return the email of a full member of the installed workspace', () => {+ expect(getEmail(vouchedMember)).toBe('[email protected]');+ });++ it('should reject an unconfirmed email', () => {+ expect(+ getEmail({ ...vouchedMember, is_email_confirmed: false }),+ ).toBeUndefined();+ expect(+ getEmail({+ team_id: INSTALLED_TEAM_ID,+ profile: { email: '[email protected]' },+ }),+ ).toBeUndefined();+ });++ it('should reject guests even with a confirmed email', () => {+ expect(getEmail({ ...vouchedMember, is_restricted: true })).toBeUndefined();+ expect(+ getEmail({ ...vouchedMember, is_ultra_restricted: true }),+ ).toBeUndefined();+ });++ it('should reject accounts from another Slack workspace', () => {+ expect(getEmail({ ...vouchedMember, team_id: 'T-other' })).toBeUndefined();+ expect(+ getEmail({+ is_email_confirmed: true,+ profile: { email: '[email protected]' },+ }),+ ).toBeUndefined();+ expect(getEmail({ ...vouchedMember, is_stranger: true })).toBeUndefined();+ });++ it('should return undefined when the vouched member has no email', () => {+ expect(+ getEmail({ team_id: INSTALLED_TEAM_ID, is_email_confirmed: true }),+ ).toBeUndefined();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-linkable-slack-roster-member.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-linkable-slack-roster-member.test.tsnew file mode 100644index 00000000000..7054d1fde24--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-linkable-slack-roster-member.test.ts@@ -0,0 +1,27 @@+import { describe, expect, it } from 'vitest';++import { isLinkableSlackRosterMember } from 'src/logic-functions/utils/is-linkable-slack-roster-member';++describe('isLinkableSlackRosterMember', () => {+ it('should accept a plain human member', () => {+ expect(isLinkableSlackRosterMember({ id: 'U1' })).toBe(true);+ });++ it('should reject a member without an id', () => {+ expect(isLinkableSlackRosterMember({})).toBe(false);+ });++ it('should reject Slackbot', () => {+ expect(isLinkableSlackRosterMember({ id: 'USLACKBOT' })).toBe(false);+ });++ it('should reject bots', () => {+ expect(isLinkableSlackRosterMember({ id: 'U1', is_bot: true })).toBe(false);+ });++ it('should reject deactivated members', () => {+ expect(isLinkableSlackRosterMember({ id: 'U1', deleted: true })).toBe(+ false,+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/link-slack-roster-candidates.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/link-slack-roster-candidates.test.tsnew file mode 100644index 00000000000..ba4be6640e8--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/link-slack-roster-candidates.test.ts@@ -0,0 +1,330 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { type SlackRosterMatchCandidate } from 'src/logic-functions/types/slack-roster-match.type';+import { linkSlackRosterCandidates } from 'src/logic-functions/utils/link-slack-roster-candidates';++const {+ createSlackUserLinksMock,+ destroySlackUserLinksMock,+ findDeletedSlackUserLinkIdsMock,+ listLinkedSlackUserIdsMock,+ createSlackUserLinkMock,+} = vi.hoisted(() => ({+ createSlackUserLinksMock: vi.fn(),+ destroySlackUserLinksMock: vi.fn(),+ findDeletedSlackUserLinkIdsMock: vi.fn(),+ listLinkedSlackUserIdsMock: vi.fn(),+ createSlackUserLinkMock: vi.fn(),+}));++vi.mock('src/logic-functions/data/create-slack-user-links', () => ({+ createSlackUserLinks: createSlackUserLinksMock,+}));++vi.mock('src/logic-functions/data/destroy-slack-user-links', () => ({+ destroySlackUserLinks: destroySlackUserLinksMock,+}));++vi.mock('src/logic-functions/data/find-deleted-slack-user-link-ids', () => ({+ findDeletedSlackUserLinkIds: findDeletedSlackUserLinkIdsMock,+}));++vi.mock('src/logic-functions/data/list-linked-slack-user-ids', () => ({+ listLinkedSlackUserIds: listLinkedSlackUserIdsMock,+}));++vi.mock('src/logic-functions/data/create-slack-user-link', () => ({+ createSlackUserLink: createSlackUserLinkMock,+}));++const SLACK_TEAM_ID = 'T-installed';+const client = {} as CoreApiClient;++const candidate = (+ slackUserId: string,+ displayName?: string,+): SlackRosterMatchCandidate => ({+ slackUserId,+ workspaceMemberId: `member-${slackUserId}`,+ displayName,+});++describe('linkSlackRosterCandidates', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ findDeletedSlackUserLinkIdsMock.mockResolvedValue([]);+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set());+ createSlackUserLinkMock.mockResolvedValue('link-new');+ });++ it('should create every candidate in one call', async () => {+ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1', 'Ada'), candidate('U2', 'Grace')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock).toHaveBeenCalledTimes(1);+ expect(createSlackUserLinksMock).toHaveBeenCalledWith(client, {+ drafts: [+ {+ slackTeamId: SLACK_TEAM_ID,+ slackUserId: 'U1',+ workspaceMemberId: 'member-U1',+ name: 'Ada',+ source: 'AUTO',+ consentState: 'ACTIVE',+ },+ {+ slackTeamId: SLACK_TEAM_ID,+ slackUserId: 'U2',+ workspaceMemberId: 'member-U2',+ name: 'Grace',+ source: 'AUTO',+ consentState: 'ACTIVE',+ },+ ],+ });+ expect(outcome).toEqual({ linkedCount: 2, failedCount: 0 });+ });++ it('should fall back to the Slack user id when the roster has no display name', async () => {+ await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock.mock.calls[0][1].drafts[0].name).toBe('U1');+ });++ it('should clear a soft-deleted link before creating', async () => {+ findDeletedSlackUserLinkIdsMock.mockResolvedValue(['deleted-link']);++ await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(findDeletedSlackUserLinkIdsMock).toHaveBeenCalledWith(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1'],+ });+ expect(destroySlackUserLinksMock).toHaveBeenCalledWith(client, {+ ids: ['deleted-link'],+ });+ });++ it('should not call destroy when nothing was soft-deleted', async () => {+ await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(destroySlackUserLinksMock).not.toHaveBeenCalled();+ });++ it('should touch nothing when there is no candidate', async () => {+ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(findDeletedSlackUserLinkIdsMock).not.toHaveBeenCalled();+ expect(createSlackUserLinksMock).not.toHaveBeenCalled();+ expect(outcome).toEqual({ linkedCount: 0, failedCount: 0 });+ });++ it('should link one at a time and count the failure when the batch fails', async () => {+ createSlackUserLinksMock.mockRejectedValue(new Error('batch failed'));+ createSlackUserLinkMock+ .mockRejectedValueOnce(new Error('write failed'))+ .mockResolvedValueOnce('link-new');++ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1'), candidate('U2')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(2);+ expect(outcome).toEqual({ linkedCount: 1, failedCount: 1 });+ });++ it('should count candidates the failed batch already wrote as linked, not failed', async () => {+ createSlackUserLinksMock.mockRejectedValue(new Error('batch failed'));+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set(['U1']));++ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1'), candidate('U2')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(1);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ client,+ expect.objectContaining({ slackUserId: 'U2' }),+ );+ expect(outcome).toEqual({ linkedCount: 2, failedCount: 0 });+ });++ it('should stop retrying one at a time once a second batch fails', async () => {+ createSlackUserLinksMock.mockRejectedValue(new Error('batch failed'));+ createSlackUserLinkMock.mockRejectedValue(new Error('write failed'));++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock).toHaveBeenCalledTimes(2);+ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(200);+ expect(outcome).toEqual({ linkedCount: 0, failedCount: 400 });+ });++ it('should keep the one-at-a-time budget when the first batches succeed', async () => {+ createSlackUserLinksMock+ .mockResolvedValueOnce(undefined)+ .mockRejectedValueOnce(new Error('batch failed'));++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(200);+ expect(outcome).toEqual({ linkedCount: 400, failedCount: 0 });+ });++ it('should count rows a given-up batch already wrote as linked', async () => {+ createSlackUserLinksMock.mockRejectedValue(new Error('batch failed'));+ createSlackUserLinkMock.mockRejectedValue(new Error('write failed'));+ listLinkedSlackUserIdsMock.mockImplementation(+ async (_client, { slackUserIds }) =>+ new Set(+ slackUserIds.filter((slackUserId: string) => slackUserId === 'U399'),+ ),+ );++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(200);+ expect(outcome).toEqual({ linkedCount: 1, failedCount: 399 });+ });++ it('should keep earlier batches when the reconciliation read fails', async () => {+ createSlackUserLinksMock+ .mockResolvedValueOnce(undefined)+ .mockRejectedValueOnce(new Error('batch failed'));+ listLinkedSlackUserIdsMock.mockRejectedValue(new Error('read failed'));++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(outcome).toEqual({ linkedCount: 200, failedCount: 200 });+ });++ it('should write a Slack user repeated by the roster only once', async () => {+ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1', 'Ada'), candidate('U1', 'Ada')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock.mock.calls[0][1].drafts).toHaveLength(1);+ expect(findDeletedSlackUserLinkIdsMock).toHaveBeenCalledWith(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserIds: ['U1'],+ });+ expect(outcome).toEqual({ linkedCount: 1, failedCount: 0 });+ });++ it('should clear soft-deleted links per batch, not for the whole set up front', async () => {+ findDeletedSlackUserLinkIdsMock.mockResolvedValue(['deleted-link']);++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(findDeletedSlackUserLinkIdsMock).toHaveBeenCalledTimes(2);+ expect(+ findDeletedSlackUserLinkIdsMock.mock.calls[0][1].slackUserIds,+ ).toHaveLength(200);+ expect(destroySlackUserLinksMock).toHaveBeenCalledTimes(2);+ });++ it('should not attempt creates or spend the retry budget when the cleanup fails', async () => {+ findDeletedSlackUserLinkIdsMock+ .mockRejectedValueOnce(new Error('cleanup failed'))+ .mockResolvedValue([]);+ createSlackUserLinksMock.mockRejectedValueOnce(new Error('batch failed'));++ const candidates = Array.from({ length: 400 }, (_, index) =>+ candidate(`U${index}`),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock).toHaveBeenCalledTimes(1);+ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(200);+ expect(outcome).toEqual({ linkedCount: 200, failedCount: 200 });+ });++ it('should credit a concurrent sweep when the cleanup fails', async () => {+ findDeletedSlackUserLinkIdsMock.mockRejectedValue(+ new Error('cleanup failed'),+ );+ listLinkedSlackUserIdsMock.mockImplementation(+ async (_client, { slackUserIds }) =>+ new Set(+ slackUserIds.filter((slackUserId: string) => slackUserId === 'U1'),+ ),+ );++ const outcome = await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1'), candidate('U2')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(outcome).toEqual({ linkedCount: 1, failedCount: 1 });+ });++ it('should never upsert, so a declined or manual link is never overwritten', async () => {+ await linkSlackRosterCandidates(client, {+ candidates: [candidate('U1')],+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(createSlackUserLinksMock.mock.calls[0][1]).not.toHaveProperty(+ 'upsert',+ );+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/match-slack-roster-by-email.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/match-slack-roster-by-email.test.tsnew file mode 100644index 00000000000..86d0d4baeec--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/match-slack-roster-by-email.test.ts@@ -0,0 +1,280 @@+import { type WebClient } from '@slack/web-api';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { matchSlackRosterByEmail } from 'src/logic-functions/utils/match-slack-roster-by-email';+import { type SlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';++const {+ coreApiClientMock,+ findWorkspaceMemberIdsByEmailsMock,+ listLinkedSlackUserIdsMock,+ linkSlackRosterCandidatesMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ findWorkspaceMemberIdsByEmailsMock: vi.fn(),+ listLinkedSlackUserIdsMock: vi.fn(),+ linkSlackRosterCandidatesMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/find-workspace-member-ids-by-emails', () => ({+ findWorkspaceMemberIdsByEmails: findWorkspaceMemberIdsByEmailsMock,+}));++vi.mock('src/logic-functions/data/list-linked-slack-user-ids', () => ({+ listLinkedSlackUserIds: listLinkedSlackUserIdsMock,+}));++vi.mock('src/logic-functions/utils/link-slack-roster-candidates', () => ({+ linkSlackRosterCandidates: linkSlackRosterCandidatesMock,+}));++const SLACK_TEAM_ID = 'T-installed';++const buildSlackClient = (members: SlackRosterMember[]): WebClient =>+ ({+ users: {+ list: vi.fn().mockResolvedValue({+ members,+ response_metadata: { next_cursor: undefined },+ }),+ },+ }) as unknown as WebClient;++const fullMember = ({+ id,+ email,+ displayName,+}: {+ id: string;+ email?: string;+ displayName?: string;+}): SlackRosterMember => ({+ id,+ team_id: SLACK_TEAM_ID,+ is_email_confirmed: true,+ real_name: displayName,+ profile: { email, display_name: displayName },+});++const linkedCandidates = () =>+ linkSlackRosterCandidatesMock.mock.calls[0][1].candidates;++describe('matchSlackRosterByEmail', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ findWorkspaceMemberIdsByEmailsMock.mockResolvedValue({+ workspaceMemberIdByEmail: new Map([['[email protected]', 'member-ada']]),+ ambiguousEmailCount: 0,+ });+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set());+ linkSlackRosterCandidatesMock.mockImplementation(+ async (_client, { candidates }) => ({+ linkedCount: candidates.length,+ failedCount: 0,+ }),+ );+ });++ it('should link a roster member whose email matches a workspace member', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]', displayName: 'Ada' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkSlackRosterCandidatesMock).toHaveBeenCalledWith(+ expect.anything(),+ {+ slackTeamId: SLACK_TEAM_ID,+ candidates: [+ {+ slackUserId: 'U1',+ workspaceMemberId: 'member-ada',+ displayName: 'Ada',+ },+ ],+ },+ );+ expect(summary).toEqual({+ linkedCount: 1,+ alreadyLinkedCount: 0,+ unmatchedCount: 0,+ ambiguousEmailCount: 0,+ failedCount: 0,+ isRosterTruncated: false,+ });+ });++ it('should match emails case-insensitively', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(summary.linkedCount).toBe(1);+ });++ it('should skip roster members that already have a link of any state', async () => {+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set(['U1']));++ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toEqual([]);+ expect(summary).toEqual({+ linkedCount: 0,+ alreadyLinkedCount: 1,+ unmatchedCount: 0,+ ambiguousEmailCount: 0,+ failedCount: 0,+ isRosterTruncated: false,+ });+ });++ it('should count a roster member with no workspace match as unmatched', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toEqual([]);+ expect(summary.unmatchedCount).toBe(1);+ });++ it('should not trust a guest email even when it matches', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ {+ ...fullMember({ id: 'U1', email: '[email protected]' }),+ is_restricted: true,+ },+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toEqual([]);+ expect(summary.unmatchedCount).toBe(1);+ });++ it('should not trust an account from another Slack workspace even when it matches', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ {+ ...fullMember({ id: 'U1', email: '[email protected]' }),+ team_id: 'T-other',+ },+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toEqual([]);+ expect(summary.unmatchedCount).toBe(1);+ });++ it('should not trust an unconfirmed email even when it matches', async () => {+ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ {+ ...fullMember({ id: 'U1', email: '[email protected]' }),+ is_email_confirmed: false,+ },+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toEqual([]);+ expect(summary.unmatchedCount).toBe(1);+ });++ it('should carry the shared-email skip count into the summary', async () => {+ findWorkspaceMemberIdsByEmailsMock.mockResolvedValue({+ workspaceMemberIdByEmail: new Map(),+ ambiguousEmailCount: 2,+ });++ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(summary.ambiguousEmailCount).toBe(2);+ });++ it('should look up only the emails the roster vouches for', async () => {+ await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ { id: 'U2', team_id: SLACK_TEAM_ID, profile: { email: '[email protected]' } },+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(findWorkspaceMemberIdsByEmailsMock).toHaveBeenCalledWith(+ expect.anything(),+ { emails: ['[email protected]'] },+ );+ });++ it('should summarize a mixed roster', async () => {+ listLinkedSlackUserIdsMock.mockResolvedValue(new Set(['U-linked']));+ findWorkspaceMemberIdsByEmailsMock.mockResolvedValue({+ workspaceMemberIdByEmail: new Map([+ ['[email protected]', 'member-ada'],+ ['[email protected]', 'member-grace'],+ ]),+ ambiguousEmailCount: 0,+ });++ const summary = await matchSlackRosterByEmail({+ slackClient: buildSlackClient([+ fullMember({ id: 'U1', email: '[email protected]' }),+ fullMember({ id: 'U2', email: '[email protected]' }),+ fullMember({ id: 'U-linked', email: '[email protected]' }),+ fullMember({ id: 'U3', email: '[email protected]' }),+ fullMember({ id: 'U4' }),+ ]),+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(linkedCandidates()).toHaveLength(2);+ expect(summary).toEqual({+ linkedCount: 2,+ alreadyLinkedCount: 1,+ unmatchedCount: 2,+ ambiguousEmailCount: 0,+ failedCount: 0,+ isRosterTruncated: false,+ });+ });++ it('should report truncation when the roster exceeds the page cap', async () => {+ const usersListMock = vi.fn().mockResolvedValue({+ members: [fullMember({ id: 'U1', email: '[email protected]' })],+ response_metadata: { next_cursor: 'cursor-next' },+ });++ const summary = await matchSlackRosterByEmail({+ slackClient: {+ users: { list: usersListMock },+ } as unknown as WebClient,+ slackTeamId: SLACK_TEAM_ID,+ });++ expect(summary.isRosterTruncated).toBe(true);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/persist-slack-user-link.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/persist-slack-user-link.test.tsindex 50d5696f665..cabb85277ba 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/persist-slack-user-link.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/persist-slack-user-link.test.ts@@ -8,12 +8,12 @@ const {createSlackUserLinkMock,destroySlackUserLinkMock,updateSlackUserLinkMock,- findDeletedSlackUserLinkIdMock,+ findDeletedSlackUserLinkIdsMock,} = vi.hoisted(() => ({createSlackUserLinkMock: vi.fn(),destroySlackUserLinkMock: vi.fn(),updateSlackUserLinkMock: vi.fn(),- findDeletedSlackUserLinkIdMock: vi.fn(),+ findDeletedSlackUserLinkIdsMock: vi.fn(),}));vi.mock('src/logic-functions/data/create-slack-user-link', () => ({@@ -28,8 +28,8 @@ vi.mock('src/logic-functions/data/update-slack-user-link', () => ({updateSlackUserLink: updateSlackUserLinkMock,}));-vi.mock('src/logic-functions/data/find-deleted-slack-user-link-id', () => ({- findDeletedSlackUserLinkId: findDeletedSlackUserLinkIdMock,+vi.mock('src/logic-functions/data/find-deleted-slack-user-link-ids', () => ({+ findDeletedSlackUserLinkIds: findDeletedSlackUserLinkIdsMock,}));const SLACK_TEAM_ID = 'T0INSTALLED';@@ -66,11 +66,11 @@ describe('persistSlackUserLink', () => {createSlackUserLinkMock.mockResolvedValue('link-new');destroySlackUserLinkMock.mockResolvedValue(undefined);updateSlackUserLinkMock.mockResolvedValue(undefined);- findDeletedSlackUserLinkIdMock.mockResolvedValue(undefined);+ findDeletedSlackUserLinkIdsMock.mockResolvedValue([]);});it('should destroy a soft-deleted ghost holding the tuple before creating', async () => {- findDeletedSlackUserLinkIdMock.mockResolvedValue('link-ghost');+ findDeletedSlackUserLinkIdsMock.mockResolvedValue(['link-ghost']);expect(await persist()).toBe('link-new');@@ -86,7 +86,7 @@ describe('persistSlackUserLink', () => {it('should not look for a ghost when replacing a live link', async () => {expect(await persist({ existingLink })).toBe('link-new');- expect(findDeletedSlackUserLinkIdMock).not.toHaveBeenCalled();+ expect(findDeletedSlackUserLinkIdsMock).not.toHaveBeenCalled();expect(destroySlackUserLinkMock).toHaveBeenCalledWith(client, {id: existingLink.id,});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/plan-slack-roster-match.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/plan-slack-roster-match.test.tsnew file mode 100644index 00000000000..963b76bc913--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/plan-slack-roster-match.test.ts@@ -0,0 +1,104 @@+import { describe, expect, it } from 'vitest';++import { type LinkableSlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { planSlackRosterMatch } from 'src/logic-functions/utils/plan-slack-roster-match';++const INSTALLED_TEAM_ID = 'T-installed';++const fullMember = ({+ id,+ email,+ displayName,+}: {+ id: string;+ email?: string;+ displayName?: string;+}): LinkableSlackRosterMember => ({+ id,+ team_id: INSTALLED_TEAM_ID,+ is_email_confirmed: true,+ real_name: displayName,+ profile: { email, display_name: displayName },+});++const planMatch = ({+ members,+ workspaceMemberIdByEmail = new Map([['[email protected]', 'member-ada']]),+ linkedSlackUserIds = new Set<string>(),+}: {+ members: LinkableSlackRosterMember[];+ workspaceMemberIdByEmail?: Map<string, string>;+ linkedSlackUserIds?: Set<string>;+}) =>+ planSlackRosterMatch({+ members,+ workspaceMemberIdByEmail,+ linkedSlackUserIds,+ installedSlackTeamId: INSTALLED_TEAM_ID,+ });++describe('planSlackRosterMatch', () => {+ it('should plan a candidate for a member whose vouched email matches', () => {+ const plan = planMatch({+ members: [+ fullMember({ id: 'U1', email: '[email protected]', displayName: 'ada' }),+ ],+ });++ expect(plan.candidates).toEqual([+ {+ slackUserId: 'U1',+ workspaceMemberId: 'member-ada',+ displayName: 'ada',+ },+ ]);+ expect(plan.alreadyLinkedCount).toBe(0);+ expect(plan.unmatchedCount).toBe(0);+ });++ it('should match the email case-insensitively', () => {+ const plan = planMatch({+ members: [fullMember({ id: 'U1', email: '[email protected]' })],+ });++ expect(plan.candidates).toHaveLength(1);+ });++ it('should skip a Slack user that already has a link', () => {+ const plan = planMatch({+ members: [fullMember({ id: 'U1', email: '[email protected]' })],+ linkedSlackUserIds: new Set(['U1']),+ });++ expect(plan.candidates).toEqual([]);+ expect(plan.alreadyLinkedCount).toBe(1);+ expect(plan.unmatchedCount).toBe(0);+ });++ it('should count a member with no matching workspace email as unmatched', () => {+ const plan = planMatch({+ members: [fullMember({ id: 'U1', email: '[email protected]' })],+ });++ expect(plan.candidates).toEqual([]);+ expect(plan.unmatchedCount).toBe(1);+ });++ it('should not trust the email of a guest or of an account from another workspace', () => {+ const plan = planMatch({+ members: [+ {+ ...fullMember({ id: 'U1', email: '[email protected]' }),+ is_restricted: true,+ },+ {+ ...fullMember({ id: 'U2', email: '[email protected]' }),+ team_id: 'T-other',+ },+ ],+ });++ expect(plan.candidates).toEqual([]);+ expect(plan.unmatchedCount).toBe(2);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/to-slack-user-search-option.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/to-slack-user-search-option.test.tsnew file mode 100644index 00000000000..8723a2ce95f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/to-slack-user-search-option.test.ts@@ -0,0 +1,46 @@+import { describe, expect, it } from 'vitest';++import { toSlackUserSearchOption } from 'src/logic-functions/utils/to-slack-user-search-option';++const INSTALLED_TEAM_ID = 'T-installed';++describe('toSlackUserSearchOption', () => {+ it('should map a vouched full member with its email', () => {+ expect(+ toSlackUserSearchOption({+ member: {+ id: 'U1',+ team_id: INSTALLED_TEAM_ID,+ is_email_confirmed: true,+ real_name: 'Ada Lovelace',+ profile: { display_name: 'ada', email: '[email protected]' },+ },+ installedSlackTeamId: INSTALLED_TEAM_ID,+ }),+ ).toEqual({+ slackUserId: 'U1',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'ada',+ email: '[email protected]',+ });+ });++ it('should leave the email out for an unvouched member', () => {+ expect(+ toSlackUserSearchOption({+ member: {+ id: 'U2',+ team_id: 'T-other',+ is_email_confirmed: true,+ profile: { email: '[email protected]' },+ },+ installedSlackTeamId: INSTALLED_TEAM_ID,+ }),+ ).toEqual({+ slackUserId: 'U2',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: undefined,+ email: undefined,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-roster-match-message.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-roster-match-message.tsnew file mode 100644index 00000000000..7ee987f6eb9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-roster-match-message.ts@@ -0,0 +1,42 @@+import { type SlackRosterMatchSummary } from 'src/logic-functions/types/slack-roster-match.type';++export const buildSlackRosterMatchMessage = ({+ linkedCount,+ alreadyLinkedCount,+ unmatchedCount,+ ambiguousEmailCount,+ failedCount,+ isRosterTruncated,+}: SlackRosterMatchSummary): string => {+ const messageParts = [+ `Matched ${linkedCount} Slack ${linkedCount === 1 ? 'user' : 'users'} by email.`,+ ];++ if (alreadyLinkedCount > 0) {+ messageParts.push(`${alreadyLinkedCount} already linked.`);+ }++ if (unmatchedCount > 0) {+ messageParts.push(`${unmatchedCount} without a matching member email.`);+ }++ if (ambiguousEmailCount > 0) {+ messageParts.push(+ `${ambiguousEmailCount} skipped because their email belongs to more than one workspace member.`,+ );+ }++ if (failedCount > 0) {+ messageParts.push(+ `${failedCount} could not be linked; try the match again.`,+ );+ }++ if (isRosterTruncated) {+ messageParts.push(+ 'The Slack roster is too large to scan in one pass, so some users were not checked.',+ );+ }++ return messageParts.join(' ');+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/collect-slack-roster-members.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/collect-slack-roster-members.tsnew file mode 100644index 00000000000..b409863b4a2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/collect-slack-roster-members.ts@@ -0,0 +1,69 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { type LinkableSlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { isLinkableSlackRosterMember } from 'src/logic-functions/utils/is-linkable-slack-roster-member';++const MEMBERS_PER_PAGE = 200;+const DEFAULT_MAX_PAGES = 5;++type CollectSlackRosterMembersResult = {+ members: LinkableSlackRosterMember[];+ isTruncated: boolean;+};++export const collectSlackRosterMembers = async ({+ slackClient,+ shouldCollectMember,+ maxMembers,+ maxPages = DEFAULT_MAX_PAGES,+}: {+ slackClient: WebClient;+ shouldCollectMember?: (member: LinkableSlackRosterMember) => boolean;+ maxMembers?: number;+ maxPages?: number;+}): Promise<CollectSlackRosterMembersResult> => {+ const members: LinkableSlackRosterMember[] = [];+ const seenSlackUserIds = new Set<string>();+ let cursor: string | undefined;++ for (let page = 0; page < maxPages; page += 1) {+ const response = await slackClient.users.list({+ limit: MEMBERS_PER_PAGE,+ cursor,+ });++ const collectiblePageMembers = (response.members ?? [])+ .filter(isLinkableSlackRosterMember)+ .filter(+ (member) =>+ !isDefined(shouldCollectMember) || shouldCollectMember(member),+ );++ cursor = response.response_metadata?.next_cursor;++ for (const member of collectiblePageMembers) {+ if (seenSlackUserIds.has(member.id)) {+ continue;+ }++ if (isDefined(maxMembers) && members.length >= maxMembers) {+ return { members, isTruncated: true };+ }++ seenSlackUserIds.add(member.id);+ members.push(member);+ }++ if (isDefined(maxMembers) && members.length >= maxMembers) {+ return { members, isTruncated: isNonEmptyString(cursor) };+ }++ if (!isNonEmptyString(cursor)) {+ return { members, isTruncated: false };+ }+ }++ return { members, isTruncated: true };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/escape-sql-like-pattern.util.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/escape-sql-like-pattern.util.tsnew file mode 100644index 00000000000..a763bfcce4f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/escape-sql-like-pattern.util.ts@@ -0,0 +1,2 @@+export const escapeSqlLikePattern = (value: string): string =>+ value.replace(/[\\%_]/g, (wildcard) => `\\${wildcard}`);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-roster-member-display-name.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-roster-member-display-name.tsnew file mode 100644index 00000000000..d64697c4aa6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-slack-roster-member-display-name.ts@@ -0,0 +1,8 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';++export const getSlackRosterMemberDisplayName = (+ member: SlackRosterMember,+): string | undefined =>+ [member.profile?.display_name, member.real_name].find(isNonEmptyString);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/get-vouched-slack-roster-email.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-vouched-slack-roster-email.tsnew file mode 100644index 00000000000..a8de1e0d065--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/get-vouched-slack-roster-email.ts@@ -0,0 +1,28 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';++const isEmailVouchedForByInstalledWorkspace = ({+ member,+ installedSlackTeamId,+}: {+ member: SlackRosterMember;+ installedSlackTeamId: string;+}): boolean =>+ member.team_id === installedSlackTeamId &&+ member.is_stranger !== true &&+ member.is_restricted !== true &&+ member.is_ultra_restricted !== true &&+ member.is_email_confirmed === true;++export const getVouchedSlackRosterEmail = ({+ member,+ installedSlackTeamId,+}: {+ member: SlackRosterMember;+ installedSlackTeamId: string;+}): string | undefined =>+ isEmailVouchedForByInstalledWorkspace({ member, installedSlackTeamId }) &&+ isNonEmptyString(member.profile?.email)+ ? member.profile.email+ : undefined;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-linkable-slack-roster-member.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-linkable-slack-roster-member.tsnew file mode 100644index 00000000000..79f963c3cc3--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-linkable-slack-roster-member.ts@@ -0,0 +1,16 @@+import { isNonEmptyString } from '@sniptt/guards';++import {+ type LinkableSlackRosterMember,+ type SlackRosterMember,+} from 'src/logic-functions/types/slack-roster-member.type';++const SLACKBOT_USER_ID = 'USLACKBOT';++export const isLinkableSlackRosterMember = (+ member: SlackRosterMember,+): member is LinkableSlackRosterMember =>+ isNonEmptyString(member.id) &&+ member.id !== SLACKBOT_USER_ID &&+ member.is_bot !== true &&+ member.deleted !== true;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/link-slack-roster-candidates.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/link-slack-roster-candidates.tsnew file mode 100644index 00000000000..25319fdc7be--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/link-slack-roster-candidates.ts@@ -0,0 +1,251 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { SLACK_USER_LINK_SOURCE } from 'src/logic-functions/constants/slack-user-link-source';+import { createSlackUserLink } from 'src/logic-functions/data/create-slack-user-link';+import { createSlackUserLinks } from 'src/logic-functions/data/create-slack-user-links';+import { destroySlackUserLinks } from 'src/logic-functions/data/destroy-slack-user-links';+import { findDeletedSlackUserLinkIds } from 'src/logic-functions/data/find-deleted-slack-user-link-ids';+import { listLinkedSlackUserIds } from 'src/logic-functions/data/list-linked-slack-user-ids';+import { type SlackRosterMatchCandidate } from 'src/logic-functions/types/slack-roster-match.type';+import { type SlackUserLinkDraft } from 'src/logic-functions/types/slack-user-link-draft.type';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const CORE_API_QUERY_MAX_RECORDS = 200;++const MAX_FALLBACK_CANDIDATES = CORE_API_QUERY_MAX_RECORDS;++type SlackRosterLinkOutcome = {+ linkedCount: number;+ failedCount: number;+};++const toSlackUserLinkDraft = ({+ candidate,+ slackTeamId,+}: {+ candidate: SlackRosterMatchCandidate;+ slackTeamId: string;+}): SlackUserLinkDraft => ({+ slackTeamId,+ slackUserId: candidate.slackUserId,+ workspaceMemberId: candidate.workspaceMemberId,+ name: isNonEmptyString(candidate.displayName)+ ? candidate.displayName+ : candidate.slackUserId,+ source: SLACK_USER_LINK_SOURCE.AUTO,+ consentState: SLACK_USER_LINK_CONSENT_STATE.ACTIVE,+});++const clearSoftDeletedLinks = async (+ client: CoreApiClient,+ {+ candidates,+ slackTeamId,+ }: { candidates: SlackRosterMatchCandidate[]; slackTeamId: string },+): Promise<void> => {+ const deletedLinkIds = await findDeletedSlackUserLinkIds(client, {+ slackTeamId,+ slackUserIds: candidates.map((candidate) => candidate.slackUserId),+ });++ if (deletedLinkIds.length > 0) {+ await destroySlackUserLinks(client, { ids: deletedLinkIds });+ }+};++const dedupeCandidatesBySlackUserId = (+ candidates: SlackRosterMatchCandidate[],+): SlackRosterMatchCandidate[] => [+ ...new Map(+ candidates.map((candidate) => [candidate.slackUserId, candidate]),+ ).values(),+];++const partitionWrittenCandidates = async (+ client: CoreApiClient,+ {+ candidates,+ slackTeamId,+ }: { candidates: SlackRosterMatchCandidate[]; slackTeamId: string },+): Promise<{+ writtenCount: number;+ unwrittenCandidates: SlackRosterMatchCandidate[];+}> => {+ const alreadyLinkedSlackUserIds = await listLinkedSlackUserIds(client, {+ slackTeamId,+ slackUserIds: candidates.map((candidate) => candidate.slackUserId),+ });++ const unwrittenCandidates = candidates.filter(+ (candidate) => !alreadyLinkedSlackUserIds.has(candidate.slackUserId),+ );++ return {+ writtenCount: candidates.length - unwrittenCandidates.length,+ unwrittenCandidates,+ };+};++const createCandidatesOneByOne = async (+ client: CoreApiClient,+ {+ candidates,+ slackTeamId,+ }: { candidates: SlackRosterMatchCandidate[]; slackTeamId: string },+): Promise<number> => {+ const outcomes: boolean[] = [];++ for (const candidate of candidates) {+ try {+ await createSlackUserLink(+ client,+ toSlackUserLinkDraft({ candidate, slackTeamId }),+ );+ outcomes.push(true);+ } catch (error) {+ console.warn(+ `[slack] roster match could not link ${candidate.slackUserId}: ${toErrorMessage(error)}`,+ );+ outcomes.push(false);+ }+ }++ return outcomes.filter((isLinked) => isLinked).length;+};++const recoverFailedBatch = async (+ client: CoreApiClient,+ {+ candidates,+ slackTeamId,+ canRetryOneByOne,+ }: {+ candidates: SlackRosterMatchCandidate[];+ slackTeamId: string;+ canRetryOneByOne: boolean;+ },+): Promise<SlackRosterLinkOutcome> => {+ try {+ const { writtenCount, unwrittenCandidates } =+ await partitionWrittenCandidates(client, {+ candidates,+ slackTeamId,+ });++ if (!canRetryOneByOne) {+ return {+ linkedCount: writtenCount,+ failedCount: unwrittenCandidates.length,+ };+ }++ const createdCount = await createCandidatesOneByOne(client, {+ candidates: unwrittenCandidates,+ slackTeamId,+ });++ return {+ linkedCount: writtenCount + createdCount,+ failedCount: unwrittenCandidates.length - createdCount,+ };+ } catch (error) {+ console.warn(+ `[slack] roster match could not reconcile a failed batch of ${candidates.length}: ${toErrorMessage(error)}`,+ );++ return { linkedCount: 0, failedCount: candidates.length };+ }+};++export const linkSlackRosterCandidates = async (+ client: CoreApiClient,+ {+ candidates,+ slackTeamId,+ }: { candidates: SlackRosterMatchCandidate[]; slackTeamId: string },+): Promise<SlackRosterLinkOutcome> => {+ const uniqueCandidates = dedupeCandidatesBySlackUserId(candidates);++ if (uniqueCandidates.length === 0) {+ return { linkedCount: 0, failedCount: 0 };+ }++ const batchOutcomes: SlackRosterLinkOutcome[] = [];+ let remainingFallbackCandidates = MAX_FALLBACK_CANDIDATES;++ for (+ let batchStart = 0;+ batchStart < uniqueCandidates.length;+ batchStart += CORE_API_QUERY_MAX_RECORDS+ ) {+ const batchCandidates = uniqueCandidates.slice(+ batchStart,+ batchStart + CORE_API_QUERY_MAX_RECORDS,+ );++ try {+ await clearSoftDeletedLinks(client, {+ candidates: batchCandidates,+ slackTeamId,+ });+ } catch (error) {+ console.warn(+ `[slack] roster match could not clear the soft-deleted links of ${batchCandidates.length} candidates: ${toErrorMessage(error)}`,+ );++ batchOutcomes.push(+ await recoverFailedBatch(client, {+ candidates: batchCandidates,+ slackTeamId,+ canRetryOneByOne: false,+ }),+ );+ continue;+ }++ try {+ await createSlackUserLinks(client, {+ drafts: batchCandidates.map((candidate) =>+ toSlackUserLinkDraft({ candidate, slackTeamId }),+ ),+ });++ batchOutcomes.push({+ linkedCount: batchCandidates.length,+ failedCount: 0,+ });+ } catch (error) {+ console.warn(+ `[slack] roster match batch of ${batchCandidates.length} failed: ${toErrorMessage(error)}`,+ );++ const canRetryOneByOne =+ remainingFallbackCandidates >= batchCandidates.length;++ if (canRetryOneByOne) {+ remainingFallbackCandidates -= batchCandidates.length;+ }++ batchOutcomes.push(+ await recoverFailedBatch(client, {+ candidates: batchCandidates,+ slackTeamId,+ canRetryOneByOne,+ }),+ );+ }+ }++ return {+ linkedCount: batchOutcomes.reduce(+ (total, outcome) => total + outcome.linkedCount,+ 0,+ ),+ failedCount: batchOutcomes.reduce(+ (total, outcome) => total + outcome.failedCount,+ 0,+ ),+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/match-slack-roster-by-email.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/match-slack-roster-by-email.tsnew file mode 100644index 00000000000..5cf60fdb44c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/match-slack-roster-by-email.ts@@ -0,0 +1,62 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';++import { listLinkedSlackUserIds } from 'src/logic-functions/data/list-linked-slack-user-ids';+import { findWorkspaceMemberIdsByEmails } from 'src/logic-functions/data/find-workspace-member-ids-by-emails';+import { type SlackRosterMatchSummary } from 'src/logic-functions/types/slack-roster-match.type';+import { collectSlackRosterMembers } from 'src/logic-functions/utils/collect-slack-roster-members';+import { getVouchedSlackRosterEmail } from 'src/logic-functions/utils/get-vouched-slack-roster-email';+import { linkSlackRosterCandidates } from 'src/logic-functions/utils/link-slack-roster-candidates';+import { planSlackRosterMatch } from 'src/logic-functions/utils/plan-slack-roster-match';++export const matchSlackRosterByEmail = async ({+ slackClient,+ slackTeamId,+}: {+ slackClient: WebClient;+ slackTeamId: string;+}): Promise<SlackRosterMatchSummary> => {+ const client = new CoreApiClient({ runAs: 'application' });++ const [linkedSlackUserIds, roster] = await Promise.all([+ listLinkedSlackUserIds(client, { slackTeamId }),+ collectSlackRosterMembers({ slackClient }),+ ]);++ const vouchedRosterEmails = roster.members+ .map((member) =>+ getVouchedSlackRosterEmail({+ member,+ installedSlackTeamId: slackTeamId,+ }),+ )+ .filter(isNonEmptyString);++ const { workspaceMemberIdByEmail, ambiguousEmailCount } =+ await findWorkspaceMemberIdsByEmails(client, {+ emails: vouchedRosterEmails,+ });++ const { candidates, alreadyLinkedCount, unmatchedCount } =+ planSlackRosterMatch({+ members: roster.members,+ workspaceMemberIdByEmail,+ linkedSlackUserIds,+ installedSlackTeamId: slackTeamId,+ });++ const { linkedCount, failedCount } = await linkSlackRosterCandidates(client, {+ candidates,+ slackTeamId,+ });++ return {+ linkedCount,+ alreadyLinkedCount,+ unmatchedCount,+ ambiguousEmailCount,+ failedCount,+ isRosterTruncated: roster.isTruncated,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/persist-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/persist-slack-user-link.tsindex 61b82a98a76..1dfb5d4122c 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/persist-slack-user-link.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/persist-slack-user-link.ts@@ -4,7 +4,7 @@ import { isDefined } from 'twenty-sdk/utils';import { createSlackUserLink } from 'src/logic-functions/data/create-slack-user-link';import { destroySlackUserLink } from 'src/logic-functions/data/destroy-slack-user-link';-import { findDeletedSlackUserLinkId } from 'src/logic-functions/data/find-deleted-slack-user-link-id';+import { findDeletedSlackUserLinkIds } from 'src/logic-functions/data/find-deleted-slack-user-link-ids';import { updateSlackUserLink } from 'src/logic-functions/data/update-slack-user-link';import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';@@ -53,9 +53,9 @@ export const persistSlackUserLink = async (if (isDefined(existingLink)) {await destroySlackUserLink(client, { id: existingLink.id });} else {- const deletedLinkId = await findDeletedSlackUserLinkId(client, {+ const [deletedLinkId] = await findDeletedSlackUserLinkIds(client, {slackTeamId,- slackUserId,+ slackUserIds: [slackUserId],});if (isDefined(deletedLinkId)) {diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/plan-slack-roster-match.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/plan-slack-roster-match.tsnew file mode 100644index 00000000000..52d329f90ba--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/plan-slack-roster-match.ts@@ -0,0 +1,84 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { type LinkableSlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import {+ type SlackRosterMatchCandidate,+ type SlackRosterMatchPlan,+} from 'src/logic-functions/types/slack-roster-match.type';+import { getSlackRosterMemberDisplayName } from 'src/logic-functions/utils/get-slack-roster-member-display-name';+import { getVouchedSlackRosterEmail } from 'src/logic-functions/utils/get-vouched-slack-roster-email';++type PlannedSlackRosterMember =+ | { status: 'alreadyLinked' }+ | { status: 'unmatched' }+ | { status: 'candidate'; candidate: SlackRosterMatchCandidate };++const planRosterMember = ({+ member,+ workspaceMemberIdByEmail,+ linkedSlackUserIds,+ installedSlackTeamId,+}: {+ member: LinkableSlackRosterMember;+ workspaceMemberIdByEmail: Map<string, string>;+ linkedSlackUserIds: Set<string>;+ installedSlackTeamId: string;+}): PlannedSlackRosterMember => {+ const slackUserId = member.id;++ if (linkedSlackUserIds.has(slackUserId)) {+ return { status: 'alreadyLinked' };+ }++ const email = getVouchedSlackRosterEmail({ member, installedSlackTeamId });+ const workspaceMemberId = isNonEmptyString(email)+ ? workspaceMemberIdByEmail.get(email.toLowerCase())+ : undefined;++ if (!isDefined(workspaceMemberId)) {+ return { status: 'unmatched' };+ }++ return {+ status: 'candidate',+ candidate: {+ slackUserId,+ workspaceMemberId,+ displayName: getSlackRosterMemberDisplayName(member),+ },+ };+};++export const planSlackRosterMatch = ({+ members,+ workspaceMemberIdByEmail,+ linkedSlackUserIds,+ installedSlackTeamId,+}: {+ members: LinkableSlackRosterMember[];+ workspaceMemberIdByEmail: Map<string, string>;+ linkedSlackUserIds: Set<string>;+ installedSlackTeamId: string;+}): SlackRosterMatchPlan => {+ const plannedMembers = members.map((member) =>+ planRosterMember({+ member,+ workspaceMemberIdByEmail,+ linkedSlackUserIds,+ installedSlackTeamId,+ }),+ );++ return {+ candidates: plannedMembers.flatMap((plannedMember) =>+ plannedMember.status === 'candidate' ? [plannedMember.candidate] : [],+ ),+ alreadyLinkedCount: plannedMembers.filter(+ (plannedMember) => plannedMember.status === 'alreadyLinked',+ ).length,+ unmatchedCount: plannedMembers.filter(+ (plannedMember) => plannedMember.status === 'unmatched',+ ).length,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/register-slack-connection.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/register-slack-connection.tsindex a02f1ff55de..e2dff26569e 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/register-slack-connection.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/register-slack-connection.ts@@ -6,6 +6,7 @@ import { autoLinkSlackInstaller } from 'src/logic-functions/utils/auto-link-slacimport { cacheSlackBotUserId } from 'src/logic-functions/utils/cache-slack-bot-user-id';import { getSlackConnectedAccountTeamKvKey } from 'src/logic-functions/utils/get-slack-connected-account-team-kv-key';import { getSlackTeamKvKey } from 'src/logic-functions/utils/get-slack-team-kv-key';+import { matchSlackRosterByEmail } from 'src/logic-functions/utils/match-slack-roster-by-email';import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';type RegisterSlackConnectionArgs = {@@ -55,5 +56,13 @@ export const registerSlackConnection = async ({);}+ try {+ await matchSlackRosterByEmail({ slackClient: client, slackTeamId: teamId });+ } catch (error) {+ console.warn(+ `[slack] roster email match skipped: ${toErrorMessage(error)}`,+ );+ }+return { ok: true, teamId };};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/to-slack-user-search-option.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/to-slack-user-search-option.tsnew file mode 100644index 00000000000..f2a483d236f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/to-slack-user-search-option.ts@@ -0,0 +1,17 @@+import { type LinkableSlackRosterMember } from 'src/logic-functions/types/slack-roster-member.type';+import { type SlackUserSearchOption } from 'src/logic-functions/types/slack-user-search.type';+import { getSlackRosterMemberDisplayName } from 'src/logic-functions/utils/get-slack-roster-member-display-name';+import { getVouchedSlackRosterEmail } from 'src/logic-functions/utils/get-vouched-slack-roster-email';++export const toSlackUserSearchOption = ({+ member,+ installedSlackTeamId,+}: {+ member: LinkableSlackRosterMember;+ installedSlackTeamId: string;+}): SlackUserSearchOption => ({+ slackUserId: member.id,+ slackTeamId: installedSlackTeamId,+ displayName: getSlackRosterMemberDisplayName(member),+ email: getVouchedSlackRosterEmail({ member, installedSlackTeamId }),+});