The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
feat(slack): settings UI and consent flow for Slack user links (#24887)
Abdul Rahman17e9b964ccfa
diff --git a/packages/twenty-apps/public/slack/README.md b/packages/twenty-apps/public/slack/README.mdindex 649d692f86d..9baf2317e24 100644--- a/packages/twenty-apps/public/slack/README.md+++ b/packages/twenty-apps/public/slack/README.md@@ -18,7 +18,11 @@ Out of the box the bot runs with the **Slack Assistant** role, which can read, cA 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 workspace members permission can link them by hand: ask the assistant to link a Slack user to a workspace member, and the pair is stored with its source set to manual. For a Slack Connect user, include their own Slack workspace's team ID so the link matches the messages they send. Manual links win 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 an admin's decision.+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.++**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.One Slack workspace answers into one Twenty workspace.@@ -26,14 +30,14 @@ When the bot is added to a channel it introduces itself once, with a short messa## 🧰 The workflow steps-| Step | Slack API |-|------|-----------|-| `slack-post-message` | `chat.postMessage` |+| Step | Slack API |+| ------------------------------ | -------------------- |+| `slack-post-message` | `chat.postMessage` || `slack-post-ephemeral-message` | `chat.postEphemeral` |-| `slack-update-message` | `chat.update` |-| `slack-delete-message` | `chat.delete` |-| `slack-add-reaction` | `reactions.add` |-| `slack-list-channels` | `conversations.list` |+| `slack-update-message` | `chat.update` |+| `slack-delete-message` | `chat.delete` |+| `slack-add-reaction` | `reactions.add` |+| `slack-list-channels` | `conversations.list` |Pick a **workspace shared** or **just for me** Slack connection; steps run with that token.diff --git a/packages/twenty-apps/public/slack/css.d.ts b/packages/twenty-apps/public/slack/css.d.tsnew file mode 100644index 00000000000..35306c6fc9a--- /dev/null+++ b/packages/twenty-apps/public/slack/css.d.ts@@ -0,0 +1 @@+declare module '*.css';diff --git a/packages/twenty-apps/public/slack/package.json b/packages/twenty-apps/public/slack/package.jsonindex 4ec39fb1bc9..bac98c8f5ba 100644--- a/packages/twenty-apps/public/slack/package.json+++ b/packages/twenty-apps/public/slack/package.json@@ -26,6 +26,8 @@"@slack/web-api": "^7.18.0"},"devDependencies": {+ "@emotion/react": "^11.14.0",+ "@emotion/styled": "^11.14.0","@types/node": "^24.7.2","@types/react": "^18.2.0","@typescript/native-preview": "^7.0.0-dev.20260116.1",@@ -35,6 +37,7 @@"react-dom": "^18.2.0","twenty-client-sdk": "^2.37.0","twenty-sdk": "^2.37.0",+ "twenty-ui": "^1.0.0-alpha.1","typescript": "^5.9.3","vite-tsconfig-paths": "^4.2.1","vitest": "^4.0.0"diff --git a/packages/twenty-apps/public/slack/src/connection-providers/slack-connection.ts b/packages/twenty-apps/public/slack/src/connection-providers/slack-connection.tsindex 4f2bec00032..562d5b99fe9 100644--- a/packages/twenty-apps/public/slack/src/connection-providers/slack-connection.ts+++ b/packages/twenty-apps/public/slack/src/connection-providers/slack-connection.ts@@ -25,6 +25,7 @@ export default defineConnectionProvider({'channels:read','chat:write','chat:write.public',+ 'im:write','groups:read','reactions:write',// Only used by the conversational assistantdiff --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.tsnew file mode 100644index 00000000000..f46eb04e5ea--- /dev/null+++ b/packages/twenty-apps/public/slack/src/constants/slack-user-links-route-path.constant.ts@@ -0,0 +1,10 @@+export const SLACK_USER_LINKS_SET_ROUTE_PATH = '/slack-user-links/set';++export const SLACK_USER_LINKS_RESOLVE_ROUTE_PATH = '/slack-user-links/resolve';++export const SLACK_USER_LINKS_SEARCH_ROUTE_PATH = '/slack-user-links/search';++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';diff --git a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.tsindex 971ed725339..9b6166b0ee7 100644--- a/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts+++ b/packages/twenty-apps/public/slack/src/constants/universal-identifiers.ts@@ -43,6 +43,9 @@ export const SLACK_INTERACTIVITY_ROUTE_UNIVERSAL_IDENTIFIER =export const SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER ='60947582-0735-4b6d-8c1f-5e237875a2e4';+export const SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER =+ '4e62a8f4-5a74-4567-9c5c-4dec8f5345d4';+export const SLACK_CHANNEL_WELCOME_UNIVERSAL_IDENTIFIER ='c5e8b13a-7f42-4d90-8a6b-1e3c9d052f47';@@ -58,6 +61,18 @@ export const SLACK_REGISTER_CONNECTION_UNIVERSAL_IDENTIFIER =export const SLACK_SET_USER_LINK_UNIVERSAL_IDENTIFIER ='32f511ac-8754-4526-8c28-e17221f2e2b0';+export const SLACK_RESOLVE_USER_LINK_UNIVERSAL_IDENTIFIER =+ '92e1291a-c416-4294-b2f7-2db992322988';++export const SLACK_SEARCH_USERS_UNIVERSAL_IDENTIFIER =+ '5cae2734-eec6-4dc6-afa8-3549c9602bb6';++export const SLACK_REMOVE_USER_LINK_UNIVERSAL_IDENTIFIER =+ '41da83fa-8a3d-4b2f-a51a-6ad340e5792d';++export const SLACK_RESEND_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER =+ '52f08a8e-d97e-4fb6-8707-328423b06a3d';+export const SLACK_TEAM_RELEASE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER ='4470aba8-5ff5-4800-88db-2a427cd8677c';@@ -130,6 +145,9 @@ export const SLACK_USER_LINK_USER_ID_FIELD_UNIVERSAL_IDENTIFIER =export const SLACK_USER_LINK_SOURCE_FIELD_UNIVERSAL_IDENTIFIER ='28ea1176-1a5a-4f7f-82d9-56927a6e4af0';+export const SLACK_USER_LINK_CONSENT_STATE_FIELD_UNIVERSAL_IDENTIFIER =+ 'd8986459-9d66-4586-b30e-0e0a381eaacb';+export const SLACK_USER_LINK_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIER ='a46fa5a5-bb6f-4474-9ba4-b816ab743d0d';@@ -150,3 +168,6 @@ export const SLACK_ASSISTANT_REQUEST_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIERexport const SLACK_ASSISTANT_REQUESTS_ON_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIER ='c837dafb-1e41-46de-8eab-076f2667eed6';++export const SLACK_USER_LINKS_SETTINGS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER =+ '20beb6d2-804f-40a5-ad7d-8d523e401651';diff --git a/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsx b/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsxnew file mode 100644index 00000000000..c71088801bf--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/ResolvedSlackUserField.tsx@@ -0,0 +1,33 @@+import { isNonEmptyString } from '@sniptt/guards';++import { SlackPickedEntityButton } from 'src/front-components/components/SlackPickedEntityButton';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++type ResolvedSlackUserFieldProps = {+ resolvedUser: SlackResolvedUser;+ onChangeRequest: () => void;+ disabled?: boolean;+};++const buildFallbackMeta = (resolvedUser: SlackResolvedUser): string =>+ isNonEmptyString(resolvedUser.slackTeamId)+ ? `Slack user ${resolvedUser.slackUserId} · Team ${resolvedUser.slackTeamId}`+ : `Slack user ${resolvedUser.slackUserId}`;++export const ResolvedSlackUserField = ({+ resolvedUser,+ onChangeRequest,+ disabled,+}: ResolvedSlackUserFieldProps) => (+ <SlackPickedEntityButton+ name={resolvedUser.displayName ?? resolvedUser.slackUserId}+ meta={+ isNonEmptyString(resolvedUser.email)+ ? resolvedUser.email+ : buildFallbackMeta(resolvedUser)+ }+ changeLabel="Change the Slack user"+ onChangeRequest={onChangeRequest}+ disabled={disabled}+ />+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsxnew file mode 100644index 00000000000..e92c9c95d22--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SearchDropdownPicker.tsx@@ -0,0 +1,153 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { themeCssVariables } from 'twenty-ui/theme-constants';++import { SlackUserLinkTextInput } from 'src/front-components/components/SlackUserLinkTextInput';++const StyledContainer = styled.div`+ position: relative;+ width: 100%;+`;++const StyledDropdown = styled.div`+ background: ${() => themeCssVariables.background.primary};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.sm};+ box-shadow: ${() => themeCssVariables.boxShadow.light};+ box-sizing: border-box;+ left: 0;+ margin-top: ${() => themeCssVariables.spacing[1]};+ max-height: 240px;+ overflow-y: auto;+ position: absolute;+ right: 0;+ top: 100%;+ z-index: 1;+`;++const StyledOption = styled.button`+ background: transparent;+ border: none;+ cursor: pointer;+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[1]};+ padding: ${() => themeCssVariables.spacing[2]};+ text-align: left;+ width: 100%;++ &:hover {+ background: ${() => themeCssVariables.background.secondary};+ }+`;++const StyledOptionName = styled.span`+ color: ${() => themeCssVariables.font.color.primary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+`;++const StyledOptionMeta = styled.span`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+`;++const StyledEmptyState = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ padding: ${() => themeCssVariables.spacing[2]};+`;++type SearchDropdownPickerProps<TOption> = {+ searchTerm: string;+ onSearchTermChange: (searchTerm: string) => void;+ options: TOption[];+ isSearching: boolean;+ onSelect: (option: TOption) => void;+ getOptionKey: (option: TOption) => string;+ getOptionName: (option: TOption) => string;+ getOptionMeta: (option: TOption) => string | undefined;+ searchLabel: string;+ emptyText: string;+ disabled?: boolean;+ autoFocus?: boolean;+};++export const SearchDropdownPicker = <TOption,>({+ searchTerm,+ onSearchTermChange,+ options,+ isSearching,+ onSelect,+ getOptionKey,+ getOptionName,+ getOptionMeta,+ searchLabel,+ emptyText,+ disabled,+ autoFocus,+}: SearchDropdownPickerProps<TOption>) => {+ const [isFocused, setIsFocused] = useState(false);++ const hasSearchTerm = isNonEmptyString(searchTerm.trim());+ const isDropdownOpen = isFocused && hasSearchTerm;++ const handleSelect = (option: TOption) => {+ onSearchTermChange('');+ onSelect(option);+ };++ return (+ <StyledContainer>+ <SlackUserLinkTextInput+ value={searchTerm}+ onChange={(event) => onSearchTermChange(event.target.value)}+ onFocus={() => setIsFocused(true)}+ onBlur={() => setIsFocused(false)}+ onKeyDown={(event) => {+ if (event.key !== 'Enter') {+ return;+ }++ event.preventDefault();++ if (options.length > 0) {+ handleSelect(options[0]);+ }+ }}+ placeholder={searchLabel}+ disabled={disabled}+ autoFocus={autoFocus}+ aria-label={searchLabel}+ />+ {isDropdownOpen && (+ <StyledDropdown onMouseDown={(event) => event.preventDefault()}>+ {options.map((option) => {+ const meta = getOptionMeta(option);++ return (+ <StyledOption+ key={getOptionKey(option)}+ type="button"+ onMouseDown={() => handleSelect(option)}+ >+ <StyledOptionName>{getOptionName(option)}</StyledOptionName>+ {isNonEmptyString(meta) && (+ <StyledOptionMeta>{meta}</StyledOptionMeta>+ )}+ </StyledOption>+ );+ })}+ {options.length === 0 && (+ <StyledEmptyState>+ {isSearching ? 'Searching…' : emptyText}+ </StyledEmptyState>+ )}+ </StyledDropdown>+ )}+ </StyledContainer>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackConnectUserIdFields.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackConnectUserIdFields.tsxnew file mode 100644index 00000000000..4379a88dab8--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackConnectUserIdFields.tsx@@ -0,0 +1,58 @@+import { SlackUserLinkFormField } from 'src/front-components/components/SlackUserLinkFormField';+import { SlackUserLinkFormHint } from 'src/front-components/components/SlackUserLinkFormHint';+import { SlackUserLinkTextInput } from 'src/front-components/components/SlackUserLinkTextInput';++type SlackConnectUserIdFieldsProps = {+ slackUserId: string;+ slackTeamId: string;+ onSlackUserIdChange: (slackUserId: string) => void;+ onSlackTeamIdChange: (slackTeamId: string) => void;+ disabled?: boolean;+};++export const SlackConnectUserIdFields = ({+ slackUserId,+ slackTeamId,+ onSlackUserIdChange,+ onSlackTeamIdChange,+ disabled,+}: SlackConnectUserIdFieldsProps) => (+ <>+ <SlackUserLinkFormField+ label="Slack user ID"+ htmlFor="slack-user-id"+ hint={+ <SlackUserLinkFormHint>+ Use this for a Slack Connect user from another workspace, who will not+ appear in the search above.+ </SlackUserLinkFormHint>+ }+ >+ <SlackUserLinkTextInput+ id="slack-user-id"+ value={slackUserId}+ onChange={(event) => onSlackUserIdChange(event.target.value)}+ placeholder="U0123456789"+ disabled={disabled}+ />+ </SlackUserLinkFormField>+ <SlackUserLinkFormField+ label="Slack team ID (optional)"+ htmlFor="slack-team-id"+ hint={+ <SlackUserLinkFormHint>+ Defaults to the installed Slack workspace. Set it for a Slack Connect+ user, using the team ID their messages carry.+ </SlackUserLinkFormHint>+ }+ >+ <SlackUserLinkTextInput+ id="slack-team-id"+ value={slackTeamId}+ onChange={(event) => onSlackTeamIdChange(event.target.value)}+ placeholder="T0123456789"+ disabled={disabled}+ />+ </SlackUserLinkFormField>+ </>+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsxnew file mode 100644index 00000000000..f5cb1639dfa--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackPickedEntityButton.tsx@@ -0,0 +1,72 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { themeCssVariables } from 'twenty-ui/theme-constants';++const StyledPickedEntity = styled.button`+ align-items: center;+ background: ${() => themeCssVariables.background.secondary};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.sm};+ box-sizing: border-box;+ cursor: pointer;+ display: flex;+ gap: ${() => themeCssVariables.spacing[2]};+ padding: ${() => themeCssVariables.spacing[2]};+ text-align: left;+ width: 100%;++ &:hover:enabled {+ border-color: ${() => themeCssVariables.color.blue};+ }++ &:disabled {+ cursor: default;+ }+`;++const StyledDetails = styled.div`+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[1]};+ min-width: 0;+`;++const StyledName = styled.span`+ color: ${() => themeCssVariables.font.color.primary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+`;++const StyledMeta = styled.span`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+`;++type SlackPickedEntityButtonProps = {+ name: string;+ meta?: string;+ changeLabel: string;+ onChangeRequest: () => void;+ disabled?: boolean;+};++export const SlackPickedEntityButton = ({+ name,+ meta,+ changeLabel,+ onChangeRequest,+ disabled,+}: SlackPickedEntityButtonProps) => (+ <StyledPickedEntity+ type="button"+ onClick={onChangeRequest}+ disabled={disabled}+ aria-label={changeLabel}+ >+ <StyledDetails>+ <StyledName>{name}</StyledName>+ {isNonEmptyString(meta) && <StyledMeta>{meta}</StyledMeta>}+ </StyledDetails>+ </StyledPickedEntity>+);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.tsxnew file mode 100644index 00000000000..9a9d68ae40a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkForm.tsx@@ -0,0 +1,253 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { enqueueSnackbar } from 'twenty-sdk/front-component';+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 { ResolvedSlackUserField } from 'src/front-components/components/ResolvedSlackUserField';+import { SlackConnectUserIdFields } from 'src/front-components/components/SlackConnectUserIdFields';+import { SlackUserLinkFormField } from 'src/front-components/components/SlackUserLinkFormField';+import { SlackUserLinkFormHint } from 'src/front-components/components/SlackUserLinkFormHint';+import { SlackUserLinkTextInput } from 'src/front-components/components/SlackUserLinkTextInput';+import { SlackUserPicker } from 'src/front-components/components/SlackUserPicker';+import { WorkspaceMemberPicker } from 'src/front-components/components/WorkspaceMemberPicker';+import { useAutoResolveSlackUser } from 'src/front-components/hooks/use-auto-resolve-slack-user';+import { useSetSlackUserLink } from 'src/front-components/hooks/use-set-slack-user-link';+import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { buildSlackUserLinkSaveNote } from 'src/front-components/utils/build-slack-user-link-save-note.util';++const StyledForm = styled.form`+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[4]};+`;++const StyledResolveError = styled.span`+ color: ${() => themeCssVariables.color.red};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+`;++const StyledDisclosureButton = styled.button`+ 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`+ display: flex;+ gap: ${() => themeCssVariables.spacing[2]};+`;++type SlackUserLinkFormProps = {+ existingLinks: SlackUserLinkRecord[];+ onLinkSaved: () => void;+};++export const SlackUserLinkForm = ({+ existingLinks,+ onLinkSaved,+}: SlackUserLinkFormProps) => {+ const [selectedMember, setSelectedMember] =+ useState<WorkspaceMemberOption | null>(null);+ const [name, setName] = useState('');+ const [slackUserId, setSlackUserId] = useState('');+ const [slackTeamId, setSlackTeamId] = useState('');+ const [isConnectUser, setIsConnectUser] = useState(false);+ const [isSlackSearchReopening, setIsSlackSearchReopening] = useState(false);++ const {+ resolvedUser,+ resolveError,+ isResolving,+ onIdentityChange,+ resolveNow,+ selectResolvedUser,+ clearResolution,+ } = useAutoResolveSlackUser();+ const { setSlackUserLink, isSubmitting } = useSetSlackUserLink();++ const canSubmit =+ isDefined(selectedMember) && isDefined(resolvedUser) && !isSubmitting;++ const existingLink = !isDefined(resolvedUser)+ ? undefined+ : existingLinks.find(+ (link) =>+ link.slackUserId === resolvedUser.slackUserId &&+ (!isNonEmptyString(link.slackTeamId) ||+ !isNonEmptyString(resolvedUser.slackTeamId) ||+ link.slackTeamId === resolvedUser.slackTeamId),+ );++ const resetForm = () => {+ setSelectedMember(null);+ setName('');+ setSlackUserId('');+ setSlackTeamId('');+ setIsConnectUser(false);+ setIsSlackSearchReopening(false);+ clearResolution();+ };++ const handleSubmit = async () => {+ if (!isDefined(selectedMember) || !isDefined(resolvedUser)) {+ return;+ }++ const result = await setSlackUserLink({+ workspaceMemberId: selectedMember.id,+ slackUserId: resolvedUser.slackUserId,+ slackTeamId: isNonEmptyString(resolvedUser.slackTeamId)+ ? resolvedUser.slackTeamId+ : undefined,+ name: isNonEmptyString(name.trim())+ ? name.trim()+ : resolvedUser.displayName,+ });++ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: result.success ? 'success' : 'error',+ });++ if (result.success) {+ resetForm();+ onLinkSaved();+ }+ };++ const handleFormSubmit = () => {+ if (!isDefined(resolvedUser)) {+ resolveNow({ slackUserId, slackTeamId });+ return;+ }++ if (canSubmit) {+ handleSubmit();+ }+ };++ return (+ <Section>+ <H2Title+ title="Link a Slack user"+ description="Pick a workspace member and the Slack account whose messages should act with that member's permissions. A link whose Slack email matches the member activates immediately; other in-workspace links ask the Slack user to approve first."+ />+ <StyledForm+ onSubmit={(event) => {+ event.preventDefault();+ handleFormSubmit();+ }}+ >+ <SlackUserLinkFormField label="Workspace member">+ <WorkspaceMemberPicker+ selectedMember={selectedMember}+ onSelect={setSelectedMember}+ onClear={() => setSelectedMember(null)}+ disabled={isSubmitting}+ />+ </SlackUserLinkFormField>+ {isDefined(resolvedUser) ? (+ <SlackUserLinkFormField label="Slack user">+ <ResolvedSlackUserField+ resolvedUser={resolvedUser}+ onChangeRequest={() => {+ setIsSlackSearchReopening(true);+ setName('');+ clearResolution();+ }}+ disabled={isSubmitting}+ />+ </SlackUserLinkFormField>+ ) : (+ <>+ <SlackUserLinkFormField label="Slack user">+ <SlackUserPicker+ onSelect={selectResolvedUser}+ disabled={isSubmitting}+ autoFocus={isSlackSearchReopening}+ />+ </SlackUserLinkFormField>+ {isConnectUser ? (+ <SlackConnectUserIdFields+ slackUserId={slackUserId}+ slackTeamId={slackTeamId}+ onSlackUserIdChange={(nextSlackUserId) => {+ setSlackUserId(nextSlackUserId);+ onIdentityChange({+ slackUserId: nextSlackUserId,+ slackTeamId,+ });+ }}+ onSlackTeamIdChange={(nextSlackTeamId) => {+ setSlackTeamId(nextSlackTeamId);+ onIdentityChange({+ slackUserId,+ slackTeamId: nextSlackTeamId,+ });+ }}+ disabled={isSubmitting}+ />+ ) : (+ <StyledDisclosureButton+ type="button"+ onClick={() => setIsConnectUser(true)}+ >+ Guest or Slack Connect user? Link by Slack ID instead+ </StyledDisclosureButton>+ )}+ {isResolving ? (+ <SlackUserLinkFormHint>+ Finding the Slack user…+ </SlackUserLinkFormHint>+ ) : isDefined(resolveError) ? (+ <StyledResolveError>{resolveError}</StyledResolveError>+ ) : null}+ </>+ )}+ <SlackUserLinkFormField+ label="Display name (optional)"+ htmlFor="slack-display-name"+ >+ <SlackUserLinkTextInput+ id="slack-display-name"+ value={name}+ onChange={(event) => setName(event.target.value)}+ placeholder={resolvedUser?.displayName ?? 'Ada Lovelace'}+ disabled={isSubmitting}+ />+ </SlackUserLinkFormField>+ {isDefined(resolvedUser) && (+ <SlackUserLinkFormHint>+ {buildSlackUserLinkSaveNote({+ resolvedUser,+ selectedMember,+ existingLink,+ })}+ </SlackUserLinkFormHint>+ )}+ <StyledActions>+ <Button+ type="button"+ title={isSubmitting ? 'Saving…' : 'Save link'}+ variant="primary"+ accent="blue"+ disabled={!canSubmit}+ onClick={handleSubmit}+ />+ </StyledActions>+ </StyledForm>+ </Section>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormField.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormField.tsxnew file mode 100644index 00000000000..ee6b4f828ad--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormField.tsx@@ -0,0 +1,36 @@+import styled from '@emotion/styled';+import { type ReactNode } from 'react';+import { themeCssVariables } from 'twenty-ui/theme-constants';++const StyledField = styled.div`+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[1]};+`;++const StyledLabel = styled.label`+ color: ${() => themeCssVariables.font.color.secondary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ font-weight: ${() => themeCssVariables.font.weight.medium};+`;++type SlackUserLinkFormFieldProps = {+ label: string;+ htmlFor?: string;+ children: ReactNode;+ hint?: ReactNode;+};++export const SlackUserLinkFormField = ({+ label,+ htmlFor,+ children,+ hint,+}: SlackUserLinkFormFieldProps) => (+ <StyledField>+ <StyledLabel htmlFor={htmlFor}>{label}</StyledLabel>+ {children}+ {hint}+ </StyledField>+);diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormHint.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormHint.tsxnew file mode 100644index 00000000000..15f87e0a2ce--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkFormHint.tsx@@ -0,0 +1,8 @@+import styled from '@emotion/styled';+import { themeCssVariables } from 'twenty-ui/theme-constants';++export const SlackUserLinkFormHint = styled.span`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+`;diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkTextInput.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkTextInput.tsxnew file mode 100644index 00000000000..214c0ee96bd--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinkTextInput.tsx@@ -0,0 +1,34 @@+import styled from '@emotion/styled';+import { themeCssVariables } from 'twenty-ui/theme-constants';++export const SlackUserLinkTextInput = styled.input`+ background-color: ${() => themeCssVariables.background.transparent.lighter};+ border: 1px solid ${() => themeCssVariables.border.color.medium};+ border-radius: ${() => themeCssVariables.border.radius.md};+ box-sizing: border-box;+ color: ${() => themeCssVariables.font.color.primary};+ display: flex;+ flex-grow: 1;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.md};+ font-weight: ${() => themeCssVariables.font.weight.regular};+ height: 32px;+ outline: none;+ padding: ${() => themeCssVariables.spacing[2]};+ text-overflow: ellipsis;+ width: 100%;++ &::placeholder {+ color: ${() => themeCssVariables.font.color.light};+ font-family: ${() => themeCssVariables.font.family};+ font-weight: ${() => themeCssVariables.font.weight.medium};+ }++ &:disabled {+ color: ${() => themeCssVariables.font.color.tertiary};+ }++ &:focus {+ border-color: ${() => themeCssVariables.color.blue};+ }+`;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.tsxnew file mode 100644index 00000000000..5d8b887e887--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksList.tsx@@ -0,0 +1,242 @@+import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { useState } from 'react';+import { isDefined } from 'twenty-sdk/utils';+import { Tag } from 'twenty-ui/data-display';+import { themeCssVariables } from 'twenty-ui/theme-constants';++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 StyledRow = 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]};+ min-width: 0;+`;++const StyledName = styled.span`+ 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};+`;++const StyledRight = styled.div`+ align-items: flex-end;+ 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]};+`;++const StyledActionButton = styled.button`+ background: transparent;+ border: none;+ color: ${() => themeCssVariables.color.blue};+ cursor: pointer;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.xs};+ padding: 0;++ &:disabled {+ color: ${() => themeCssVariables.font.color.tertiary};+ cursor: default;+ }+`;++const StyledEmptyState = styled.div`+ color: ${() => themeCssVariables.font.color.tertiary};+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ padding: ${() => themeCssVariables.spacing[2]};+`;++type TagColor = 'blue' | 'green' | 'orange' | 'red' | 'gray';++const getSourceLabel = (source: string | null): string =>+ source === SLACK_USER_LINK_SOURCE.MANUAL+ ? 'Set manually'+ : 'Matched on email';++const getSourceColor = (source: string | null): TagColor =>+ source === SLACK_USER_LINK_SOURCE.MANUAL ? 'blue' : 'green';++// An absent state is a pre-consent link and still lends access; a state this+// version cannot interpret is not the same thing and is left unlabelled.+const toDisplayedConsentState = (+ consentState: string | null,+): SlackUserLinkConsentState | undefined => {+ if (!isNonEmptyString(consentState)) {+ return SLACK_USER_LINK_CONSENT_STATE.ACTIVE;+ }++ return isSlackUserLinkConsentState(consentState) ? consentState : undefined;+};++const CONSENT_LABELS: Record<SlackUserLinkConsentState, string> = {+ [SLACK_USER_LINK_CONSENT_STATE.ACTIVE]: 'Active',+ [SLACK_USER_LINK_CONSENT_STATE.PENDING]: 'Awaiting consent',+ [SLACK_USER_LINK_CONSENT_STATE.DECLINED]: 'Declined',+ [SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET]: 'Admin set',+};++const CONSENT_COLORS: Record<SlackUserLinkConsentState, TagColor> = {+ [SLACK_USER_LINK_CONSENT_STATE.ACTIVE]: 'green',+ [SLACK_USER_LINK_CONSENT_STATE.PENDING]: 'orange',+ [SLACK_USER_LINK_CONSENT_STATE.DECLINED]: 'red',+ [SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET]: 'gray',+};++type SlackUserLinksListProps = {+ slackUserLinks: SlackUserLinkRecord[];+ canManage: boolean;+ hasMore?: boolean;+ onRemove: (slackUserLink: SlackUserLinkRecord) => void;+ onResend: (slackUserLink: SlackUserLinkRecord) => void;+ removingLinkId: string | undefined;+ resendingLinkId: string | undefined;+};++export const SlackUserLinksList = ({+ slackUserLinks,+ canManage,+ hasMore = false,+ onRemove,+ onResend,+ removingLinkId,+ resendingLinkId,+}: SlackUserLinksListProps) => {+ const [removalArmedLinkId, setRemovalArmedLinkId] = useState<string | null>(+ null,+ );++ const isActionInFlight =+ isDefined(removingLinkId) || isDefined(resendingLinkId);++ if (slackUserLinks.length === 0) {+ return <StyledEmptyState>No Slack user links yet.</StyledEmptyState>;+ }++ 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>+ {isDefined(consentState) && (+ <Tag+ color={CONSENT_COLORS[consentState]}+ text={CONSENT_LABELS[consentState]}+ />+ )}+ <Tag+ 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>+ );+};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.tsxnew file mode 100644index 00000000000..26d37cd7b01--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserLinksSettings.tsx@@ -0,0 +1,138 @@+import 'twenty-ui/style.css';++import styled from '@emotion/styled';+import { isNonEmptyString } from '@sniptt/guards';+import { enqueueSnackbar } from 'twenty-sdk/front-component';+import { isDefined } from 'twenty-sdk/utils';+import { Callout } from 'twenty-ui/feedback';+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 { useCanManageSlackUserLinks } from 'src/front-components/hooks/use-can-manage-slack-user-links';+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 { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';++const StyledContainer = styled.div`+ box-sizing: border-box;+ display: flex;+ flex-direction: column;+ gap: ${() => themeCssVariables.spacing[8]};+ width: 100%;+`;++const StyledCenteredState = styled.div`+ align-items: center;+ box-sizing: border-box;+ color: ${() => themeCssVariables.font.color.tertiary};+ display: flex;+ font-family: ${() => themeCssVariables.font.family};+ font-size: ${() => themeCssVariables.font.size.sm};+ height: 100%;+ justify-content: center;+ padding: ${() => themeCssVariables.spacing[4]};+ width: 100%;+`;++export const SlackUserLinksSettings = () => {+ const { canManage, isPermissionLoading } = useCanManageSlackUserLinks();+ const {+ slackUserLinks,+ isSlackUserLinksLoading,+ errorMessage,+ hasMoreSlackUserLinks,+ refetchSlackUserLinks,+ } = useSlackUserLinks();+ const { removeSlackUserLink, removingLinkId } = useRemoveSlackUserLink();+ const { resendConsent, resendingLinkId } = useResendSlackUserLinkConsent();++ const handleRemove = async (slackUserLink: SlackUserLinkRecord) => {+ const result = await removeSlackUserLink(slackUserLink.id);++ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: result.success ? 'success' : 'error',+ });++ if (result.success) {+ await refetchSlackUserLinks();+ }+ };++ const handleResend = async (slackUserLink: SlackUserLinkRecord) => {+ if (+ !isNonEmptyString(slackUserLink.slackTeamId) ||+ !isNonEmptyString(slackUserLink.slackUserId)+ ) {+ enqueueSnackbar({+ message:+ 'This link is missing its Slack ids, so the request cannot be resent.',+ variant: 'error',+ });++ return;+ }++ const result = await resendConsent({+ id: slackUserLink.id,+ slackTeamId: slackUserLink.slackTeamId,+ slackUserId: slackUserLink.slackUserId,+ });++ enqueueSnackbar({+ message: isNonEmptyString(result.error) ? result.error : result.message,+ variant: result.success ? 'success' : 'error',+ });++ if (result.success) {+ await refetchSlackUserLinks();+ }+ };++ if (isPermissionLoading) {+ return <StyledCenteredState>Loading Slack user links…</StyledCenteredState>;+ }++ return (+ <StyledContainer>+ {!canManage && (+ <Callout+ variant="warning"+ title="You need the roles permission"+ description="Only members with the roles permission can create or change Slack user links. You can review the existing links below."+ />+ )}+ {canManage && (+ <SlackUserLinkForm+ existingLinks={slackUserLinks}+ onLinkSaved={refetchSlackUserLinks}+ />+ )}+ <Section>+ <H2Title+ title="Slack user links"+ description="Each link maps a Slack account to the workspace member whose permissions the assistant borrows."+ />+ {isSlackUserLinksLoading && slackUserLinks.length === 0 ? (+ <StyledCenteredState>Loading links…</StyledCenteredState>+ ) : isDefined(errorMessage) ? (+ <StyledCenteredState>{errorMessage}</StyledCenteredState>+ ) : (+ <SlackUserLinksList+ slackUserLinks={slackUserLinks}+ canManage={canManage}+ hasMore={hasMoreSlackUserLinks}+ onRemove={handleRemove}+ onResend={handleResend}+ removingLinkId={removingLinkId}+ resendingLinkId={resendingLinkId}+ />+ )}+ </Section>+ </StyledContainer>+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsx b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsxnew file mode 100644index 00000000000..efed8089e46--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/SlackUserPicker.tsx@@ -0,0 +1,43 @@+import { useState } from 'react';++import { SearchDropdownPicker } from 'src/front-components/components/SearchDropdownPicker';+import { useSlackUserSearch } from 'src/front-components/hooks/use-slack-user-search';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++type SlackUserPickerProps = {+ onSelect: (slackUser: SlackResolvedUser) => void;+ disabled?: boolean;+ autoFocus?: boolean;+};++export const SlackUserPicker = ({+ onSelect,+ disabled,+ autoFocus,+}: SlackUserPickerProps) => {+ const [searchTerm, setSearchTerm] = useState('');+ const { options, isSearching, searchErrorMessage } =+ useSlackUserSearch(searchTerm);++ return (+ <SearchDropdownPicker+ searchTerm={searchTerm}+ onSearchTermChange={setSearchTerm}+ options={options}+ isSearching={isSearching}+ onSelect={onSelect}+ getOptionKey={(slackUser) => slackUser.slackUserId}+ getOptionName={(slackUser) =>+ slackUser.displayName ?? slackUser.slackUserId+ }+ getOptionMeta={(slackUser) => slackUser.email}+ searchLabel="Search Slack by name or email"+ emptyText={+ searchErrorMessage ??+ 'No Slack users found. For a guest or Slack Connect user, link by Slack ID below.'+ }+ disabled={disabled}+ autoFocus={autoFocus}+ />+ );+};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.tsxnew file mode 100644index 00000000000..09d1430622d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/components/WorkspaceMemberPicker.tsx@@ -0,0 +1,67 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';+import { useState } from 'react';++import { SearchDropdownPicker } from 'src/front-components/components/SearchDropdownPicker';+import { 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';++type WorkspaceMemberPickerProps = {+ selectedMember: WorkspaceMemberOption | null;+ onSelect: (member: WorkspaceMemberOption) => void;+ onClear: () => void;+ disabled?: boolean;+};++export const WorkspaceMemberPicker = ({+ selectedMember,+ onSelect,+ onClear,+ disabled,+}: WorkspaceMemberPickerProps) => {+ const [searchTerm, setSearchTerm] = useState('');+ const [isReopening, setIsReopening] = useState(false);+ const { options, isSearching, searchErrorMessage } =+ useWorkspaceMemberSearch(searchTerm);++ if (isDefined(selectedMember)) {+ return (+ <SlackPickedEntityButton+ name={+ isNonEmptyString(selectedMember.name)+ ? selectedMember.name+ : (selectedMember.userEmail ?? selectedMember.id)+ }+ changeLabel="Change the workspace member"+ onChangeRequest={() => {+ setIsReopening(true);+ onClear();+ }}+ disabled={disabled}+ />+ );+ }++ return (+ <SearchDropdownPicker+ searchTerm={searchTerm}+ onSearchTermChange={setSearchTerm}+ options={options}+ isSearching={isSearching}+ onSelect={(member) => {+ setIsReopening(false);+ onSelect(member);+ }}+ getOptionKey={(member) => member.id}+ getOptionName={(member) =>+ isNonEmptyString(member.name) ? member.name : member.id+ }+ getOptionMeta={(member) => member.userEmail ?? undefined}+ searchLabel="Search a workspace member by name"+ emptyText={searchErrorMessage ?? 'No members found'}+ disabled={disabled}+ autoFocus={isReopening}+ />+ );+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-auto-resolve-slack-user.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-auto-resolve-slack-user.tsnew file mode 100644index 00000000000..54aa2414c31--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-auto-resolve-slack-user.ts@@ -0,0 +1,99 @@+import { useEffect, useRef, useState } from 'react';++import { useResolveSlackUser } from 'src/front-components/hooks/use-resolve-slack-user';+import { isResolvableSlackIdentity } from 'src/front-components/utils/is-resolvable-slack-identity.util';+import {+ type SlackResolveInput,+ toSlackResolveInput,+} from 'src/front-components/utils/to-slack-resolve-input.util';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++const AUTO_RESOLVE_DEBOUNCE_MS = 600;++type RawSlackIdentity = {+ slackUserId: string;+ slackTeamId: string;+};++export const useAutoResolveSlackUser = () => {+ const [resolvedUser, setResolvedUser] = useState<SlackResolvedUser | null>(+ null,+ );+ const [resolveError, setResolveError] = useState<string | null>(null);+ const resolveRequestIdRef = useRef(0);+ const autoResolveTimerRef = useRef<ReturnType<typeof setTimeout>>();++ const { resolveSlackUser, isResolving } = useResolveSlackUser();++ useEffect(() => () => clearTimeout(autoResolveTimerRef.current), []);++ const resolveIdentity = async (input: SlackResolveInput) => {+ const requestId = resolveRequestIdRef.current;++ const result = await resolveSlackUser(input);++ if (requestId !== resolveRequestIdRef.current) {+ return;+ }++ if (!result.success) {+ setResolvedUser(null);+ setResolveError(result.error);+ return;+ }++ setResolvedUser(result.slackUser);+ setResolveError(null);+ };++ const clearResolution = () => {+ resolveRequestIdRef.current += 1;+ clearTimeout(autoResolveTimerRef.current);+ setResolvedUser(null);+ setResolveError(null);+ };++ const onIdentityChange = (rawIdentity: RawSlackIdentity) => {+ clearResolution();++ const input = toSlackResolveInput(rawIdentity);++ if (!isResolvableSlackIdentity(input)) {+ return;+ }++ autoResolveTimerRef.current = setTimeout(() => {+ resolveIdentity(input);+ }, AUTO_RESOLVE_DEBOUNCE_MS);+ };++ const selectResolvedUser = (slackUser: SlackResolvedUser) => {+ clearResolution();+ setResolvedUser(slackUser);+ };++ const resolveNow = (rawIdentity: RawSlackIdentity) => {+ const input = toSlackResolveInput(rawIdentity);++ if (!isResolvableSlackIdentity(input)) {+ setResolveError(+ 'Search for the Slack user by name or email, or enter their full Slack user id.',+ );++ return;+ }++ clearResolution();+ resolveIdentity(input);+ };++ return {+ resolvedUser,+ resolveError,+ isResolving,+ onIdentityChange,+ resolveNow,+ selectResolvedUser,+ clearResolution,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-can-manage-slack-user-links.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-can-manage-slack-user-links.tsnew file mode 100644index 00000000000..3296ce242ae--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-can-manage-slack-user-links.ts@@ -0,0 +1,40 @@+import { useEffect, useState } from 'react';++import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';++type CanManageSlackUserLinksState = {+ canManage: boolean;+ isPermissionLoading: boolean;+};++const LOADING_STATE: CanManageSlackUserLinksState = {+ canManage: false,+ isPermissionLoading: true,+};++export const useCanManageSlackUserLinks = (): CanManageSlackUserLinksState => {+ const [state, setState] =+ useState<CanManageSlackUserLinksState>(LOADING_STATE);++ useEffect(() => {+ let cancelled = false;++ setState(LOADING_STATE);++ const fetchPermission = async () => {+ const canManage = await currentUserHasRolesPermission();++ if (!cancelled) {+ setState({ canManage, isPermissionLoading: false });+ }+ };++ fetchPermission();++ return () => {+ cancelled = true;+ };+ }, []);++ return state;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-user-link.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-user-link.tsnew file mode 100644index 00000000000..7bc1dd35b06--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-remove-slack-user-link.ts@@ -0,0 +1,21 @@+import { SLACK_USER_LINKS_REMOVE_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { useSlackToolPost } from 'src/front-components/hooks/use-slack-tool-post';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++type RemoveSlackUserLinkState = {+ removeSlackUserLink: (id: string) => Promise<SlackToolResult>;+ removingLinkId: string | undefined;+};++export const useRemoveSlackUserLink = (): RemoveSlackUserLinkState => {+ const { postSlackTool, inFlightLinkId } = useSlackToolPost({+ routePath: SLACK_USER_LINKS_REMOVE_ROUTE_PATH,+ fallbackMessage: 'Could not remove the link',+ busyError: 'Another removal is still in progress. Please wait.',+ });++ return {+ removeSlackUserLink: (id) => postSlackTool({ linkId: id, payload: { id } }),+ removingLinkId: inFlightLinkId,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-resend-slack-user-link-consent.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-resend-slack-user-link-consent.tsnew file mode 100644index 00000000000..2ccd06cab94--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-resend-slack-user-link-consent.ts@@ -0,0 +1,29 @@+import { SLACK_USER_LINKS_RESEND_CONSENT_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { useSlackToolPost } from 'src/front-components/hooks/use-slack-tool-post';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++type ResendConsentInput = {+ id: string;+ slackTeamId: string;+ slackUserId: string;+};++type ResendSlackUserLinkConsentState = {+ resendConsent: (input: ResendConsentInput) => Promise<SlackToolResult>;+ resendingLinkId: string | undefined;+};++export const useResendSlackUserLinkConsent =+ (): ResendSlackUserLinkConsentState => {+ const { postSlackTool, inFlightLinkId } = useSlackToolPost({+ routePath: SLACK_USER_LINKS_RESEND_CONSENT_ROUTE_PATH,+ fallbackMessage: 'Could not resend the consent request',+ busyError: 'Another consent request is still being sent. Please wait.',+ });++ return {+ resendConsent: ({ id, slackTeamId, slackUserId }) =>+ postSlackTool({ linkId: id, payload: { slackTeamId, slackUserId } }),+ resendingLinkId: inFlightLinkId,+ };+ };diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-resolve-slack-user.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-resolve-slack-user.tsnew file mode 100644index 00000000000..bb654676f90--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-resolve-slack-user.ts@@ -0,0 +1,42 @@+import { useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { SLACK_USER_LINKS_RESOLVE_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import {+ GENERIC_RESOLVE_ERROR,+ parseResolveSlackUserResult,+ type ResolveSlackUserResult,+} from 'src/front-components/utils/parse-resolve-slack-user-result.util';+import { type SlackResolveInput } from 'src/front-components/utils/to-slack-resolve-input.util';++type ResolveSlackUserState = {+ resolveSlackUser: (+ input: SlackResolveInput,+ ) => Promise<ResolveSlackUserResult>;+ isResolving: boolean;+};++export const useResolveSlackUser = (): ResolveSlackUserState => {+ const [inFlightResolveCount, setInFlightResolveCount] = useState(0);++ const resolveSlackUser = async (+ input: SlackResolveInput,+ ): Promise<ResolveSlackUserResult> => {+ setInFlightResolveCount((count) => count + 1);++ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_RESOLVE_ROUTE_PATH}`,+ input,+ );++ return parseResolveSlackUserResult(result);+ } catch {+ return GENERIC_RESOLVE_ERROR;+ } finally {+ setInFlightResolveCount((count) => count - 1);+ }+ };++ return { resolveSlackUser, isResolving: inFlightResolveCount > 0 };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-user-link.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-user-link.tsnew file mode 100644index 00000000000..e775d5e3b57--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-set-slack-user-link.ts@@ -0,0 +1,48 @@+import { useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { SLACK_USER_LINKS_SET_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { parseSlackToolResult } from 'src/front-components/utils/parse-slack-tool-result.util';+import { type SlackSetUserLinkInput } from 'src/logic-functions/types/slack-set-user-link-input.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++const FALLBACK_MESSAGE = 'Could not save the link';++const GENERIC_ERROR_RESULT: SlackToolResult = {+ success: false,+ message: FALLBACK_MESSAGE,+ error: 'The request failed. Please try again.',+};++type SetSlackUserLinkState = {+ setSlackUserLink: (input: SlackSetUserLinkInput) => Promise<SlackToolResult>;+ isSubmitting: boolean;+};++export const useSetSlackUserLink = (): SetSlackUserLinkState => {+ const [isSubmitting, setIsSubmitting] = useState(false);++ const setSlackUserLink = async (+ input: SlackSetUserLinkInput,+ ): Promise<SlackToolResult> => {+ setIsSubmitting(true);++ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_SET_ROUTE_PATH}`,+ input,+ );++ return parseSlackToolResult({+ value: result,+ fallbackMessage: FALLBACK_MESSAGE,+ });+ } catch {+ return GENERIC_ERROR_RESULT;+ } finally {+ setIsSubmitting(false);+ }+ };++ return { setSlackUserLink, isSubmitting };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-tool-post.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-tool-post.tsnew file mode 100644index 00000000000..d28a843aa78--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-tool-post.ts@@ -0,0 +1,64 @@+import { useRef, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';+import { parseSlackToolResult } from 'src/front-components/utils/parse-slack-tool-result.util';++type SlackToolPostState = {+ postSlackTool: (input: {+ linkId: string;+ payload: Record<string, unknown>;+ }) => Promise<SlackToolResult>;+ inFlightLinkId: string | undefined;+};++export const useSlackToolPost = ({+ routePath,+ fallbackMessage,+ busyError,+}: {+ routePath: string;+ fallbackMessage: string;+ busyError: string;+}): SlackToolPostState => {+ const [inFlightLinkId, setInFlightLinkId] = useState<string | undefined>(+ undefined,+ );+ const isPostingRef = useRef(false);++ const postSlackTool = async ({+ linkId,+ payload,+ }: {+ linkId: string;+ payload: Record<string, unknown>;+ }): Promise<SlackToolResult> => {+ if (isPostingRef.current) {+ return {+ success: false,+ message: fallbackMessage,+ error: busyError,+ };+ }++ isPostingRef.current = true;+ setInFlightLinkId(linkId);++ try {+ const result = await new RestApiClient().post(`/s${routePath}`, payload);++ return parseSlackToolResult({ value: result, fallbackMessage });+ } catch {+ return {+ success: false,+ message: fallbackMessage,+ error: 'The request failed. Please try again.',+ };+ } finally {+ isPostingRef.current = false;+ setInFlightLinkId(undefined);+ }+ };++ return { postSlackTool, inFlightLinkId };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-links.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-links.tsnew file mode 100644index 00000000000..5277c2ca005--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-links.ts@@ -0,0 +1,126 @@+import { isNonEmptyString, isNumber } from '@sniptt/guards';+import { useCallback, useEffect, useRef, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+import { formatWorkspaceMemberName } from 'src/front-components/utils/format-workspace-member-name.util';++const SLACK_USER_LINKS_PAGE_SIZE = 200;++const SLACK_USER_LINKS_ERROR_MESSAGE =+ 'Could not load Slack user links. Please try again later.';++type SlackUserLinkRestRecord = {+ id?: string | null;+ name?: string | null;+ slackUserId?: string | null;+ slackTeamId?: string | null;+ source?: string | null;+ consentState?: string | null;+ workspaceMemberId?: string | null;+ workspaceMember?: {+ id?: string | null;+ name?: { firstName?: string | null; lastName?: string | null } | null;+ } | null;+};++type SlackUserLinksResponse = {+ data?: { slackUserLinks?: SlackUserLinkRestRecord[] | null } | null;+ totalCount?: number | null;+};++type SlackUserLinksState = {+ slackUserLinks: SlackUserLinkRecord[];+ isSlackUserLinksLoading: boolean;+ errorMessage: string | undefined;+ hasMoreSlackUserLinks: boolean;+ refetchSlackUserLinks: () => Promise<void>;+};++export const useSlackUserLinks = (): SlackUserLinksState => {+ const [slackUserLinks, setSlackUserLinks] = useState<SlackUserLinkRecord[]>(+ [],+ );+ const [isSlackUserLinksLoading, setIsSlackUserLinksLoading] = useState(true);+ const [errorMessage, setErrorMessage] = useState<string | undefined>(+ undefined,+ );+ const [hasMoreSlackUserLinks, setHasMoreSlackUserLinks] = useState(false);+ const fetchIdRef = useRef(0);++ const fetchSlackUserLinks = useCallback(async () => {+ fetchIdRef.current += 1;+ const fetchId = fetchIdRef.current;++ setIsSlackUserLinksLoading(true);+ setErrorMessage(undefined);++ try {+ const response = await new RestApiClient().get<SlackUserLinksResponse>(+ '/rest/slackUserLinks',+ {+ query: {+ depth: '1',+ limit: String(SLACK_USER_LINKS_PAGE_SIZE),+ },+ },+ );++ const records: SlackUserLinkRecord[] = [];++ for (const record of response.data?.slackUserLinks ?? []) {+ if (!isNonEmptyString(record.id)) {+ continue;+ }++ records.push({+ id: record.id,+ name: record.name ?? null,+ slackUserId: record.slackUserId ?? null,+ slackTeamId: record.slackTeamId ?? null,+ source: record.source ?? null,+ consentState: record.consentState ?? null,+ workspaceMemberId: record.workspaceMemberId ?? null,+ workspaceMemberName: record.workspaceMember+ ? formatWorkspaceMemberName(record.workspaceMember.name)+ : null,+ });+ }++ records.sort((left, right) =>+ (left.name ?? left.slackUserId ?? '').localeCompare(+ right.name ?? right.slackUserId ?? '',+ ),+ );++ if (fetchId !== fetchIdRef.current) {+ return;+ }++ setHasMoreSlackUserLinks(+ isNumber(response.totalCount) && response.totalCount > records.length,+ );+ setSlackUserLinks(records);+ } catch {+ if (fetchId === fetchIdRef.current) {+ setErrorMessage(SLACK_USER_LINKS_ERROR_MESSAGE);+ }+ } finally {+ if (fetchId === fetchIdRef.current) {+ setIsSlackUserLinksLoading(false);+ }+ }+ }, []);++ useEffect(() => {+ fetchSlackUserLinks();+ }, [fetchSlackUserLinks]);++ return {+ slackUserLinks,+ isSlackUserLinksLoading,+ errorMessage,+ hasMoreSlackUserLinks,+ refetchSlackUserLinks: fetchSlackUserLinks,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.ts b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.tsnew file mode 100644index 00000000000..adf080eb0f6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-slack-user-search.ts@@ -0,0 +1,79 @@+import { isNonEmptyString } from '@sniptt/guards';+import { useEffect, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { SLACK_USER_LINKS_SEARCH_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import {+ FALLBACK_SEARCH_ERROR_MESSAGE,+ parseSlackUserSearchResponse,+} from 'src/front-components/utils/parse-slack-user-search-response.util';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++const SLACK_USER_SEARCH_DEBOUNCE_MS = 400;++type SlackUserSearchState = {+ options: SlackResolvedUser[];+ isSearching: boolean;+ searchErrorMessage: string | undefined;+};++export const useSlackUserSearch = (+ searchTerm: string,+): SlackUserSearchState => {+ const [options, setOptions] = useState<SlackResolvedUser[]>([]);+ const [isSearching, setIsSearching] = useState(false);+ const [searchErrorMessage, setSearchErrorMessage] = useState<+ string | undefined+ >(undefined);++ useEffect(() => {+ const trimmedSearchTerm = searchTerm.trim();++ if (!isNonEmptyString(trimmedSearchTerm)) {+ setOptions([]);+ setSearchErrorMessage(undefined);+ setIsSearching(false);++ return;+ }++ let cancelled = false;++ setOptions([]);+ setSearchErrorMessage(undefined);+ setIsSearching(true);++ const timeoutId = setTimeout(async () => {+ try {+ const result = await new RestApiClient().post(+ `/s${SLACK_USER_LINKS_SEARCH_ROUTE_PATH}`,+ { query: trimmedSearchTerm },+ );++ if (!cancelled) {+ const { options: parsedOptions, errorMessage } =+ parseSlackUserSearchResponse(result);++ setOptions(parsedOptions);+ setSearchErrorMessage(errorMessage);+ }+ } catch {+ if (!cancelled) {+ setOptions([]);+ setSearchErrorMessage(FALLBACK_SEARCH_ERROR_MESSAGE);+ }+ } finally {+ if (!cancelled) {+ setIsSearching(false);+ }+ }+ }, SLACK_USER_SEARCH_DEBOUNCE_MS);++ return () => {+ cancelled = true;+ clearTimeout(timeoutId);+ };+ }, [searchTerm]);++ return { options, isSearching, searchErrorMessage };+};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.tsnew file mode 100644index 00000000000..3d0087366a7--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/hooks/use-workspace-member-search.ts@@ -0,0 +1,107 @@+import { isNonEmptyString } from '@sniptt/guards';+import { useEffect, useState } from 'react';+import { RestApiClient } from 'twenty-client-sdk/rest';++import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { buildWorkspaceMemberSearchFilter } from 'src/front-components/utils/build-workspace-member-search-filter.util';+import { formatWorkspaceMemberName } from 'src/front-components/utils/format-workspace-member-name.util';++const WORKSPACE_MEMBER_SEARCH_DEBOUNCE_MS = 250;+const WORKSPACE_MEMBER_SEARCH_PAGE_SIZE = 20;++const MEMBER_SEARCH_ERROR_MESSAGE =+ 'Workspace member search failed. Try again.';++type WorkspaceMemberRestRecord = {+ id?: string | null;+ name?: { firstName?: string | null; lastName?: string | null } | null;+ userEmail?: string | null;+};++type WorkspaceMembersResponse = {+ data?: { workspaceMembers?: WorkspaceMemberRestRecord[] | null } | null;+};++type WorkspaceMemberSearchState = {+ options: WorkspaceMemberOption[];+ isSearching: boolean;+ searchErrorMessage: string | undefined;+};++export const useWorkspaceMemberSearch = (+ searchTerm: string,+): WorkspaceMemberSearchState => {+ const [options, setOptions] = useState<WorkspaceMemberOption[]>([]);+ const [isSearching, setIsSearching] = useState(false);+ const [searchErrorMessage, setSearchErrorMessage] = useState<+ string | undefined+ >(undefined);++ useEffect(() => {+ const filter = buildWorkspaceMemberSearchFilter(searchTerm);++ setOptions([]);+ setSearchErrorMessage(undefined);++ if (!isNonEmptyString(filter)) {+ setIsSearching(false);++ return;+ }++ let cancelled = false;++ setIsSearching(true);++ const timeoutId = setTimeout(async () => {+ try {+ const response =+ await new RestApiClient().get<WorkspaceMembersResponse>(+ '/rest/workspaceMembers',+ {+ query: {+ filter,+ limit: String(WORKSPACE_MEMBER_SEARCH_PAGE_SIZE),+ },+ },+ );++ if (cancelled) {+ return;+ }++ const memberOptions: WorkspaceMemberOption[] = [];++ for (const record of response.data?.workspaceMembers ?? []) {+ if (!isNonEmptyString(record.id)) {+ continue;+ }++ memberOptions.push({+ id: record.id,+ name: formatWorkspaceMemberName(record.name),+ userEmail: record.userEmail ?? null,+ });+ }++ setOptions(memberOptions);+ } catch {+ if (!cancelled) {+ setOptions([]);+ setSearchErrorMessage(MEMBER_SEARCH_ERROR_MESSAGE);+ }+ } finally {+ if (!cancelled) {+ setIsSearching(false);+ }+ }+ }, WORKSPACE_MEMBER_SEARCH_DEBOUNCE_MS);++ return () => {+ cancelled = true;+ clearTimeout(timeoutId);+ };+ }, [searchTerm]);++ return { options, isSearching, searchErrorMessage };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/slack-user-links-settings.front-component.tsx b/packages/twenty-apps/public/slack/src/front-components/slack-user-links-settings.front-component.tsxnew file mode 100644index 00000000000..946e0de01e3--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/slack-user-links-settings.front-component.tsx@@ -0,0 +1,13 @@+import { defineSettingsFrontComponent } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_SETTINGS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { SlackUserLinksSettings } from 'src/front-components/components/SlackUserLinksSettings';++export default defineSettingsFrontComponent({+ universalIdentifier:+ SLACK_USER_LINKS_SETTINGS_FRONT_COMPONENT_UNIVERSAL_IDENTIFIER,+ name: 'slack-user-links-settings',+ description:+ 'Manage Slack user links: review existing links and, with the roles permission, link a Slack account to a workspace member.',+ component: SlackUserLinksSettings,+});diff --git a/packages/twenty-apps/public/slack/src/front-components/types/slack-user-link-record.type.ts b/packages/twenty-apps/public/slack/src/front-components/types/slack-user-link-record.type.tsnew file mode 100644index 00000000000..15c47a7c1cc--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/types/slack-user-link-record.type.ts@@ -0,0 +1,10 @@+export type SlackUserLinkRecord = {+ id: string;+ name: string | null;+ slackUserId: string | null;+ slackTeamId: string | null;+ source: string | null;+ consentState: string | null;+ workspaceMemberId: string | null;+ workspaceMemberName: string | null;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/types/workspace-member-option.type.ts b/packages/twenty-apps/public/slack/src/front-components/types/workspace-member-option.type.tsnew file mode 100644index 00000000000..bceaac40284--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/types/workspace-member-option.type.ts@@ -0,0 +1,5 @@+export type WorkspaceMemberOption = {+ id: string;+ name: string;+ userEmail: string | null;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-slack-user-link-save-note.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-slack-user-link-save-note.util.test.tsnew file mode 100644index 00000000000..ca6ced3ff51--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-slack-user-link-save-note.util.test.ts@@ -0,0 +1,120 @@+import { describe, expect, it } from 'vitest';++import { buildSlackUserLinkSaveNote } from 'src/front-components/utils/build-slack-user-link-save-note.util';+import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+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 buildResolvedUser = (+ overrides: Partial<SlackResolvedUser> = {},+): SlackResolvedUser => ({+ slackUserId: 'U0123456789',+ slackTeamId: 'T0INSTALLED',+ displayName: 'Ada Lovelace',+ email: '[email protected]',+ isInInstalledWorkspace: true,+ ...overrides,+});++const MEMBER: WorkspaceMemberOption = {+ id: 'member-1',+ name: 'Ada Member',+ userEmail: '[email protected]',+};++const buildExistingLink = (+ overrides: Partial<SlackUserLinkRecord> = {},+): SlackUserLinkRecord => ({+ id: 'link-1',+ name: 'Ada Lovelace',+ slackUserId: 'U0123456789',+ slackTeamId: 'T0INSTALLED',+ source: 'MANUAL',+ consentState: 'ACTIVE',+ workspaceMemberId: 'member-1',+ workspaceMemberName: 'Ada Member',+ ...overrides,+});++describe('buildSlackUserLinkSaveNote', () => {+ it('should announce an admin-set link for an outside-workspace account', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser({ isInInstalledWorkspace: false }),+ selectedMember: MEMBER,+ existingLink: undefined,+ }),+ ).toContain('admin-set');+ });++ it('should nudge for a member before promising an outcome', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser(),+ selectedMember: null,+ existingLink: undefined,+ }),+ ).toContain('Pick the workspace member');+ });++ it('should announce immediate activation when the emails match', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser({ email: '[email protected]' }),+ selectedMember: MEMBER,+ existingLink: undefined,+ }),+ ).toContain('activates immediately');+ });++ it('should announce the approval request for a mismatched member', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser(),+ selectedMember: { ...MEMBER, userEmail: '[email protected]' },+ existingLink: undefined,+ }),+ ).toContain('send Ada Lovelace an approval request');+ });++ it('should say a same-member re-save changes nothing', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser({ email: '[email protected]' }),+ selectedMember: MEMBER,+ existingLink: buildExistingLink(),+ }),+ ).toContain('changes nothing');+ });++ it('should say a pending same-member link gets no new request', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser(),+ selectedMember: MEMBER,+ existingLink: buildExistingLink({ consentState: 'PENDING' }),+ }),+ ).toContain('sends no new request');+ });++ it('should say a declined same-member link will not re-ask', () => {+ expect(+ buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser(),+ selectedMember: MEMBER,+ existingLink: buildExistingLink({ consentState: 'DECLINED' }),+ }),+ ).toContain('will not ask them again');+ });++ it('should announce replacement plus the outcome when re-pointing to another member', () => {+ const note = buildSlackUserLinkSaveNote({+ resolvedUser: buildResolvedUser(),+ selectedMember: { ...MEMBER, id: 'member-2', userEmail: '[email protected]' },+ existingLink: buildExistingLink(),+ });++ expect(note).toContain('saving replaces that link');+ expect(note).toContain('approval request');+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-workspace-member-search-filter.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-workspace-member-search-filter.util.test.tsnew file mode 100644index 00000000000..f669ec1132f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/build-workspace-member-search-filter.util.test.ts@@ -0,0 +1,44 @@+import { describe, expect, it } from 'vitest';++import { buildWorkspaceMemberSearchFilter } from 'src/front-components/utils/build-workspace-member-search-filter.util';++describe('buildWorkspaceMemberSearchFilter', () => {+ it('matches a single word against first and last name', () => {+ expect(buildWorkspaceMemberSearchFilter('ada')).toBe(+ 'or(name.firstName[ilike]:%ada%,name.lastName[ilike]:%ada%)',+ );+ });++ it('requires every word of a full name to match a name part', () => {+ expect(buildWorkspaceMemberSearchFilter('Ada Lovelace')).toBe(+ 'and(or(name.firstName[ilike]:%Ada%,name.lastName[ilike]:%Ada%),or(name.firstName[ilike]:%Lovelace%,name.lastName[ilike]:%Lovelace%))',+ );+ });++ it('strips filter-breaking characters and treats them as separators', () => {+ expect(buildWorkspaceMemberSearchFilter('Lovelace,Ada')).toBe(+ 'and(or(name.firstName[ilike]:%Lovelace%,name.lastName[ilike]:%Lovelace%),or(name.firstName[ilike]:%Ada%,name.lastName[ilike]:%Ada%))',+ );+ });++ it('keeps the marks that appear inside real names', () => {+ expect(buildWorkspaceMemberSearchFilter("O'Brien")).toBe(+ "or(name.firstName[ilike]:%O'Brien%,name.lastName[ilike]:%O'Brien%)",+ );+ expect(buildWorkspaceMemberSearchFilter('Jean-Luc')).toBe(+ 'or(name.firstName[ilike]:%Jean-Luc%,name.lastName[ilike]:%Jean-Luc%)',+ );+ expect(buildWorkspaceMemberSearchFilter('Ada Lovelace')).toContain('Ada');+ });++ it('drops characters that could reach the query string or the filter grammar', () => {+ expect(buildWorkspaceMemberSearchFilter('ada&limit=1000')).toBe(+ 'and(or(name.firstName[ilike]:%ada%,name.lastName[ilike]:%ada%),or(name.firstName[ilike]:%limit%,name.lastName[ilike]:%limit%),or(name.firstName[ilike]:%1000%,name.lastName[ilike]:%1000%))',+ );+ });++ it('returns undefined when nothing searchable remains', () => {+ expect(buildWorkspaceMemberSearchFilter(' %_() ')).toBeUndefined();+ expect(buildWorkspaceMemberSearchFilter('')).toBeUndefined();+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-resolvable-slack-identity.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-resolvable-slack-identity.util.test.tsnew file mode 100644index 00000000000..6c2c9e0ef2b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/is-resolvable-slack-identity.util.test.ts@@ -0,0 +1,41 @@+import { describe, expect, it } from 'vitest';++import { isResolvableSlackIdentity } from 'src/front-components/utils/is-resolvable-slack-identity.util';++describe('isResolvableSlackIdentity', () => {+ it('should accept a Slack-shaped user id', () => {+ expect(+ isResolvableSlackIdentity({+ slackUserId: 'U0123456789',+ }),+ ).toBe(true);+ });++ it('should accept a workspace-scoped user id', () => {+ expect(+ isResolvableSlackIdentity({+ slackUserId: 'W0123456789',+ }),+ ).toBe(true);+ });++ it('should reject an id still being typed', () => {+ expect(isResolvableSlackIdentity({ slackUserId: 'U01' })).toBe(false);+ });++ it('should reject an id not shaped like a Slack user id', () => {+ expect(+ isResolvableSlackIdentity({+ slackUserId: 'not-an-id',+ }),+ ).toBe(false);+ });++ it('should reject an empty identity', () => {+ expect(+ isResolvableSlackIdentity({+ slackUserId: undefined,+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-resolve-slack-user-result.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-resolve-slack-user-result.util.test.tsnew file mode 100644index 00000000000..9bf36ab1b99--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-resolve-slack-user-result.util.test.ts@@ -0,0 +1,66 @@+import { describe, expect, it } from 'vitest';++import { parseResolveSlackUserResult } from 'src/front-components/utils/parse-resolve-slack-user-result.util';++describe('parseResolveSlackUserResult', () => {+ it('should fail generically when the value is not a record', () => {+ const result = parseResolveSlackUserResult('nope');++ expect(result.success).toBe(false);+ });++ it('should fail generically when success is not a boolean', () => {+ const result = parseResolveSlackUserResult({ success: 'yes' });++ expect(result.success).toBe(false);+ });++ it('should surface the server error, then message, then the fallback', () => {+ expect(+ parseResolveSlackUserResult({ success: false, error: 'Not allowed' }),+ ).toEqual({ success: false, error: 'Not allowed' });+ expect(+ parseResolveSlackUserResult({ success: false, message: 'Nope' }),+ ).toEqual({ success: false, error: 'Nope' });++ const fallback = parseResolveSlackUserResult({ success: false });++ expect(fallback.success).toBe(false);++ if (fallback.success === false) {+ expect(fallback.error).toContain('try again');+ }+ });++ it('should fail generically when the slack user is missing or lacks an id', () => {+ expect(parseResolveSlackUserResult({ success: true }).success).toBe(false);+ expect(+ parseResolveSlackUserResult({ success: true, slackUser: { email: 'a' } })+ .success,+ ).toBe(false);+ });++ it('should parse a populated slack user', () => {+ expect(+ parseResolveSlackUserResult({+ success: true,+ slackUser: {+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ isInInstalledWorkspace: true,+ },+ }),+ ).toEqual({+ success: true,+ slackUser: {+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ isInInstalledWorkspace: true,+ },+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-tool-result.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-tool-result.util.test.tsnew file mode 100644index 00000000000..64bcbea070a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-tool-result.util.test.ts@@ -0,0 +1,68 @@+import { describe, expect, it } from 'vitest';++import { parseSlackToolResult } from 'src/front-components/utils/parse-slack-tool-result.util';++const FALLBACK_MESSAGE = 'Could not do the thing';++describe('parseSlackToolResult', () => {+ it('should fail with the fallback message when the value is not a record', () => {+ expect(+ parseSlackToolResult({+ value: 'nope',+ fallbackMessage: FALLBACK_MESSAGE,+ }),+ ).toEqual({+ success: false,+ message: FALLBACK_MESSAGE,+ error: 'The request failed. Please try again.',+ });+ });++ it('should fail with the fallback message when success is not a boolean', () => {+ expect(+ parseSlackToolResult({+ value: { success: 'yes' },+ fallbackMessage: FALLBACK_MESSAGE,+ }),+ ).toEqual({+ success: false,+ message: FALLBACK_MESSAGE,+ error: 'The request failed. Please try again.',+ });+ });++ it('should pass through a populated result', () => {+ expect(+ parseSlackToolResult({+ value: {+ success: false,+ message: 'Not allowed',+ error: 'No permission',+ },+ fallbackMessage: FALLBACK_MESSAGE,+ }),+ ).toEqual({+ success: false,+ message: 'Not allowed',+ error: 'No permission',+ });+ });++ it('should default non-string message and error fields', () => {+ expect(+ parseSlackToolResult({+ value: { success: true, message: 42, error: null },+ fallbackMessage: FALLBACK_MESSAGE,+ }),+ ).toEqual({ success: true, message: FALLBACK_MESSAGE, error: undefined });+ });++ it('should fall back on an empty message so the snackbar is never blank', () => {+ expect(+ parseSlackToolResult({+ value: { success: true, message: '' },+ fallbackMessage: FALLBACK_MESSAGE,+ }),+ ).toEqual({ success: true, message: FALLBACK_MESSAGE, error: undefined });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-user-search-response.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-user-search-response.util.test.tsnew file mode 100644index 00000000000..4c6d061811c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/parse-slack-user-search-response.util.test.ts@@ -0,0 +1,61 @@+import { describe, expect, it } from 'vitest';++import {+ FALLBACK_SEARCH_ERROR_MESSAGE,+ parseSlackUserSearchResponse,+} from 'src/front-components/utils/parse-slack-user-search-response.util';++describe('parseSlackUserSearchResponse', () => {+ it('should fall back to the generic error when the value is not a record', () => {+ expect(parseSlackUserSearchResponse('nope')).toEqual({+ options: [],+ errorMessage: FALLBACK_SEARCH_ERROR_MESSAGE,+ });+ });++ it('should surface the server error on failure, falling back when missing', () => {+ expect(+ parseSlackUserSearchResponse({ success: false, error: 'Not allowed' }),+ ).toEqual({ options: [], errorMessage: 'Not allowed' });+ expect(parseSlackUserSearchResponse({ success: false })).toEqual({+ options: [],+ errorMessage: FALLBACK_SEARCH_ERROR_MESSAGE,+ });+ });++ it('should return no options and no error when slackUsers is not an array', () => {+ expect(+ parseSlackUserSearchResponse({ success: true, slackUsers: 'nope' }),+ ).toEqual({ options: [], errorMessage: undefined });+ });++ it('should map valid entries and skip malformed or teamless ones', () => {+ expect(+ parseSlackUserSearchResponse({+ success: true,+ slackUsers: [+ 'not-a-record',+ { displayName: 'No Id' },+ { slackUserId: 'U2', slackTeamId: '' },+ {+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ },+ ],+ }),+ ).toEqual({+ options: [+ {+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ isInInstalledWorkspace: true,+ },+ ],+ errorMessage: undefined,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolve-input.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolve-input.util.test.tsnew file mode 100644index 00000000000..a02fb9a3f08--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolve-input.util.test.ts@@ -0,0 +1,36 @@+import { describe, expect, it } from 'vitest';++import { toSlackResolveInput } from 'src/front-components/utils/to-slack-resolve-input.util';++describe('toSlackResolveInput', () => {+ it('should trim every field', () => {+ expect(+ toSlackResolveInput({+ slackUserId: ' U0123456789 ',+ slackTeamId: ' T0INSTALLED ',+ }),+ ).toEqual({+ slackUserId: 'U0123456789',+ slackTeamId: 'T0INSTALLED',+ });+ });++ it('should drop whitespace-only fields as absent', () => {+ expect(+ toSlackResolveInput({+ slackUserId: '\t',+ slackTeamId: ' T0INSTALLED ',+ }),+ ).toEqual({+ slackUserId: undefined,+ slackTeamId: 'T0INSTALLED',+ });+ });++ it('should drop empty fields as absent', () => {+ expect(toSlackResolveInput({ slackUserId: '', slackTeamId: '' })).toEqual({+ slackUserId: undefined,+ slackTeamId: undefined,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolved-user.util.test.ts b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolved-user.util.test.tsnew file mode 100644index 00000000000..81bcac8a77b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/__tests__/to-slack-resolved-user.util.test.ts@@ -0,0 +1,49 @@+import { describe, expect, it } from 'vitest';++import { toSlackResolvedUser } from 'src/front-components/utils/to-slack-resolved-user.util';++describe('toSlackResolvedUser', () => {+ it('should return undefined without a slack user id', () => {+ expect(+ toSlackResolvedUser({+ record: { email: '[email protected]' },+ isInInstalledWorkspace: true,+ }),+ ).toBeUndefined();+ });++ it('should map a populated record and stamp the given workspace flag', () => {+ expect(+ toSlackResolvedUser({+ record: {+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ },+ isInInstalledWorkspace: false,+ }),+ ).toEqual({+ slackUserId: 'U1',+ slackTeamId: 'T1',+ displayName: 'Ada',+ email: '[email protected]',+ isInInstalledWorkspace: false,+ });+ });++ it('should default a missing team to empty and non-string extras to undefined', () => {+ expect(+ toSlackResolvedUser({+ record: { slackUserId: 'U1', displayName: 42, email: null },+ isInInstalledWorkspace: true,+ }),+ ).toEqual({+ slackUserId: 'U1',+ slackTeamId: '',+ displayName: undefined,+ email: undefined,+ isInInstalledWorkspace: true,+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/build-slack-user-link-save-note.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/build-slack-user-link-save-note.util.tsnew file mode 100644index 00000000000..8ea38719378--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/build-slack-user-link-save-note.util.ts@@ -0,0 +1,60 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { type SlackUserLinkRecord } from 'src/front-components/types/slack-user-link-record.type';+import { type WorkspaceMemberOption } from 'src/front-components/types/workspace-member-option.type';+import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++export const buildSlackUserLinkSaveNote = ({+ resolvedUser,+ selectedMember,+ existingLink,+}: {+ resolvedUser: SlackResolvedUser;+ selectedMember: WorkspaceMemberOption | null;+ existingLink: SlackUserLinkRecord | undefined;+}): string => {+ if (!isDefined(selectedMember)) {+ return 'Pick the workspace member this Slack account should act as.';+ }++ const isSameMemberRelink =+ isDefined(existingLink) &&+ existingLink.workspaceMemberId === selectedMember.id;++ if (isSameMemberRelink) {+ if (existingLink.consentState === SLACK_USER_LINK_CONSENT_STATE.DECLINED) {+ return 'This person already declined this link, and saving will not ask them again. Remove the link and add it back to ask once more.';+ }++ if (existingLink.consentState === SLACK_USER_LINK_CONSENT_STATE.PENDING) {+ return 'This link is already awaiting their approval; saving sends no new request. Use resend on the link below to nudge them.';+ }++ return 'This Slack account is already linked to this member, so saving changes nothing.';+ }++ const replacementPrefix = isDefined(existingLink)+ ? 'This Slack account is linked to another member; saving replaces that link. '+ : '';++ if (!resolvedUser.isInInstalledWorkspace) {+ return `${replacementPrefix}This account is outside your Slack workspace, so the link is admin-set and active right away.`;+ }++ const matchesSelectedMember =+ isNonEmptyString(resolvedUser.email) &&+ isNonEmptyString(selectedMember.userEmail) &&+ resolvedUser.email.toLowerCase() === selectedMember.userEmail.toLowerCase();++ if (matchesSelectedMember) {+ return `${replacementPrefix}The emails match, so the link activates immediately with no approval step.`;+ }++ const displayName = isNonEmptyString(resolvedUser.displayName)+ ? resolvedUser.displayName+ : 'this person';++ return `${replacementPrefix}Saving will send ${displayName} an approval request in Slack. The link activates once they approve.`;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/build-workspace-member-search-filter.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/build-workspace-member-search-filter.util.tsnew file mode 100644index 00000000000..2919984e2bd--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/build-workspace-member-search-filter.util.ts@@ -0,0 +1,30 @@+import { isNonEmptyString } from '@sniptt/guards';++// Allow-list rather than strip today's delimiters: the REST filter grammar can+// grow new ones, and a name only needs letters, digits and these marks.+const NON_NAME_CHARACTERS = /[^\p{L}\p{M}\p{N}'\-.]+/gu;++const toSearchWords = (searchTerm: string): string[] =>+ searchTerm+ .replace(NON_NAME_CHARACTERS, ' ')+ .split(' ')+ .filter(isNonEmptyString);++export const buildWorkspaceMemberSearchFilter = (+ searchTerm: string,+): string | undefined => {+ const words = toSearchWords(searchTerm);++ if (words.length === 0) {+ return undefined;+ }++ const wordFilters = words.map(+ (word) =>+ `or(name.firstName[ilike]:%${word}%,name.lastName[ilike]:%${word}%)`,+ );++ return wordFilters.length === 1+ ? wordFilters[0]+ : `and(${wordFilters.join(',')})`;+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/format-workspace-member-name.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/format-workspace-member-name.util.tsnew file mode 100644index 00000000000..b291e8e6fa1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/format-workspace-member-name.util.ts@@ -0,0 +1,18 @@+import { isNonEmptyString } from '@sniptt/guards';++type WorkspaceMemberName =+ | {+ firstName?: string | null;+ lastName?: string | null;+ }+ | null+ | undefined;++export const formatWorkspaceMemberName = (+ name: WorkspaceMemberName,+): string => {+ const firstName = name?.firstName?.trim() ?? '';+ const lastName = name?.lastName?.trim() ?? '';++ return [firstName, lastName].filter(isNonEmptyString).join(' ');+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/is-resolvable-slack-identity.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/is-resolvable-slack-identity.util.tsnew file mode 100644index 00000000000..8821517f1fc--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/is-resolvable-slack-identity.util.ts@@ -0,0 +1,10 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackResolveInput } from 'src/front-components/utils/to-slack-resolve-input.util';++const SLACK_USER_ID_PATTERN = /^[UW][A-Z0-9]{7,}$/i;++export const isResolvableSlackIdentity = ({+ slackUserId,+}: Pick<SlackResolveInput, 'slackUserId'>): boolean =>+ isNonEmptyString(slackUserId) && SLACK_USER_ID_PATTERN.test(slackUserId);diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/parse-resolve-slack-user-result.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/parse-resolve-slack-user-result.util.tsnew file mode 100644index 00000000000..cc87c47ab2b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/parse-resolve-slack-user-result.util.ts@@ -0,0 +1,51 @@+import { isBoolean, isString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { toSlackResolvedUser } from 'src/front-components/utils/to-slack-resolved-user.util';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++export type ResolveSlackUserResult =+ | { success: true; slackUser: SlackResolvedUser }+ | { success: false; error: string };++export const GENERIC_RESOLVE_ERROR: ResolveSlackUserResult = {+ success: false,+ error: 'Could not resolve that Slack user. Please try again.',+};++export const parseResolveSlackUserResult = (+ value: unknown,+): ResolveSlackUserResult => {+ const record = asRecord(value);++ if (!isDefined(record) || !isBoolean(record.success)) {+ return GENERIC_RESOLVE_ERROR;+ }++ if (!record.success) {+ return {+ success: false,+ error: isString(record.error)+ ? record.error+ : isString(record.message)+ ? record.message+ : GENERIC_RESOLVE_ERROR.error,+ };+ }++ const slackUserRecord = asRecord(record.slackUser);++ const resolvedUser = isDefined(slackUserRecord)+ ? toSlackResolvedUser({+ record: slackUserRecord,+ isInInstalledWorkspace: slackUserRecord.isInInstalledWorkspace === true,+ })+ : undefined;++ if (!isDefined(resolvedUser)) {+ return GENERIC_RESOLVE_ERROR;+ }++ return { success: true, slackUser: resolvedUser };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-tool-result.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-tool-result.util.tsnew file mode 100644index 00000000000..043f5004889--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-tool-result.util.ts@@ -0,0 +1,31 @@+import { isBoolean, isNonEmptyString, isString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';++export const parseSlackToolResult = ({+ value,+ fallbackMessage,+}: {+ value: unknown;+ fallbackMessage: string;+}): SlackToolResult => {+ const record = asRecord(value);++ if (!isDefined(record) || !isBoolean(record.success)) {+ return {+ success: false,+ message: fallbackMessage,+ error: 'The request failed. Please try again.',+ };+ }++ return {+ success: record.success,+ message: isNonEmptyString(record.message)+ ? record.message+ : fallbackMessage,+ error: isString(record.error) ? record.error : undefined,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-user-search-response.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-user-search-response.util.tsnew file mode 100644index 00000000000..b4cd4610bf0--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/parse-slack-user-search-response.util.ts@@ -0,0 +1,54 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { toSlackResolvedUser } from 'src/front-components/utils/to-slack-resolved-user.util';+import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';++export type SlackUserSearchResponse = {+ options: SlackResolvedUser[];+ errorMessage: string | undefined;+};++export const FALLBACK_SEARCH_ERROR_MESSAGE =+ 'Slack user search failed. Try again.';++export const parseSlackUserSearchResponse = (+ value: unknown,+): SlackUserSearchResponse => {+ const record = asRecord(value);++ if (!isDefined(record) || record.success !== true) {+ const error = record?.error;++ return {+ options: [],+ errorMessage: isNonEmptyString(error)+ ? error+ : FALLBACK_SEARCH_ERROR_MESSAGE,+ };+ }++ const slackUsers = Array.isArray(record.slackUsers) ? record.slackUsers : [];++ const options: SlackResolvedUser[] = [];++ for (const entry of slackUsers) {+ const slackUserRecord = asRecord(entry);++ const option = isDefined(slackUserRecord)+ ? toSlackResolvedUser({+ record: slackUserRecord,+ isInInstalledWorkspace: true,+ })+ : undefined;++ if (!isDefined(option) || !isNonEmptyString(option.slackTeamId)) {+ continue;+ }++ options.push(option);+ }++ return { options, errorMessage: undefined };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolve-input.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolve-input.util.tsnew file mode 100644index 00000000000..a57d23ba93a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolve-input.util.ts@@ -0,0 +1,26 @@+import { isNonEmptyString } from '@sniptt/guards';++export type SlackResolveInput = {+ slackUserId: string | undefined;+ slackTeamId: string | undefined;+};++export const toSlackResolveInput = ({+ slackUserId,+ slackTeamId,+}: {+ slackUserId: string;+ slackTeamId: string;+}): SlackResolveInput => {+ const trimmedSlackUserId = slackUserId.trim();+ const trimmedSlackTeamId = slackTeamId.trim();++ return {+ slackUserId: isNonEmptyString(trimmedSlackUserId)+ ? trimmedSlackUserId+ : undefined,+ slackTeamId: isNonEmptyString(trimmedSlackTeamId)+ ? trimmedSlackTeamId+ : undefined,+ };+};diff --git a/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolved-user.util.ts b/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolved-user.util.tsnew file mode 100644index 00000000000..2341aabceec--- /dev/null+++ b/packages/twenty-apps/public/slack/src/front-components/utils/to-slack-resolved-user.util.ts@@ -0,0 +1,25 @@+import { isNonEmptyString, isString } from '@sniptt/guards';++import { type SlackResolvedUser } from 'src/logic-functions/types/slack-resolved-user.type';++export const toSlackResolvedUser = ({+ record,+ isInInstalledWorkspace,+}: {+ record: Record<string, unknown>;+ isInInstalledWorkspace: boolean;+}): SlackResolvedUser | undefined => {+ if (!isNonEmptyString(record.slackUserId)) {+ return undefined;+ }++ return {+ slackUserId: record.slackUserId,+ slackTeamId: isString(record.slackTeamId) ? record.slackTeamId : '',+ displayName: isNonEmptyString(record.displayName)+ ? record.displayName+ : undefined,+ email: isNonEmptyString(record.email) ? record.email : undefined,+ isInInstalledWorkspace,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-action-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-action-id.tsnew file mode 100644index 00000000000..7685e450ab7--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-action-id.ts@@ -0,0 +1 @@+export const SLACK_USER_LINK_CONSENT_ACTION_ID = 'slack-user-link-consent';diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-decision.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-decision.tsnew file mode 100644index 00000000000..bcb6522f096--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-decision.ts@@ -0,0 +1,4 @@+export const SLACK_USER_LINK_CONSENT_DECISION = {+ APPROVE: 'APPROVE',+ DECLINE: 'DECLINE',+} as const;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-state.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-state.tsnew file mode 100644index 00000000000..02301e841d3--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/slack-user-link-consent-state.ts@@ -0,0 +1,6 @@+export const SLACK_USER_LINK_CONSENT_STATE = {+ PENDING: 'PENDING',+ ACTIVE: 'ACTIVE',+ DECLINED: 'DECLINED',+ ADMIN_SET: 'ADMIN_SET',+} as const;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/constants/unverifiable-slack-team-id-failure.ts b/packages/twenty-apps/public/slack/src/logic-functions/constants/unverifiable-slack-team-id-failure.tsnew file mode 100644index 00000000000..ac847565062--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/constants/unverifiable-slack-team-id-failure.ts@@ -0,0 +1,6 @@+export const UNVERIFIABLE_SLACK_TEAM_ID_FAILURE = {+ success: false,+ message: 'Could not verify the Slack workspace for that user',+ error:+ 'Slack did not confirm which workspace this user belongs to, so that team id cannot be accepted. Leave the team id blank to use the installed workspace.',+} as const;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-user-link.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-user-link.test.tsnew file mode 100644index 00000000000..b590fffe5dc--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/__tests__/find-slack-user-link.test.ts@@ -0,0 +1,79 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { findSlackUserLink } from 'src/logic-functions/data/find-slack-user-link';++const SLACK_TEAM_ID = 'T0INSTALLED';+const SLACK_USER_ID = 'U0123456789';++const queryMock = vi.fn();++const client = { query: queryMock } as unknown as CoreApiClient;++const buildQueryResult = (node: Record<string, unknown> | undefined) => ({+ slackUserLinks: { edges: node === undefined ? [] : [{ node }] },+});++const buildNode = (overrides: Record<string, unknown> = {}) => ({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'ACTIVE',+ ...overrides,+});++const find = () =>+ findSlackUserLink(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserId: SLACK_USER_ID,+ });++describe('findSlackUserLink', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ queryMock.mockResolvedValue(buildQueryResult(buildNode()));+ });++ it('should return the stored link', async () => {+ expect(await find()).toEqual({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'ACTIVE',+ });+ });++ it('should return undefined when the Slack account has no link', async () => {+ queryMock.mockResolvedValue(buildQueryResult(undefined));++ expect(await find()).toBeUndefined();+ });++ it('should keep a link written before consent existed readable', async () => {+ queryMock.mockResolvedValue(+ buildQueryResult(buildNode({ consentState: null })),+ );++ expect(await find()).toMatchObject({ consentState: undefined });+ });++ it('should refuse a consent state it cannot interpret rather than reading it as absent', async () => {+ queryMock.mockResolvedValue(+ buildQueryResult(buildNode({ consentState: 'REVOKED' })),+ );++ await expect(find()).rejects.toThrow(+ 'Slack user link link-1 has an unsupported consentState "REVOKED"',+ );+ });++ it('should refuse a source it cannot interpret', async () => {+ queryMock.mockResolvedValue(+ buildQueryResult(buildNode({ source: 'IMPORTED' })),+ );++ await expect(find()).rejects.toThrow(+ 'Slack user link link-1 has an unsupported source "IMPORTED"',+ );+ });+});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 8e6e5398120..69be98dcdd7 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,6 +1,7 @@+import { isNonEmptyString } from '@sniptt/guards';import { type CoreApiClient } from 'twenty-client-sdk/core';-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 { type SlackUserLinkSource } from 'src/logic-functions/types/slack-user-link-source.type';export const createSlackUserLink = async (@@ -10,16 +11,18 @@ export const createSlackUserLink = async (slackUserId,workspaceMemberId,name,- source = SLACK_USER_LINK_SOURCE.AUTO,+ source,+ consentState,}: {slackTeamId: string;slackUserId: string;workspaceMemberId: string;name: string;- source?: SlackUserLinkSource;+ source: SlackUserLinkSource;+ consentState: SlackUserLinkConsentState;},-): Promise<void> => {- await client.mutation({+): Promise<string> => {+ const result = await client.mutation({createSlackUserLink: {__args: {data: {@@ -28,9 +31,18 @@ export const createSlackUserLink = async (workspaceMemberId,name,source,+ consentState,},},id: true,},});++ const createdId = result.createSlackUserLink?.id;++ if (!isNonEmptyString(createdId)) {+ throw new Error('Slack user link creation returned no id');+ }++ return createdId;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-link.tsnew file mode 100644index 00000000000..2b0d3dfd6b5--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/destroy-slack-user-link.ts@@ -0,0 +1,13 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';++export const destroySlackUserLink = async (+ client: CoreApiClient,+ { id }: { id: string },+): Promise<void> => {+ await client.mutation({+ destroySlackUserLink: {+ __args: { id },+ id: true,+ },+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/does-workspace-member-exist.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/does-workspace-member-exist.tsnew file mode 100644index 00000000000..9dfd0dee8a1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/does-workspace-member-exist.ts@@ -0,0 +1,21 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++export const doesWorkspaceMemberExist = async (+ client: CoreApiClient,+ workspaceMemberId: string,+): Promise<boolean> => {+ const queryResult = await client.query({+ workspaceMembers: {+ __args: {+ filter: { id: { eq: workspaceMemberId } },+ first: 1,+ },+ edges: {+ node: { id: true },+ },+ },+ });++ return isNonEmptyString(queryResult.workspaceMembers?.edges?.[0]?.node?.id);+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-link.tsindex dd071a40ee0..112844ddd23 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-link.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-slack-user-link.ts@@ -2,6 +2,8 @@ import { isNonEmptyString } from '@sniptt/guards';import { type CoreApiClient } from 'twenty-client-sdk/core';import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';+import { isSlackUserLinkConsentState } from 'src/logic-functions/utils/is-slack-user-link-consent-state';+import { isSlackUserLinkSource } from 'src/logic-functions/utils/is-slack-user-link-source';export const findSlackUserLink = async (client: CoreApiClient,@@ -17,7 +19,12 @@ export const findSlackUserLink = async (first: 1,},edges: {- node: { id: true, workspaceMemberId: true, source: true },+ node: {+ id: true,+ workspaceMemberId: true,+ source: true,+ consentState: true,+ },},},});@@ -28,9 +35,29 @@ export const findSlackUserLink = async (return undefined;}+ // The consent check trusts an absent value as a pre-consent link, so a value+ // this version cannot interpret must never collapse into one.+ if (isNonEmptyString(node.source) && !isSlackUserLinkSource(node.source)) {+ throw new Error(+ `Slack user link ${node.id} has an unsupported source "${node.source}"`,+ );+ }++ if (+ isNonEmptyString(node.consentState) &&+ !isSlackUserLinkConsentState(node.consentState)+ ) {+ throw new Error(+ `Slack user link ${node.id} has an unsupported consentState "${node.consentState}"`,+ );+ }+return {id: node.id,workspaceMemberId: node.workspaceMemberId ?? undefined,- source: node.source ?? undefined,+ source: isSlackUserLinkSource(node.source) ? node.source : undefined,+ consentState: isSlackUserLinkConsentState(node.consentState)+ ? node.consentState+ : undefined,};};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-email-by-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-email-by-id.tsnew file mode 100644index 00000000000..b5d64cf43e5--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-email-by-id.ts@@ -0,0 +1,25 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++export const findWorkspaceMemberEmailById = async (+ client: CoreApiClient,+ workspaceMemberId: string,+): Promise<string | undefined> => {+ const queryResult = await client+ .query({+ workspaceMembers: {+ __args: {+ filter: { id: { eq: workspaceMemberId } },+ first: 1,+ },+ edges: {+ node: { userEmail: true },+ },+ },+ })+ .catch(() => undefined);++ const userEmail = queryResult?.workspaceMembers?.edges?.[0]?.node?.userEmail;++ return isNonEmptyString(userEmail) ? userEmail : undefined;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-name-by-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-name-by-id.tsnew file mode 100644index 00000000000..97d35038967--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/find-workspace-member-name-by-id.ts@@ -0,0 +1,30 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';++export const findWorkspaceMemberNameById = async (+ client: CoreApiClient,+ workspaceMemberId: string,+): Promise<string | undefined> => {+ const queryResult = await client+ .query({+ workspaceMembers: {+ __args: {+ filter: { id: { eq: workspaceMemberId } },+ first: 1,+ },+ edges: {+ node: { name: { firstName: true, lastName: true } },+ },+ },+ })+ .catch(() => undefined);++ const name = queryResult?.workspaceMembers?.edges?.[0]?.node?.name;++ const fullName = [name?.firstName, name?.lastName]+ .filter(isNonEmptyString)+ .join(' ')+ .trim();++ return isNonEmptyString(fullName) ? fullName : undefined;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-user-link.tsindex 9f41d8dc5ad..4ed7879cee5 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-user-link.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/data/update-slack-user-link.ts@@ -2,6 +2,7 @@ import { isNonEmptyString } from '@sniptt/guards';import { type CoreApiClient } from 'twenty-client-sdk/core';import { isDefined } from 'twenty-sdk/utils';+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 const updateSlackUserLink = async (@@ -11,11 +12,13 @@ export const updateSlackUserLink = async (workspaceMemberId,name,source,+ consentState,}: {id: string;- workspaceMemberId: string;+ workspaceMemberId?: string;name?: string;source?: SlackUserLinkSource;+ consentState?: SlackUserLinkConsentState;},): Promise<void> => {await client.mutation({@@ -23,9 +26,10 @@ export const updateSlackUserLink = async (__args: {id,data: {- workspaceMemberId,+ ...(isNonEmptyString(workspaceMemberId) ? { workspaceMemberId } : {}),...(isNonEmptyString(name) ? { name } : {}),...(isDefined(source) ? { source } : {}),+ ...(isDefined(consentState) ? { consentState } : {}),},},id: true,diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-interactivity-resolver-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-interactivity-resolver-handler.test.tsnew file mode 100644index 00000000000..08a1746a1ba--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-interactivity-resolver-handler.test.ts@@ -0,0 +1,100 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import {+ SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER,+ SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+} from 'src/constants/universal-identifiers';+import { SLACK_ASSISTANT_FEEDBACK_ACTION_ID } from 'src/logic-functions/constants/slack-assistant-feedback-action-id';+import { SLACK_USER_LINK_CONSENT_ACTION_ID } from 'src/logic-functions/constants/slack-user-link-consent-action-id';+import { slackInteractivityResolverHandler } from 'src/logic-functions/handlers/slack-interactivity-resolver-handler';+import { type SlackInteractivityPayload } from 'src/logic-functions/types/slack-interactivity-payload.type';++const { parsePayloadMock, resolveTargetWorkspaceIdMock } = vi.hoisted(() => ({+ parsePayloadMock: vi.fn(),+ resolveTargetWorkspaceIdMock: vi.fn(),+}));++vi.mock(+ 'src/logic-functions/utils/verify-slack-webhook-request-or-throw',+ () => ({+ verifySlackWebhookRequestOrThrow: vi.fn(),+ }),+);++vi.mock(+ 'src/logic-functions/utils/parse-slack-interactivity-payload-or-throw',+ () => ({+ parseSlackInteractivityPayloadOrThrow: parsePayloadMock,+ }),+);++vi.mock('src/logic-functions/utils/resolve-target-workspace-id', () => ({+ resolveTargetWorkspaceId: resolveTargetWorkspaceIdMock,+}));++const routePayload = {+ body: {},+ headers: {},+ queryStringParameters: {},+ pathParameters: {},+ isBase64Encoded: false,+ requestContext: {+ http: { method: 'POST', path: '/s/slack-interactivity' },+ },+ userWorkspaceId: 'workspace-1',+};++const run = async (payload: SlackInteractivityPayload) => {+ parsePayloadMock.mockReturnValue(payload);++ return slackInteractivityResolverHandler(routePayload);+};++describe('slackInteractivityResolverHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ resolveTargetWorkspaceIdMock.mockResolvedValue('workspace-1');+ });++ it('should route a feedback action to the feedback function', async () => {+ const result = await run({+ type: 'block_actions',+ team: { id: 'T1' },+ actions: [{ action_id: SLACK_ASSISTANT_FEEDBACK_ACTION_ID }],+ });++ expect(result).toMatchObject({+ targetLogicFunctionUniversalIdentifier:+ SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER,+ });+ });++ it('should route a consent action to the consent function', async () => {+ const result = await run({+ type: 'block_actions',+ team: { id: 'T1' },+ actions: [{ action_id: `${SLACK_USER_LINK_CONSENT_ACTION_ID}:approve` }],+ });++ expect(result).toMatchObject({+ targetLogicFunctionUniversalIdentifier:+ SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+ });+ });++ it('should acknowledge an unrelated action without routing', async () => {+ const result = await run({+ type: 'block_actions',+ team: { id: 'T1' },+ actions: [{ action_id: 'unrelated' }],+ });++ expect(result).not.toHaveProperty('targetLogicFunctionUniversalIdentifier');+ });++ it('should acknowledge a non block_actions payload', async () => {+ const result = await run({ type: 'view_submission' });++ expect(result).not.toHaveProperty('targetLogicFunctionUniversalIdentifier');+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-user-link-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-user-link-handler.test.tsnew file mode 100644index 00000000000..b63af94dda6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-remove-user-link-handler.test.ts@@ -0,0 +1,78 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackRemoveUserLinkHandler } from 'src/logic-functions/handlers/slack-remove-user-link-handler';++const {+ currentUserHasRolesPermissionMock,+ coreApiClientMock,+ destroySlackUserLinkMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ coreApiClientMock: vi.fn(),+ destroySlackUserLinkMock: vi.fn(),+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/destroy-slack-user-link', () => ({+ destroySlackUserLink: destroySlackUserLinkMock,+}));++const buildPayload = (body: unknown) => ({ body });++describe('slackRemoveUserLinkHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ destroySlackUserLinkMock.mockResolvedValue(undefined);+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackRemoveUserLinkHandler(+ buildPayload({ id: 'link-1' }),+ );++ expect(result.success).toBe(false);+ expect(destroySlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should fail closed when the id is missing', async () => {+ const result = await slackRemoveUserLinkHandler(buildPayload({}));++ expect(result.success).toBe(false);+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ expect(destroySlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should delete the link with the application access', async () => {+ const result = await slackRemoveUserLinkHandler(+ buildPayload({ id: 'link-1' }),+ );++ expect(result.success).toBe(true);+ expect(coreApiClientMock).toHaveBeenCalledWith({ runAs: 'application' });+ expect(destroySlackUserLinkMock).toHaveBeenCalledTimes(1);+ expect(destroySlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ });+ });++ it('should fail with a structured result when the delete errors', async () => {+ destroySlackUserLinkMock.mockRejectedValueOnce(new Error('delete refused'));++ const result = await slackRemoveUserLinkHandler(+ buildPayload({ id: 'link-1' }),+ );++ expect(result.success).toBe(false);+ expect(result.error).toBe('delete refused');+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resend-user-link-consent-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resend-user-link-consent-handler.test.tsnew file mode 100644index 00000000000..55ef5ef81dd--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resend-user-link-consent-handler.test.ts@@ -0,0 +1,171 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackResendUserLinkConsentHandler } from 'src/logic-functions/handlers/slack-resend-user-link-consent-handler';++const {+ currentUserHasRolesPermissionMock,+ coreApiClientMock,+ findSlackUserLinkMock,+ findWorkspaceMemberNameByIdMock,+ getSlackClientMock,+ sendSlackUserLinkConsentDmMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ coreApiClientMock: vi.fn(),+ findSlackUserLinkMock: vi.fn(),+ findWorkspaceMemberNameByIdMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ sendSlackUserLinkConsentDmMock: vi.fn(),+}));++vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/find-slack-user-link', () => ({+ findSlackUserLink: findSlackUserLinkMock,+}));++vi.mock('src/logic-functions/data/find-workspace-member-name-by-id', () => ({+ findWorkspaceMemberNameById: findWorkspaceMemberNameByIdMock,+}));++vi.mock('src/logic-functions/utils/get-slack-client', () => ({+ getSlackClient: getSlackClientMock,+}));++vi.mock('src/logic-functions/utils/send-slack-user-link-consent-dm', () => ({+ sendSlackUserLinkConsentDm: sendSlackUserLinkConsentDmMock,+}));++const buildPayload = (body: unknown) => ({ body });++const PENDING_BODY = { slackTeamId: 'T1', slackUserId: 'U1' };++describe('slackResendUserLinkConsentHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'PENDING',+ });+ findWorkspaceMemberNameByIdMock.mockResolvedValue('Ada Member');+ getSlackClientMock.mockResolvedValue({ success: true, client: {} });+ sendSlackUserLinkConsentDmMock.mockResolvedValue({ success: true });+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail closed when identity fields are missing', async () => {+ const result = await slackResendUserLinkConsentHandler(+ buildPayload({ slackTeamId: 'T1' }),+ );++ expect(result.success).toBe(false);+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ });++ it('should fail when there is no link to resend', async () => {+ findSlackUserLinkMock.mockResolvedValue(undefined);++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should refuse to resend for a link that is not pending', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'ACTIVE',+ });++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should resend the consent request for a pending link', async () => {+ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(true);+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledTimes(1);+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ slackTeamId: 'T1',+ slackUserId: 'U1',+ workspaceMemberId: 'member-1',+ slackUserLinkId: 'link-1',+ memberName: 'Ada Member',+ }),+ );+ });++ it('should fail with a structured error when the link lookup throws', async () => {+ findSlackUserLinkMock.mockRejectedValue(new Error('GraphQL error'));++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(result.error).toBe('GraphQL error');+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail when the pending link has no workspace member assigned', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: '',+ source: 'MANUAL',+ consentState: 'PENDING',+ });++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should report a delivery failure', async () => {+ sendSlackUserLinkConsentDmMock.mockResolvedValue({+ success: false,+ error: 'channel_not_found',+ });++ const result = await slackResendUserLinkConsentHandler(+ buildPayload(PENDING_BODY),+ );++ expect(result.success).toBe(false);+ expect(result.error).toBe('channel_not_found');+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resolve-user-link-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resolve-user-link-handler.test.tsnew file mode 100644index 00000000000..8aeb93c3317--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-resolve-user-link-handler.test.ts@@ -0,0 +1,221 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackResolveUserLinkHandler } from 'src/logic-functions/handlers/slack-resolve-user-link-handler';++const {+ currentUserHasRolesPermissionMock,+ getSlackClientMock,+ authTestMock,+ resolveSlackUserByEmailMock,+ fetchSlackUserIdentityMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ authTestMock: vi.fn(),+ resolveSlackUserByEmailMock: vi.fn(),+ fetchSlackUserIdentityMock: 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('src/logic-functions/utils/resolve-slack-user-by-email', () => ({+ resolveSlackUserByEmail: resolveSlackUserByEmailMock,+}));++vi.mock('src/logic-functions/utils/fetch-slack-user-identity', () => ({+ fetchSlackUserIdentity: fetchSlackUserIdentityMock,+}));++const INSTALLED_TEAM_ID = 'T0INSTALLED';++const buildPayload = (body: unknown) => ({ body });++describe('slackResolveUserLinkHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ currentUserHasRolesPermissionMock.mockResolvedValue(true);+ getSlackClientMock.mockResolvedValue({+ success: true,+ client: { auth: { test: authTestMock } },+ });+ authTestMock.mockResolvedValue({ team_id: INSTALLED_TEAM_ID });+ });++ it('should fail closed when nothing is provided', async () => {+ const result = await slackResolveUserLinkHandler(buildPayload({}));++ expect(result.success).toBe(false);+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result.success).toBe(false);+ });++ it('should resolve an in-workspace user from an email', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U1',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ isRegularUserAccount: true,+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result).toEqual({+ success: true,+ slackUser: {+ slackUserId: 'U1',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ email: '[email protected]',+ isInInstalledWorkspace: true,+ },+ });+ });++ it('should not carry a guest email into the preview', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U1',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Guest',+ isRegularUserAccount: false,+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result.success).toBe(true);++ if (result.success) {+ expect(result.slackUser.email).toBeUndefined();+ }+ });++ it('should fail closed when the installed workspace cannot be confirmed', async () => {+ authTestMock.mockRejectedValue(new Error('network'));+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U1',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ isRegularUserAccount: true,+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result.success).toBe(false);+ expect(resolveSlackUserByEmailMock).not.toHaveBeenCalled();+ });++ it('should fail with a helpful error when the email is not in the workspace', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue(undefined);++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('Slack user id');+ }+ });++ it('should fail with a structured error when the email lookup throws', async () => {+ resolveSlackUserByEmailMock.mockRejectedValue(new Error('ratelimited'));++ const result = await slackResolveUserLinkHandler(+ buildPayload({ email: '[email protected]' }),+ );++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toBe('ratelimited');+ }+ });++ it('should fail closed when an id-only identity lookup omits the team', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: 'U2',+ slackTeamId: undefined,+ displayName: 'Guest',+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ slackUserId: 'U2' }),+ );++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('team id');+ }+ });++ it('should refuse an unresolvable id that claims the installed workspace', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(undefined);++ const result = await slackResolveUserLinkHandler(+ buildPayload({ slackUserId: 'U2', slackTeamId: INSTALLED_TEAM_ID }),+ );++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('could not find that user id');+ }+ });++ it('should refuse a supplied team id that does not match the Slack user', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: 'U2',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ slackUserId: 'U2', slackTeamId: 'T-EXTERNAL' }),+ );++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('belongs to workspace');+ }+ });++ it('should resolve from a Slack user id and flag an out-of-workspace team', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: 'U2',+ slackTeamId: 'T-EXTERNAL',+ displayName: 'Guest',+ });++ const result = await slackResolveUserLinkHandler(+ buildPayload({ slackUserId: 'U2', slackTeamId: 'T-EXTERNAL' }),+ );++ expect(result).toEqual({+ success: true,+ slackUser: {+ slackUserId: 'U2',+ slackTeamId: 'T-EXTERNAL',+ displayName: 'Guest',+ isInInstalledWorkspace: false,+ },+ });+ });+});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.tsnew file mode 100644index 00000000000..d01d0a2c8ed--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-search-users-handler.test.ts@@ -0,0 +1,183 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { slackSearchUsersHandler } from 'src/logic-functions/handlers/slack-search-users-handler';++const {+ currentUserHasRolesPermissionMock,+ getSlackClientMock,+ authTestMock,+ usersListMock,+} = vi.hoisted(() => ({+ currentUserHasRolesPermissionMock: vi.fn(),+ getSlackClientMock: vi.fn(),+ authTestMock: vi.fn(),+ usersListMock: 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,+}));++const INSTALLED_TEAM_ID = 'T0INSTALLED';++const ADA = {+ id: 'U0ADA',+ real_name: 'Ada Lovelace',+ is_email_confirmed: true,+ profile: { display_name: 'ada', email: '[email protected]' },+};++const BOB = {+ id: 'U0BOB',+ real_name: 'Bob Builder',+ is_email_confirmed: true,+ profile: { display_name: 'bob', email: '[email protected]' },+};++const buildPayload = (query: unknown) => ({ body: { query } });++describe('slackSearchUsersHandler', () => {+ 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] });+ });++ it('should return no users for an empty query without calling Slack', async () => {+ const result = await slackSearchUsersHandler(buildPayload(' '));++ expect(result).toEqual({ success: true, slackUsers: [] });+ expect(usersListMock).not.toHaveBeenCalled();+ });++ it('should refuse when the user lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ expect(result.success).toBe(false);+ expect(usersListMock).not.toHaveBeenCalled();+ });++ it('should refuse an empty query from someone without the permission rather than answering it', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);++ const result = await slackSearchUsersHandler(buildPayload(' '));++ expect(result.success).toBe(false);+ });++ it('should match by name or email, case-insensitively', async () => {+ const result = await slackSearchUsersHandler(buildPayload('ADA'));++ expect(result).toEqual({+ success: true,+ slackUsers: [+ {+ slackUserId: 'U0ADA',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'ada',+ email: '[email protected]',+ },+ ],+ });+ });++ it('should list a guest but leave their email out of the option', async () => {+ usersListMock.mockResolvedValue({+ members: [{ ...ADA, is_restricted: true }],+ });++ 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 }],+ });++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers[0]?.email).toBeUndefined();+ }+ });++ it('should skip bots and deleted accounts', async () => {+ usersListMock.mockResolvedValue({+ members: [+ { ...ADA, is_bot: true },+ { ...BOB, real_name: 'Ada Bobsdottir', deleted: true },+ ],+ });++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ expect(result).toEqual({ success: true, slackUsers: [] });+ });++ it('should follow the roster cursor until it finds the match', async () => {+ usersListMock+ .mockResolvedValueOnce({+ members: [BOB],+ response_metadata: { next_cursor: 'cursor-2' },+ })+ .mockResolvedValueOnce({ members: [ADA] });++ const result = await slackSearchUsersHandler(buildPayload('ada@twenty'));++ expect(result.success).toBe(true);+ if (result.success) {+ expect(result.slackUsers).toHaveLength(1);+ }+ expect(usersListMock).toHaveBeenCalledTimes(2);+ expect(usersListMock).toHaveBeenLastCalledWith(+ expect.objectContaining({ cursor: 'cursor-2' }),+ );+ });++ it('should fail closed when the installed workspace cannot be confirmed', async () => {+ authTestMock.mockRejectedValue(new Error('network'));++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ expect(result.success).toBe(false);+ expect(usersListMock).not.toHaveBeenCalled();+ });++ it('should fail with a structured error when the roster read throws', async () => {+ usersListMock.mockRejectedValue(new Error('ratelimited'));++ const result = await slackSearchUsersHandler(buildPayload('ada'));++ 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-set-user-link-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-set-user-link-handler.test.tsindex 575d9ce6066..6cf3363acb9 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@@ -3,30 +3,40 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';import { slackSetUserLinkHandler } from 'src/logic-functions/handlers/slack-set-user-link-handler';const {- currentUserHasWorkspaceMembersPermissionMock,+ currentUserHasRolesPermissionMock,coreApiClientMock,getSlackClientMock,authTestMock,+ doesWorkspaceMemberExistMock,findSlackUserLinkMock,createSlackUserLinkMock,updateSlackUserLinkMock,+ destroySlackUserLinkMock,+ resolveSlackUserByEmailMock,+ fetchSlackUserIdentityMock,+ findWorkspaceMemberEmailByIdMock,+ findWorkspaceMemberNameByIdMock,+ sendSlackUserLinkConsentDmMock,} = vi.hoisted(() => ({- currentUserHasWorkspaceMembersPermissionMock: vi.fn(),+ currentUserHasRolesPermissionMock: vi.fn(),coreApiClientMock: vi.fn(),getSlackClientMock: vi.fn(),authTestMock: vi.fn(),+ doesWorkspaceMemberExistMock: vi.fn(),findSlackUserLinkMock: vi.fn(),createSlackUserLinkMock: vi.fn(),updateSlackUserLinkMock: vi.fn(),+ destroySlackUserLinkMock: vi.fn(),+ resolveSlackUserByEmailMock: vi.fn(),+ fetchSlackUserIdentityMock: vi.fn(),+ findWorkspaceMemberEmailByIdMock: vi.fn(),+ findWorkspaceMemberNameByIdMock: vi.fn(),+ sendSlackUserLinkConsentDmMock: vi.fn(),}));-vi.mock(- 'src/logic-functions/utils/current-user-has-workspace-members-permission',- () => ({- currentUserHasWorkspaceMembersPermission:- currentUserHasWorkspaceMembersPermissionMock,- }),-);+vi.mock('src/logic-functions/utils/current-user-has-roles-permission', () => ({+ currentUserHasRolesPermission: currentUserHasRolesPermissionMock,+}));vi.mock('twenty-client-sdk/core', () => ({CoreApiClient: coreApiClientMock,@@ -36,6 +46,18 @@ vi.mock('src/logic-functions/utils/get-slack-client', () => ({getSlackClient: getSlackClientMock,}));+vi.mock('src/logic-functions/utils/resolve-slack-user-by-email', () => ({+ resolveSlackUserByEmail: resolveSlackUserByEmailMock,+}));++vi.mock('src/logic-functions/utils/fetch-slack-user-identity', () => ({+ fetchSlackUserIdentity: fetchSlackUserIdentityMock,+}));++vi.mock('src/logic-functions/data/does-workspace-member-exist', () => ({+ doesWorkspaceMemberExist: doesWorkspaceMemberExistMock,+}));+vi.mock('src/logic-functions/data/find-slack-user-link', () => ({findSlackUserLink: findSlackUserLinkMock,}));@@ -48,6 +70,24 @@ vi.mock('src/logic-functions/data/update-slack-user-link', () => ({updateSlackUserLink: updateSlackUserLinkMock,}));+vi.mock('src/logic-functions/data/destroy-slack-user-link', () => ({+ destroySlackUserLink: destroySlackUserLinkMock,+}));++vi.mock('src/logic-functions/data/find-workspace-member-email-by-id', () => ({+ findWorkspaceMemberEmailById: findWorkspaceMemberEmailByIdMock,+}));++vi.mock('src/logic-functions/data/find-workspace-member-name-by-id', () => ({+ findWorkspaceMemberNameById: findWorkspaceMemberNameByIdMock,+}));++vi.mock('src/logic-functions/utils/send-slack-user-link-consent-dm', () => ({+ sendSlackUserLinkConsentDm: sendSlackUserLinkConsentDmMock,+}));++const INSTALLED_TEAM_ID = 'T0123456789';+const INPUT = {slackUserId: 'U0123456789',workspaceMemberId: 'workspace-member-1',@@ -56,17 +96,27 @@ const INPUT = {describe('slackSetUserLinkHandler', () => {beforeEach(() => {vi.clearAllMocks();- currentUserHasWorkspaceMembersPermissionMock.mockResolvedValue(true);+ currentUserHasRolesPermissionMock.mockResolvedValue(true);getSlackClientMock.mockResolvedValue({success: true,client: { auth: { test: authTestMock } },});- authTestMock.mockResolvedValue({ team_id: 'T0123456789' });+ authTestMock.mockResolvedValue({ team_id: INSTALLED_TEAM_ID });+ doesWorkspaceMemberExistMock.mockResolvedValue(true);findSlackUserLinkMock.mockResolvedValue(undefined);+ createSlackUserLinkMock.mockResolvedValue('link-new');+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: undefined,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue(undefined);+ findWorkspaceMemberNameByIdMock.mockResolvedValue('Ada Member');+ sendSlackUserLinkConsentDmMock.mockResolvedValue({ success: true });});- it('should refuse when the triggering person lacks the workspace members permission', async () => {- currentUserHasWorkspaceMembersPermissionMock.mockResolvedValue(false);+ it('should refuse when the triggering person lacks the roles permission', async () => {+ currentUserHasRolesPermissionMock.mockResolvedValue(false);const result = await slackSetUserLinkHandler(INPUT);@@ -75,6 +125,35 @@ describe('slackSetUserLinkHandler', () => {expect(updateSlackUserLinkMock).not.toHaveBeenCalled();});+ it('should refuse a member id the workspace cannot confirm', async () => {+ doesWorkspaceMemberExistMock.mockResolvedValue(false);++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result).toEqual({+ success: false,+ message: 'Workspace member not found',+ error: expect.stringContaining(INPUT.workspaceMemberId),+ });+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail closed when the member existence check errors', async () => {+ doesWorkspaceMemberExistMock.mockRejectedValue(new Error('GraphQL error'));++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result).toEqual({+ success: false,+ message: 'Could not verify the workspace member',+ error: 'GraphQL error',+ });+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });+it('should refuse when Slack is not connected', async () => {getSlackClientMock.mockResolvedValue({success: false,@@ -113,57 +192,246 @@ describe('slackSetUserLinkHandler', () => {expect(result.error).toBe('write refused');});- it('should not require a Slack connection when a team id is provided', async () => {- getSlackClientMock.mockResolvedValue({+ it('should create a pending link and send a consent request for an in-workspace user', async () => {+ const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledTimes(1);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ slackTeamId: INSTALLED_TEAM_ID,+ slackUserId: INPUT.slackUserId,+ workspaceMemberId: INPUT.workspaceMemberId,+ name: 'Ada',+ source: 'MANUAL',+ consentState: 'PENDING',+ });+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledTimes(1);+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ slackUserId: INPUT.slackUserId,+ slackTeamId: INSTALLED_TEAM_ID,+ workspaceMemberId: INPUT.workspaceMemberId,+ slackUserLinkId: 'link-new',+ memberName: 'Ada Member',+ }),+ );+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should still succeed as pending when the consent request cannot be delivered', async () => {+ sendSlackUserLinkConsentDmMock.mockResolvedValue({success: false,- error: 'Slack is not connected.',+ error: 'channel_not_found',});+ const result = await slackSetUserLinkHandler(INPUT);++ expect(result.success).toBe(true);+ expect(result.message).toContain('Resend');+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ consentState: 'PENDING' }),+ );+ });++ it('should refuse a supplied team id that does not match the Slack user', async () => {+ const result = await slackSetUserLinkHandler({+ ...INPUT,+ slackTeamId: 'T9876543210',+ });++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('belongs to workspace');+ }+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should admin-set the link without consent for a Slack Connect user from another workspace', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(undefined);+const result = await slackSetUserLinkHandler({...INPUT,slackTeamId: 'T9876543210',});expect(result.success).toBe(true);- expect(getSlackClientMock).not.toHaveBeenCalled();expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(),- expect.objectContaining({ slackTeamId: 'T9876543210' }),+ expect.objectContaining({+ slackTeamId: 'T9876543210',+ consentState: 'ADMIN_SET',+ }),);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();});- it('should store the link under the requested team for Slack Connect users', async () => {+ it('should refuse an unresolvable id that claims the installed workspace', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(undefined);++ const result = await slackSetUserLinkHandler({+ ...INPUT,+ slackTeamId: INSTALLED_TEAM_ID,+ });++ expect(result.success).toBe(false);+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail closed when the installed workspace cannot be verified', async () => {+ authTestMock.mockResolvedValue({});+const result = await slackSetUserLinkHandler({...INPUT,slackTeamId: 'T9876543210',});+ expect(result.success).toBe(false);+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail closed when an id-only user cannot be resolved to a workspace', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(undefined);++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result.success).toBe(false);+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should fail closed when the identity lookup omits the team id', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: undefined,+ displayName: 'Ada Lovelace',+ });++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result.success).toBe(false);+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should admin-set a cross-workspace user given by id without a team id', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: 'T-EXTERNAL',+ displayName: 'Guest',+ });++ const result = await slackSetUserLinkHandler(INPUT);+expect(result.success).toBe(true);expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(),- expect.objectContaining({ slackTeamId: 'T9876543210' }),+ expect.objectContaining({+ slackTeamId: 'T-EXTERNAL',+ consentState: 'ADMIN_SET',+ }),);+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();});- it('should create a manual link when none exists', async () => {+ it('should require a Slack connection even when a team id is provided', async () => {+ getSlackClientMock.mockResolvedValue({+ success: false,+ error: 'Slack is not connected.',+ });++ const result = await slackSetUserLinkHandler({+ ...INPUT,+ slackTeamId: 'T9876543210',+ });++ expect(result.success).toBe(false);+ expect(getSlackClientMock).toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should mint a fresh record when re-pointing the link to another member', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'someone-else',+ source: 'AUTO',+ consentState: 'ACTIVE',+ });+const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });expect(result.success).toBe(true);- expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {- slackTeamId: 'T0123456789',- slackUserId: INPUT.slackUserId,+ expect(destroySlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ });+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ workspaceMemberId: INPUT.workspaceMemberId,+ name: 'Ada',+ source: 'MANUAL',+ consentState: 'PENDING',+ }),+ );+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ slackUserLinkId: 'link-new' }),+ );+ });++ it('should keep an already-active link active when re-linking the same member', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',workspaceMemberId: INPUT.workspaceMemberId,- name: 'Ada',source: 'MANUAL',+ consentState: 'ACTIVE',});- expect(updateSlackUserLinkMock).not.toHaveBeenCalled();++ const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });++ expect(result.success).toBe(true);+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ workspaceMemberId: INPUT.workspaceMemberId,+ name: 'Ada',+ source: undefined,+ consentState: undefined,+ });+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();});- it('should update the existing link and mark it manual', async () => {+ it('should not pin an AUTO link to manual when re-saving the same member', async () => {findSlackUserLinkMock.mockResolvedValue({id: 'link-1',- workspaceMemberId: 'someone-else',+ workspaceMemberId: INPUT.workspaceMemberId,source: 'AUTO',+ consentState: 'ACTIVE',+ });++ const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });++ expect(result.success).toBe(true);+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: undefined, consentState: undefined }),+ );+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should respect a decline and not re-request consent when re-linking the same member', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: INPUT.workspaceMemberId,+ source: 'MANUAL',+ consentState: 'DECLINED',});const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });@@ -173,8 +441,339 @@ describe('slackSetUserLinkHandler', () => {id: 'link-1',workspaceMemberId: INPUT.workspaceMemberId,name: 'Ada',+ source: undefined,+ consentState: undefined,+ });+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should re-request consent when linking a declined user to a different member', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'someone-else',+ source: 'MANUAL',+ consentState: 'DECLINED',+ });++ const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });++ expect(result.success).toBe(true);+ expect(destroySlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ });+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ workspaceMemberId: INPUT.workspaceMemberId,+ consentState: 'PENDING',+ }),+ );+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalled();+ });++ it('should not re-send a consent request when re-saving a still-pending same-member link', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: INPUT.workspaceMemberId,+ source: 'MANUAL',+ consentState: 'PENDING',+ });++ const result = await slackSetUserLinkHandler({ ...INPUT, name: 'Ada' });++ expect(result.success).toBe(true);+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ consentState: undefined }),+ );+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should read the input from the route payload body', async () => {+ const result = await slackSetUserLinkHandler({+ body: { ...INPUT, name: 'Ada' },+ headers: {},+ queryStringParameters: {},+ pathParameters: {},+ isBase64Encoded: false,+ requestContext: {+ http: { method: 'POST', path: '/s/slack-user-links/set' },+ },+ userWorkspaceId: 'workspace-1',+ });++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ slackUserId: INPUT.slackUserId,+ workspaceMemberId: INPUT.workspaceMemberId,+ name: 'Ada',+ source: 'MANUAL',+ }),+ );+ });++ it('should fail closed when required fields are blank', async () => {+ const result = await slackSetUserLinkHandler({+ ...INPUT,+ workspaceMemberId: '',+ });++ expect(result.success).toBe(false);+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should require a Slack email or a Slack user id', async () => {+ const result = await slackSetUserLinkHandler({+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(false);+ expect(currentUserHasRolesPermissionMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should resolve the Slack user by email when no user id is given', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ });++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(true);+ expect(resolveSlackUserByEmailMock).toHaveBeenCalledWith(+ expect.anything(),+ '[email protected]',+ );+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ slackTeamId: INSTALLED_TEAM_ID,+ slackUserId: 'U9999999999',+ workspaceMemberId: 'workspace-member-1',+ name: 'Ada Lovelace',source: 'MANUAL',+ consentState: 'PENDING',});+ });++ it('should fail with a helpful error when the email is not in the workspace', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue(undefined);++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(false);+ expect(result.error).toContain('Slack user id');+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should fail with a structured error when the email lookup throws', async () => {+ resolveSlackUserByEmailMock.mockRejectedValue(new Error('ratelimited'));++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(false);+ expect(result.error).toBe('ratelimited');+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should refuse a supplied team id that disagrees with the email lookup', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ });++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ slackTeamId: 'T9876543210',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(false);+ if (result.success === false) {+ expect(result.error).toContain('belongs to workspace');+ }expect(createSlackUserLinkMock).not.toHaveBeenCalled();});++ it('should activate immediately as an AUTO link when the email matches the member', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ });+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ email: '[email protected]',+ isRegularUserAccount: true,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(true);+ expect(findWorkspaceMemberEmailByIdMock).toHaveBeenCalledWith(+ expect.anything(),+ 'workspace-member-1',+ );+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ slackTeamId: INSTALLED_TEAM_ID,+ slackUserId: 'U9999999999',+ workspaceMemberId: 'workspace-member-1',+ name: 'Ada Lovelace',+ source: 'AUTO',+ consentState: 'ACTIVE',+ });+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should still ask for consent when an email-submitted account is not a regular user', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Guest',+ });+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Guest',+ email: '[email protected]',+ isRegularUserAccount: false,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: 'MANUAL', consentState: 'PENDING' }),+ );+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalled();+ });++ it('should activate immediately when a regular account given by id matches the member email', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ email: '[email protected]',+ isRegularUserAccount: true,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: 'AUTO', consentState: 'ACTIVE' }),+ );+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should activate immediately when the form submits a resolved id and team that match', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ email: '[email protected]',+ isRegularUserAccount: true,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ const result = await slackSetUserLinkHandler({+ ...INPUT,+ slackTeamId: INSTALLED_TEAM_ID,+ });++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: 'AUTO', consentState: 'ACTIVE' }),+ );+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should still ask for consent when a matching email belongs to a non-regular account', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue({+ slackUserId: INPUT.slackUserId,+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Bot Account',+ email: '[email protected]',+ isRegularUserAccount: false,+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ const result = await slackSetUserLinkHandler(INPUT);++ expect(result.success).toBe(true);+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: 'MANUAL', consentState: 'PENDING' }),+ );+ expect(sendSlackUserLinkConsentDmMock).toHaveBeenCalledTimes(1);+ });++ it('should keep a same-member decline declined even when the emails match', async () => {+ resolveSlackUserByEmailMock.mockResolvedValue({+ slackUserId: 'U9999999999',+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ });+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'workspace-member-1',+ source: 'MANUAL',+ consentState: 'DECLINED',+ });++ const result = await slackSetUserLinkHandler({+ email: '[email protected]',+ workspaceMemberId: 'workspace-member-1',+ });++ expect(result.success).toBe(true);+ expect(findWorkspaceMemberEmailByIdMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ source: undefined, consentState: undefined }),+ );+ expect(sendSlackUserLinkConsentDmMock).not.toHaveBeenCalled();+ });++ it('should prefer the Slack user id over the email when both are given', async () => {+ const result = await slackSetUserLinkHandler({+ ...INPUT,+ email: '[email protected]',+ });++ expect(result.success).toBe(true);+ expect(resolveSlackUserByEmailMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({ slackUserId: INPUT.slackUserId }),+ );+ });});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-user-link-consent-handler.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-user-link-consent-handler.test.tsnew file mode 100644index 00000000000..80f40069206--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/__tests__/slack-user-link-consent-handler.test.ts@@ -0,0 +1,197 @@+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { SLACK_USER_LINK_CONSENT_ACTION_ID } from 'src/logic-functions/constants/slack-user-link-consent-action-id';+import { slackUserLinkConsentHandler } from 'src/logic-functions/handlers/slack-user-link-consent-handler';+import { type SlackInteractivityPayload } from 'src/logic-functions/types/slack-interactivity-payload.type';++const {+ coreApiClientMock,+ findSlackUserLinkMock,+ updateSlackUserLinkMock,+ updateSlackMessageViaResponseUrlMock,+} = vi.hoisted(() => ({+ coreApiClientMock: vi.fn(),+ findSlackUserLinkMock: vi.fn(),+ updateSlackUserLinkMock: vi.fn(),+ updateSlackMessageViaResponseUrlMock: vi.fn(),+}));++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: coreApiClientMock,+}));++vi.mock('src/logic-functions/data/find-slack-user-link', () => ({+ findSlackUserLink: findSlackUserLinkMock,+}));++vi.mock('src/logic-functions/data/update-slack-user-link', () => ({+ updateSlackUserLink: updateSlackUserLinkMock,+}));++vi.mock(+ 'src/logic-functions/utils/update-slack-message-via-response-url',+ () => ({+ updateSlackMessageViaResponseUrl: updateSlackMessageViaResponseUrlMock,+ }),+);++const buildPayload = (+ decision: 'APPROVE' | 'DECLINE',+ overrides: {+ userId?: string;+ teamId?: string;+ workspaceMemberId?: string;+ slackUserLinkId?: string;+ } = {},+): SlackInteractivityPayload => ({+ type: 'block_actions',+ team: { id: overrides.teamId ?? 'T1' },+ user: { id: overrides.userId ?? 'U1' },+ response_url: 'https://hooks.slack.test/1',+ actions: [+ {+ action_id: `${SLACK_USER_LINK_CONSENT_ACTION_ID}:${decision.toLowerCase()}`,+ block_id: SLACK_USER_LINK_CONSENT_ACTION_ID,+ value: JSON.stringify({+ decision,+ slackTeamId: 'T1',+ slackUserId: 'U1',+ workspaceMemberId: overrides.workspaceMemberId ?? 'member-1',+ slackUserLinkId: overrides.slackUserLinkId ?? 'link-1',+ }),+ },+ ],+});++describe('slackUserLinkConsentHandler', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ coreApiClientMock.mockImplementation(function () {+ return {};+ });+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'PENDING',+ });+ updateSlackUserLinkMock.mockResolvedValue(undefined);+ updateSlackMessageViaResponseUrlMock.mockResolvedValue({ success: true });+ });++ it('should activate the link when the invited user approves', async () => {+ const result = await slackUserLinkConsentHandler(buildPayload('APPROVE'));++ expect(result).toEqual({ done: true });+ expect(updateSlackUserLinkMock).toHaveBeenCalledTimes(1);+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ consentState: 'ACTIVE',+ });+ expect(updateSlackMessageViaResponseUrlMock).toHaveBeenCalledTimes(1);+ expect(updateSlackMessageViaResponseUrlMock).toHaveBeenCalledWith(+ expect.objectContaining({+ text: expect.stringContaining('approved'),+ }),+ );+ });++ it('should report a failure to the user when the write fails', async () => {+ updateSlackUserLinkMock.mockRejectedValue(new Error('write refused'));++ const result = await slackUserLinkConsentHandler(buildPayload('APPROVE'));++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackMessageViaResponseUrlMock).toHaveBeenCalledTimes(1);+ expect(updateSlackMessageViaResponseUrlMock).toHaveBeenCalledWith(+ expect.objectContaining({+ text: expect.stringContaining('went wrong'),+ }),+ );+ });++ it('should ignore a decision that targets a superseded member assignment', async () => {+ const result = await slackUserLinkConsentHandler(+ buildPayload('APPROVE', { workspaceMemberId: 'member-old' }),+ );++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should ignore a decision whose link was deleted and recreated with a new id', async () => {+ const result = await slackUserLinkConsentHandler(+ buildPayload('APPROVE', { slackUserLinkId: 'link-old' }),+ );++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should decline the link when the invited user declines', async () => {+ const result = await slackUserLinkConsentHandler(buildPayload('DECLINE'));++ expect(result).toEqual({ done: true });+ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(expect.anything(), {+ id: 'link-1',+ consentState: 'DECLINED',+ });+ expect(updateSlackMessageViaResponseUrlMock).toHaveBeenCalledWith(+ expect.objectContaining({+ text: expect.stringContaining('declined'),+ }),+ );+ });++ it('should ignore a decision from a different Slack user', async () => {+ const result = await slackUserLinkConsentHandler(+ buildPayload('APPROVE', { userId: 'U-someone-else' }),+ );++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should ignore a decision from a different Slack workspace', async () => {+ const result = await slackUserLinkConsentHandler(+ buildPayload('APPROVE', { teamId: 'T-other' }),+ );++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should not transition a link that is no longer pending', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ id: 'link-1',+ workspaceMemberId: 'member-1',+ source: 'MANUAL',+ consentState: 'ACTIVE',+ });++ const result = await slackUserLinkConsentHandler(buildPayload('APPROVE'));++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should skip when there is no link for the Slack user', async () => {+ findSlackUserLinkMock.mockResolvedValue(undefined);++ const result = await slackUserLinkConsentHandler(buildPayload('APPROVE'));++ expect(result).toMatchObject({ skipped: true });+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should skip when there is no consent action in the payload', async () => {+ const result = await slackUserLinkConsentHandler({+ type: 'block_actions',+ team: { id: 'T1' },+ user: { id: 'U1' },+ actions: [{ action_id: 'something-else' }],+ });++ expect(result).toMatchObject({ skipped: true });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-interactivity-resolver-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-interactivity-resolver-handler.tsindex 755cc4ef029..d6249562f0e 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-interactivity-resolver-handler.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-interactivity-resolver-handler.ts@@ -1,8 +1,13 @@import { type RoutePayload } from 'twenty-sdk/define';import { Response } from 'twenty-sdk/logic-function';+import { isDefined } from 'twenty-sdk/utils';-import { SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import {+ SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER,+ SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+} from 'src/constants/universal-identifiers';import { SLACK_ASSISTANT_FEEDBACK_ACTION_ID } from 'src/logic-functions/constants/slack-assistant-feedback-action-id';+import { SLACK_USER_LINK_CONSENT_ACTION_ID } from 'src/logic-functions/constants/slack-user-link-consent-action-id';import { type SlackInteractivityPayload } from 'src/logic-functions/types/slack-interactivity-payload.type';import { type SlackInteractivityRequestBody } from 'src/logic-functions/types/slack-interactivity-request-body.type';import { parseSlackInteractivityPayloadOrThrow } from 'src/logic-functions/utils/parse-slack-interactivity-payload-or-throw';@@ -24,20 +29,38 @@ export const slackInteractivityResolverHandler = async (const payload = parseSlackInteractivityPayloadOrThrow(routePayload.body);- const hasAssistantFeedbackAction =- payload.type === 'block_actions' &&- (payload.actions ?? []).some(- (action) => action.action_id === SLACK_ASSISTANT_FEEDBACK_ACTION_ID,- );+ if (payload.type !== 'block_actions') {+ return new Response({ ok: true });+ }++ const actions = payload.actions ?? [];++ const hasAssistantFeedbackAction = actions.some(+ (action) => action.action_id === SLACK_ASSISTANT_FEEDBACK_ACTION_ID,+ );++ const hasUserLinkConsentAction = actions.some((action) =>+ action.action_id?.startsWith(SLACK_USER_LINK_CONSENT_ACTION_ID),+ );++ const targetLogicFunctionUniversalIdentifier = [+ {+ isMatched: hasAssistantFeedbackAction,+ identifier: SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER,+ },+ {+ isMatched: hasUserLinkConsentAction,+ identifier: SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+ },+ ].find(({ isMatched }) => isMatched)?.identifier;- if (!hasAssistantFeedbackAction) {+ if (!isDefined(targetLogicFunctionUniversalIdentifier)) {return new Response({ ok: true });}return {workspaceId: await resolveTargetWorkspaceId(payload.team?.id),- targetLogicFunctionUniversalIdentifier:- SLACK_ASSISTANT_FEEDBACK_UNIVERSAL_IDENTIFIER,+ targetLogicFunctionUniversalIdentifier,payload,};};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-user-link-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-user-link-handler.tsnew file mode 100644index 00000000000..5347df9f77b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-remove-user-link-handler.ts@@ -0,0 +1,52 @@+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';++import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';+import { destroySlackUserLink } from 'src/logic-functions/data/destroy-slack-user-link';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const readId = (payload: SlackRouteBody): string | undefined =>+ readOptionalString(asRecord(payload.body)?.id);++export const slackRemoveUserLinkHandler = async (+ payload: SlackRouteBody,+): Promise<SlackToolResult> => {+ const id = readId(payload);++ if (!isNonEmptyString(id)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'id is required.',+ };+ }++ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error:+ 'Only members with the roles permission can remove Slack user links.',+ };+ }++ try {+ await destroySlackUserLink(new CoreApiClient({ runAs: 'application' }), {+ id,+ });+ } catch (error) {+ return {+ success: false,+ message: 'Could not remove the link',+ error: toErrorMessage(error),+ };+ }++ return { success: true, message: 'Removed the Slack user link.' };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resend-user-link-consent-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resend-user-link-consent-handler.tsnew file mode 100644index 00000000000..af43bf49495--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resend-user-link-consent-handler.ts@@ -0,0 +1,126 @@+import { isNonEmptyString } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { findSlackUserLink } from 'src/logic-functions/data/find-slack-user-link';+import { findWorkspaceMemberNameById } from 'src/logic-functions/data/find-workspace-member-name-by-id';+import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';+import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { sendSlackUserLinkConsentDm } from 'src/logic-functions/utils/send-slack-user-link-consent-dm';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const readBody = (+ payload: SlackRouteBody,+): { slackTeamId?: string; slackUserId?: string } => {+ const body = asRecord(payload.body) ?? {};++ return {+ slackTeamId: readOptionalString(body.slackTeamId),+ slackUserId: readOptionalString(body.slackUserId),+ };+};++export const slackResendUserLinkConsentHandler = async (+ payload: SlackRouteBody,+): Promise<SlackToolResult> => {+ const { slackTeamId, slackUserId } = readBody(payload);++ if (!isNonEmptyString(slackTeamId) || !isNonEmptyString(slackUserId)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'slackTeamId and slackUserId are required.',+ };+ }++ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error:+ 'Only members with the roles permission can resend consent requests.',+ };+ }++ const client = new CoreApiClient({ runAs: 'application' });++ let link: SlackUserLink | undefined;++ try {+ link = await findSlackUserLink(client, { slackTeamId, slackUserId });+ } catch (error) {+ return {+ success: false,+ message: 'Could not look up the link',+ error: toErrorMessage(error),+ };+ }++ if (!isDefined(link)) {+ return {+ success: false,+ message: 'No link to resend',+ error: 'No Slack user link found for that account.',+ };+ }++ if (link.consentState !== SLACK_USER_LINK_CONSENT_STATE.PENDING) {+ return {+ success: false,+ message: 'Nothing to resend',+ error: 'This link is not awaiting consent.',+ };+ }++ const slackClientResult = await getSlackClient();++ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }++ if (!isNonEmptyString(link.workspaceMemberId)) {+ return {+ success: false,+ message: 'Nothing to resend',+ error: 'This link is not assigned to a workspace member.',+ };+ }++ const memberName = await findWorkspaceMemberNameById(+ client,+ link.workspaceMemberId,+ );++ const dmResult = await sendSlackUserLinkConsentDm(slackClientResult.client, {+ slackTeamId,+ slackUserId,+ workspaceMemberId: link.workspaceMemberId,+ slackUserLinkId: link.id,+ memberName,+ });++ if (!dmResult.success) {+ return {+ success: false,+ message: 'Could not deliver the consent request',+ error: dmResult.error,+ };+ }++ return {+ success: true,+ message: `Resent the consent request to Slack user ${slackUserId}.`,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resolve-user-link-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resolve-user-link-handler.tsnew file mode 100644index 00000000000..75720e63cd6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-resolve-user-link-handler.ts@@ -0,0 +1,137 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { type SlackResolveUserLinkResult } from 'src/logic-functions/types/slack-resolved-user.type';+import { type SlackRouteBody } from 'src/logic-functions/types/slack-route-body.type';+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 { resolveLinkTargetById } from 'src/logic-functions/utils/resolve-link-target-by-id';+import {+ type ResolvedSlackUser,+ resolveSlackUserByEmail,+} from 'src/logic-functions/utils/resolve-slack-user-by-email';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const readBody = (+ payload: SlackRouteBody,+): { email?: string; slackUserId?: string; slackTeamId?: string } => {+ const body = asRecord(payload.body) ?? {};++ return {+ email: readOptionalString(body.email),+ slackUserId: readOptionalString(body.slackUserId),+ slackTeamId: readOptionalString(body.slackTeamId),+ };+};++export const slackResolveUserLinkHandler = async (+ payload: SlackRouteBody,+): Promise<SlackResolveUserLinkResult> => {+ const {+ email,+ slackUserId: requestedSlackUserId,+ slackTeamId,+ } = readBody(payload);++ if (!isNonEmptyString(email) && !isNonEmptyString(requestedSlackUserId)) {+ return {+ success: false,+ message: 'Nothing to resolve',+ error: 'Provide a Slack email or a Slack user id.',+ };+ }++ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error: 'Only members with the roles permission can resolve 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 (!isNonEmptyString(installedTeamId)) {+ return {+ success: false,+ message: 'Could not verify the installed Slack workspace',+ error: 'Slack did not confirm the installed workspace. Please try again.',+ };+ }++ if (isNonEmptyString(requestedSlackUserId)) {+ const idTarget = await resolveLinkTargetById({+ slackClient,+ slackUserId: requestedSlackUserId,+ requestedSlackTeamId: slackTeamId,+ installedSlackTeamId: installedTeamId,+ });++ if (!idTarget.success) {+ return idTarget;+ }++ return {+ success: true,+ slackUser: {+ slackUserId: requestedSlackUserId,+ slackTeamId: idTarget.slackTeamId,+ displayName: idTarget.identity?.displayName,+ email: idTarget.identity?.isRegularUserAccount+ ? idTarget.identity.email+ : undefined,+ isInInstalledWorkspace: idTarget.slackTeamId === installedTeamId,+ },+ };+ }++ let resolvedUser: ResolvedSlackUser | undefined;++ try {+ resolvedUser = await resolveSlackUserByEmail(slackClient, email ?? '');+ } catch (error) {+ return {+ success: false,+ message: 'Could not look up that Slack email',+ error: toErrorMessage(error),+ };+ }++ if (!isDefined(resolvedUser)) {+ return {+ success: false,+ message: 'No Slack user with that email',+ error:+ 'No Slack user with that email in the installed workspace. For a guest or Slack Connect user from another workspace, use their Slack user id instead.',+ };+ }++ const resolvedTeamId = resolvedUser.slackTeamId ?? installedTeamId;++ return {+ success: true,+ slackUser: {+ slackUserId: resolvedUser.slackUserId,+ slackTeamId: resolvedTeamId,+ displayName: resolvedUser.displayName,+ email: resolvedUser.isRegularUserAccount ? email : undefined,+ isInInstalledWorkspace: resolvedTeamId === installedTeamId,+ },+ };+};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.tsnew file mode 100644index 00000000000..1936e14eee9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-search-users-handler.ts@@ -0,0 +1,157 @@+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 { asRecord } from 'src/logic-functions/utils/as-record.util';+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';++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 =>+ [+ member.real_name,+ member.profile?.display_name,+ member.profile?.email,+ member.id,+ ].some(+ (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> => {+ const isAllowed = await currentUserHasRolesPermission();++ if (!isAllowed) {+ return {+ success: false,+ message: 'Not allowed',+ error: 'Only members with the roles permission can search Slack users.',+ };+ }++ const body = asRecord(payload.body) ?? {};+ const query = readOptionalString(body.query)?.trim().toLowerCase();++ if (!isNonEmptyString(query)) {+ return { success: true, slackUsers: [] };+ }++ 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 {+ return {+ success: true,+ slackUsers: await collectMatches(slackClient, query, installedTeamId),+ };+ } catch (error) {+ return {+ success: false,+ message: 'Could not search Slack users',+ error: toErrorMessage(error),+ };+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-user-link-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-user-link-handler.tsindex 37c47e3e0a8..416508ae3cc 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-user-link-handler.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-set-user-link-handler.ts@@ -2,60 +2,136 @@ import { isNonEmptyString } from '@sniptt/guards';import { CoreApiClient } from 'twenty-client-sdk/core';import { isDefined } from 'twenty-sdk/utils';-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 { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { doesWorkspaceMemberExist } from 'src/logic-functions/data/does-workspace-member-exist';import { findSlackUserLink } from 'src/logic-functions/data/find-slack-user-link';-import { updateSlackUserLink } from 'src/logic-functions/data/update-slack-user-link';-import { type SlackSetUserLinkInput } from 'src/logic-functions/types/slack-set-user-link-input.type';+import { findWorkspaceMemberNameById } from 'src/logic-functions/data/find-workspace-member-name-by-id';import { type SlackToolResult } from 'src/logic-functions/types/slack-tool-result.type';import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';-import { currentUserHasWorkspaceMembersPermission } from 'src/logic-functions/utils/current-user-has-workspace-members-permission';+import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';+import { decideSlackUserLinkWrite } from 'src/logic-functions/utils/decide-slack-user-link-write';+import {+ extractSlackSetUserLinkInput,+ type SlackSetUserLinkPayload,+} from 'src/logic-functions/utils/extract-slack-set-user-link-input';import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';import { getSlackClient } from 'src/logic-functions/utils/get-slack-client';+import { persistSlackUserLink } from 'src/logic-functions/utils/persist-slack-user-link';+import { resolveSlackUserLinkTarget } from 'src/logic-functions/utils/resolve-slack-user-link-target';+import { sendSlackUserLinkConsentDm } from 'src/logic-functions/utils/send-slack-user-link-consent-dm';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';-export const slackSetUserLinkHandler = async ({- slackUserId,- workspaceMemberId,- slackTeamId: requestedSlackTeamId,- name,-}: SlackSetUserLinkInput): Promise<SlackToolResult> => {- const isAllowed = await currentUserHasWorkspaceMembersPermission();+const RELINK_STATE_NOTES: Partial<Record<SlackUserLinkConsentState, string>> = {+ [SLACK_USER_LINK_CONSENT_STATE.DECLINED]:+ 'They previously declined, so their choice stands and no new request was sent. Remove the link and add it again to ask them once more.',+ [SLACK_USER_LINK_CONSENT_STATE.PENDING]:+ 'It is still awaiting their approval, so no new request was sent. Use resend to nudge them.',+};++export const slackSetUserLinkHandler = async (+ payload: SlackSetUserLinkPayload,+): Promise<SlackToolResult> => {+ const {+ slackUserId: requestedSlackUserId,+ email,+ workspaceMemberId,+ slackTeamId: requestedSlackTeamId,+ name,+ } = extractSlackSetUserLinkInput(payload);++ if (!isNonEmptyString(workspaceMemberId)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'workspaceMemberId is required.',+ };+ }++ if (!isNonEmptyString(requestedSlackUserId) && !isNonEmptyString(email)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'Provide a Slack email or a Slack user id.',+ };+ }++ const isAllowed = await currentUserHasRolesPermission();if (!isAllowed) {return {success: false,message: 'Not allowed',- error:- 'Only members with the workspace members permission can set Slack user links.',+ error: 'Only members with the roles permission can set Slack user links.',};}- let slackTeamId = requestedSlackTeamId;+ const slackClientResult = await getSlackClient();- if (!isNonEmptyString(slackTeamId)) {- const slackClientResult = await getSlackClient();+ if (!slackClientResult.success) {+ return {+ success: false,+ message: 'Slack is not connected',+ error: slackClientResult.error,+ };+ }- if (!slackClientResult.success) {- return {- success: false,- message: 'Slack is not connected',- error: slackClientResult.error,- };- }+ const slackClient = slackClientResult.client;- slackTeamId = await getInstalledSlackTeamId(slackClientResult.client);- }+ const installedTeamId = await getInstalledSlackTeamId(slackClient);- if (!isNonEmptyString(slackTeamId)) {+ if (!isNonEmptyString(installedTeamId)) {return {success: false,- message: 'Could not resolve the Slack workspace',- error: 'Slack did not return a team id for the installed connection.',+ message: 'Could not verify the installed Slack workspace',+ error: 'Slack did not confirm the installed workspace. Please try again.',};}+ const target = await resolveSlackUserLinkTarget({+ slackClient,+ requestedSlackUserId,+ email,+ requestedSlackTeamId,+ requestedName: name,+ installedSlackTeamId: installedTeamId,+ });++ if (!target.success) {+ return target;+ }++ const {+ slackUserId,+ slackTeamId,+ name: resolvedName,+ identity: fetchedIdentity,+ } = target;++ const isInInstalledWorkspace = slackTeamId === installedTeamId;+const client = new CoreApiClient({ runAs: 'application' });+ let memberExists: boolean;++ try {+ memberExists = await doesWorkspaceMemberExist(client, workspaceMemberId);+ } catch (error) {+ return {+ success: false,+ message: 'Could not verify the workspace member',+ error: toErrorMessage(error),+ };+ }++ if (!memberExists) {+ return {+ success: false,+ message: 'Workspace member not found',+ error: `No workspace member with id ${workspaceMemberId}. Check the id and try again.`,+ };+ }+let existingLink: SlackUserLink | undefined;try {@@ -67,37 +143,99 @@ export const slackSetUserLinkHandler = async ({return {success: false,message: 'Could not look up the existing link',- error: error instanceof Error ? error.message : String(error),+ error: toErrorMessage(error),};}+ const isSameMemberRelink =+ isDefined(existingLink) &&+ existingLink.workspaceMemberId === workspaceMemberId;++ const {+ isEagerAutoMatch,+ requiresConsent,+ consentState: consentStateForWrite,+ source: sourceForWrite,+ } = await decideSlackUserLinkWrite({+ client,+ slackClient,+ slackUserId,+ workspaceMemberId,+ fetchedIdentity,+ isInInstalledWorkspace,+ isSameMemberRelink,+ });++ let slackUserLinkId: string;+try {- if (isDefined(existingLink)) {- await updateSlackUserLink(client, {- id: existingLink.id,- workspaceMemberId,- name,- source: SLACK_USER_LINK_SOURCE.MANUAL,- });- } else {- await createSlackUserLink(client, {- slackTeamId,- slackUserId,- workspaceMemberId,- name: isNonEmptyString(name) ? name : slackUserId,- source: SLACK_USER_LINK_SOURCE.MANUAL,- });- }+ slackUserLinkId = await persistSlackUserLink(client, {+ existingLink,+ isSameMemberRelink,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ name: resolvedName,+ source: sourceForWrite,+ consentState: consentStateForWrite,+ });} catch (error) {return {success: false,message: 'Could not save the link',- error: error instanceof Error ? error.message : String(error),+ error: toErrorMessage(error),+ };+ }++ if (!isInInstalledWorkspace) {+ return {+ success: true,+ message: `Linked Slack user ${slackUserId} to workspace member ${workspaceMemberId}. This account is outside the installed workspace, so it is admin-set without a consent request.`,+ };+ }++ if (isEagerAutoMatch) {+ return {+ success: true,+ message: `Linked Slack user ${slackUserId} to workspace member ${workspaceMemberId}. Their Slack email matches this member, so the link is active immediately with no approval step.`,+ };+ }++ if (!requiresConsent) {+ const stateNote =+ (isDefined(existingLink?.consentState)+ ? RELINK_STATE_NOTES[existingLink.consentState]+ : undefined) ??+ 'It is already active for that workspace member, so no new consent request was sent.';++ return {+ success: true,+ message: `Updated the link for Slack user ${slackUserId}. ${stateNote}`,+ };+ }++ const memberName = await findWorkspaceMemberNameById(+ client,+ workspaceMemberId,+ );++ const dmResult = await sendSlackUserLinkConsentDm(slackClient, {+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ memberName,+ });++ if (!dmResult.success) {+ return {+ success: true,+ message: `Saved a pending link for Slack user ${slackUserId}, but could not deliver the consent request (${dmResult.error}). Resend it from the settings tab.`,};}return {success: true,- message: `Linked Slack user ${slackUserId} to workspace member ${workspaceMemberId}.`,+ message: `Asked Slack user ${slackUserId} to approve linking to workspace member ${workspaceMemberId}. The link activates once they approve.`,};};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-user-link-consent-handler.ts b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-user-link-consent-handler.tsnew file mode 100644index 00000000000..73c711c3966--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/handlers/slack-user-link-consent-handler.ts@@ -0,0 +1,129 @@+import { CoreApiClient } from 'twenty-client-sdk/core';+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_USER_LINK_CONSENT_ACTION_ID } from 'src/logic-functions/constants/slack-user-link-consent-action-id';+import { SLACK_USER_LINK_CONSENT_DECISION } from 'src/logic-functions/constants/slack-user-link-consent-decision';+import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { findSlackUserLink } from 'src/logic-functions/data/find-slack-user-link';+import { updateSlackUserLink } from 'src/logic-functions/data/update-slack-user-link';+import { type SlackInteractivityPayload } from 'src/logic-functions/types/slack-interactivity-payload.type';+import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';+import { type SlackUserLinkConsentResult } from 'src/logic-functions/types/slack-user-link-consent-result.type';+import { parseSlackUserLinkConsentButtonValue } from 'src/logic-functions/utils/parse-slack-user-link-consent-button-value';+import { updateSlackMessageViaResponseUrl } from 'src/logic-functions/utils/update-slack-message-via-response-url';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const APPROVED_MESSAGE =+ 'Thanks, you approved the link. The Twenty assistant can now act with that member access when you message it.';++const DECLINED_MESSAGE =+ 'No problem, you declined the link. The Twenty assistant will keep answering with its own access.';++const FAILURE_MESSAGE =+ 'Something went wrong saving your choice. Please try the button again in a moment.';++export const slackUserLinkConsentHandler = async (+ payload: SlackInteractivityPayload,+): Promise<SlackUserLinkConsentResult> => {+ const consentAction = payload.actions?.find((action) =>+ action.action_id?.startsWith(SLACK_USER_LINK_CONSENT_ACTION_ID),+ );++ if (!isDefined(consentAction)) {+ return { skipped: true, reason: 'No consent action in payload' };+ }++ const buttonValue = parseSlackUserLinkConsentButtonValue(consentAction.value);++ if (!isDefined(buttonValue)) {+ return { skipped: true, reason: 'Consent action has no valid value' };+ }++ if (+ payload.user?.id !== buttonValue.slackUserId ||+ payload.team?.id !== buttonValue.slackTeamId+ ) {+ return {+ skipped: true,+ reason: 'Consent decision came from a different Slack user',+ };+ }++ const client = new CoreApiClient({ runAs: 'application' });++ let link: SlackUserLink | undefined;++ try {+ link = await findSlackUserLink(client, {+ slackTeamId: buttonValue.slackTeamId,+ slackUserId: buttonValue.slackUserId,+ });+ } catch {+ return { skipped: true, reason: 'Could not read the link' };+ }++ if (!isDefined(link)) {+ return { skipped: true, reason: 'No link for this Slack user' };+ }++ if (link.consentState !== SLACK_USER_LINK_CONSENT_STATE.PENDING) {+ return {+ skipped: true,+ reason: `Link is not awaiting consent (state: ${link.consentState})`,+ };+ }++ if (+ link.id !== buttonValue.slackUserLinkId ||+ link.workspaceMemberId !== buttonValue.workspaceMemberId+ ) {+ return {+ skipped: true,+ reason: 'Consent decision targets a superseded link',+ };+ }++ const approved =+ buttonValue.decision === SLACK_USER_LINK_CONSENT_DECISION.APPROVE;++ try {+ await updateSlackUserLink(client, {+ id: link.id,+ consentState: approved+ ? SLACK_USER_LINK_CONSENT_STATE.ACTIVE+ : SLACK_USER_LINK_CONSENT_STATE.DECLINED,+ });+ } catch (error) {+ const failureNotice = await updateSlackMessageViaResponseUrl({+ responseUrl: payload.response_url,+ text: FAILURE_MESSAGE,+ });++ if (!failureNotice.success) {+ console.warn(+ `[slack] response_url message update failed: ${failureNotice.error}`,+ );+ }++ return {+ skipped: true,+ reason: toErrorMessage(error),+ };+ }++ const messageUpdate = await updateSlackMessageViaResponseUrl({+ responseUrl: payload.response_url,+ text: approved ? APPROVED_MESSAGE : DECLINED_MESSAGE,+ });++ // The decision is already saved, so a failed message refresh is worth+ // reporting but must not undo it.+ if (!messageUpdate.success) {+ return {+ done: true,+ messageUpdateError: messageUpdate.error,+ };+ }++ return { done: true };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/schemas/slack-set-user-link-input.schema.ts b/packages/twenty-apps/public/slack/src/logic-functions/schemas/slack-set-user-link-input.schema.tsindex cfa9f8be7ea..950bcf2d9cb 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/schemas/slack-set-user-link-input.schema.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/schemas/slack-set-user-link-input.schema.ts@@ -3,17 +3,24 @@ import { type InputJsonSchema } from 'twenty-sdk/logic-function';export const slackSetUserLinkInputSchema: InputJsonSchema = {type: 'object',properties: {- slackUserId: {- type: 'string',- label: 'Slack user ID',- description: 'Slack account to link (Slack member ID like U…).',- },workspaceMemberId: {type: 'string',label: 'Workspace member ID',description:'Workspace member whose permissions the assistant borrows when this Slack user talks to it.',},+ email: {+ type: 'string',+ label: 'Slack email',+ description:+ 'Email of the Slack account to link. Resolved to a Slack user in the installed workspace. Use slackUserId instead for guests or Slack Connect users from another workspace.',+ },+ slackUserId: {+ type: 'string',+ label: 'Slack user ID',+ description:+ 'Slack account to link (Slack member ID like U…). Provide this instead of email for guests or Slack Connect users; it takes precedence over email when both are given.',+ },slackTeamId: {type: 'string',label: 'Slack team ID',@@ -24,9 +31,9 @@ export const slackSetUserLinkInputSchema: InputJsonSchema = {type: 'string',label: 'Display name',description:- 'Slack display name to store on the link. Defaults to the Slack user ID.',+ 'Slack display name to store on the link. Defaults to the resolved Slack name or the Slack user ID.',},},- required: ['slackUserId', 'workspaceMemberId'],+ required: ['workspaceMemberId'],additionalProperties: false,};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-user-link.tsnew file mode 100644index 00000000000..274563f1b63--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-remove-user-link.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_REMOVE_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_REMOVE_USER_LINK_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackRemoveUserLinkHandler } from 'src/logic-functions/handlers/slack-remove-user-link-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_REMOVE_USER_LINK_UNIVERSAL_IDENTIFIER,+ name: 'slack-remove-user-link',+ description:+ 'Removes a Slack user link so the assistant stops acting with that member permissions for the account. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_REMOVE_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackRemoveUserLinkHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-resend-user-link-consent.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-resend-user-link-consent.tsnew file mode 100644index 00000000000..adbd72574da--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-resend-user-link-consent.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_RESEND_CONSENT_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_RESEND_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackResendUserLinkConsentHandler } from 'src/logic-functions/handlers/slack-resend-user-link-consent-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_RESEND_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+ name: 'slack-resend-user-link-consent',+ description:+ 'Resends the Slack consent request for a pending manual user link. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_RESEND_CONSENT_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackResendUserLinkConsentHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-resolve-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-resolve-user-link.tsnew file mode 100644index 00000000000..d7b8c19eb71--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-resolve-user-link.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_RESOLVE_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_RESOLVE_USER_LINK_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackResolveUserLinkHandler } from 'src/logic-functions/handlers/slack-resolve-user-link-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_RESOLVE_USER_LINK_UNIVERSAL_IDENTIFIER,+ name: 'slack-resolve-user-link',+ description:+ 'Resolves a Slack account from an email or Slack user id so an admin can confirm the right person before linking. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_RESOLVE_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackResolveUserLinkHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-search-users.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-search-users.tsnew file mode 100644index 00000000000..9fbca5af83c--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-search-users.ts@@ -0,0 +1,19 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINKS_SEARCH_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';+import { SLACK_SEARCH_USERS_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackSearchUsersHandler } from 'src/logic-functions/handlers/slack-search-users-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_SEARCH_USERS_UNIVERSAL_IDENTIFIER,+ name: 'slack-search-users',+ description:+ 'Searches the installed Slack workspace for users by name or email so an admin can pick the right account to link. Restricted to members with the roles permission.',+ timeoutSeconds: 30,+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_SEARCH_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },+ handler: slackSearchUsersHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-set-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-set-user-link.tsindex a626f6ff629..6a11f169095 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/slack-set-user-link.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-set-user-link.ts@@ -1,5 +1,6 @@import { defineLogicFunction } from 'twenty-sdk/define';+import { SLACK_USER_LINKS_SET_ROUTE_PATH } from 'src/constants/slack-user-links-route-path.constant';import { SLACK_SET_USER_LINK_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';import { slackSetUserLinkHandler } from 'src/logic-functions/handlers/slack-set-user-link-handler';import { slackSetUserLinkInputSchema } from './schemas/slack-set-user-link-input.schema';@@ -8,10 +9,15 @@ export default defineLogicFunction({universalIdentifier: SLACK_SET_USER_LINK_UNIVERSAL_IDENTIFIER,name: 'slack-set-user-link',description:- 'Link a Slack user to a workspace member so the assistant acts with that member permissions. Restricted to members with the workspace members permission; the link is stored with source MANUAL and wins over email matching.',+ 'Link a Slack user to a workspace member so the assistant acts with that member permissions. Restricted to members with the roles permission. A link whose emails match activates immediately as an AUTO link; any other in-workspace link asks the Slack user for consent first, and accounts outside the installed workspace are admin-set.',timeoutSeconds: 30,toolTriggerSettings: {inputSchema: slackSetUserLinkInputSchema,},+ httpRouteTriggerSettings: {+ path: SLACK_USER_LINKS_SET_ROUTE_PATH,+ httpMethod: 'POST',+ isAuthRequired: true,+ },handler: slackSetUserLinkHandler,});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/slack-user-link-consent.ts b/packages/twenty-apps/public/slack/src/logic-functions/slack-user-link-consent.tsnew file mode 100644index 00000000000..ec520e547c9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/slack-user-link-consent.ts@@ -0,0 +1,13 @@+import { defineLogicFunction } from 'twenty-sdk/define';++import { SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';+import { slackUserLinkConsentHandler } from 'src/logic-functions/handlers/slack-user-link-consent-handler';++export default defineLogicFunction({+ universalIdentifier: SLACK_USER_LINK_CONSENT_UNIVERSAL_IDENTIFIER,+ name: 'slack-user-link-consent',+ description:+ 'Runs in the resolved workspace: records the Approve or Decline decision a Slack user made on the consent request for a manual Slack user link, and refreshes the message they acted on.',+ timeoutSeconds: 15,+ handler: slackUserLinkConsentHandler,+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-interactivity-payload.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-interactivity-payload.type.tsindex 2abc089ee39..a2d4910a2c4 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-interactivity-payload.type.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-interactivity-payload.type.ts@@ -2,6 +2,10 @@ type SlackInteractionTeam = {id?: string;};+type SlackInteractionUser = {+ id?: string;+};+type SlackInteractionAction = {action_id?: string;block_id?: string;@@ -11,5 +15,7 @@ type SlackInteractionAction = {export type SlackInteractivityPayload = {type?: string;team?: SlackInteractionTeam;+ user?: SlackInteractionUser;+ response_url?: string;actions?: SlackInteractionAction[];};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-message-update-result.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-message-update-result.type.tsnew file mode 100644index 00000000000..03973b6612d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-message-update-result.type.ts@@ -0,0 +1,3 @@+export type SlackMessageUpdateResult =+ | { success: true }+ | { success: false; error: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-resolved-user.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-resolved-user.type.tsnew file mode 100644index 00000000000..8552a5b41c9--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-resolved-user.type.ts@@ -0,0 +1,11 @@+export type SlackResolvedUser = {+ slackUserId: string;+ slackTeamId: string;+ displayName: string | undefined;+ email: string | undefined;+ isInInstalledWorkspace: boolean;+};++export type SlackResolveUserLinkResult =+ | { success: true; slackUser: SlackResolvedUser }+ | { success: false; message: string; error?: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-route-body.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-route-body.type.tsnew file mode 100644index 00000000000..dcfa6e547aa--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-route-body.type.ts@@ -0,0 +1,3 @@+import { type RoutePayload } from 'twenty-sdk/define';++export type SlackRouteBody = Pick<RoutePayload<unknown>, 'body'>;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-user-link-input.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-user-link-input.type.tsindex 6711bcf405f..26170b9b760 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-user-link-input.type.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-set-user-link-input.type.ts@@ -1,6 +1,7 @@export type SlackSetUserLinkInput = {- slackUserId: string;workspaceMemberId: string;+ slackUserId?: string;+ email?: string;slackTeamId?: string;name?: string;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-button-value.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-button-value.type.tsnew file mode 100644index 00000000000..488f1a1fb1e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-button-value.type.ts@@ -0,0 +1,9 @@+import { type SlackUserLinkConsentDecision } from 'src/logic-functions/types/slack-user-link-consent-decision.type';++export type SlackUserLinkConsentButtonValue = {+ decision: SlackUserLinkConsentDecision;+ slackTeamId: string;+ slackUserId: string;+ workspaceMemberId: string;+ slackUserLinkId: string;+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-decision.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-decision.type.tsnew file mode 100644index 00000000000..2b646455de4--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-decision.type.ts@@ -0,0 +1,4 @@+import { type SLACK_USER_LINK_CONSENT_DECISION } from 'src/logic-functions/constants/slack-user-link-consent-decision';++export type SlackUserLinkConsentDecision =+ (typeof SLACK_USER_LINK_CONSENT_DECISION)[keyof typeof SLACK_USER_LINK_CONSENT_DECISION];diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-result.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-result.type.tsnew file mode 100644index 00000000000..d43229eb411--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-result.type.ts@@ -0,0 +1,3 @@+export type SlackUserLinkConsentResult =+ | { done: true; messageUpdateError?: string }+ | { skipped: true; reason: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-state.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-state.type.tsnew file mode 100644index 00000000000..0a0243c3481--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link-consent-state.type.ts@@ -0,0 +1,4 @@+import { type SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';++export type SlackUserLinkConsentState =+ (typeof SLACK_USER_LINK_CONSENT_STATE)[keyof typeof SLACK_USER_LINK_CONSENT_STATE];diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link.type.tsindex 5e3ec52db36..4e6c6778684 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link.type.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-link.type.ts@@ -1,5 +1,9 @@+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 SlackUserLink = {id: string;workspaceMemberId: string | undefined;- source: string | undefined;+ source: SlackUserLinkSource | undefined;+ consentState: SlackUserLinkConsentState | undefined;};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-search.type.ts b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-search.type.tsnew file mode 100644index 00000000000..134e611eef6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/types/slack-user-search.type.ts@@ -0,0 +1,10 @@+export type SlackUserSearchOption = {+ slackUserId: string;+ slackTeamId: string;+ displayName: string | undefined;+ email: string | undefined;+};++export type SlackUserSearchResult =+ | { success: true; slackUsers: SlackUserSearchOption[] }+ | { success: false; message: string; error?: string };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-user-link-consent-blocks.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-user-link-consent-blocks.test.tsnew file mode 100644index 00000000000..8415efbdeee--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/build-slack-user-link-consent-blocks.test.ts@@ -0,0 +1,74 @@+import { describe, expect, it } from 'vitest';++import { buildSlackUserLinkConsentBlocks } from 'src/logic-functions/utils/build-slack-user-link-consent-blocks';+import { parseSlackUserLinkConsentButtonValue } from 'src/logic-functions/utils/parse-slack-user-link-consent-button-value';++const BLOCK_INPUT = {+ memberName: 'Ada Member',+ slackTeamId: 'T0123456789',+ slackUserId: 'U0123456789',+ workspaceMemberId: 'workspace-member-1',+ slackUserLinkId: 'link-1',+};++const findButtonValue = (decisionActionId: string): string | undefined => {+ const blocks = buildSlackUserLinkConsentBlocks(BLOCK_INPUT);++ for (const block of blocks) {+ if (block.type !== 'actions') {+ continue;+ }++ for (const element of block.elements) {+ if (+ element.type === 'button' &&+ element.action_id?.endsWith(decisionActionId)+ ) {+ return element.value;+ }+ }+ }++ return undefined;+};++describe('buildSlackUserLinkConsentBlocks', () => {+ it('should encode an approve value the consent parser reads back intact', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(findButtonValue(':approve')),+ ).toEqual({+ decision: 'APPROVE',+ slackTeamId: BLOCK_INPUT.slackTeamId,+ slackUserId: BLOCK_INPUT.slackUserId,+ workspaceMemberId: BLOCK_INPUT.workspaceMemberId,+ slackUserLinkId: BLOCK_INPUT.slackUserLinkId,+ });+ });++ it('should encode a decline value the consent parser reads back intact', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(findButtonValue(':decline')),+ ).toEqual({+ decision: 'DECLINE',+ slackTeamId: BLOCK_INPUT.slackTeamId,+ slackUserId: BLOCK_INPUT.slackUserId,+ workspaceMemberId: BLOCK_INPUT.workspaceMemberId,+ slackUserLinkId: BLOCK_INPUT.slackUserLinkId,+ });+ });++ it('should name the member in the consent message', () => {+ const blocks = buildSlackUserLinkConsentBlocks(BLOCK_INPUT);++ expect(JSON.stringify(blocks)).toContain('Ada Member');+ });++ it('should fall back to a generic clause when the member has no name', () => {+ const blocks = buildSlackUserLinkConsentBlocks({+ ...BLOCK_INPUT,+ memberName: undefined,+ });++ expect(JSON.stringify(blocks)).toContain('a workspace member');+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-workspace-members-permission.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-roles-permission.test.tssimilarity index 61%rename from packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-workspace-members-permission.test.tsrename to packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-roles-permission.test.tsindex fc3dbd003e6..0dab5b01e34 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-workspace-members-permission.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/current-user-has-roles-permission.test.ts@@ -1,6 +1,6 @@import { beforeEach, describe, expect, it, vi } from 'vitest';-import { currentUserHasWorkspaceMembersPermission } from 'src/logic-functions/utils/current-user-has-workspace-members-permission';+import { currentUserHasRolesPermission } from 'src/logic-functions/utils/current-user-has-roles-permission';const { metadataApiClientMock, queryMock } = vi.hoisted(() => ({metadataApiClientMock: vi.fn(),@@ -11,7 +11,7 @@ vi.mock('twenty-client-sdk/metadata', () => ({MetadataApiClient: metadataApiClientMock,}));-describe('currentUserHasWorkspaceMembersPermission', () => {+describe('currentUserHasRolesPermission', () => {beforeEach(() => {vi.clearAllMocks();metadataApiClientMock.mockImplementation(function (this: {@@ -21,26 +21,26 @@ describe('currentUserHasWorkspaceMembersPermission', () => {});});- it('should allow when the current user has the workspace members flag', async () => {+ it('should allow when the current user has the roles flag', async () => {queryMock.mockResolvedValue({currentUser: {currentUserWorkspace: {- permissionFlags: ['SETTINGS', 'WORKSPACE_MEMBERS'],+ permissionFlags: ['SETTINGS', 'ROLES'],},},});- expect(await currentUserHasWorkspaceMembersPermission()).toBe(true);+ expect(await currentUserHasRolesPermission()).toBe(true);});- it('should deny when the workspace members flag is absent', async () => {+ it('should deny when the roles flag is absent', async () => {queryMock.mockResolvedValue({currentUser: {currentUserWorkspace: { permissionFlags: ['SETTINGS'] },},});- expect(await currentUserHasWorkspaceMembersPermission()).toBe(false);+ expect(await currentUserHasRolesPermission()).toBe(false);});it('should deny when the current user workspace carries no flags', async () => {@@ -48,18 +48,18 @@ describe('currentUserHasWorkspaceMembersPermission', () => {currentUser: { currentUserWorkspace: { permissionFlags: null } },});- expect(await currentUserHasWorkspaceMembersPermission()).toBe(false);+ expect(await currentUserHasRolesPermission()).toBe(false);});it('should deny when nobody is behind the request', async () => {queryMock.mockResolvedValue({ currentUser: null });- expect(await currentUserHasWorkspaceMembersPermission()).toBe(false);+ expect(await currentUserHasRolesPermission()).toBe(false);});it('should deny when the permission query throws', async () => {queryMock.mockRejectedValue(new Error('unauthenticated'));- expect(await currentUserHasWorkspaceMembersPermission()).toBe(false);+ expect(await currentUserHasRolesPermission()).toBe(false);});});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/decide-slack-user-link-write.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/decide-slack-user-link-write.test.tsnew file mode 100644index 00000000000..1626a14e85b--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/decide-slack-user-link-write.test.ts@@ -0,0 +1,142 @@+import { type WebClient } from '@slack/web-api';+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { decideSlackUserLinkWrite } from 'src/logic-functions/utils/decide-slack-user-link-write';++const { findWorkspaceMemberEmailByIdMock, fetchSlackUserIdentityMock } =+ vi.hoisted(() => ({+ findWorkspaceMemberEmailByIdMock: vi.fn(),+ fetchSlackUserIdentityMock: vi.fn(),+ }));++vi.mock('src/logic-functions/data/find-workspace-member-email-by-id', () => ({+ findWorkspaceMemberEmailById: findWorkspaceMemberEmailByIdMock,+}));++vi.mock('src/logic-functions/utils/fetch-slack-user-identity', () => ({+ fetchSlackUserIdentity: fetchSlackUserIdentityMock,+}));++const SLACK_USER_ID = 'U0123456789';+const WORKSPACE_MEMBER_ID = 'member-1';+const EMAIL = '[email protected]';++const client = {} as CoreApiClient;+const slackClient = {} as WebClient;++type DecideOverrides = Partial<+ Pick<+ Parameters<typeof decideSlackUserLinkWrite>[0],+ 'fetchedIdentity' | 'isInInstalledWorkspace' | 'isSameMemberRelink'+ >+>;++const decide = (overrides: DecideOverrides = {}) =>+ decideSlackUserLinkWrite({+ client,+ slackClient,+ slackUserId: SLACK_USER_ID,+ workspaceMemberId: WORKSPACE_MEMBER_ID,+ fetchedIdentity: undefined,+ isInInstalledWorkspace: true,+ isSameMemberRelink: false,+ ...overrides,+ });++const buildIdentity = (overrides: Record<string, unknown> = {}) => ({+ slackUserId: SLACK_USER_ID,+ slackTeamId: 'T0INSTALLED',+ displayName: 'Ada Lovelace',+ email: EMAIL,+ isRegularUserAccount: true,+ ...overrides,+});++describe('decideSlackUserLinkWrite', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ findWorkspaceMemberEmailByIdMock.mockResolvedValue(EMAIL);+ fetchSlackUserIdentityMock.mockResolvedValue(buildIdentity());+ });++ it('should activate a link whose emails match, with no approval step', async () => {+ expect(await decide()).toEqual({+ isEagerAutoMatch: true,+ requiresConsent: false,+ consentState: 'ACTIVE',+ source: 'AUTO',+ });+ });++ it('should match emails case-insensitively', async () => {+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ expect(await decide()).toMatchObject({ isEagerAutoMatch: true });+ });++ it('should ask for consent when the emails differ', async () => {+ findWorkspaceMemberEmailByIdMock.mockResolvedValue('[email protected]');++ expect(await decide()).toEqual({+ isEagerAutoMatch: false,+ requiresConsent: true,+ consentState: 'PENDING',+ source: 'MANUAL',+ });+ });++ it('should ask for consent when Slack reports no email for the account', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(+ buildIdentity({ email: undefined }),+ );++ expect(await decide()).toMatchObject({+ requiresConsent: true,+ consentState: 'PENDING',+ });+ });++ it('should not treat a guest account email as a match even when it is equal', async () => {+ fetchSlackUserIdentityMock.mockResolvedValue(+ buildIdentity({ isRegularUserAccount: false }),+ );++ expect(await decide()).toMatchObject({+ isEagerAutoMatch: false,+ requiresConsent: true,+ consentState: 'PENDING',+ });+ });++ it('should admin-set an account outside the installed workspace without asking', async () => {+ expect(await decide({ isInInstalledWorkspace: false })).toEqual({+ isEagerAutoMatch: false,+ requiresConsent: false,+ consentState: 'ADMIN_SET',+ source: 'MANUAL',+ });+ });++ it('should not look the account up at all when it is outside the installed workspace', async () => {+ await decide({ isInInstalledWorkspace: false });++ expect(fetchSlackUserIdentityMock).not.toHaveBeenCalled();+ expect(findWorkspaceMemberEmailByIdMock).not.toHaveBeenCalled();+ });++ it('should leave consent untouched when the same member is saved again', async () => {+ expect(await decide({ isSameMemberRelink: true })).toEqual({+ isEagerAutoMatch: false,+ requiresConsent: false,+ consentState: undefined,+ source: undefined,+ });+ });++ it('should reuse an identity already fetched instead of asking Slack again', async () => {+ await decide({ fetchedIdentity: buildIdentity() });++ expect(fetchSlackUserIdentityMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-consented-slack-user-link.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-consented-slack-user-link.test.tsnew file mode 100644index 00000000000..b2156099638--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-consented-slack-user-link.test.ts@@ -0,0 +1,25 @@+import { describe, expect, it } from 'vitest';++import { isConsentedSlackUserLink } from 'src/logic-functions/utils/is-consented-slack-user-link';++describe('isConsentedSlackUserLink', () => {+ it('should treat ACTIVE as consented', () => {+ expect(isConsentedSlackUserLink('ACTIVE')).toBe(true);+ });++ it('should treat ADMIN_SET as consented', () => {+ expect(isConsentedSlackUserLink('ADMIN_SET')).toBe(true);+ });++ it('should not treat PENDING as consented', () => {+ expect(isConsentedSlackUserLink('PENDING')).toBe(false);+ });++ it('should not treat DECLINED as consented', () => {+ expect(isConsentedSlackUserLink('DECLINED')).toBe(false);+ });++ it('should treat a legacy link without a consent state as consented', () => {+ expect(isConsentedSlackUserLink(undefined)).toBe(true);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-unverifiable-slack-team-id-claim.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-unverifiable-slack-team-id-claim.test.tsnew file mode 100644index 00000000000..9f0c4d014c7--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/is-unverifiable-slack-team-id-claim.test.ts@@ -0,0 +1,66 @@+import { describe, expect, it } from 'vitest';++import { isUnverifiableSlackTeamIdClaim } from 'src/logic-functions/utils/is-unverifiable-slack-team-id-claim';++const INSTALLED_TEAM_ID = 'T0INSTALLED';+const OTHER_TEAM_ID = 'T0CONNECTED';++const isUnverifiable = ({+ requestedSlackTeamId,+ resolvedSlackAccount,+}: {+ requestedSlackTeamId: string | undefined;+ resolvedSlackAccount: { slackTeamId: string | undefined } | undefined;+}) =>+ isUnverifiableSlackTeamIdClaim({+ requestedSlackTeamId,+ resolvedSlackAccount,+ installedSlackTeamId: INSTALLED_TEAM_ID,+ });++describe('isUnverifiableSlackTeamIdClaim', () => {+ it('should refuse a foreign team id Slack would not corroborate', () => {+ expect(+ isUnverifiable({+ requestedSlackTeamId: OTHER_TEAM_ID,+ resolvedSlackAccount: { slackTeamId: undefined },+ }),+ ).toBe(true);+ });++ it('should accept the installed team id for an account Slack reports no team for', () => {+ expect(+ isUnverifiable({+ requestedSlackTeamId: INSTALLED_TEAM_ID,+ resolvedSlackAccount: { slackTeamId: undefined },+ }),+ ).toBe(false);+ });++ it('should leave a team id Slack does corroborate to the mismatch check', () => {+ expect(+ isUnverifiable({+ requestedSlackTeamId: OTHER_TEAM_ID,+ resolvedSlackAccount: { slackTeamId: OTHER_TEAM_ID },+ }),+ ).toBe(false);+ });++ it('should not apply to an account Slack could not resolve at all', () => {+ expect(+ isUnverifiable({+ requestedSlackTeamId: OTHER_TEAM_ID,+ resolvedSlackAccount: undefined,+ }),+ ).toBe(false);+ });++ it('should not apply when no team id was requested', () => {+ expect(+ isUnverifiable({+ requestedSlackTeamId: undefined,+ resolvedSlackAccount: { slackTeamId: undefined },+ }),+ ).toBe(false);+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/parse-slack-user-link-consent-button-value.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/parse-slack-user-link-consent-button-value.test.tsnew file mode 100644index 00000000000..d564ae5c39a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/parse-slack-user-link-consent-button-value.test.ts@@ -0,0 +1,79 @@+import { describe, expect, it } from 'vitest';++import { parseSlackUserLinkConsentButtonValue } from 'src/logic-functions/utils/parse-slack-user-link-consent-button-value';++describe('parseSlackUserLinkConsentButtonValue', () => {+ it('should parse a well-formed approve value', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(+ JSON.stringify({+ decision: 'APPROVE',+ slackTeamId: 'T1',+ slackUserId: 'U1',+ workspaceMemberId: 'member-1',+ slackUserLinkId: 'link-1',+ }),+ ),+ ).toEqual({+ decision: 'APPROVE',+ slackTeamId: 'T1',+ slackUserId: 'U1',+ workspaceMemberId: 'member-1',+ slackUserLinkId: 'link-1',+ });+ });++ it('should return undefined when the workspace member is missing', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(+ JSON.stringify({+ decision: 'APPROVE',+ slackTeamId: 'T1',+ slackUserId: 'U1',+ slackUserLinkId: 'link-1',+ }),+ ),+ ).toBeUndefined();+ });++ it('should return undefined when the link id is missing', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(+ JSON.stringify({+ decision: 'APPROVE',+ slackTeamId: 'T1',+ slackUserId: 'U1',+ workspaceMemberId: 'member-1',+ }),+ ),+ ).toBeUndefined();+ });++ it('should return undefined for undefined input', () => {+ expect(parseSlackUserLinkConsentButtonValue(undefined)).toBeUndefined();+ });++ it('should return undefined for invalid JSON', () => {+ expect(parseSlackUserLinkConsentButtonValue('not json')).toBeUndefined();+ });++ it('should return undefined for an unknown decision', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(+ JSON.stringify({+ decision: 'MAYBE',+ slackTeamId: 'T1',+ slackUserId: 'U1',+ }),+ ),+ ).toBeUndefined();+ });++ it('should return undefined when identity fields are missing', () => {+ expect(+ parseSlackUserLinkConsentButtonValue(+ JSON.stringify({ decision: 'DECLINE', slackTeamId: 'T1' }),+ ),+ ).toBeUndefined();+ });+});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.tsnew file mode 100644index 00000000000..30551a4c93e--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/persist-slack-user-link.test.ts@@ -0,0 +1,133 @@+import { type CoreApiClient } from 'twenty-client-sdk/core';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';+import { persistSlackUserLink } from 'src/logic-functions/utils/persist-slack-user-link';++const {+ createSlackUserLinkMock,+ destroySlackUserLinkMock,+ updateSlackUserLinkMock,+} = vi.hoisted(() => ({+ createSlackUserLinkMock: vi.fn(),+ destroySlackUserLinkMock: vi.fn(),+ updateSlackUserLinkMock: vi.fn(),+}));++vi.mock('src/logic-functions/data/create-slack-user-link', () => ({+ createSlackUserLink: createSlackUserLinkMock,+}));++vi.mock('src/logic-functions/data/destroy-slack-user-link', () => ({+ destroySlackUserLink: destroySlackUserLinkMock,+}));++vi.mock('src/logic-functions/data/update-slack-user-link', () => ({+ updateSlackUserLink: updateSlackUserLinkMock,+}));++const SLACK_TEAM_ID = 'T0INSTALLED';+const SLACK_USER_ID = 'U0123456789';+const WORKSPACE_MEMBER_ID = 'member-1';++const client = {} as CoreApiClient;++const existingLink: SlackUserLink = {+ id: 'link-1',+ workspaceMemberId: WORKSPACE_MEMBER_ID,+ source: 'MANUAL',+ consentState: 'DECLINED',+};++const persist = (+ overrides: Partial<Parameters<typeof persistSlackUserLink>[1]> = {},+) =>+ persistSlackUserLink(client, {+ existingLink: undefined,+ isSameMemberRelink: false,+ slackTeamId: SLACK_TEAM_ID,+ slackUserId: SLACK_USER_ID,+ workspaceMemberId: WORKSPACE_MEMBER_ID,+ name: 'Ada Lovelace',+ source: 'MANUAL',+ consentState: 'PENDING',+ ...overrides,+ });++describe('persistSlackUserLink', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ createSlackUserLinkMock.mockResolvedValue('link-new');+ destroySlackUserLinkMock.mockResolvedValue(undefined);+ updateSlackUserLinkMock.mockResolvedValue(undefined);+ });++ it('should create a link when the Slack account has none', async () => {+ expect(await persist()).toBe('link-new');++ expect(createSlackUserLinkMock).toHaveBeenCalledWith(client, {+ slackTeamId: SLACK_TEAM_ID,+ slackUserId: SLACK_USER_ID,+ workspaceMemberId: WORKSPACE_MEMBER_ID,+ name: 'Ada Lovelace',+ source: 'MANUAL',+ consentState: 'PENDING',+ });+ });++ it('should fall back to the Slack user id when no name was resolved', async () => {+ await persist({ name: undefined });++ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ client,+ expect.objectContaining({ name: SLACK_USER_ID }),+ );+ });++ it('should never rewrite consent when the same member is saved again', async () => {+ expect(+ await persist({+ existingLink,+ isSameMemberRelink: true,+ source: undefined,+ consentState: undefined,+ }),+ ).toBe('link-1');++ expect(updateSlackUserLinkMock).toHaveBeenCalledWith(client, {+ id: 'link-1',+ workspaceMemberId: WORKSPACE_MEMBER_ID,+ name: 'Ada Lovelace',+ source: undefined,+ consentState: undefined,+ });+ expect(destroySlackUserLinkMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should replace the link when the Slack account moves to another member', async () => {+ expect(await persist({ existingLink, workspaceMemberId: 'member-2' })).toBe(+ 'link-new',+ );++ expect(destroySlackUserLinkMock).toHaveBeenCalledWith(client, {+ id: 'link-1',+ });+ expect(createSlackUserLinkMock).toHaveBeenCalledWith(+ client,+ expect.objectContaining({+ workspaceMemberId: 'member-2',+ consentState: 'PENDING',+ }),+ );+ });++ it('should refuse to create a link without an explicit source and consent state', async () => {+ await expect(persist({ consentState: undefined })).rejects.toThrow(+ 'A new Slack user link needs an explicit source and consent state',+ );++ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(destroySlackUserLinkMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-run-as-workspace-member-id.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-run-as-workspace-member-id.test.tsindex f9d94843a9a..2b8e6ad1851 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-run-as-workspace-member-id.test.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-run-as-workspace-member-id.test.ts@@ -58,12 +58,14 @@ const AUTO_LINK = {id: 'link-1',workspaceMemberId: 'member-1',source: 'AUTO',+ consentState: 'ACTIVE',};const MANUAL_LINK = {id: 'link-1',workspaceMemberId: 'member-1',source: 'MANUAL',+ consentState: 'ACTIVE',};describe('resolveSlackRunAsWorkspaceMemberId', () => {@@ -130,6 +132,76 @@ describe('resolveSlackRunAsWorkspaceMemberId', () => {expect(createSlackUserLinkMock).not.toHaveBeenCalled();});+ it('should keep honoring a legacy manual link that predates the consent field', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ ...MANUAL_LINK,+ consentState: undefined,+ });++ expect(+ await resolveSlackRunAsWorkspaceMemberId({+ client,+ slackClient,+ identity: IDENTITY,+ }),+ ).toBe('member-1');+ expect(findWorkspaceMemberIdByEmailMock).not.toHaveBeenCalled();+ });++ it('should treat an admin-set manual link as consented', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ ...MANUAL_LINK,+ consentState: 'ADMIN_SET',+ });++ expect(+ await resolveSlackRunAsWorkspaceMemberId({+ client,+ slackClient,+ identity: IDENTITY,+ }),+ ).toBe('member-1');+ expect(findWorkspaceMemberIdByEmailMock).not.toHaveBeenCalled();+ });++ it('should fall through to the email match for a pending manual link, without touching it', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ ...MANUAL_LINK,+ workspaceMemberId: 'member-2',+ consentState: 'PENDING',+ });+ findWorkspaceMemberIdByEmailMock.mockResolvedValue('member-1');++ expect(+ await resolveSlackRunAsWorkspaceMemberId({+ client,+ slackClient,+ identity: IDENTITY,+ }),+ ).toBe('member-1');+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ });++ it('should not run as anyone for a declined manual link, even when the email matches', async () => {+ findSlackUserLinkMock.mockResolvedValue({+ ...MANUAL_LINK,+ consentState: 'DECLINED',+ });+ findWorkspaceMemberIdByEmailMock.mockResolvedValue('member-1');++ expect(+ await resolveSlackRunAsWorkspaceMemberId({+ client,+ slackClient,+ identity: IDENTITY,+ }),+ ).toBeUndefined();+ expect(findWorkspaceMemberIdByEmailMock).not.toHaveBeenCalled();+ expect(createSlackUserLinkMock).not.toHaveBeenCalled();+ expect(updateSlackUserLinkMock).not.toHaveBeenCalled();+ });+it('should honor a matched link when the live email match still agrees', async () => {findSlackUserLinkMock.mockResolvedValue(AUTO_LINK);findWorkspaceMemberIdByEmailMock.mockResolvedValue('member-1');@@ -220,6 +292,8 @@ describe('resolveSlackRunAsWorkspaceMemberId', () => {slackUserId: 'U0123456789',workspaceMemberId: 'member-1',name: 'ada',+ source: 'AUTO',+ consentState: 'ACTIVE',});});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-by-email.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-by-email.test.tsnew file mode 100644index 00000000000..faf2613aa91--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-by-email.test.ts@@ -0,0 +1,123 @@+import { type WebClient } from '@slack/web-api';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { resolveSlackUserByEmail } from 'src/logic-functions/utils/resolve-slack-user-by-email';++const INSTALLED_TEAM_ID = 'T0INSTALLED';+const SLACK_USER_ID = 'U0123456789';+const EMAIL = '[email protected]';++const lookupByEmailMock = vi.fn();++const client = {+ users: { lookupByEmail: lookupByEmailMock },+} as unknown as WebClient;++const buildSlackUser = (overrides: Record<string, unknown> = {}) => ({+ id: SLACK_USER_ID,+ team_id: INSTALLED_TEAM_ID,+ real_name: 'Ada Lovelace',+ is_email_confirmed: true,+ ...overrides,+});++describe('resolveSlackUserByEmail', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ lookupByEmailMock.mockResolvedValue({ user: buildSlackUser() });+ });++ it('should return undefined when the email is not in the workspace', async () => {+ lookupByEmailMock.mockRejectedValue({ data: { error: 'users_not_found' } });++ expect(await resolveSlackUserByEmail(client, EMAIL)).toBeUndefined();+ });++ it('should rethrow a transient Slack error instead of reporting not found', async () => {+ lookupByEmailMock.mockRejectedValue({ data: { error: 'ratelimited' } });++ await expect(resolveSlackUserByEmail(client, EMAIL)).rejects.toEqual({+ data: { error: 'ratelimited' },+ });+ });++ it('should return undefined when the resolved user has no id', async () => {+ lookupByEmailMock.mockResolvedValue({ user: buildSlackUser({ id: '' }) });++ expect(await resolveSlackUserByEmail(client, EMAIL)).toBeUndefined();+ });++ it('should refuse an account whose profile email Slack has not confirmed', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ is_email_confirmed: false }),+ });++ expect(await resolveSlackUserByEmail(client, EMAIL)).toBeUndefined();+ });++ it('should refuse a bot account', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ is_bot: true }),+ });++ expect(await resolveSlackUserByEmail(client, EMAIL)).toBeUndefined();+ });++ it('should refuse a deactivated account', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ deleted: true }),+ });++ expect(await resolveSlackUserByEmail(client, EMAIL)).toBeUndefined();+ });++ it('should resolve the Slack user id, team id and display name', async () => {+ expect(await resolveSlackUserByEmail(client, EMAIL)).toEqual({+ slackUserId: SLACK_USER_ID,+ slackTeamId: INSTALLED_TEAM_ID,+ displayName: 'Ada Lovelace',+ isRegularUserAccount: true,+ });+ });++ it('should resolve a guest but not vouch for their email', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ is_restricted: true }),+ });++ const resolved = await resolveSlackUserByEmail(client, EMAIL);++ expect(resolved?.slackUserId).toBe(SLACK_USER_ID);+ expect(resolved?.isRegularUserAccount).toBe(false);+ });++ it('should prefer the profile display name over the real name', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ profile: { display_name: 'ada' } }),+ });++ const resolved = await resolveSlackUserByEmail(client, EMAIL);++ expect(resolved?.displayName).toBe('ada');+ });++ it('should leave the team id undefined when Slack omits it', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ team_id: '' }),+ });++ const resolved = await resolveSlackUserByEmail(client, EMAIL);++ expect(resolved?.slackTeamId).toBeUndefined();+ });++ it('should leave the display name undefined when Slack omits the real name', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ real_name: '' }),+ });++ const resolved = await resolveSlackUserByEmail(client, EMAIL);++ expect(resolved?.displayName).toBeUndefined();+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-link-target.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-link-target.test.tsnew file mode 100644index 00000000000..6d4e18973d1--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/resolve-slack-user-link-target.test.ts@@ -0,0 +1,174 @@+import { type WebClient } from '@slack/web-api';+import { beforeEach, describe, expect, it, vi } from 'vitest';++import { resolveSlackUserLinkTarget } from 'src/logic-functions/utils/resolve-slack-user-link-target';++const INSTALLED_TEAM_ID = 'T0INSTALLED';+const OTHER_TEAM_ID = 'T0CONNECTED';+const SLACK_USER_ID = 'U0123456789';+const EMAIL = '[email protected]';++const userInfoMock = vi.fn();+const lookupByEmailMock = vi.fn();++const slackClient = {+ users: { info: userInfoMock, lookupByEmail: lookupByEmailMock },+} as unknown as WebClient;++const buildSlackUser = (overrides: Record<string, unknown> = {}) => ({+ id: SLACK_USER_ID,+ team_id: INSTALLED_TEAM_ID,+ real_name: 'Ada Lovelace',+ is_email_confirmed: true,+ profile: { email: EMAIL },+ ...overrides,+});++const resolveTarget = (+ overrides: {+ requestedSlackUserId?: string;+ email?: string;+ requestedSlackTeamId?: string;+ requestedName?: string;+ } = {},+) =>+ resolveSlackUserLinkTarget({+ slackClient,+ requestedSlackUserId: undefined,+ email: undefined,+ requestedSlackTeamId: undefined,+ requestedName: undefined,+ installedSlackTeamId: INSTALLED_TEAM_ID,+ ...overrides,+ });++describe('resolveSlackUserLinkTarget', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ userInfoMock.mockResolvedValue({ user: buildSlackUser() });+ lookupByEmailMock.mockResolvedValue({ user: buildSlackUser() });+ });++ it('should resolve by Slack user id and carry the team Slack reports', async () => {+ expect(+ await resolveTarget({ requestedSlackUserId: SLACK_USER_ID }),+ ).toMatchObject({+ success: true,+ slackUserId: SLACK_USER_ID,+ slackTeamId: INSTALLED_TEAM_ID,+ name: 'Ada Lovelace',+ });+ });++ it('should prefer the Slack user id over the email when both are given', async () => {+ await resolveTarget({ requestedSlackUserId: SLACK_USER_ID, email: EMAIL });++ expect(lookupByEmailMock).not.toHaveBeenCalled();+ });++ it('should keep an explicitly requested name over the Slack display name', async () => {+ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedName: 'Ada from support',+ }),+ ).toMatchObject({ name: 'Ada from support' });+ });++ it('should refuse a team id that contradicts the one Slack reports', async () => {+ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedSlackTeamId: OTHER_TEAM_ID,+ }),+ ).toMatchObject({+ success: false,+ message: 'Slack team id does not match the user',+ });+ });++ it('should refuse an unverifiable foreign team id when Slack resolved the user without one', async () => {+ userInfoMock.mockResolvedValue({ user: buildSlackUser({ team_id: '' }) });++ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedSlackTeamId: OTHER_TEAM_ID,+ }),+ ).toMatchObject({+ success: false,+ message: 'Could not verify the Slack workspace for that user',+ });+ });++ it('should accept the installed team id when Slack resolved the user without one', async () => {+ userInfoMock.mockResolvedValue({ user: buildSlackUser({ team_id: '' }) });++ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedSlackTeamId: INSTALLED_TEAM_ID,+ }),+ ).toMatchObject({ success: true, slackTeamId: INSTALLED_TEAM_ID });+ });++ it('should accept a foreign team id for an account Slack cannot see at all', async () => {+ userInfoMock.mockResolvedValue(undefined);++ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedSlackTeamId: OTHER_TEAM_ID,+ }),+ ).toMatchObject({ success: true, slackTeamId: OTHER_TEAM_ID });+ });++ it('should refuse an id Slack cannot resolve that claims the installed workspace', async () => {+ userInfoMock.mockResolvedValue(undefined);++ expect(+ await resolveTarget({+ requestedSlackUserId: SLACK_USER_ID,+ requestedSlackTeamId: INSTALLED_TEAM_ID,+ }),+ ).toMatchObject({+ success: false,+ message: 'Could not verify the Slack user in your workspace',+ });+ });++ it('should resolve by email and default to the installed workspace', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ team_id: '' }),+ });++ expect(await resolveTarget({ email: EMAIL })).toMatchObject({+ success: true,+ slackUserId: SLACK_USER_ID,+ slackTeamId: INSTALLED_TEAM_ID,+ });+ });++ it('should refuse an unverifiable foreign team id on the email path', async () => {+ lookupByEmailMock.mockResolvedValue({+ user: buildSlackUser({ team_id: '' }),+ });++ expect(+ await resolveTarget({+ email: EMAIL,+ requestedSlackTeamId: OTHER_TEAM_ID,+ }),+ ).toMatchObject({+ success: false,+ message: 'Could not verify the Slack workspace for that user',+ });+ });++ it('should report missing input when neither a Slack user id nor an email is given', async () => {+ expect(await resolveTarget()).toMatchObject({+ success: false,+ message: 'Missing required fields',+ });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/update-slack-message-via-response-url.test.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/update-slack-message-via-response-url.test.tsnew file mode 100644index 00000000000..2f4d593613a--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/__tests__/update-slack-message-via-response-url.test.ts@@ -0,0 +1,96 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++import { updateSlackMessageViaResponseUrl } from 'src/logic-functions/utils/update-slack-message-via-response-url';++const RESPONSE_URL = 'https://hooks.slack.com/actions/T1/123/abc';++const fetchMock = vi.fn();++describe('updateSlackMessageViaResponseUrl', () => {+ beforeEach(() => {+ vi.clearAllMocks();+ fetchMock.mockResolvedValue({ ok: true });+ vi.stubGlobal('fetch', fetchMock);+ });++ afterEach(() => {+ vi.unstubAllGlobals();+ });++ it('should replace the original message on Slack own host', async () => {+ expect(+ await updateSlackMessageViaResponseUrl({+ responseUrl: RESPONSE_URL,+ text: 'Thanks',+ }),+ ).toEqual({ success: true });++ expect(fetchMock).toHaveBeenCalledWith(RESPONSE_URL, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify({ replace_original: true, text: 'Thanks' }),+ });+ });++ it('should refuse a response url pointing somewhere other than Slack', async () => {+ const result = await updateSlackMessageViaResponseUrl({+ responseUrl: 'https://attacker.example.com/collect',+ text: 'Thanks',+ });++ expect(result.success).toBe(false);+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('should refuse a look-alike host that only ends with the Slack domain', async () => {+ const result = await updateSlackMessageViaResponseUrl({+ responseUrl: 'https://hooks.slack.com.attacker.example/collect',+ text: 'Thanks',+ });++ expect(result.success).toBe(false);+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('should refuse a plain http response url', async () => {+ const result = await updateSlackMessageViaResponseUrl({+ responseUrl: 'http://hooks.slack.com/actions/T1/123/abc',+ text: 'Thanks',+ });++ expect(result.success).toBe(false);+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('should report a missing response url instead of throwing', async () => {+ const result = await updateSlackMessageViaResponseUrl({+ responseUrl: undefined,+ text: 'Thanks',+ });++ expect(result.success).toBe(false);+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('should report a rejected response url rather than calling it a success', async () => {+ fetchMock.mockResolvedValue({ ok: false, status: 404 });++ const result = await updateSlackMessageViaResponseUrl({+ responseUrl: RESPONSE_URL,+ text: 'Thanks',+ });++ expect(result.success).toBe(false);+ });++ it('should report a network failure instead of throwing', async () => {+ fetchMock.mockRejectedValue(new Error('network down'));++ expect(+ await updateSlackMessageViaResponseUrl({+ responseUrl: RESPONSE_URL,+ text: 'Thanks',+ }),+ ).toEqual({ success: false, error: 'network down' });+ });+});diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/as-record.util.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/as-record.util.tsnew file mode 100644index 00000000000..3d4aec6ffce--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/as-record.util.ts@@ -0,0 +1,6 @@+import { isArray, isObject } from '@sniptt/guards';++export const asRecord = (value: unknown): Record<string, unknown> | undefined =>+ isObject<Record<string, unknown>, unknown>(value) && !isArray(value)+ ? value+ : undefined;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-user-link-consent-blocks.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-user-link-consent-blocks.tsnew file mode 100644index 00000000000..98a46f413cc--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/build-slack-user-link-consent-blocks.ts@@ -0,0 +1,69 @@+import { type KnownBlock } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';++import { SLACK_USER_LINK_CONSENT_ACTION_ID } from 'src/logic-functions/constants/slack-user-link-consent-action-id';+import { SLACK_USER_LINK_CONSENT_DECISION } from 'src/logic-functions/constants/slack-user-link-consent-decision';+import { type SlackUserLinkConsentButtonValue } from 'src/logic-functions/types/slack-user-link-consent-button-value.type';++const encodeValue = (value: SlackUserLinkConsentButtonValue): string =>+ JSON.stringify(value);++export const buildSlackUserLinkConsentBlocks = ({+ memberName,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+}: {+ memberName: string | undefined;+ slackTeamId: string;+ slackUserId: string;+ workspaceMemberId: string;+ slackUserLinkId: string;+}): KnownBlock[] => {+ const memberClause = isNonEmptyString(memberName)+ ? `*${memberName}*`+ : 'a workspace member';++ return [+ {+ type: 'section',+ text: {+ type: 'mrkdwn',+ text: `An admin wants to let the Twenty assistant answer you using ${memberClause}'s access in this workspace. If you approve, the assistant's replies to you can see and do whatever that member's permissions allow. Approve to turn this on, or decline to keep it off.`,+ },+ },+ {+ type: 'actions',+ block_id: SLACK_USER_LINK_CONSENT_ACTION_ID,+ elements: [+ {+ type: 'button',+ action_id: `${SLACK_USER_LINK_CONSENT_ACTION_ID}:approve`,+ style: 'primary',+ text: { type: 'plain_text', text: 'Approve' },+ value: encodeValue({+ decision: SLACK_USER_LINK_CONSENT_DECISION.APPROVE,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ }),+ },+ {+ type: 'button',+ action_id: `${SLACK_USER_LINK_CONSENT_ACTION_ID}:decline`,+ style: 'danger',+ text: { type: 'plain_text', text: 'Decline' },+ value: encodeValue({+ decision: SLACK_USER_LINK_CONSENT_DECISION.DECLINE,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ }),+ },+ ],+ },+ ];+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-roles-permission.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-roles-permission.tsnew file mode 100644index 00000000000..0deb6419085--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-roles-permission.ts@@ -0,0 +1,21 @@+import { MetadataApiClient } from 'twenty-client-sdk/metadata';++const ROLES_PERMISSION_FLAG = 'ROLES';++export const currentUserHasRolesPermission = async (): Promise<boolean> => {+ try {+ const { currentUser } = await new MetadataApiClient().query({+ currentUser: {+ currentUserWorkspace: {+ permissionFlags: true,+ },+ },+ });++ return (currentUser.currentUserWorkspace?.permissionFlags ?? []).includes(+ ROLES_PERMISSION_FLAG,+ );+ } catch {+ return false;+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-workspace-members-permission.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-workspace-members-permission.tsdeleted file mode 100644index 0465c060ca8..00000000000--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/current-user-has-workspace-members-permission.ts+++ /dev/null@@ -1,22 +0,0 @@-import { MetadataApiClient } from 'twenty-client-sdk/metadata';--const WORKSPACE_MEMBERS_PERMISSION_FLAG = 'WORKSPACE_MEMBERS';--export const currentUserHasWorkspaceMembersPermission =- async (): Promise<boolean> => {- try {- const { currentUser } = await new MetadataApiClient().query({- currentUser: {- currentUserWorkspace: {- permissionFlags: true,- },- },- });-- return (currentUser.currentUserWorkspace?.permissionFlags ?? []).includes(- WORKSPACE_MEMBERS_PERMISSION_FLAG,- );- } catch {- return false;- }- };diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/decide-slack-user-link-write.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/decide-slack-user-link-write.tsnew file mode 100644index 00000000000..ce737967501--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/decide-slack-user-link-write.ts@@ -0,0 +1,85 @@+import { type WebClient } from '@slack/web-api';+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 { findWorkspaceMemberEmailById } from 'src/logic-functions/data/find-workspace-member-email-by-id';+import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';+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 { fetchSlackUserIdentity } from 'src/logic-functions/utils/fetch-slack-user-identity';++type SlackUserLinkWriteDecision = {+ isEagerAutoMatch: boolean;+ requiresConsent: boolean;+ consentState: SlackUserLinkConsentState | undefined;+ source: SlackUserLinkSource | undefined;+};++export const decideSlackUserLinkWrite = async ({+ client,+ slackClient,+ slackUserId,+ workspaceMemberId,+ fetchedIdentity,+ isInInstalledWorkspace,+ isSameMemberRelink,+}: {+ client: CoreApiClient;+ slackClient: WebClient;+ slackUserId: string;+ workspaceMemberId: string;+ fetchedIdentity: SlackUserIdentity | undefined;+ isInInstalledWorkspace: boolean;+ isSameMemberRelink: boolean;+}): Promise<SlackUserLinkWriteDecision> => {+ const shouldCheckEmailMatch = isInInstalledWorkspace && !isSameMemberRelink;++ const resolveVerifiedEmail = async (): Promise<string | undefined> => {+ if (!shouldCheckEmailMatch) {+ return undefined;+ }++ const identity =+ fetchedIdentity ??+ (await fetchSlackUserIdentity({ client: slackClient, slackUserId }));++ return identity?.isRegularUserAccount ? identity.email : undefined;+ };++ const verifiedEmail = await resolveVerifiedEmail();++ const memberEmail = isNonEmptyString(verifiedEmail)+ ? await findWorkspaceMemberEmailById(client, workspaceMemberId)+ : undefined;++ const isEagerAutoMatch =+ isNonEmptyString(verifiedEmail) &&+ isNonEmptyString(memberEmail) &&+ verifiedEmail.toLowerCase() === memberEmail.toLowerCase();++ const requiresConsent =+ isInInstalledWorkspace && !isSameMemberRelink && !isEagerAutoMatch;++ if (isSameMemberRelink) {+ return {+ isEagerAutoMatch,+ requiresConsent,+ consentState: undefined,+ source: undefined,+ };+ }++ const consentState = !isInInstalledWorkspace+ ? SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET+ : isEagerAutoMatch+ ? SLACK_USER_LINK_CONSENT_STATE.ACTIVE+ : SLACK_USER_LINK_CONSENT_STATE.PENDING;++ const source = isEagerAutoMatch+ ? SLACK_USER_LINK_SOURCE.AUTO+ : SLACK_USER_LINK_SOURCE.MANUAL;++ return { isEagerAutoMatch, requiresConsent, consentState, source };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/extract-slack-set-user-link-input.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/extract-slack-set-user-link-input.tsnew file mode 100644index 00000000000..2a146dc1247--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/extract-slack-set-user-link-input.ts@@ -0,0 +1,30 @@+import { type RoutePayload } from 'twenty-sdk/define';++import { type SlackSetUserLinkInput } from 'src/logic-functions/types/slack-set-user-link-input.type';+import { asRecord } from 'src/logic-functions/utils/as-record.util';+import { readOptionalString } from 'src/logic-functions/utils/read-optional-string.util';++export type SlackSetUserLinkPayload =+ | SlackSetUserLinkInput+ | RoutePayload<SlackSetUserLinkInput>;++const isRoutePayload = (+ payload: SlackSetUserLinkPayload,+): payload is RoutePayload<SlackSetUserLinkInput> => 'body' in payload;++const toSlackSetUserLinkInput = (source: unknown): SlackSetUserLinkInput => {+ const body = asRecord(source) ?? {};++ return {+ workspaceMemberId: readOptionalString(body.workspaceMemberId) ?? '',+ slackUserId: readOptionalString(body.slackUserId),+ email: readOptionalString(body.email),+ slackTeamId: readOptionalString(body.slackTeamId),+ name: readOptionalString(body.name),+ };+};++export const extractSlackSetUserLinkInput = (+ payload: SlackSetUserLinkPayload,+): SlackSetUserLinkInput =>+ toSlackSetUserLinkInput(isRoutePayload(payload) ? payload.body : payload);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-consented-slack-user-link.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-consented-slack-user-link.tsnew file mode 100644index 00000000000..38968672d02--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-consented-slack-user-link.ts@@ -0,0 +1,13 @@+import { isDefined } from 'twenty-sdk/utils';++import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';++// A link written before consent existed carries no state, and stays trusted so+// upgrading does not silently revoke links an admin already set.+export const isConsentedSlackUserLink = (+ consentState: SlackUserLinkConsentState | undefined,+): boolean =>+ !isDefined(consentState) ||+ consentState === SLACK_USER_LINK_CONSENT_STATE.ACTIVE ||+ consentState === SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-interactivity-payload.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-interactivity-payload.tsindex 43c2af76261..7c4002e2710 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-interactivity-payload.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-interactivity-payload.ts@@ -10,6 +10,11 @@ const isTeam = (value: unknown): boolean =>(isObject<Record<string, unknown>, unknown>(value) &&isOptionalString(value.id));+const isUser = (value: unknown): boolean =>+ isUndefined(value) ||+ (isObject<Record<string, unknown>, unknown>(value) &&+ isOptionalString(value.id));+const isInteractionAction = (value: unknown): boolean =>isObject<Record<string, unknown>, unknown>(value) &&isOptionalString(value.action_id) &&@@ -26,6 +31,8 @@ export const isSlackInteractivityPayload = (return (isOptionalString(value.type) &&isTeam(value.team) &&+ isUser(value.user) &&+ isOptionalString(value.response_url) &&(isUndefined(value.actions) ||(isArray(value.actions) && value.actions.every(isInteractionAction))));diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-consent-state.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-consent-state.tsnew file mode 100644index 00000000000..9c54e624d9d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-consent-state.ts@@ -0,0 +1,7 @@+import { SLACK_USER_LINK_CONSENT_STATE } from 'src/logic-functions/constants/slack-user-link-consent-state';+import { type SlackUserLinkConsentState } from 'src/logic-functions/types/slack-user-link-consent-state.type';++export const isSlackUserLinkConsentState = (+ value: unknown,+): value is SlackUserLinkConsentState =>+ Object.values(SLACK_USER_LINK_CONSENT_STATE).some((state) => state === value);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-source.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-source.tsnew file mode 100644index 00000000000..fa2a3348cc6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-slack-user-link-source.ts@@ -0,0 +1,7 @@+import { SLACK_USER_LINK_SOURCE } from 'src/logic-functions/constants/slack-user-link-source';+import { type SlackUserLinkSource } from 'src/logic-functions/types/slack-user-link-source.type';++export const isSlackUserLinkSource = (+ value: unknown,+): value is SlackUserLinkSource =>+ Object.values(SLACK_USER_LINK_SOURCE).some((source) => source === value);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/is-unverifiable-slack-team-id-claim.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-unverifiable-slack-team-id-claim.tsnew file mode 100644index 00000000000..f87237dfd52--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/is-unverifiable-slack-team-id-claim.ts@@ -0,0 +1,18 @@+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++// Claiming a workspace other than the installed one is what skips the consent+// request, so a claim Slack will not corroborate has to fail closed.+export const isUnverifiableSlackTeamIdClaim = ({+ requestedSlackTeamId,+ resolvedSlackAccount,+ installedSlackTeamId,+}: {+ requestedSlackTeamId: string | undefined;+ resolvedSlackAccount: { slackTeamId: string | undefined } | undefined;+ installedSlackTeamId: string;+}): boolean =>+ isDefined(resolvedSlackAccount) &&+ isNonEmptyString(requestedSlackTeamId) &&+ !isNonEmptyString(resolvedSlackAccount.slackTeamId) &&+ requestedSlackTeamId !== installedSlackTeamId;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/parse-slack-user-link-consent-button-value.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/parse-slack-user-link-consent-button-value.tsnew file mode 100644index 00000000000..b79968cb41f--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/parse-slack-user-link-consent-button-value.ts@@ -0,0 +1,51 @@+import { isNonEmptyString, isObject } from '@sniptt/guards';++import { SLACK_USER_LINK_CONSENT_DECISION } from 'src/logic-functions/constants/slack-user-link-consent-decision';+import { type SlackUserLinkConsentButtonValue } from 'src/logic-functions/types/slack-user-link-consent-button-value.type';++const isConsentDecision = (+ value: unknown,+): value is SlackUserLinkConsentButtonValue['decision'] =>+ value === SLACK_USER_LINK_CONSENT_DECISION.APPROVE ||+ value === SLACK_USER_LINK_CONSENT_DECISION.DECLINE;++export const parseSlackUserLinkConsentButtonValue = (+ value: string | undefined,+): SlackUserLinkConsentButtonValue | undefined => {+ if (!isNonEmptyString(value)) {+ return undefined;+ }++ let parsed: unknown;++ try {+ parsed = JSON.parse(value);+ } catch {+ return undefined;+ }++ if (!isObject<Record<string, unknown>, unknown>(parsed)) {+ return undefined;+ }++ const { decision, slackTeamId, slackUserId, workspaceMemberId, slackUserLinkId } =+ parsed;++ if (+ !isConsentDecision(decision) ||+ !isNonEmptyString(slackTeamId) ||+ !isNonEmptyString(slackUserId) ||+ !isNonEmptyString(workspaceMemberId) ||+ !isNonEmptyString(slackUserLinkId)+ ) {+ return undefined;+ }++ return {+ decision,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ };+};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.tsnew file mode 100644index 00000000000..83d4417b2c2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/persist-slack-user-link.ts@@ -0,0 +1,64 @@+import { isNonEmptyString } from '@sniptt/guards';+import { type CoreApiClient } from 'twenty-client-sdk/core';+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 { 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';+import { type SlackUserLinkSource } from 'src/logic-functions/types/slack-user-link-source.type';++export const persistSlackUserLink = async (+ client: CoreApiClient,+ {+ existingLink,+ isSameMemberRelink,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ name,+ source,+ consentState,+ }: {+ existingLink: SlackUserLink | undefined;+ isSameMemberRelink: boolean;+ slackTeamId: string;+ slackUserId: string;+ workspaceMemberId: string;+ name: string | undefined;+ source: SlackUserLinkSource | undefined;+ consentState: SlackUserLinkConsentState | undefined;+ },+): Promise<string> => {+ if (isDefined(existingLink) && isSameMemberRelink) {+ await updateSlackUserLink(client, {+ id: existingLink.id,+ workspaceMemberId,+ name,+ source,+ consentState,+ });++ return existingLink.id;+ }++ if (!isDefined(source) || !isDefined(consentState)) {+ throw new Error(+ 'A new Slack user link needs an explicit source and consent state',+ );+ }++ if (isDefined(existingLink)) {+ await destroySlackUserLink(client, { id: existingLink.id });+ }++ return createSlackUserLink(client, {+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ name: isNonEmptyString(name) ? name : slackUserId,+ source,+ consentState,+ });+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/read-optional-string.util.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/read-optional-string.util.tsnew file mode 100644index 00000000000..f910604be7d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/read-optional-string.util.ts@@ -0,0 +1,4 @@+import { isNonEmptyString } from '@sniptt/guards';++export const readOptionalString = (value: unknown): string | undefined =>+ isNonEmptyString(value) ? value : undefined;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-email.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-email.tsnew file mode 100644index 00000000000..30c246882c0--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-email.ts@@ -0,0 +1,82 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { UNVERIFIABLE_SLACK_TEAM_ID_FAILURE } from 'src/logic-functions/constants/unverifiable-slack-team-id-failure';+import { isUnverifiableSlackTeamIdClaim } from 'src/logic-functions/utils/is-unverifiable-slack-team-id-claim';+import {+ type ResolvedSlackUser,+ resolveSlackUserByEmail,+} from 'src/logic-functions/utils/resolve-slack-user-by-email';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++type EmailLinkTarget =+ | {+ success: true;+ slackUserId: string;+ slackTeamId: string | undefined;+ displayName: string | undefined;+ }+ | { success: false; message: string; error: string };++export const resolveLinkTargetByEmail = async ({+ slackClient,+ email,+ requestedSlackTeamId,+ installedSlackTeamId,+}: {+ slackClient: WebClient;+ email: string;+ requestedSlackTeamId: string | undefined;+ installedSlackTeamId: string;+}): Promise<EmailLinkTarget> => {+ let resolvedUser: ResolvedSlackUser | undefined;++ try {+ resolvedUser = await resolveSlackUserByEmail(slackClient, email);+ } catch (error) {+ return {+ success: false,+ message: 'Could not look up that Slack email',+ error: toErrorMessage(error),+ };+ }++ if (!isDefined(resolvedUser)) {+ return {+ success: false,+ message: 'No Slack user with that email',+ error:+ 'No Slack user with that email in the installed workspace. For a guest or Slack Connect user from another workspace, enter their Slack user id instead.',+ };+ }++ if (+ isNonEmptyString(requestedSlackTeamId) &&+ isNonEmptyString(resolvedUser.slackTeamId) &&+ resolvedUser.slackTeamId !== requestedSlackTeamId+ ) {+ return {+ success: false,+ message: 'Slack team id does not match the user',+ error: `That Slack user belongs to workspace ${resolvedUser.slackTeamId}, not ${requestedSlackTeamId}. Check the team id and try again.`,+ };+ }++ if (+ isUnverifiableSlackTeamIdClaim({+ requestedSlackTeamId,+ resolvedSlackAccount: resolvedUser,+ installedSlackTeamId,+ })+ ) {+ return UNVERIFIABLE_SLACK_TEAM_ID_FAILURE;+ }++ return {+ success: true,+ slackUserId: resolvedUser.slackUserId,+ slackTeamId: resolvedUser.slackTeamId ?? requestedSlackTeamId,+ displayName: resolvedUser.displayName,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-id.tsnew file mode 100644index 00000000000..fed85b368b2--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-link-target-by-id.ts@@ -0,0 +1,80 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';+import { isDefined } from 'twenty-sdk/utils';++import { UNVERIFIABLE_SLACK_TEAM_ID_FAILURE } from 'src/logic-functions/constants/unverifiable-slack-team-id-failure';+import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';+import { fetchSlackUserIdentity } from 'src/logic-functions/utils/fetch-slack-user-identity';+import { isUnverifiableSlackTeamIdClaim } from 'src/logic-functions/utils/is-unverifiable-slack-team-id-claim';++type IdLinkTarget =+ | {+ success: true;+ slackTeamId: string;+ identity: SlackUserIdentity | undefined;+ }+ | { success: false; message: string; error: string };++export const resolveLinkTargetById = async ({+ slackClient,+ slackUserId,+ requestedSlackTeamId,+ installedSlackTeamId,+}: {+ slackClient: WebClient;+ slackUserId: string;+ requestedSlackTeamId: string | undefined;+ installedSlackTeamId: string;+}): Promise<IdLinkTarget> => {+ const identity = await fetchSlackUserIdentity({+ client: slackClient,+ slackUserId,+ });++ if (+ isNonEmptyString(requestedSlackTeamId) &&+ isDefined(identity) &&+ isNonEmptyString(identity.slackTeamId) &&+ identity.slackTeamId !== requestedSlackTeamId+ ) {+ return {+ success: false,+ message: 'Slack team id does not match the user',+ error: `That Slack user belongs to workspace ${identity.slackTeamId}, not ${requestedSlackTeamId}. Check the team id and try again.`,+ };+ }++ if (+ isUnverifiableSlackTeamIdClaim({+ requestedSlackTeamId,+ resolvedSlackAccount: identity,+ installedSlackTeamId,+ })+ ) {+ return UNVERIFIABLE_SLACK_TEAM_ID_FAILURE;+ }++ const slackTeamId = isNonEmptyString(requestedSlackTeamId)+ ? requestedSlackTeamId+ : identity?.slackTeamId;++ if (!isNonEmptyString(slackTeamId)) {+ return {+ success: false,+ message: 'Could not resolve the Slack workspace',+ error:+ 'Could not determine which Slack workspace this user belongs to. Provide their Slack team id and try again.',+ };+ }++ if (!isDefined(identity) && slackTeamId === installedSlackTeamId) {+ return {+ success: false,+ message: 'Could not verify the Slack user in your workspace',+ error:+ 'Slack could not find that user id in the installed workspace. Check the id, or for a guest or Slack Connect user enter their own Slack team id.',+ };+ }++ return { success: true, slackTeamId, identity };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-run-as-workspace-member-id.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-run-as-workspace-member-id.tsindex d20f54dbfac..d65ad028291 100644--- a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-run-as-workspace-member-id.ts+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-run-as-workspace-member-id.ts@@ -3,6 +3,7 @@ import { isNonEmptyString } from '@sniptt/guards';import { CoreApiClient } from 'twenty-client-sdk/core';import { isDefined } from 'twenty-sdk/utils';+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 { findSlackUserLink } from 'src/logic-functions/data/find-slack-user-link';@@ -11,6 +12,7 @@ import { updateSlackUserLink } from 'src/logic-functions/data/update-slack-user-import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';import { type SlackUserLink } from 'src/logic-functions/types/slack-user-link.type';import { getInstalledSlackTeamId } from 'src/logic-functions/utils/get-installed-slack-team-id';+import { isConsentedSlackUserLink } from 'src/logic-functions/utils/is-consented-slack-user-link';const resolveLinkableEmail = async ({slackClient,@@ -53,18 +55,26 @@ export const resolveSlackRunAsWorkspaceMemberId = async ({let existingLink: SlackUserLink | undefined;try {- existingLink = await findSlackUserLink(client, { slackTeamId, slackUserId });+ existingLink = await findSlackUserLink(client, {+ slackTeamId,+ slackUserId,+ });} catch {return undefined;}- const isManualLink =- existingLink?.source === SLACK_USER_LINK_SOURCE.MANUAL;+ const isManualLink = existingLink?.source === SLACK_USER_LINK_SOURCE.MANUAL;if (isManualLink) {- return isNonEmptyString(existingLink?.workspaceMemberId)- ? existingLink.workspaceMemberId- : undefined;+ if (isConsentedSlackUserLink(existingLink?.consentState)) {+ return isNonEmptyString(existingLink?.workspaceMemberId)+ ? existingLink.workspaceMemberId+ : undefined;+ }++ if (existingLink?.consentState === SLACK_USER_LINK_CONSENT_STATE.DECLINED) {+ return undefined;+ }}const linkableEmail = await resolveLinkableEmail({ slackClient, identity });@@ -82,6 +92,10 @@ export const resolveSlackRunAsWorkspaceMemberId = async ({return undefined;}+ if (isManualLink) {+ return workspaceMemberId;+ }+const applicationClient = new CoreApiClient({ runAs: 'application' });if (!isDefined(existingLink)) {@@ -90,6 +104,8 @@ export const resolveSlackRunAsWorkspaceMemberId = async ({slackUserId,workspaceMemberId,name: identity.displayName ?? slackUserId,+ source: SLACK_USER_LINK_SOURCE.AUTO,+ consentState: SLACK_USER_LINK_CONSENT_STATE.ACTIVE,}).catch(() => undefined);return workspaceMemberId;diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-by-email.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-by-email.tsnew file mode 100644index 00000000000..535f6cce17d--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-by-email.ts@@ -0,0 +1,49 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';++import { getSlackApiErrorCode } from 'src/logic-functions/utils/get-slack-api-error-code';++export type ResolvedSlackUser = {+ slackUserId: string;+ slackTeamId: string | undefined;+ displayName: string | undefined;+ isRegularUserAccount: boolean;+};++const USERS_NOT_FOUND_ERROR_CODE = 'users_not_found';++export const resolveSlackUserByEmail = async (+ slackClient: WebClient,+ email: string,+): Promise<ResolvedSlackUser | undefined> => {+ let result;++ try {+ result = await slackClient.users.lookupByEmail({ email });+ } catch (error) {+ if (getSlackApiErrorCode(error) === USERS_NOT_FOUND_ERROR_CODE) {+ return undefined;+ }++ throw error;+ }++ const user = result.user;++ if (!isNonEmptyString(user?.id)) {+ return undefined;+ }++ if (user.is_bot || user.deleted || !user.is_email_confirmed) {+ return undefined;+ }++ return {+ slackUserId: user.id,+ slackTeamId: isNonEmptyString(user.team_id) ? user.team_id : undefined,+ displayName: [user.profile?.display_name, user.real_name].find(+ isNonEmptyString,+ ),+ isRegularUserAccount: !user.is_restricted && !user.is_ultra_restricted,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-link-target.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-link-target.tsnew file mode 100644index 00000000000..dfd1234f966--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/resolve-slack-user-link-target.ts@@ -0,0 +1,81 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackUserIdentity } from 'src/logic-functions/types/slack-user-identity.type';+import { resolveLinkTargetByEmail } from 'src/logic-functions/utils/resolve-link-target-by-email';+import { resolveLinkTargetById } from 'src/logic-functions/utils/resolve-link-target-by-id';++type SlackUserLinkTarget =+ | {+ success: true;+ slackUserId: string;+ slackTeamId: string;+ name: string | undefined;+ identity: SlackUserIdentity | undefined;+ }+ | { success: false; message: string; error: string };++export const resolveSlackUserLinkTarget = async ({+ slackClient,+ requestedSlackUserId,+ email,+ requestedSlackTeamId,+ requestedName,+ installedSlackTeamId,+}: {+ slackClient: WebClient;+ requestedSlackUserId: string | undefined;+ email: string | undefined;+ requestedSlackTeamId: string | undefined;+ requestedName: string | undefined;+ installedSlackTeamId: string;+}): Promise<SlackUserLinkTarget> => {+ // A Slack user id is the more specific of the two, so it wins when both are given.+ if (isNonEmptyString(requestedSlackUserId)) {+ const idTarget = await resolveLinkTargetById({+ slackClient,+ slackUserId: requestedSlackUserId,+ requestedSlackTeamId,+ installedSlackTeamId,+ });++ if (!idTarget.success) {+ return idTarget;+ }++ return {+ success: true,+ slackUserId: requestedSlackUserId,+ slackTeamId: idTarget.slackTeamId,+ name: requestedName ?? idTarget.identity?.displayName,+ identity: idTarget.identity,+ };+ }++ if (!isNonEmptyString(email)) {+ return {+ success: false,+ message: 'Missing required fields',+ error: 'Provide a Slack email or a Slack user id.',+ };+ }++ const emailTarget = await resolveLinkTargetByEmail({+ slackClient,+ email,+ requestedSlackTeamId,+ installedSlackTeamId,+ });++ if (!emailTarget.success) {+ return emailTarget;+ }++ return {+ success: true,+ slackUserId: emailTarget.slackUserId,+ slackTeamId: emailTarget.slackTeamId ?? installedSlackTeamId,+ name: requestedName ?? emailTarget.displayName,+ identity: undefined,+ };+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.tsnew file mode 100644index 00000000000..7b1da269268--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/send-slack-user-link-consent-dm.ts@@ -0,0 +1,56 @@+import { type WebClient } from '@slack/web-api';+import { isNonEmptyString } from '@sniptt/guards';++import { buildSlackUserLinkConsentBlocks } from 'src/logic-functions/utils/build-slack-user-link-consent-blocks';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++export const sendSlackUserLinkConsentDm = async (+ slackClient: WebClient,+ {+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ memberName,+ }: {+ slackTeamId: string;+ slackUserId: string;+ workspaceMemberId: string;+ slackUserLinkId: string;+ memberName: string | undefined;+ },+): Promise<{ success: boolean; error?: string }> => {+ try {+ const conversation = await slackClient.conversations.open({+ users: slackUserId,+ });++ const channelId = conversation.channel?.id;++ if (!isNonEmptyString(channelId)) {+ return {+ success: false,+ error: 'Slack did not open a direct message with that user.',+ };+ }++ await slackClient.chat.postMessage({+ channel: channelId,+ text: 'A Twenty admin asked to link your Slack account. Approve or decline it here.',+ blocks: buildSlackUserLinkConsentBlocks({+ memberName,+ slackTeamId,+ slackUserId,+ workspaceMemberId,+ slackUserLinkId,+ }),+ });++ return { success: true };+ } catch (error) {+ return {+ success: false,+ error: toErrorMessage(error),+ };+ }+};diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/to-error-message.util.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/to-error-message.util.tsnew file mode 100644index 00000000000..d9fa1691ab6--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/to-error-message.util.ts@@ -0,0 +1,2 @@+export const toErrorMessage = (error: unknown): string =>+ error instanceof Error ? error.message : String(error);diff --git a/packages/twenty-apps/public/slack/src/logic-functions/utils/update-slack-message-via-response-url.ts b/packages/twenty-apps/public/slack/src/logic-functions/utils/update-slack-message-via-response-url.tsnew file mode 100644index 00000000000..ecc1a99da15--- /dev/null+++ b/packages/twenty-apps/public/slack/src/logic-functions/utils/update-slack-message-via-response-url.ts@@ -0,0 +1,59 @@+import { isNonEmptyString } from '@sniptt/guards';++import { type SlackMessageUpdateResult } from 'src/logic-functions/types/slack-message-update-result.type';+import { toErrorMessage } from 'src/logic-functions/utils/to-error-message.util';++const SLACK_RESPONSE_URL_ORIGIN = 'https://hooks.slack.com';++const isSlackResponseUrl = (responseUrl: string): boolean => {+ try {+ return new URL(responseUrl).origin === SLACK_RESPONSE_URL_ORIGIN;+ } catch {+ return false;+ }+};++export const updateSlackMessageViaResponseUrl = async ({+ responseUrl,+ text,+}: {+ responseUrl: string | undefined;+ text: string;+}): Promise<SlackMessageUpdateResult> => {+ if (!isNonEmptyString(responseUrl)) {+ return {+ success: false,+ error: 'The Slack payload carried no response url.',+ };+ }++ // The payload is Slack-signed, but this is the one place the app calls a url+ // it was handed rather than one it built, so keep it on Slack's own host.+ if (!isSlackResponseUrl(responseUrl)) {+ return {+ success: false,+ error: `Refused to post to a response url outside ${SLACK_RESPONSE_URL_ORIGIN}.`,+ };+ }++ try {+ const response = await fetch(responseUrl, {+ method: 'POST',+ headers: { 'Content-Type': 'application/json' },+ body: JSON.stringify({ replace_original: true, text }),+ });++ // fetch only rejects on a transport failure, so an expired or revoked+ // response url comes back as a resolved non-2xx.+ if (!response.ok) {+ return {+ success: false,+ error: `Slack rejected the message update with status ${response.status}.`,+ };+ }++ return { success: true };+ } catch (error) {+ return { success: false, error: toErrorMessage(error) };+ }+};diff --git a/packages/twenty-apps/public/slack/src/objects/slack-user-link.object.ts b/packages/twenty-apps/public/slack/src/objects/slack-user-link.object.tsindex 5b560850a0f..d2975ea338c 100644--- a/packages/twenty-apps/public/slack/src/objects/slack-user-link.object.ts+++ b/packages/twenty-apps/public/slack/src/objects/slack-user-link.object.ts@@ -8,6 +8,7 @@ import {} from 'twenty-sdk/define';import {+ SLACK_USER_LINK_CONSENT_STATE_FIELD_UNIVERSAL_IDENTIFIER,SLACK_USER_LINK_NAME_FIELD_UNIVERSAL_IDENTIFIER,SLACK_USER_LINK_OBJECT_UNIVERSAL_IDENTIFIER,SLACK_USER_LINK_SOURCE_FIELD_UNIVERSAL_IDENTIFIER,@@ -16,6 +17,7 @@ import {SLACK_USER_LINK_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIER,SLACK_USER_LINKS_ON_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIER,} from 'src/constants/universal-identifiers';+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';export default defineObject({@@ -80,6 +82,47 @@ export default defineObject({],name: 'source',},+ {+ universalIdentifier:+ SLACK_USER_LINK_CONSENT_STATE_FIELD_UNIVERSAL_IDENTIFIER,+ type: FieldType.SELECT,+ label: 'Consent state',+ description:+ 'Whether the linked Slack user has consented to the assistant acting with the mapped member permissions',+ icon: 'IconShieldCheck',+ defaultValue: `'${SLACK_USER_LINK_CONSENT_STATE.ACTIVE}'`,+ options: [+ {+ id: '57e1a3f1-37d2-4a1d-a1ed-f69a237a819b',+ value: SLACK_USER_LINK_CONSENT_STATE.ACTIVE,+ label: 'Active',+ position: 0,+ color: 'green',+ },+ {+ id: '99cdcf02-893f-47f8-bb88-77c2ebc85c33',+ value: SLACK_USER_LINK_CONSENT_STATE.PENDING,+ label: 'Awaiting consent',+ position: 1,+ color: 'orange',+ },+ {+ id: '738afb28-4ec5-4d72-879a-319baaf16eae',+ value: SLACK_USER_LINK_CONSENT_STATE.DECLINED,+ label: 'Declined',+ position: 2,+ color: 'red',+ },+ {+ id: '14dab847-b348-4331-bd01-7622939553a3',+ value: SLACK_USER_LINK_CONSENT_STATE.ADMIN_SET,+ label: 'Admin set',+ position: 3,+ color: 'gray',+ },+ ],+ name: 'consentState',+ },{universalIdentifier:SLACK_USER_LINK_WORKSPACE_MEMBER_FIELD_UNIVERSAL_IDENTIFIER,diff --git a/packages/twenty-apps/public/slack/src/roles/default-function.role.ts b/packages/twenty-apps/public/slack/src/roles/default-function.role.tsindex 02f13f4622b..529f988538b 100644--- a/packages/twenty-apps/public/slack/src/roles/default-function.role.ts+++ b/packages/twenty-apps/public/slack/src/roles/default-function.role.ts@@ -37,7 +37,7 @@ export default defineApplicationRole({canReadObjectRecords: true,canUpdateObjectRecords: true,canSoftDeleteObjectRecords: false,- canDestroyObjectRecords: false,+ canDestroyObjectRecords: true,},{objectUniversalIdentifier:diff --git a/packages/twenty-apps/public/slack/tsconfig.spec.json b/packages/twenty-apps/public/slack/tsconfig.spec.jsonindex ea69a6c0105..b780a60a65e 100644--- a/packages/twenty-apps/public/slack/tsconfig.spec.json+++ b/packages/twenty-apps/public/slack/tsconfig.spec.json@@ -4,6 +4,6 @@"composite": true,"types": ["vitest/globals", "node"]},- "include": ["src/**/*.ts", "src/**/*.tsx"],+ "include": ["css.d.ts", "src/**/*.ts", "src/**/*.tsx"],"exclude": ["node_modules", "dist"]}diff --git a/packages/twenty-apps/public/slack/yarn.lock b/packages/twenty-apps/public/slack/yarn.lockindex d362d17f0f7..84c74337a01 100644--- a/packages/twenty-apps/public/slack/yarn.lock+++ b/packages/twenty-apps/public/slack/yarn.lock@@ -15,6 +15,160 @@ __metadata:languageName: nodelinkType: hard+"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.29.7":+ version: 7.29.7+ resolution: "@babel/code-frame@npm:7.29.7"+ dependencies:+ "@babel/helper-validator-identifier": "npm:^7.29.7"+ js-tokens: "npm:^4.0.0"+ picocolors: "npm:^1.1.1"+ checksum: 10c0/169fc2080169a40c1760155eaaaf739bcb882df0bec76a83adbda5493645bc17270a3434b8848c494b1933e96fe1d147370001e3cda09a39f43ae30f08ef2069+ languageName: node+ linkType: hard++"@babel/generator@npm:^7.29.8":+ version: 7.29.8+ resolution: "@babel/generator@npm:7.29.8"+ dependencies:+ "@babel/parser": "npm:^7.29.8"+ "@babel/types": "npm:^7.29.8"+ "@jridgewell/gen-mapping": "npm:^0.3.12"+ "@jridgewell/trace-mapping": "npm:^0.3.28"+ jsesc: "npm:^3.0.2"+ checksum: 10c0/7b896696314a659652393b76d78276e236acd0f7fae40a9a1af7f01c76aeafc630dd0966aad6f9386d35d7c674a8e6e2d8e217c44d25fb11460e68afa9ba8441+ languageName: node+ linkType: hard++"@babel/helper-globals@npm:^7.29.7":+ version: 7.29.7+ resolution: "@babel/helper-globals@npm:7.29.7"+ checksum: 10c0/f38417c40b1129a1b2b519ca961b9040c8827d1444fd74068702286b91b77089431dc76b6b9d5c1496e5da2a4f3ad329c6946e688ba3fa0d1d0b3d2b4f34f36a+ languageName: node+ linkType: hard++"@babel/helper-module-imports@npm:^7.16.7":+ version: 7.29.7+ resolution: "@babel/helper-module-imports@npm:7.29.7"+ dependencies:+ "@babel/traverse": "npm:^7.29.7"+ "@babel/types": "npm:^7.29.7"+ checksum: 10c0/6adf60d97356027413342a092f818d9678c4f5caff716a33e3284b5ae14e47a9e88059d421dde4ee4894691260039a12602c0e7becadc175602194b40dfa345d+ languageName: node+ linkType: hard++"@babel/helper-string-parser@npm:^7.29.7":+ version: 7.29.7+ resolution: "@babel/helper-string-parser@npm:7.29.7"+ checksum: 10c0/194bc0f1716e396d5ffde56ad6119745fb9557662c98611590e5e454906783a4ccb21ce93056b8eb69a4909044834e45d96e50ac695bbe9e3221648fe033c06c+ languageName: node+ linkType: hard++"@babel/helper-validator-identifier@npm:^7.29.7":+ version: 7.29.7+ resolution: "@babel/helper-validator-identifier@npm:7.29.7"+ checksum: 10c0/4795354e7ae0dcafa72de1cd04ec51252dc1498517170beaf019e03effc5b7bf13c6b21a3949a77e07b8125be7f106ed1131350d8ebd4566ae874094a726d62b+ languageName: node+ linkType: hard++"@babel/parser@npm:^7.29.7, @babel/parser@npm:^7.29.8":+ version: 7.29.8+ resolution: "@babel/parser@npm:7.29.8"+ dependencies:+ "@babel/types": "npm:^7.29.8"+ bin:+ parser: ./bin/babel-parser.js+ checksum: 10c0/acc890c5e6a6dd40863a47b50bac111d7185ee6fbbe163ebe11d5214854ca2adb901462ad4d718a65090ef84bd2230e9e8ab45a2e0caccc685f1f57ab0bb1e28+ languageName: node+ linkType: hard++"@babel/runtime@npm:^7.12.5, @babel/runtime@npm:^7.18.3, @babel/runtime@npm:^7.29.2":+ version: 7.29.7+ resolution: "@babel/runtime@npm:7.29.7"+ checksum: 10c0/ca11572f7146b21e0bde6a9ed4bb6a89eafbee5f0944c7eb54d0d8a2dac962c33638a1d611e14faa71dfbb92b4b5f9236232208568a6b7d5c6f3f39ddb91771e+ languageName: node+ linkType: hard++"@babel/template@npm:^7.29.7":+ version: 7.29.7+ resolution: "@babel/template@npm:7.29.7"+ dependencies:+ "@babel/code-frame": "npm:^7.29.7"+ "@babel/parser": "npm:^7.29.7"+ "@babel/types": "npm:^7.29.7"+ checksum: 10c0/8bb7f900dcab0e9e1c5ffbc33ca10e0d26b7b2e2ca804becb73ee771b9c4ed6e2908a4ae4a14c08560febb45d2b6b9a173955e42ad404d05f8b04840a14d9c58+ languageName: node+ linkType: hard++"@babel/traverse@npm:^7.29.7":+ version: 7.29.8+ resolution: "@babel/traverse@npm:7.29.8"+ dependencies:+ "@babel/code-frame": "npm:^7.29.7"+ "@babel/generator": "npm:^7.29.8"+ "@babel/helper-globals": "npm:^7.29.7"+ "@babel/parser": "npm:^7.29.8"+ "@babel/template": "npm:^7.29.7"+ "@babel/types": "npm:^7.29.8"+ debug: "npm:^4.3.1"+ checksum: 10c0/87a28989c434add26d787776ac6d30f749b89cb030f2a605c89f671a516a6fa165ac0476f07e2b69feed70128b2734cae1cbbf41dfe95ccf22081bd8f8b91923+ languageName: node+ linkType: hard++"@babel/types@npm:^7.29.7, @babel/types@npm:^7.29.8":+ version: 7.29.8+ resolution: "@babel/types@npm:7.29.8"+ dependencies:+ "@babel/helper-string-parser": "npm:^7.29.7"+ "@babel/helper-validator-identifier": "npm:^7.29.7"+ checksum: 10c0/be7c279f0abf2a086c633e21b49c7ca80275d05283cc5a268b67a708c9914bd0c944f1422b3eb3cb37682a2af5d560abf520ccf9b01b53ecbfe6b71fbc3fdde6+ languageName: node+ linkType: hard++"@base-ui/react@npm:^1.5.0":+ version: 1.7.0+ resolution: "@base-ui/react@npm:1.7.0"+ dependencies:+ "@babel/runtime": "npm:^7.29.2"+ "@base-ui/utils": "npm:0.3.2"+ "@floating-ui/react-dom": "npm:^2.1.9"+ "@floating-ui/utils": "npm:^0.2.12"+ use-sync-external-store: "npm:^1.6.0"+ peerDependencies:+ "@date-fns/tz": ^1.2.0+ "@types/react": ^17 || ^18 || ^19+ date-fns: ^4.0.0+ react: ^17 || ^18 || ^19+ react-dom: ^17 || ^18 || ^19+ peerDependenciesMeta:+ "@date-fns/tz":+ optional: true+ "@types/react":+ optional: true+ date-fns:+ optional: true+ checksum: 10c0/05bc69f68431ff30a5fac98d8e75c77af7c27749d10aeac10ab7f26843a0a8b49ca5cff32654aad1a107cb7f44aeb1705c15138c9c7f7ddc19d6321fbb263e4d+ languageName: node+ linkType: hard++"@base-ui/utils@npm:0.3.2":+ version: 0.3.2+ resolution: "@base-ui/utils@npm:0.3.2"+ dependencies:+ "@babel/runtime": "npm:^7.29.2"+ "@floating-ui/utils": "npm:^0.2.12"+ reselect: "npm:^5.2.0"+ use-sync-external-store: "npm:^1.6.0"+ peerDependencies:+ "@types/react": ^17 || ^18 || ^19+ react: ^17 || ^18 || ^19+ react-dom: ^17 || ^18 || ^19+ peerDependenciesMeta:+ "@types/react":+ optional: true+ checksum: 10c0/b523339f350679915550605e59754b5db9806a41a3b390d6f6adad29fedc0caf084c8ad1bad6bb62a463360593382defb7d3ea941a94404ed9db0142fdae5800+ languageName: node+ linkType: hard+"@emnapi/core@npm:1.10.0":version: 1.10.0resolution: "@emnapi/core@npm:1.10.0"@@ -52,6 +206,152 @@ __metadata:languageName: nodelinkType: hard+"@emotion/babel-plugin@npm:^11.13.5":+ version: 11.13.5+ resolution: "@emotion/babel-plugin@npm:11.13.5"+ dependencies:+ "@babel/helper-module-imports": "npm:^7.16.7"+ "@babel/runtime": "npm:^7.18.3"+ "@emotion/hash": "npm:^0.9.2"+ "@emotion/memoize": "npm:^0.9.0"+ "@emotion/serialize": "npm:^1.3.3"+ babel-plugin-macros: "npm:^3.1.0"+ convert-source-map: "npm:^1.5.0"+ escape-string-regexp: "npm:^4.0.0"+ find-root: "npm:^1.1.0"+ source-map: "npm:^0.5.7"+ stylis: "npm:4.2.0"+ checksum: 10c0/8ccbfec7defd0e513cb8a1568fa179eac1e20c35fda18aed767f6c59ea7314363ebf2de3e9d2df66c8ad78928dc3dceeded84e6fa8059087cae5c280090aeeeb+ languageName: node+ linkType: hard++"@emotion/cache@npm:^11.14.0":+ version: 11.14.0+ resolution: "@emotion/cache@npm:11.14.0"+ dependencies:+ "@emotion/memoize": "npm:^0.9.0"+ "@emotion/sheet": "npm:^1.4.0"+ "@emotion/utils": "npm:^1.4.2"+ "@emotion/weak-memoize": "npm:^0.4.0"+ stylis: "npm:4.2.0"+ checksum: 10c0/3fa3e7a431ab6f8a47c67132a00ac8358f428c1b6c8421d4b20de9df7c18e95eec04a5a6ff5a68908f98d3280044f247b4965ac63df8302d2c94dba718769724+ languageName: node+ linkType: hard++"@emotion/hash@npm:^0.9.2":+ version: 0.9.2+ resolution: "@emotion/hash@npm:0.9.2"+ checksum: 10c0/0dc254561a3cc0a06a10bbce7f6a997883fd240c8c1928b93713f803a2e9153a257a488537012efe89dbe1246f2abfe2add62cdb3471a13d67137fcb808e81c2+ languageName: node+ linkType: hard++"@emotion/is-prop-valid@npm:^1.3.0":+ version: 1.4.0+ resolution: "@emotion/is-prop-valid@npm:1.4.0"+ dependencies:+ "@emotion/memoize": "npm:^0.9.0"+ checksum: 10c0/5f857814ec7d8c7e727727346dfb001af6b1fb31d621a3ce9c3edf944a484d8b0d619546c30899ae3ade2f317c76390ba4394449728e9bf628312defc2c41ac3+ languageName: node+ linkType: hard++"@emotion/memoize@npm:^0.9.0":+ version: 0.9.0+ resolution: "@emotion/memoize@npm:0.9.0"+ checksum: 10c0/13f474a9201c7f88b543e6ea42f55c04fb2fdc05e6c5a3108aced2f7e7aa7eda7794c56bba02985a46d8aaa914fcdde238727a98341a96e2aec750d372dadd15+ languageName: node+ linkType: hard++"@emotion/react@npm:^11.14.0":+ version: 11.14.0+ resolution: "@emotion/react@npm:11.14.0"+ dependencies:+ "@babel/runtime": "npm:^7.18.3"+ "@emotion/babel-plugin": "npm:^11.13.5"+ "@emotion/cache": "npm:^11.14.0"+ "@emotion/serialize": "npm:^1.3.3"+ "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0"+ "@emotion/utils": "npm:^1.4.2"+ "@emotion/weak-memoize": "npm:^0.4.0"+ hoist-non-react-statics: "npm:^3.3.1"+ peerDependencies:+ react: ">=16.8.0"+ peerDependenciesMeta:+ "@types/react":+ optional: true+ checksum: 10c0/d0864f571a9f99ec643420ef31fde09e2006d3943a6aba079980e4d5f6e9f9fecbcc54b8f617fe003c00092ff9d5241179149ffff2810cb05cf72b4620cfc031+ languageName: node+ linkType: hard++"@emotion/serialize@npm:^1.3.3":+ version: 1.3.3+ resolution: "@emotion/serialize@npm:1.3.3"+ dependencies:+ "@emotion/hash": "npm:^0.9.2"+ "@emotion/memoize": "npm:^0.9.0"+ "@emotion/unitless": "npm:^0.10.0"+ "@emotion/utils": "npm:^1.4.2"+ csstype: "npm:^3.0.2"+ checksum: 10c0/b28cb7de59de382021de2b26c0c94ebbfb16967a1b969a56fdb6408465a8993df243bfbd66430badaa6800e1834724e84895f5a6a9d97d0d224de3d77852acb4+ languageName: node+ linkType: hard++"@emotion/sheet@npm:^1.4.0":+ version: 1.4.0+ resolution: "@emotion/sheet@npm:1.4.0"+ checksum: 10c0/3ca72d1650a07d2fbb7e382761b130b4a887dcd04e6574b2d51ce578791240150d7072a9bcb4161933abbcd1e38b243a6fb4464a7fe991d700c17aa66bb5acc7+ languageName: node+ linkType: hard++"@emotion/styled@npm:^11.14.0":+ version: 11.14.1+ resolution: "@emotion/styled@npm:11.14.1"+ dependencies:+ "@babel/runtime": "npm:^7.18.3"+ "@emotion/babel-plugin": "npm:^11.13.5"+ "@emotion/is-prop-valid": "npm:^1.3.0"+ "@emotion/serialize": "npm:^1.3.3"+ "@emotion/use-insertion-effect-with-fallbacks": "npm:^1.2.0"+ "@emotion/utils": "npm:^1.4.2"+ peerDependencies:+ "@emotion/react": ^11.0.0-rc.0+ react: ">=16.8.0"+ peerDependenciesMeta:+ "@types/react":+ optional: true+ checksum: 10c0/2bbf8451df49c967e41fbcf8111a7f6dafe6757f0cc113f2f6e287206c45ac1d54dc8a95a483b7c0cee8614b8a8d08155bded6453d6721de1f8cc8d5b9216963+ languageName: node+ linkType: hard++"@emotion/unitless@npm:^0.10.0":+ version: 0.10.0+ resolution: "@emotion/unitless@npm:0.10.0"+ checksum: 10c0/150943192727b7650eb9a6851a98034ddb58a8b6958b37546080f794696141c3760966ac695ab9af97efe10178690987aee4791f9f0ad1ff76783cdca83c1d49+ languageName: node+ linkType: hard++"@emotion/use-insertion-effect-with-fallbacks@npm:^1.2.0":+ version: 1.2.0+ resolution: "@emotion/use-insertion-effect-with-fallbacks@npm:1.2.0"+ peerDependencies:+ react: ">=16.8.0"+ checksum: 10c0/074dbc92b96bdc09209871070076e3b0351b6b47efefa849a7d9c37ab142130767609ca1831da0055988974e3b895c1de7606e4c421fecaa27c3e56a2afd3b08+ languageName: node+ linkType: hard++"@emotion/utils@npm:^1.4.2":+ version: 1.4.2+ resolution: "@emotion/utils@npm:1.4.2"+ checksum: 10c0/7d0010bf60a2a8c1a033b6431469de4c80e47aeb8fd856a17c1d1f76bbc3a03161a34aeaa78803566e29681ca551e7bf9994b68e9c5f5c796159923e44f78d9a+ languageName: node+ linkType: hard++"@emotion/weak-memoize@npm:^0.4.0":+ version: 0.4.0+ resolution: "@emotion/weak-memoize@npm:0.4.0"+ checksum: 10c0/64376af11f1266042d03b3305c30b7502e6084868e33327e944b539091a472f089db307af69240f7188f8bc6b319276fd7b141a36613f1160d73d12a60f6ca1a+ languageName: node+ linkType: hard+"@esbuild/aix-ppc64@npm:0.28.1":version: 0.28.1resolution: "@esbuild/aix-ppc64@npm:0.28.1"@@ -234,6 +534,44 @@ __metadata:languageName: nodelinkType: hard+"@floating-ui/core@npm:^1.8.0":+ version: 1.8.0+ resolution: "@floating-ui/core@npm:1.8.0"+ dependencies:+ "@floating-ui/utils": "npm:^0.2.12"+ checksum: 10c0/cece958f6fab0f8cd7740cd57988c4f8bc5356dca39dd4c093433d44c91952c3a02c7a54d93d7ed6c078b6544d531a29f66621d2839c8bfbb4467dca6aed7df0+ languageName: node+ linkType: hard++"@floating-ui/dom@npm:^1.8.0":+ version: 1.8.0+ resolution: "@floating-ui/dom@npm:1.8.0"+ dependencies:+ "@floating-ui/core": "npm:^1.8.0"+ "@floating-ui/utils": "npm:^0.2.12"+ checksum: 10c0/c32b2de7a596b69cfffa909c7028825e14f6319be1b45da529f8943c89fe16b75a49c214e800c87ded3f172353d3b99163d50072f11410488e756961b7b629cc+ languageName: node+ linkType: hard++"@floating-ui/react-dom@npm:^2.1.9":+ version: 2.1.9+ resolution: "@floating-ui/react-dom@npm:2.1.9"+ dependencies:+ "@floating-ui/dom": "npm:^1.8.0"+ peerDependencies:+ react: ">=16.8.0"+ react-dom: ">=16.8.0"+ checksum: 10c0/9fa9851069738cb9591a1ab2da16e257f193eae5fd2d6d48ad0b1e73f3c049929b6805c5ad43d4af3c1da63c60b215b0ee4651a1fe5caeb80e66d9d423744348+ languageName: node+ linkType: hard++"@floating-ui/utils@npm:^0.2.12":+ version: 0.2.12+ resolution: "@floating-ui/utils@npm:0.2.12"+ checksum: 10c0/bb910b90d56991a62011afaf5f8e0c4b7fb6dab69403f4dd17fbd6eb25560b28d533dff9791f270b4f459852e9006a1077b5d73cbedb5e34d9424afc6a828314+ languageName: node+ linkType: hard+"@genql/runtime@npm:^2.10.0":version: 2.10.0resolution: "@genql/runtime@npm:2.10.0"@@ -749,13 +1087,62 @@ __metadata:languageName: nodelinkType: hard-"@jridgewell/sourcemap-codec@npm:^1.5.5":+"@jridgewell/gen-mapping@npm:^0.3.12":+ version: 0.3.13+ resolution: "@jridgewell/gen-mapping@npm:0.3.13"+ dependencies:+ "@jridgewell/sourcemap-codec": "npm:^1.5.0"+ "@jridgewell/trace-mapping": "npm:^0.3.24"+ checksum: 10c0/9a7d65fb13bd9aec1fbab74cda08496839b7e2ceb31f5ab922b323e94d7c481ce0fc4fd7e12e2610915ed8af51178bdc61e168e92a8c8b8303b030b03489b13b+ languageName: node+ linkType: hard++"@jridgewell/resolve-uri@npm:^3.1.0":+ version: 3.1.2+ resolution: "@jridgewell/resolve-uri@npm:3.1.2"+ checksum: 10c0/d502e6fb516b35032331406d4e962c21fe77cdf1cbdb49c6142bcbd9e30507094b18972778a6e27cbad756209cfe34b1a27729e6fa08a2eb92b33943f680cf1e+ languageName: node+ linkType: hard++"@jridgewell/sourcemap-codec@npm:^1.4.14, @jridgewell/sourcemap-codec@npm:^1.5.0, @jridgewell/sourcemap-codec@npm:^1.5.5":version: 1.5.5resolution: "@jridgewell/sourcemap-codec@npm:1.5.5"checksum: 10c0/f9e538f302b63c0ebc06eecb1dd9918dd4289ed36147a0ddce35d6ea4d7ebbda243cda7b2213b6a5e1d8087a298d5cf630fb2bd39329cdecb82017023f6081a0languageName: nodelinkType: hard+"@jridgewell/trace-mapping@npm:^0.3.24, @jridgewell/trace-mapping@npm:^0.3.28":+ version: 0.3.31+ resolution: "@jridgewell/trace-mapping@npm:0.3.31"+ dependencies:+ "@jridgewell/resolve-uri": "npm:^3.1.0"+ "@jridgewell/sourcemap-codec": "npm:^1.4.14"+ checksum: 10c0/4b30ec8cd56c5fd9a661f088230af01e0c1a3888d11ffb6b47639700f71225be21d1f7e168048d6d4f9449207b978a235c07c8f15c07705685d16dc06280e9d9+ languageName: node+ linkType: hard++"@monaco-editor/loader@npm:^1.5.0":+ version: 1.7.0+ resolution: "@monaco-editor/loader@npm:1.7.0"+ dependencies:+ state-local: "npm:^1.0.6"+ checksum: 10c0/1fd3579cb09b669493cf553dfc0723a93483140a44353ce9a739827edfa7b2c6541b254024d15c48176ece749ef666b6d16cce6cf0e4396c7fa1c5a48012d08a+ languageName: node+ linkType: hard++"@monaco-editor/react@npm:^4.7.0":+ version: 4.7.0+ resolution: "@monaco-editor/react@npm:4.7.0"+ dependencies:+ "@monaco-editor/loader": "npm:^1.5.0"+ peerDependencies:+ monaco-editor: ">= 0.25.0 < 1"+ react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0+ react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0+ checksum: 10c0/a4e91c6eda1a71f5fd23871bd801de435490ccbc43934d23cba65cefe2be7e9d02c9a57c4ef80fc9fe99e4d4deea51e5db19cb4e0ecf3f51818dda0eb9cdbf12+ languageName: node+ linkType: hard+"@mswjs/interceptors@npm:^0.41.3":version: 0.41.9resolution: "@mswjs/interceptors@npm:0.41.9"@@ -876,6 +1263,20 @@ __metadata:languageName: nodelinkType: hard+"@radix-ui/colors@npm:^3.0.0":+ version: 3.0.0+ resolution: "@radix-ui/colors@npm:3.0.0"+ checksum: 10c0/612c6bb4efe987f2d49aaca2f785687d08150da59a248328bc2b4e187ece4ef731c1dc5c6a9430fffcac4af9e65cf2f89ceb9806f8809940c9eb238b79d2cf2f+ languageName: node+ linkType: hard++"@remix-run/router@npm:1.23.4":+ version: 1.23.4+ resolution: "@remix-run/router@npm:1.23.4"+ checksum: 10c0/ef17eb2a606c125f09c55683585099725421af1c11f1c1d1c3841fe4eea3f99eb56b26ecbb17429a173c704ecae336c37e0d74855faa9330667433ef4f419436+ languageName: node+ linkType: hard+"@rolldown/binding-android-arm64@npm:1.0.3":version: 1.0.3resolution: "@rolldown/binding-android-arm64@npm:1.0.3"@@ -1042,10 +1443,30 @@ __metadata:languageName: nodelinkType: hard+"@tabler/icons-react@npm:^3.31.0":+ version: 3.46.0+ resolution: "@tabler/icons-react@npm:3.46.0"+ dependencies:+ "@tabler/icons": "npm:3.46.0"+ peerDependencies:+ react: ">= 16"+ checksum: 10c0/8fab7d3a9ec6b62724a1628b8bad68a7b503979e4418f97d057c442adc5257b227a08185a884d452d171983648e36fa92cd7bfe9457f693e9b67bbf4ecf8ec24+ languageName: node+ linkType: hard++"@tabler/icons@npm:3.46.0":+ version: 3.46.0+ resolution: "@tabler/icons@npm:3.46.0"+ checksum: 10c0/c9671449c2f53fa7e329c487162f89a28417cdd5ce96cfa290fe21388724da303dd2297af3b39a88a74b02c36ce55598bc3cf6537dbddf548881da2c05f35f5e+ languageName: node+ linkType: hard+"@twentyhq/slack@workspace:.":version: 0.0.0-use.localresolution: "@twentyhq/slack@workspace:."dependencies:+ "@emotion/react": "npm:^11.14.0"+ "@emotion/styled": "npm:^11.14.0""@slack/web-api": "npm:^7.18.0""@types/node": "npm:^24.7.2""@types/react": "npm:^18.2.0"@@ -1056,6 +1477,7 @@ __metadata:react-dom: "npm:^18.2.0"twenty-client-sdk: "npm:^2.37.0"twenty-sdk: "npm:^2.37.0"+ twenty-ui: "npm:^1.0.0-alpha.1"typescript: "npm:^5.9.3"vite-tsconfig-paths: "npm:^4.2.1"vitest: "npm:^4.0.0"@@ -1113,6 +1535,13 @@ __metadata:languageName: nodelinkType: hard+"@types/parse-json@npm:^4.0.0":+ version: 4.0.2+ resolution: "@types/parse-json@npm:4.0.2"+ checksum: 10c0/b1b863ac34a2c2172fbe0807a1ec4d5cb684e48d422d15ec95980b81475fac4fdb3768a8b13eef39130203a7c04340fc167bae057c7ebcafd7dec9fe6c36aeb1+ languageName: node+ linkType: hard+"@types/prop-types@npm:*":version: 15.7.15resolution: "@types/prop-types@npm:15.7.15"@@ -1441,6 +1870,17 @@ __metadata:languageName: nodelinkType: hard+"babel-plugin-macros@npm:^3.1.0":+ version: 3.1.0+ resolution: "babel-plugin-macros@npm:3.1.0"+ dependencies:+ "@babel/runtime": "npm:^7.12.5"+ cosmiconfig: "npm:^7.0.0"+ resolve: "npm:^1.19.0"+ checksum: 10c0/c6dfb15de96f67871d95bd2e8c58b0c81edc08b9b087dc16755e7157f357dc1090a8dc60ebab955e92587a9101f02eba07e730adc253a1e4cf593ca3ebd3839c+ languageName: node+ linkType: hard+"backo2@npm:^1.0.2":version: 1.0.2resolution: "backo2@npm:1.0.2"@@ -1458,6 +1898,13 @@ __metadata:languageName: nodelinkType: hard+"callsites@npm:^3.0.0":+ version: 3.1.0+ resolution: "callsites@npm:3.1.0"+ checksum: 10c0/fff92277400eb06c3079f9e74f3af120db9f8ea03bad0e84d9aede54bbe2d44a56cccb5f6cf12211f93f52306df87077ecec5b712794c5a9b5dac6d615a3f301+ languageName: node+ linkType: hard+"chai@npm:^6.2.2":version: 6.2.2resolution: "chai@npm:6.2.2"@@ -1539,6 +1986,13 @@ __metadata:languageName: nodelinkType: hard+"clsx@npm:^2.1.1":+ version: 2.1.1+ resolution: "clsx@npm:2.1.1"+ checksum: 10c0/c4c8eb865f8c82baab07e71bfa8897c73454881c4f99d6bc81585aecd7c441746c1399d08363dc096c550cceaf97bd4ce1e8854e1771e9998d9f94c4fe075839+ languageName: node+ linkType: hard+"code-excerpt@npm:^4.0.0":version: 4.0.0resolution: "code-excerpt@npm:4.0.0"@@ -1580,6 +2034,13 @@ __metadata:languageName: nodelinkType: hard+"convert-source-map@npm:^1.5.0":+ version: 1.9.0+ resolution: "convert-source-map@npm:1.9.0"+ checksum: 10c0/281da55454bf8126cbc6625385928c43479f2060984180c42f3a86c8b8c12720a24eac260624a7d1e090004028d2dee78602330578ceec1a08e27cb8bb0a8a5b+ languageName: node+ linkType: hard+"convert-source-map@npm:^2.0.0":version: 2.0.0resolution: "convert-source-map@npm:2.0.0"@@ -1601,14 +2062,34 @@ __metadata:languageName: nodelinkType: hard-"csstype@npm:^3.2.2":+"cosmiconfig@npm:^7.0.0":+ version: 7.1.0+ resolution: "cosmiconfig@npm:7.1.0"+ dependencies:+ "@types/parse-json": "npm:^4.0.0"+ import-fresh: "npm:^3.2.1"+ parse-json: "npm:^5.0.0"+ path-type: "npm:^4.0.0"+ yaml: "npm:^1.10.0"+ checksum: 10c0/b923ff6af581638128e5f074a5450ba12c0300b71302398ea38dbeabd33bbcaa0245ca9adbedfcf284a07da50f99ede5658c80bb3e39e2ce770a99d28a21ef03+ languageName: node+ linkType: hard++"css-mediaquery@npm:^0.1.2":+ version: 0.1.2+ resolution: "css-mediaquery@npm:0.1.2"+ checksum: 10c0/b7825a78f52ce8a8198e004fcad0d7be1d3c9a0463ecd05ba31a0f2c94fb81468ad6f4d7bf715a6ca775696e7a17500c2a339b5216a6d0f789cbf78f9454d048+ languageName: node+ linkType: hard++"csstype@npm:^3.0.2, csstype@npm:^3.2.2":version: 3.2.3resolution: "csstype@npm:3.2.3"checksum: 10c0/cd29c51e70fa822f1cecd8641a1445bed7063697469d35633b516e60fe8c1bde04b08f6c5b6022136bb669b64c63d4173af54864510fbb4ee23281801841a3celanguageName: nodelinkType: hard-"debug@npm:4, debug@npm:^4.1.1":+"debug@npm:4, debug@npm:^4.1.1, debug@npm:^4.3.1":version: 4.4.3resolution: "debug@npm:4.4.3"dependencies:@@ -1673,6 +2154,15 @@ __metadata:languageName: nodelinkType: hard+"error-ex@npm:^1.3.1":+ version: 1.3.4+ resolution: "error-ex@npm:1.3.4"+ dependencies:+ is-arrayish: "npm:^0.2.1"+ checksum: 10c0/b9e34ff4778b8f3b31a8377e1c654456f4c41aeaa3d10a1138c3b7635d8b7b2e03eb2475d46d8ae055c1f180a1063e100bffabf64ea7e7388b37735df5328664+ languageName: node+ linkType: hard+"es-define-property@npm:^1.0.1":version: 1.0.1resolution: "es-define-property@npm:1.0.1"@@ -1830,6 +2320,13 @@ __metadata:languageName: nodelinkType: hard+"escape-string-regexp@npm:^4.0.0":+ version: 4.0.0+ resolution: "escape-string-regexp@npm:4.0.0"+ checksum: 10c0/9497d4dd307d845bd7f75180d8188bb17ea8c151c1edbf6b6717c100e104d629dc2dfb687686181b0f4b7d732c7dfdc4d5e7a8ff72de1b0ca283a75bbb3a9cd9+ languageName: node+ linkType: hard+"estree-walker@npm:^3.0.3":version: 3.0.3resolution: "estree-walker@npm:3.0.3"@@ -1911,6 +2408,13 @@ __metadata:languageName: nodelinkType: hard+"find-root@npm:^1.1.0":+ version: 1.1.0+ resolution: "find-root@npm:1.1.0"+ checksum: 10c0/1abc7f3bf2f8d78ff26d9e00ce9d0f7b32e5ff6d1da2857bcdf4746134c422282b091c672cde0572cac3840713487e0a7a636af9aa1b74cb11894b447a521efa+ languageName: node+ linkType: hard+"follow-redirects@npm:^1.16.0":version: 1.16.0resolution: "follow-redirects@npm:1.16.0"@@ -2088,7 +2592,7 @@ __metadata:languageName: nodelinkType: hard-"hasown@npm:^2.0.4":+"hasown@npm:^2.0.3, hasown@npm:^2.0.4":version: 2.0.4resolution: "hasown@npm:2.0.4"dependencies:@@ -2107,6 +2611,15 @@ __metadata:languageName: nodelinkType: hard+"hoist-non-react-statics@npm:^3.3.1":+ version: 3.3.2+ resolution: "hoist-non-react-statics@npm:3.3.2"+ dependencies:+ react-is: "npm:^16.7.0"+ checksum: 10c0/fe0889169e845d738b59b64badf5e55fa3cf20454f9203d1eb088df322d49d4318df774828e789898dcb280e8a5521bb59b3203385662ca5e9218a6ca5820e74+ languageName: node+ linkType: hard+"https-proxy-agent@npm:^5.0.1":version: 5.0.1resolution: "https-proxy-agent@npm:5.0.1"@@ -2117,6 +2630,13 @@ __metadata:languageName: nodelinkType: hard+"hyphenate-style-name@npm:^1.0.0":+ version: 1.1.0+ resolution: "hyphenate-style-name@npm:1.1.0"+ checksum: 10c0/bfe88deac2414a41a0d08811e277c8c098f23993d6a1eb17f14a0f11b54c4d42865a63d3cfe1914668eefb9a188e2de58f38b55a179a238fd1fef606893e194f+ languageName: node+ linkType: hard+"iconv-lite@npm:^0.7.2":version: 0.7.2resolution: "iconv-lite@npm:0.7.2"@@ -2126,6 +2646,16 @@ __metadata:languageName: nodelinkType: hard+"import-fresh@npm:^3.2.1":+ version: 3.3.1+ resolution: "import-fresh@npm:3.3.1"+ dependencies:+ parent-module: "npm:^1.0.0"+ resolve-from: "npm:^4.0.0"+ checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec+ languageName: node+ linkType: hard+"indent-string@npm:^5.0.0":version: 5.0.0resolution: "indent-string@npm:5.0.0"@@ -2194,6 +2724,22 @@ __metadata:languageName: nodelinkType: hard+"is-arrayish@npm:^0.2.1":+ version: 0.2.1+ resolution: "is-arrayish@npm:0.2.1"+ checksum: 10c0/e7fb686a739068bb70f860b39b67afc62acc62e36bb61c5f965768abce1873b379c563e61dd2adad96ebb7edf6651111b385e490cf508378959b0ed4cac4e729+ languageName: node+ linkType: hard++"is-core-module@npm:^2.16.1":+ version: 2.16.2+ resolution: "is-core-module@npm:2.16.2"+ dependencies:+ hasown: "npm:^2.0.3"+ checksum: 10c0/14b4258390283709c15476d023ec173e27458d5d014ccdb8ed39d576e551c3fa45498b7c9fe178f1529c4cb2648ddd58852a6a62107a019f6e349529f277518a+ languageName: node+ linkType: hard+"is-electron@npm:2.2.2":version: 2.2.2resolution: "is-electron@npm:2.2.2"@@ -2264,13 +2810,29 @@ __metadata:languageName: nodelinkType: hard-"js-tokens@npm:^3.0.0 || ^4.0.0":+"js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":version: 4.0.0resolution: "js-tokens@npm:4.0.0"checksum: 10c0/e248708d377aa058eacf2037b07ded847790e6de892bbad3dac0abba2e759cb9f121b00099a65195616badcb6eca8d14d975cb3e89eb1cfda644756402c8aeedlanguageName: nodelinkType: hard+"jsesc@npm:^3.0.2":+ version: 3.1.0+ resolution: "jsesc@npm:3.1.0"+ bin:+ jsesc: bin/jsesc+ checksum: 10c0/531779df5ec94f47e462da26b4cbf05eb88a83d9f08aac2ba04206508fc598527a153d08bd462bae82fc78b3eaa1a908e1a4a79f886e9238641c4cdefaf118b1+ languageName: node+ linkType: hard++"json-parse-even-better-errors@npm:^2.3.0":+ version: 2.3.1+ resolution: "json-parse-even-better-errors@npm:2.3.1"+ checksum: 10c0/140932564c8f0b88455432e0f33c4cb4086b8868e37524e07e723f4eaedb9425bdc2bafd71bd1d9765bd15fd1e2d126972bc83990f55c467168c228c24d665f3+ languageName: node+ linkType: hard+"jsonc-parser@npm:^3.2.0":version: 3.3.1resolution: "jsonc-parser@npm:3.3.1"@@ -2398,6 +2960,13 @@ __metadata:languageName: nodelinkType: hard+"lines-and-columns@npm:^1.1.6":+ version: 1.2.4+ resolution: "lines-and-columns@npm:1.2.4"+ checksum: 10c0/3da6ee62d4cd9f03f5dc90b4df2540fb85b352081bee77fe4bbcd12c9000ead7f35e0a38b8d09a9bb99b13223446dd8689ff3c4959807620726d788701a83d2d+ languageName: node+ linkType: hard+"lodash@npm:^4.17.20, lodash@npm:^4.17.21":version: 4.18.1resolution: "lodash@npm:4.18.1"@@ -2405,7 +2974,7 @@ __metadata:languageName: nodelinkType: hard-"loose-envify@npm:^1.1.0":+"loose-envify@npm:^1.1.0, loose-envify@npm:^1.4.0":version: 1.4.0resolution: "loose-envify@npm:1.4.0"dependencies:@@ -2425,6 +2994,15 @@ __metadata:languageName: nodelinkType: hard+"matchmediaquery@npm:^0.3.0":+ version: 0.3.1+ resolution: "matchmediaquery@npm:0.3.1"+ dependencies:+ css-mediaquery: "npm:^0.1.2"+ checksum: 10c0/19a254e0a1eb639fcc6aa7428a6e2d36cb5646a165579897e771580653e470b43d7f4a224c522700dbf1d8f19fb7c63a9719e0a6017727ade967155a2ae89fea+ languageName: node+ linkType: hard+"math-intrinsics@npm:^1.1.0":version: 1.1.0resolution: "math-intrinsics@npm:1.1.0"@@ -2572,6 +3150,13 @@ __metadata:languageName: nodelinkType: hard+"object-assign@npm:^4.1.1":+ version: 4.1.1+ resolution: "object-assign@npm:4.1.1"+ checksum: 10c0/1f4df9945120325d041ccf7b86f31e8bcc14e73d29171e37a7903050e96b81323784ec59f93f102ec635bcf6fa8034ba3ea0a8c7e69fa202b87ae3b6cec5a414+ languageName: node+ linkType: hard+"obug@npm:^2.1.1":version: 2.1.2resolution: "obug@npm:2.1.2"@@ -2667,6 +3252,27 @@ __metadata:languageName: nodelinkType: hard+"parent-module@npm:^1.0.0":+ version: 1.0.1+ resolution: "parent-module@npm:1.0.1"+ dependencies:+ callsites: "npm:^3.0.0"+ checksum: 10c0/c63d6e80000d4babd11978e0d3fee386ca7752a02b035fd2435960ffaa7219dc42146f07069fb65e6e8bf1caef89daf9af7535a39bddf354d78bf50d8294f556+ languageName: node+ linkType: hard++"parse-json@npm:^5.0.0":+ version: 5.2.0+ resolution: "parse-json@npm:5.2.0"+ dependencies:+ "@babel/code-frame": "npm:^7.0.0"+ error-ex: "npm:^1.3.1"+ json-parse-even-better-errors: "npm:^2.3.0"+ lines-and-columns: "npm:^1.1.6"+ checksum: 10c0/77947f2253005be7a12d858aedbafa09c9ae39eb4863adf330f7b416ca4f4a08132e453e08de2db46459256fb66afaac5ee758b44fe6541b7cdaf9d252e59585+ languageName: node+ linkType: hard+"patch-console@npm:^2.0.0":version: 2.0.0resolution: "patch-console@npm:2.0.0"@@ -2674,6 +3280,13 @@ __metadata:languageName: nodelinkType: hard+"path-parse@npm:^1.0.7":+ version: 1.0.7+ resolution: "path-parse@npm:1.0.7"+ checksum: 10c0/11ce261f9d294cc7a58d6a574b7f1b935842355ec66fba3c3fd79e0f036462eaf07d0aa95bb74ff432f9afef97ce1926c720988c6a7451d8a584930ae7de86e1+ languageName: node+ linkType: hard+"path-to-regexp@npm:^6.3.0":version: 6.3.0resolution: "path-to-regexp@npm:6.3.0"@@ -2681,6 +3294,13 @@ __metadata:languageName: nodelinkType: hard+"path-type@npm:^4.0.0":+ version: 4.0.0+ resolution: "path-type@npm:4.0.0"+ checksum: 10c0/666f6973f332f27581371efaf303fd6c272cc43c2057b37aa99e3643158c7e4b2626549555d88626e99ea9e046f82f32e41bbde5f1508547e9a11b149b52387c+ languageName: node+ linkType: hard+"pathe@npm:^2.0.3":version: 2.0.3resolution: "pathe@npm:2.0.3"@@ -2736,6 +3356,17 @@ __metadata:languageName: nodelinkType: hard+"prop-types@npm:^15.6.1":+ version: 15.8.1+ resolution: "prop-types@npm:15.8.1"+ dependencies:+ loose-envify: "npm:^1.4.0"+ object-assign: "npm:^4.1.1"+ react-is: "npm:^16.13.1"+ checksum: 10c0/59ece7ca2fb9838031d73a48d4becb9a7cc1ed10e610517c7d8f19a1e02fa47f7c27d557d8a5702bec3cfeccddc853579832b43f449e54635803f277b1c78077+ languageName: node+ linkType: hard+"proxy-from-env@npm:^2.1.0":version: 2.1.0resolution: "proxy-from-env@npm:2.1.0"@@ -2766,6 +3397,13 @@ __metadata:languageName: nodelinkType: hard+"react-is@npm:^16.13.1, react-is@npm:^16.7.0":+ version: 16.13.1+ resolution: "react-is@npm:16.13.1"+ checksum: 10c0/33977da7a5f1a287936a0c85639fec6ca74f4f15ef1e59a6bc20338fc73dc69555381e211f7a3529b8150a1f71e4225525b41b60b52965bda53ce7d47377ada1+ languageName: node+ linkType: hard+"react-reconciler@npm:^0.33.0":version: 0.33.0resolution: "react-reconciler@npm:0.33.0"@@ -2777,6 +3415,44 @@ __metadata:languageName: nodelinkType: hard+"react-responsive@npm:^9.0.2":+ version: 9.0.2+ resolution: "react-responsive@npm:9.0.2"+ dependencies:+ hyphenate-style-name: "npm:^1.0.0"+ matchmediaquery: "npm:^0.3.0"+ prop-types: "npm:^15.6.1"+ shallow-equal: "npm:^1.2.1"+ peerDependencies:+ react: ">=16.8.0"+ checksum: 10c0/c58b30d8b8ff993edbc73f7de59a2d86d8abd6380b06a9b41667c3bdd5401e5e710fa1d0fdac21368759ab9b958e8b479a111329a06e9b0241ee08f500b37a20+ languageName: node+ linkType: hard++"react-router-dom@npm:^6.4.4":+ version: 6.30.6+ resolution: "react-router-dom@npm:6.30.6"+ dependencies:+ "@remix-run/router": "npm:1.23.4"+ react-router: "npm:6.30.6"+ peerDependencies:+ react: ">=16.8"+ react-dom: ">=16.8"+ checksum: 10c0/57dbb2ae4ac787f78c4d10b764c1c5223635378033e33dda4e0a4417144ae847fb43dc98008075951826258287c27c67729ca713c90957cf2ecf9055561bdc2e+ languageName: node+ linkType: hard++"react-router@npm:6.30.6":+ version: 6.30.6+ resolution: "react-router@npm:6.30.6"+ dependencies:+ "@remix-run/router": "npm:1.23.4"+ peerDependencies:+ react: ">=16.8"+ checksum: 10c0/d101388d92a44e159ef30dd2402a7f7b6aace8f837bb42aed1f8a6b3a4eff769d1822bf69382f0acb85a790628dac081c22bedb2bca12707e0e5e91427010fc3+ languageName: node+ linkType: hard+"react@npm:^18.2.0":version: 18.3.1resolution: "react@npm:18.3.1"@@ -2807,6 +3483,48 @@ __metadata:languageName: nodelinkType: hard+"reselect@npm:^5.2.0":+ version: 5.3.0+ resolution: "reselect@npm:5.3.0"+ checksum: 10c0/c79728e4f315152bfb2d82456d35075b705392d9e72c485d7d9b1061bd80af628416216d80f02a42f24dbb24d738aec7fec45806930aaa1d17c32e9875fa1bd6+ languageName: node+ linkType: hard++"resolve-from@npm:^4.0.0":+ version: 4.0.0+ resolution: "resolve-from@npm:4.0.0"+ checksum: 10c0/8408eec31a3112ef96e3746c37be7d64020cda07c03a920f5024e77290a218ea758b26ca9529fd7b1ad283947f34b2291c1c0f6aa0ed34acfdda9c6014c8d190+ languageName: node+ linkType: hard++"resolve@npm:^1.19.0":+ version: 1.22.12+ resolution: "resolve@npm:1.22.12"+ dependencies:+ es-errors: "npm:^1.3.0"+ is-core-module: "npm:^2.16.1"+ path-parse: "npm:^1.0.7"+ supports-preserve-symlinks-flag: "npm:^1.0.0"+ bin:+ resolve: bin/resolve+ checksum: 10c0/b16dc9b537c02e8c3388f7d3dcff9741d3071625f9a97ac1c885f2b0ca51e78df22328fb6d6ef214dd9101fb7cfc19aa2836fe3410402a94f3f7b8639c7149bf+ languageName: node+ linkType: hard++"resolve@patch:resolve@npm%3A^1.19.0#optional!builtin<compat/resolve>":+ version: 1.22.12+ resolution: "resolve@patch:resolve@npm%3A1.22.12#optional!builtin<compat/resolve>::version=1.22.12&hash=c3c19d"+ dependencies:+ es-errors: "npm:^1.3.0"+ is-core-module: "npm:^2.16.1"+ path-parse: "npm:^1.0.7"+ supports-preserve-symlinks-flag: "npm:^1.0.0"+ bin:+ resolve: bin/resolve+ checksum: 10c0/fc6519984ae1f894d877c0060ba8b1f5ba3bc0e85a02f74e141929c118c23d74d9735619a9cc2965397387e514884245c65d72a40731dcb6cfc84c7bcdc8321e+ languageName: node+ linkType: hard+"restore-cursor@npm:^4.0.0":version: 4.0.0resolution: "restore-cursor@npm:4.0.0"@@ -2953,6 +3671,13 @@ __metadata:languageName: nodelinkType: hard+"shallow-equal@npm:^1.2.1":+ version: 1.2.1+ resolution: "shallow-equal@npm:1.2.1"+ checksum: 10c0/51e03abadd97c9ebe590547d92db9148446962a3f23a3a0fb1ba2fccab80af881eef0ff1f8ccefd3f066c0bc5a4c8ca53706194813b95c8835fa66448a843a26+ languageName: node+ linkType: hard+"sharp@npm:^0.35.3":version: 0.35.3resolution: "sharp@npm:0.35.3"@@ -3081,6 +3806,13 @@ __metadata:languageName: nodelinkType: hard+"source-map@npm:^0.5.7":+ version: 0.5.7+ resolution: "source-map@npm:0.5.7"+ checksum: 10c0/904e767bb9c494929be013017380cbba013637da1b28e5943b566031e29df04fba57edf3f093e0914be094648b577372bd8ad247fa98cfba9c600794cd16b599+ languageName: node+ linkType: hard+"stack-utils@npm:^2.0.6":version: 2.0.6resolution: "stack-utils@npm:2.0.6"@@ -3097,6 +3829,13 @@ __metadata:languageName: nodelinkType: hard+"state-local@npm:^1.0.6":+ version: 1.0.7+ resolution: "state-local@npm:1.0.7"+ checksum: 10c0/8dc7daeac71844452fafb514a6d6b6f40d7e2b33df398309ea1c7b3948d6110c57f112b7196500a10c54fdde40291488c52c875575670fb5c819602deca48bd9+ languageName: node+ linkType: hard+"statuses@npm:^2.0.2":version: 2.0.2resolution: "statuses@npm:2.0.2"@@ -3168,6 +3907,13 @@ __metadata:languageName: nodelinkType: hard+"stylis@npm:4.2.0":+ version: 4.2.0+ resolution: "stylis@npm:4.2.0"+ checksum: 10c0/a7128ad5a8ed72652c6eba46bed4f416521bc9745a460ef5741edc725252cebf36ee45e33a8615a7057403c93df0866ab9ee955960792db210bb80abd5ac6543+ languageName: node+ linkType: hard+"subscriptions-transport-ws@npm:^0.9.16":version: 0.9.19resolution: "subscriptions-transport-ws@npm:0.9.19"@@ -3183,6 +3929,13 @@ __metadata:languageName: nodelinkType: hard+"supports-preserve-symlinks-flag@npm:^1.0.0":+ version: 1.0.0+ resolution: "supports-preserve-symlinks-flag@npm:1.0.0"+ checksum: 10c0/6c4032340701a9950865f7ae8ef38578d8d7053f5e10518076e6554a9381fa91bd9c6850193695c141f32b21f979c985db07265a758867bac95de05f7d8aeb39+ languageName: node+ linkType: hard+"symbol-observable@npm:^1.0.4":version: 1.2.0resolution: "symbol-observable@npm:1.2.0"@@ -3363,6 +4116,35 @@ __metadata:languageName: nodelinkType: hard+"twenty-ui@npm:^1.0.0-alpha.1":+ version: 1.0.0-alpha.1+ resolution: "twenty-ui@npm:1.0.0-alpha.1"+ dependencies:+ "@base-ui/react": "npm:^1.5.0"+ "@monaco-editor/react": "npm:^4.7.0"+ "@radix-ui/colors": "npm:^3.0.0"+ "@sniptt/guards": "npm:^0.2.0"+ "@tabler/icons-react": "npm:^3.31.0"+ clsx: "npm:^2.1.1"+ react-responsive: "npm:^9.0.2"+ react-router-dom: "npm:^6.4.4"+ type-fest: "npm:^4.10.1"+ zod: "npm:^4.1.11"+ peerDependencies:+ monaco-editor: ">= 0.25.0 < 1"+ react: ^19.0.0+ react-dom: ^19.0.0+ checksum: 10c0/213582e582949d6ffe90a7a8ab89a1d4e9dc724d34ed1b80bd7d50e834a8cb8539723556d41b39dc658f76f176bd8490ae0da8a3d6a713e79e6573b732084179+ languageName: node+ linkType: hard++"type-fest@npm:^4.10.1":+ version: 4.41.0+ resolution: "type-fest@npm:4.41.0"+ checksum: 10c0/f5ca697797ed5e88d33ac8f1fec21921839871f808dc59345c9cf67345bfb958ce41bd821165dbf3ae591cedec2bf6fe8882098dfdd8dc54320b859711a2c1e4+ languageName: node+ linkType: hard+"type-fest@npm:^5.4.1":version: 5.6.0resolution: "type-fest@npm:5.6.0"@@ -3436,6 +4218,15 @@ __metadata:languageName: nodelinkType: hard+"use-sync-external-store@npm:^1.6.0":+ version: 1.6.0+ resolution: "use-sync-external-store@npm:1.6.0"+ peerDependencies:+ react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0+ checksum: 10c0/35e1179f872a53227bdf8a827f7911da4c37c0f4091c29b76b1e32473d1670ebe7bcd880b808b7549ba9a5605c233350f800ffab963ee4a4ee346ee983b6019b+ languageName: node+ linkType: hard+"utility-types@npm:^3.10.0":version: 3.11.0resolution: "utility-types@npm:3.11.0"@@ -3717,6 +4508,13 @@ __metadata:languageName: nodelinkType: hard+"yaml@npm:^1.10.0":+ version: 1.10.3+ resolution: "yaml@npm:1.10.3"+ checksum: 10c0/c309ff85a0a569a981d71ab9cf0fef68672a16b9cdf40639d1c3b30034f6cd16ee428602bd6d64ecf006f8c8bee499023cac236538f79898aa99fb5db529a2ed+ languageName: node+ linkType: hard+"yargs-parser@npm:^21.1.1":version: 21.1.1resolution: "yargs-parser@npm:21.1.1"@@ -3762,3 +4560,10 @@ __metadata:checksum: 10c0/71cc2f2bbb537300c3f569e25693d37b3bc91f225cefce251a71c30bc6bb3e7f8e9420ca0eb57f2ac9e492b085b8dfa075fd1e8195c40b83c951dd59c6e4fbf8languageName: nodelinkType: hard++"zod@npm:^4.1.11":+ version: 4.4.3+ resolution: "zod@npm:4.4.3"+ checksum: 10c0/7ea31b558e88f9faf44f31dd185e2e1cbf51fed3081787fb96cc2534749b50c0acfc6da7f0922a7353ed092dd358c7d50c28ea96c94d04af64191bd33152eca3+ languageName: node+ linkType: hard