Skip to content

The open alternative to Salesforce, designed for AI.

Partners app: apply-to-brief flow (#24786)

Rashad Karanouh648d5b126112
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/__tests__/apply-to-brief.test.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/__tests__/apply-to-brief.test.ts
new file mode 100644
index 00000000000..655e8ded391
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/__tests__/apply-to-brief.test.ts
@@ -0,0 +1,278 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { queryMock, mutationMock, metadataQueryMock } = vi.hoisted(() => ({
+ queryMock: vi.fn(),
+ mutationMock: vi.fn(),
+ metadataQueryMock: vi.fn(),
+}));
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: vi.fn(function () {
+ return { query: queryMock, mutation: mutationMock };
+ }),
+}));
+
+vi.mock('twenty-client-sdk/metadata', () => ({
+ MetadataApiClient: vi.fn(function () {
+ return { query: metadataQueryMock };
+ }),
+}));
+
+import { MIN_PITCH_LENGTH } from 'src/modules/application/apply/constants/apply-to-brief.constants';
+import { applyToBrief } from 'src/modules/application/apply/services/apply-to-brief.service';
+
+const USER_ID = 'user-1';
+const WORKSPACE_ID = 'workspace-1';
+const WORKSPACE_MEMBER_ID = 'member-1';
+const PARTNER_ID = 'partner-1';
+const PARTNER_NAME = 'Acme Partners';
+const OPPORTUNITY_ID = 'opportunity-1';
+const AUTHORIZATION = 'Bearer caller-token';
+
+const APP_TOKEN = `header.${Buffer.from(
+ JSON.stringify({ workspaceId: WORKSPACE_ID }),
+).toString('base64url')}.sig`;
+
+type QueryResponses = {
+ workspaceMembers?: unknown;
+ partners?: unknown;
+ opportunities?: unknown;
+ applications?: unknown;
+};
+
+const defaultResponses = (): QueryResponses => ({
+ workspaceMembers: { edges: [{ node: { id: WORKSPACE_MEMBER_ID } }] },
+ partners: { edges: [{ node: { id: PARTNER_ID, name: PARTNER_NAME } }] },
+ opportunities: {
+ edges: [{ node: { id: OPPORTUNITY_ID, name: 'Q3 Renewal', isListed: true } }],
+ },
+ applications: { edges: [] },
+});
+
+const respondWith = (overrides: QueryResponses = {}) => {
+ const responses = { ...defaultResponses(), ...overrides };
+ queryMock.mockImplementation((selection: Record<string, unknown>) => {
+ const key = Object.keys(selection)[0] as keyof QueryResponses;
+ return Promise.resolve({ [key as string]: responses[key] });
+ });
+};
+
+const pitchOf = (length: number) => 'a'.repeat(length);
+
+const event = (body: unknown, authorization: string | null = AUTHORIZATION) => ({
+ body,
+ headers: { authorization: authorization ?? undefined },
+});
+
+const validBody = { opportunityId: OPPORTUNITY_ID, pitch: pitchOf(MIN_PITCH_LENGTH) };
+
+describe('applyToBrief', () => {
+ const originalAppToken = process.env.TWENTY_APP_ACCESS_TOKEN;
+ afterEach(() => {
+ if (originalAppToken === undefined) delete process.env.TWENTY_APP_ACCESS_TOKEN;
+ else process.env.TWENTY_APP_ACCESS_TOKEN = originalAppToken;
+ });
+
+ beforeEach(() => {
+ queryMock.mockReset();
+ mutationMock.mockReset();
+ metadataQueryMock.mockReset();
+ process.env.TWENTY_APP_ACCESS_TOKEN = APP_TOKEN;
+ metadataQueryMock.mockResolvedValue({
+ currentUser: { id: USER_ID, currentWorkspace: { id: WORKSPACE_ID } },
+ });
+ mutationMock.mockResolvedValue({ createApplication: { id: 'application-1' } });
+ respondWith();
+ });
+
+ it('refuses an unauthenticated caller without creating anything', async () => {
+ const result = await applyToBrief(event(validBody, null));
+
+ expect(result).toEqual({ ok: false, reason: 'UNAUTHENTICATED' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a caller with no partner without creating anything', async () => {
+ respondWith({ partners: { edges: [] } });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'NO_PARTNER' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a token minted in another workspace without creating anything', async () => {
+ metadataQueryMock.mockResolvedValue({
+ currentUser: { id: USER_ID, currentWorkspace: { id: 'workspace-other' } },
+ });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'UNAUTHENTICATED' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a brief that is not listed without creating anything', async () => {
+ respondWith({
+ opportunities: {
+ edges: [{ node: { id: OPPORTUNITY_ID, name: 'Q3 Renewal', isListed: false } }],
+ },
+ });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'BRIEF_NOT_OPEN' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a brief that does not exist without creating anything', async () => {
+ respondWith({ opportunities: { edges: [] } });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'BRIEF_NOT_OPEN' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a body without an opportunityId without creating anything', async () => {
+ const result = await applyToBrief(event({ pitch: pitchOf(MIN_PITCH_LENGTH) }));
+
+ expect(result).toEqual({ ok: false, reason: 'BAD_REQUEST' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses a pitch one character below the minimum after trim', async () => {
+ const pitch = ` ${pitchOf(MIN_PITCH_LENGTH - 1)} `;
+
+ const result = await applyToBrief(event({ opportunityId: OPPORTUNITY_ID, pitch }));
+
+ expect(result).toEqual({ ok: false, reason: 'PITCH_TOO_SHORT' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it('refuses an existing application that already carries a pitch', async () => {
+ respondWith({
+ applications: {
+ edges: [
+ { node: { id: 'existing-application', pitch: 'a real pitch', state: 'APPLIED' } },
+ ],
+ },
+ });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'ALREADY_APPLIED' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+
+ it.each([['INTRODUCED'], ['WON'], ['DECLINED']])(
+ 'refuses to fill the pitch of a pitchless row already decided at %s',
+ async (state) => {
+ respondWith({
+ applications: { edges: [{ node: { id: 'decided-application', pitch: null, state } }] },
+ });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: false, reason: 'BRIEF_NOT_OPEN' });
+ expect(mutationMock).not.toHaveBeenCalled();
+ },
+ );
+
+ it.each([['INVITED'], ['APPLIED'], ['BACKUP']])(
+ 'fills the pitch of a pitchless row still in the running at %s',
+ async (state) => {
+ respondWith({
+ applications: { edges: [{ node: { id: 'live-application', pitch: null, state } }] },
+ });
+
+ const result = await applyToBrief(event(validBody));
+
+ expect(result).toEqual({ ok: true, applicationId: 'live-application' });
+ },
+ );
+
+ it.each([
+ ['null', null],
+ ['whitespace only', ' \n '],
+ ])('fills the pitch of an existing row whose pitch is %s', async (_label, pitch) => {
+ respondWith({
+ applications: {
+ edges: [{ node: { id: 'invited-application', pitch, state: 'INVITED' } }],
+ },
+ });
+ const submittedPitch = ` ${pitchOf(MIN_PITCH_LENGTH)} `;
+
+ const result = await applyToBrief(
+ event({ opportunityId: OPPORTUNITY_ID, pitch: submittedPitch }),
+ );
+
+ expect(result).toEqual({ ok: true, applicationId: 'invited-application' });
+ expect(mutationMock).toHaveBeenCalledTimes(1);
+ expect(mutationMock).toHaveBeenCalledWith({
+ updateApplication: {
+ __args: { id: 'invited-application', data: { pitch: submittedPitch.trim() } },
+ id: true,
+ },
+ });
+
+ const data = mutationMock.mock.calls[0][0].updateApplication.__args.data;
+ expect(Object.keys(data)).toEqual(['pitch']);
+ expect(data).not.toHaveProperty('state');
+ });
+
+ it('creates the application once with the five derived fields', async () => {
+ const pitch = ` ${pitchOf(MIN_PITCH_LENGTH + 20)} `;
+
+ const result = await applyToBrief(event({ opportunityId: OPPORTUNITY_ID, pitch }));
+
+ expect(result).toEqual({ ok: true, applicationId: 'application-1' });
+ expect(mutationMock).toHaveBeenCalledTimes(1);
+ expect(mutationMock).toHaveBeenCalledWith({
+ createApplication: {
+ __args: {
+ data: {
+ opportunityId: OPPORTUNITY_ID,
+ partnerId: PARTNER_ID,
+ partnerUserId: WORKSPACE_MEMBER_ID,
+ pitch: pitch.trim(),
+ name: 'Acme Partners · Q3 Renewal',
+ },
+ },
+ id: true,
+ },
+ });
+ });
+
+ it('accepts a pitch of exactly the minimum length', async () => {
+ const result = await applyToBrief(
+ event({ opportunityId: OPPORTUNITY_ID, pitch: pitchOf(MIN_PITCH_LENGTH) }),
+ );
+
+ expect(result).toEqual({ ok: true, applicationId: 'application-1' });
+ expect(mutationMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('never reads partnerId or partnerUserId from the request body', async () => {
+ await applyToBrief(
+ event({
+ ...validBody,
+ partnerId: 'spoofed-partner',
+ partnerUserId: 'spoofed-member',
+ }),
+ );
+
+ expect(mutationMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ createApplication: expect.objectContaining({
+ __args: {
+ data: expect.objectContaining({
+ partnerId: PARTNER_ID,
+ partnerUserId: WORKSPACE_MEMBER_ID,
+ }),
+ },
+ }),
+ }),
+ );
+ });
+});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/apply-to-brief.logic-function.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/apply-to-brief.logic-function.ts
new file mode 100644
index 00000000000..8af65566cc3
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/apply-to-brief.logic-function.ts
@@ -0,0 +1,29 @@
+import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';
+
+import { APPLY_TO_BRIEF_FUNCTION_ID } from 'src/modules/application/apply/constants/apply-to-brief.constants';
+import { applyToBrief } from 'src/modules/application/apply/services/apply-to-brief.service';
+import { type ApplyToBriefResult } from 'src/modules/application/apply/types/apply-to-brief.types';
+
+export const handler = (
+ event: Pick<RoutePayload<unknown>, 'body' | 'headers'>,
+): Promise<ApplyToBriefResult> => applyToBrief(event);
+
+export default defineLogicFunction({
+ universalIdentifier: APPLY_TO_BRIEF_FUNCTION_ID,
+ name: 'apply-to-brief',
+ description: 'Creates an Application for the calling partner on a listed brief.',
+ // Six sequential round trips behind a cold isolate start: a first invocation measured
+ // 47s wall on a local dev server, so 20s killed it before the first query returned.
+ timeoutSeconds: 60,
+ handler,
+ httpRouteTriggerSettings: {
+ path: '/apply-to-brief',
+ httpMethod: 'POST',
+ // isAuthRequired would make the server mint a token carrying the caller's user claims,
+ // and the executor intersects the caller's role with the app role — the Partner role
+ // denies Application writes, so the create would be refused. The function verifies the
+ // forwarded header itself instead, and keeps an app-only token for the write.
+ isAuthRequired: false,
+ forwardedRequestHeaders: ['authorization'],
+ },
+});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/command-menu-items/apply-to-brief.command-menu-item.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/command-menu-items/apply-to-brief.command-menu-item.ts
new file mode 100644
index 00000000000..dca5db6e308
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/command-menu-items/apply-to-brief.command-menu-item.ts
@@ -0,0 +1,18 @@
+import { STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS, defineCommandMenuItem } from 'twenty-sdk/define';
+
+import {
+ APPLY_TO_BRIEF_COMMAND_MENU_ITEM_ID,
+ APPLY_TO_BRIEF_FRONT_COMPONENT_ID,
+} from 'src/modules/application/apply/constants/apply-to-brief.constants';
+
+export default defineCommandMenuItem({
+ universalIdentifier: APPLY_TO_BRIEF_COMMAND_MENU_ITEM_ID,
+ label: 'Apply to this brief',
+ shortLabel: 'Apply to this opportunity',
+ icon: 'IconSend',
+ isPinned: true,
+ availabilityType: 'RECORD_SELECTION',
+ availabilityObjectUniversalIdentifier:
+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.opportunity.universalIdentifier,
+ frontComponentUniversalIdentifier: APPLY_TO_BRIEF_FRONT_COMPONENT_ID,
+});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/constants/apply-to-brief.constants.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/constants/apply-to-brief.constants.ts
new file mode 100644
index 00000000000..fd7a68ec7d1
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/constants/apply-to-brief.constants.ts
@@ -0,0 +1,9 @@
+export const APPLY_TO_BRIEF_FRONT_COMPONENT_ID = '54f96b09-3c98-4d3c-815a-3f95a2e42527';
+export const APPLY_TO_BRIEF_FUNCTION_ID = '38fb146a-abe0-495f-8e20-1ebe99a9926a';
+export const APPLY_TO_BRIEF_COMMAND_MENU_ITEM_ID = 'e4668652-9212-4794-ab07-3514c1d0d829';
+export const MIN_PITCH_LENGTH = 100;
+
+// The states an existing row may still receive a pitch in. BACKUP belongs here: it is a
+// standing shortlist set before the introduction, which is why the outcome cascade also
+// leaves it alone. INTRODUCED, WON and DECLINED are decided.
+export const PITCHABLE_STATES = ['APPLIED', 'INVITED', 'BACKUP'] as const;
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief.front-component.tsx b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief.front-component.tsx
new file mode 100644
index 00000000000..f334ca069aa
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief.front-component.tsx
@@ -0,0 +1,161 @@
+import { useCallback, useState, type CSSProperties } from 'react';
+import { defineFrontComponent } from 'twenty-sdk/define';
+import {
+ enqueueSnackbar,
+ openSidePanelPage,
+ SidePanelPages,
+ useFrontComponentExecutionContext,
+ type FrontComponentExecutionContext,
+} from 'twenty-sdk/front-component';
+
+import {
+ APPLY_TO_BRIEF_FRONT_COMPONENT_ID,
+ MIN_PITCH_LENGTH,
+} from 'src/modules/application/apply/constants/apply-to-brief.constants';
+import {
+ GENERIC_APPLY_FAILURE_MESSAGE,
+ getRefusalMessage,
+} from 'src/modules/application/apply/front-components/apply-to-brief/refusal-message';
+import { type ApplyToBriefResult } from 'src/modules/application/apply/types/apply-to-brief.types';
+import { callAppRoute } from 'src/modules/shared/front-components/call-app-route';
+import { COLORS, FONT } from 'src/modules/shared/front-components/palette';
+
+const pageStyle: CSSProperties = {
+ fontFamily: FONT,
+ color: COLORS.fg,
+ maxWidth: '100%',
+ padding: '20px 24px',
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 12,
+};
+const titleStyle: CSSProperties = { fontSize: 16, fontWeight: 700, margin: 0 };
+const labelStyle: CSSProperties = { fontSize: 12.5, color: COLORS.muted, lineHeight: 1.5 };
+const textareaStyle: CSSProperties = {
+ width: '100%',
+ boxSizing: 'border-box',
+ minHeight: 180,
+ padding: 12,
+ borderRadius: 8,
+ border: `1px solid ${COLORS.border}`,
+ background: COLORS.surface,
+ color: COLORS.fg,
+ fontSize: 14,
+ fontFamily: FONT,
+ lineHeight: 1.5,
+ outline: 'none',
+ resize: 'vertical',
+};
+const counterStyle: CSSProperties = { fontSize: 12, color: COLORS.muted };
+const errorStyle: CSSProperties = { fontSize: 13, color: COLORS.danger };
+const footerStyle: CSSProperties = { display: 'flex', justifyContent: 'flex-end' };
+const buttonStyle: CSSProperties = {
+ height: 36,
+ padding: '0 18px',
+ borderRadius: 8,
+ border: 'none',
+ background: COLORS.accent,
+ color: '#fff',
+ fontSize: 13.5,
+ fontWeight: 650,
+ fontFamily: FONT,
+ cursor: 'pointer',
+};
+const disabledButtonStyle: CSSProperties = {
+ ...buttonStyle,
+ opacity: 0.5,
+ cursor: 'not-allowed',
+};
+
+// `recordId` is deprecated and only covers a renderer that sends no selection.
+const selectBriefId = (context: FrontComponentExecutionContext): string | null =>
+ context.selectedRecordIds[0] ?? context.recordId;
+
+const ApplyToBrief = () => {
+ const briefId = useFrontComponentExecutionContext(selectBriefId);
+ const [pitch, setPitch] = useState('');
+ const [isSubmitting, setIsSubmitting] = useState(false);
+ const [errorMessage, setErrorMessage] = useState<string | null>(null);
+
+ const pitchLength = pitch.trim().length;
+ const isPitchLongEnough = pitchLength >= MIN_PITCH_LENGTH;
+
+ const apply = useCallback(async () => {
+ if (!briefId) return;
+ setIsSubmitting(true);
+ setErrorMessage(null);
+ try {
+ const result = (await callAppRoute('/apply-to-brief', {
+ opportunityId: briefId,
+ pitch,
+ })) as ApplyToBriefResult;
+
+ if (result.ok) {
+ await enqueueSnackbar({ message: 'Application sent', variant: 'success' });
+ await openSidePanelPage({
+ page: SidePanelPages.ViewRecord,
+ recordId: result.applicationId,
+ objectNameSingular: 'application',
+ resetNavigationStack: true,
+ });
+ } else {
+ setErrorMessage(getRefusalMessage(result.reason));
+ }
+ } catch {
+ setErrorMessage(GENERIC_APPLY_FAILURE_MESSAGE);
+ } finally {
+ setIsSubmitting(false);
+ }
+ }, [briefId, pitch]);
+
+ if (!briefId) {
+ return <div style={pageStyle}>Open a brief to apply.</div>;
+ }
+
+ return (
+ <div style={pageStyle}>
+ <h1 style={titleStyle}>Apply to this brief</h1>
+
+ <label htmlFor="apply-pitch" style={labelStyle}>
+ Tell the client why your team fits this brief. Twenty introduces up to 2 partners
+ per brief, so an application is not a guarantee of an introduction.
+ </label>
+
+ <textarea
+ id="apply-pitch"
+ style={textareaStyle}
+ value={pitch}
+ onChange={(event) => setPitch(event.target.value)}
+ placeholder="Describe the relevant work you have done…"
+ disabled={isSubmitting}
+ />
+
+ <div style={counterStyle}>
+ {pitchLength} / {MIN_PITCH_LENGTH} characters minimum
+ </div>
+
+ {errorMessage && (
+ <div role="alert" style={errorStyle}>
+ {errorMessage}
+ </div>
+ )}
+
+ <div style={footerStyle}>
+ <button
+ style={isPitchLongEnough && !isSubmitting ? buttonStyle : disabledButtonStyle}
+ onClick={() => void apply()}
+ disabled={!isPitchLongEnough || isSubmitting}
+ >
+ {isSubmitting ? 'Sending…' : 'Send application'}
+ </button>
+ </div>
+ </div>
+ );
+};
+
+export default defineFrontComponent({
+ universalIdentifier: APPLY_TO_BRIEF_FRONT_COMPONENT_ID,
+ name: 'Apply to Brief',
+ description: 'Side panel for a partner to pitch on an open brief.',
+ component: ApplyToBrief,
+});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.test.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.test.ts
new file mode 100644
index 00000000000..e6c107861d5
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+
+import { GENERIC_APPLY_FAILURE_MESSAGE, getRefusalMessage } from './refusal-message';
+
+describe('getRefusalMessage', () => {
+ it('maps every known reason to its own plain sentence', () => {
+ expect(getRefusalMessage('UNAUTHENTICATED')).toBe('Sign in again to apply.');
+ expect(getRefusalMessage('NO_PARTNER')).toBe(
+ 'This account is not linked to a partner.',
+ );
+ expect(getRefusalMessage('BAD_REQUEST')).toBe('Reopen this brief and try again.');
+ expect(getRefusalMessage('BRIEF_NOT_OPEN')).toBe(
+ 'This brief is no longer open for applications.',
+ );
+ expect(getRefusalMessage('PITCH_TOO_SHORT')).toBe(
+ 'Add a little more detail before you apply.',
+ );
+ expect(getRefusalMessage('ALREADY_APPLIED')).toBe(
+ 'You have already applied to this brief.',
+ );
+ });
+
+ it('falls back to the generic sentence for an unknown reason', () => {
+ expect(getRefusalMessage('SOMETHING_NEW')).toBe(GENERIC_APPLY_FAILURE_MESSAGE);
+ expect(getRefusalMessage('')).toBe(GENERIC_APPLY_FAILURE_MESSAGE);
+ });
+});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.ts
new file mode 100644
index 00000000000..19ca012f359
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/front-components/apply-to-brief/refusal-message.ts
@@ -0,0 +1,19 @@
+import { type ApplyRefusalReason } from 'src/modules/application/apply/types/apply-to-brief.types';
+
+export const GENERIC_APPLY_FAILURE_MESSAGE = 'Could not send your application. Try again.';
+
+const REFUSAL_MESSAGES: Record<ApplyRefusalReason, string> = {
+ UNAUTHENTICATED: 'Sign in again to apply.',
+ NO_PARTNER: 'This account is not linked to a partner.',
+ BAD_REQUEST: 'Reopen this brief and try again.',
+ BRIEF_NOT_OPEN: 'This brief is no longer open for applications.',
+ PITCH_TOO_SHORT: 'Add a little more detail before you apply.',
+ ALREADY_APPLIED: 'You have already applied to this brief.',
+};
+
+const isApplyRefusalReason = (reason: string): reason is ApplyRefusalReason =>
+ reason in REFUSAL_MESSAGES;
+
+// The route may add a reason the front component does not know yet, so never index blindly.
+export const getRefusalMessage = (reason: string): string =>
+ isApplyRefusalReason(reason) ? REFUSAL_MESSAGES[reason] : GENERIC_APPLY_FAILURE_MESSAGE;
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/mutations/create-application.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/mutations/create-application.ts
new file mode 100644
index 00000000000..409bef9f070
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/mutations/create-application.ts
@@ -0,0 +1,10 @@
+import { type CoreApiClient, type CoreSchema } from 'twenty-client-sdk/core';
+
+export function createApplication(
+ client: CoreApiClient,
+ data: CoreSchema.ApplicationCreateInput,
+) {
+ return client.mutation({
+ createApplication: { __args: { data }, id: true },
+ });
+}
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/queries/find-opportunity-for-apply.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/queries/find-opportunity-for-apply.ts
new file mode 100644
index 00000000000..6360eadf4fe
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/graphql/queries/find-opportunity-for-apply.ts
@@ -0,0 +1,12 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+// List form on purpose: the single-record read throws `Record not found` for an unknown id,
+// which would hide a missing brief behind the generic failure message.
+export function findOpportunityForApply(client: CoreApiClient, opportunityId: string) {
+ return client.query({
+ opportunities: {
+ __args: { filter: { id: { eq: opportunityId } }, first: 1 },
+ edges: { node: { id: true, name: true, isListed: true } },
+ },
+ });
+}
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/services/apply-to-brief.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/services/apply-to-brief.service.ts
new file mode 100644
index 00000000000..5eb0b525fa6
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/services/apply-to-brief.service.ts
@@ -0,0 +1,84 @@
+import { type RoutePayload } from 'twenty-sdk/define';
+import { z } from 'zod';
+
+import {
+ MIN_PITCH_LENGTH,
+ PITCHABLE_STATES,
+} from 'src/modules/application/apply/constants/apply-to-brief.constants';
+import { createApplication } from 'src/modules/application/apply/graphql/mutations/create-application';
+import { findOpportunityForApply } from 'src/modules/application/apply/graphql/queries/find-opportunity-for-apply';
+import { type ApplyToBriefResult } from 'src/modules/application/apply/types/apply-to-brief.types';
+import { updateApplication } from 'src/modules/application/graphql/mutations/update-application';
+import { findDuplicateApplication } from 'src/modules/application/graphql/queries/find-duplicate-application';
+import { buildApplicationName } from 'src/modules/application/utils/build-application-name';
+import {
+ buildAppClient,
+ errorResponse,
+ failureResponse,
+ resolvePartnerFromForwardedToken,
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
+import { isNonEmptyString } from 'src/modules/shared/utils/is-non-empty-string.util';
+
+const applyToBriefSchema = z.object({
+ opportunityId: z.string().min(1),
+ pitch: z.string(),
+});
+
+export const applyToBrief = async (
+ event: Pick<RoutePayload<unknown>, 'body' | 'headers'>,
+): Promise<ApplyToBriefResult> => {
+ const resolved = await resolvePartnerFromForwardedToken(event);
+ if ('error' in resolved) return errorResponse(resolved.error);
+
+ const parsed = applyToBriefSchema.safeParse(event.body);
+ if (!parsed.success) return errorResponse('BAD_REQUEST');
+
+ const { opportunityId, pitch } = parsed.data;
+
+ try {
+ const client = buildAppClient();
+
+ const briefs = await findOpportunityForApply(client, opportunityId);
+ const brief = briefs.opportunities?.edges?.[0]?.node;
+ if (!brief || brief.isListed !== true) return errorResponse('BRIEF_NOT_OPEN');
+
+ const trimmedPitch = pitch.trim();
+ if (trimmedPitch.length < MIN_PITCH_LENGTH) return errorResponse('PITCH_TOO_SHORT');
+
+ const duplicates = await findDuplicateApplication(client, opportunityId, resolved.partnerId);
+ const existing = duplicates.applications?.edges?.[0]?.node;
+ if (existing?.id) {
+ if (isNonEmptyString(existing.pitch)) return errorResponse('ALREADY_APPLIED');
+
+ // Fill the pitch in place and leave the state alone — an INVITED row records that
+ // Twenty pushed this brief at the partner. Guard on the state rather than on the
+ // brief being listed: the WON/DECLINED cascade fires on Opportunity.partner, which
+ // is not coupled to isListed, so a decided row can still sit under a listed brief.
+ if (!PITCHABLE_STATES.some((state) => state === existing.state)) {
+ return errorResponse('BRIEF_NOT_OPEN');
+ }
+
+ await updateApplication(client, existing.id, { pitch: trimmedPitch });
+ return { ok: true, applicationId: existing.id };
+ }
+
+ // on-application-set-name fires on application.updated only, so an insert that already
+ // carries partnerId never triggers it — the label must be written here.
+ const created = await createApplication(client, {
+ opportunityId,
+ partnerId: resolved.partnerId,
+ partnerUserId: resolved.workspaceMemberId,
+ pitch: trimmedPitch,
+ name: buildApplicationName(resolved.partnerName, brief.name),
+ });
+
+ const applicationId = created.createApplication?.id;
+ if (!isNonEmptyString(applicationId)) {
+ return failureResponse('apply-to-brief', new Error('createApplication returned no id'));
+ }
+
+ return { ok: true, applicationId };
+ } catch (err) {
+ return failureResponse('apply-to-brief', err);
+ }
+};
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/types/apply-to-brief.types.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/types/apply-to-brief.types.ts
new file mode 100644
index 00000000000..3aa01dbbdf0
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/application/apply/types/apply-to-brief.types.ts
@@ -0,0 +1,12 @@
+export type ApplyRefusalReason =
+ | 'UNAUTHENTICATED'
+ | 'NO_PARTNER'
+ | 'BAD_REQUEST'
+ | 'BRIEF_NOT_OPEN'
+ | 'PITCH_TOO_SHORT'
+ | 'ALREADY_APPLIED';
+
+// `reason` widens to string because failureResponse answers with a sentence, not a code.
+export type ApplyToBriefResult =
+ | { ok: true; applicationId: string }
+ | { ok: false; reason: ApplyRefusalReason | string };
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/get-my-partner-profile.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/get-my-partner-profile.service.ts
index 522838646f4..57d8a978bf3 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/get-my-partner-profile.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/get-my-partner-profile.service.ts
@@ -11,7 +11,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
export type MyPartnerProfileResult =
| { ok: true; profile: MyProfilePayload; options: ProfileOptions }
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.test.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.test.ts
deleted file mode 100644
index ce10943de89..00000000000
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.test.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-
-import {
- decodeJwtClaims,
- errorResponse,
- resolvePartnerFromRequest,
-} from './resolve-partner-from-request.service';
-
-const makeToken = (payload: Record<string, unknown>): string => {
- const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
- return `header.${body}.sig`;
-};
-
-describe('decodeJwtClaims', () => {
- it('decodes userId and userWorkspaceId from a base64url payload', () => {
- const token = makeToken({ userId: 'u-1', userWorkspaceId: 'uw-1', extra: 'x' });
- expect(decodeJwtClaims(token)).toMatchObject({ userId: 'u-1', userWorkspaceId: 'uw-1' });
- });
-
- it('returns {} for a garbage string', () => {
- expect(decodeJwtClaims('not-a-jwt')).toEqual({});
- });
-
- it('returns {} for an empty string', () => {
- expect(decodeJwtClaims('')).toEqual({});
- });
-
- it('returns {} when the payload segment is not valid JSON', () => {
- expect(decodeJwtClaims('header.%%%.sig')).toEqual({});
- });
-
- it('returns {} when the payload decodes to a non-object (null)', () => {
- const token = `header.${Buffer.from('null').toString('base64url')}.sig`;
- expect(decodeJwtClaims(token)).toEqual({});
- });
-});
-
-describe('resolvePartnerFromRequest guards (no network)', () => {
- const original = process.env.TWENTY_APP_ACCESS_TOKEN;
- afterEach(() => {
- if (original === undefined) delete process.env.TWENTY_APP_ACCESS_TOKEN;
- else process.env.TWENTY_APP_ACCESS_TOKEN = original;
- });
-
- it('returns UNAUTHENTICATED when userWorkspaceId is absent', async () => {
- expect(await resolvePartnerFromRequest({})).toEqual({ error: 'UNAUTHENTICATED' });
- expect(await resolvePartnerFromRequest({ userWorkspaceId: null })).toEqual({
- error: 'UNAUTHENTICATED',
- });
- });
-
- it('returns UNAUTHENTICATED when no app token is present to decode', async () => {
- delete process.env.TWENTY_APP_ACCESS_TOKEN;
- expect(await resolvePartnerFromRequest({ userWorkspaceId: 'uw-1' })).toEqual({
- error: 'UNAUTHENTICATED',
- });
- });
-
- it('returns UNAUTHENTICATED when the token userWorkspaceId does not match the injected one', async () => {
- process.env.TWENTY_APP_ACCESS_TOKEN = makeToken({
- userId: 'u-1',
- userWorkspaceId: 'uw-other',
- });
- expect(await resolvePartnerFromRequest({ userWorkspaceId: 'uw-1' })).toEqual({
- error: 'UNAUTHENTICATED',
- });
- });
-});
-
-describe('errorResponse', () => {
- it('wraps a reason in a failure envelope', () => {
- expect(errorResponse('NO_PARTNER')).toEqual({ ok: false, reason: 'NO_PARTNER' });
- });
-});
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-content.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-content.service.ts
index 9c7b4984748..7d732553ade 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-content.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-content.service.ts
@@ -17,7 +17,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
import { buildReconcilePlan } from 'src/modules/partner/self-service/utils/reconcile-children';
import { isCaseStudy } from 'src/modules/partner/utils/content-type';
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-links.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-links.service.ts
index 164258619d5..b590a0ff651 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-links.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-links.service.ts
@@ -15,7 +15,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
import { buildReconcilePlan } from 'src/modules/partner/self-service/utils/reconcile-children';
export type SaveLinksResult = { ok: true; links: LinkRow[] } | { ok: false; reason: string };
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-profile.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-profile.service.ts
index ee6d95ebf8c..49c242bf784 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-profile.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-profile.service.ts
@@ -11,7 +11,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
export type SaveResult = { ok: true } | { ok: false; reason: string };
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-services.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-services.service.ts
index d5991567994..4c70bf12e63 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-services.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/save-my-partner-services.service.ts
@@ -15,7 +15,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
import { buildReconcilePlan } from 'src/modules/partner/self-service/utils/reconcile-children';
export type SaveServicesResult =
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/submit-partner-content-for-review.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/submit-partner-content-for-review.service.ts
index 9146368404e..534d6ef6b2d 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/submit-partner-content-for-review.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/submit-partner-content-for-review.service.ts
@@ -12,7 +12,7 @@ import {
errorResponse,
failureResponse,
resolvePartnerFromRequest,
-} from 'src/modules/partner/self-service/services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
export type SubmitContentForReviewResult =
| { ok: true; status: 'UNDER_CUSTOMER_PARTNER_REVIEW' }
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/__tests__/resolve-partner-from-request.integration-test.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.integration-test.ts
similarity index 82%
rename from packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/__tests__/resolve-partner-from-request.integration-test.ts
rename to packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.integration-test.ts
index 76d4d927a81..e9bb6f8ee42 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/__tests__/resolve-partner-from-request.integration-test.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.integration-test.ts
@@ -5,7 +5,7 @@ import {
decodeJwtClaims,
resolvePartnerByUserId,
resolvePartnerFromRequest,
-} from '../services/resolve-partner-from-request.service';
+} from 'src/modules/shared/http/resolve-partner-from-request.service';
function requireId(id: string | null | undefined, what: string): string {
if (!id) throw new Error(`${what} returned no id`);
@@ -28,12 +28,16 @@ async function getWorkspaceMember(
return { id: node.id, userId: node.userId };
}
-async function createPartner(client: CoreApiClient, memberId: string): Promise<string> {
+async function createPartner(
+ client: CoreApiClient,
+ memberId: string,
+): Promise<{ id: string; name: string }> {
+ const name = `[test-resolve] partner ${Date.now()}`;
const r = await client.mutation({
createPartner: {
__args: {
data: {
- name: `[test-resolve] partner ${Date.now()}`,
+ name,
slug: `test-resolve-${Date.now()}`,
partnerUserId: memberId,
},
@@ -41,7 +45,7 @@ async function createPartner(client: CoreApiClient, memberId: string): Promise<s
id: true,
},
});
- return requireId(r.createPartner?.id, 'createPartner');
+ return { id: requireId(r.createPartner?.id, 'createPartner'), name };
}
async function destroyPartner(client: CoreApiClient, id: string) {
@@ -78,12 +82,16 @@ describe('resolvePartnerByUserId', () => {
it('resolves partnerId and workspaceMemberId for a member with a linked partner', async () => {
const member = await getWorkspaceMember(client);
- const partnerId = await createPartner(client, member.id);
- createdPartnerIds.push(partnerId);
+ const partner = await createPartner(client, member.id);
+ createdPartnerIds.push(partner.id);
const result = await resolvePartnerByUserId(client, member.userId);
- expect(result).toEqual({ partnerId, workspaceMemberId: member.id });
+ expect(result).toEqual({
+ partnerId: partner.id,
+ partnerName: partner.name,
+ workspaceMemberId: member.id,
+ });
});
it('returns null for a userId with no matching workspace member', async () => {
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.service.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.service.ts
similarity index 56%
rename from packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.service.ts
rename to packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.service.ts
index 16f1550bb67..3b8c8cea1ed 100644
--- a/packages/twenty-apps/internal/twenty-partners/src/modules/partner/self-service/services/resolve-partner-from-request.service.ts
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.service.ts
@@ -1,4 +1,5 @@
import { CoreApiClient } from 'twenty-client-sdk/core';
+import { MetadataApiClient } from 'twenty-client-sdk/metadata';
import { findPartnerByMember } from 'src/modules/shared/graphql/queries/find-partner-by-member';
@@ -16,7 +17,7 @@ export const buildAppClient = (): CoreApiClient => {
export const decodeJwtClaims = (
token: string,
-): { userId?: string; userWorkspaceId?: string } => {
+): { userId?: string; userWorkspaceId?: string; workspaceId?: string } => {
const part = token.split('.')[1];
if (!part) return {};
try {
@@ -34,10 +35,16 @@ export const decodeJwtClaims = (
}
};
+export type PartnerIdentity = {
+ partnerId: string;
+ partnerName: string | null;
+ workspaceMemberId: string;
+};
+
export const resolvePartnerByUserId = async (
client: CoreApiClient,
userId: string,
-): Promise<{ partnerId: string; workspaceMemberId: string } | null> => {
+): Promise<PartnerIdentity | null> => {
const members = await client.query({
workspaceMembers: {
__args: { filter: { userId: { eq: userId } }, first: 1 },
@@ -48,14 +55,18 @@ export const resolvePartnerByUserId = async (
if (!workspaceMemberId) return null;
const partners = await findPartnerByMember(client, workspaceMemberId);
- const partnerId = partners.partners?.edges?.[0]?.node?.id;
- if (!partnerId) return null;
+ const partner = partners.partners?.edges?.[0]?.node;
+ if (!partner?.id) return null;
- return { partnerId, workspaceMemberId };
+ return {
+ partnerId: partner.id,
+ partnerName: partner.name ?? null,
+ workspaceMemberId,
+ };
};
export type ResolvedPartner =
- | { partnerId: string; workspaceMemberId: string }
+ | PartnerIdentity
| { error: 'UNAUTHENTICATED' | 'NO_PARTNER' };
export const resolvePartnerFromRequest = async (event: {
@@ -74,6 +85,45 @@ export const resolvePartnerFromRequest = async (event: {
return resolved ?? { error: 'NO_PARTNER' };
};
+// Two identity paths on purpose. resolvePartnerFromRequest serves routes that act AS the
+// partner, where intersecting the caller's role with the app role is the correct behaviour.
+// This one serves a route that acts ON BEHALF OF the partner under app authority, so it
+// verifies the forwarded header itself and leaves the function's own token app-only.
+export const resolvePartnerFromForwardedToken = async (event: {
+ headers?: Record<string, string | undefined>;
+}): Promise<ResolvedPartner> => {
+ const authorization = event.headers?.authorization;
+ if (!authorization?.startsWith('Bearer ')) return { error: 'UNAUTHENTICATED' };
+
+ let userId: string | undefined;
+ let callerWorkspaceId: string | undefined;
+ try {
+ // Verification is the round trip itself: the server checks the signature, so the ids it
+ // returns are trustworthy in a way a decoded claim never is.
+ const current = await new MetadataApiClient({
+ headers: { Authorization: authorization },
+ }).query({ currentUser: { id: true, currentWorkspace: { id: true } } });
+ userId = current.currentUser?.id;
+ callerWorkspaceId = current.currentUser?.currentWorkspace?.id;
+ } catch {
+ return { error: 'UNAUTHENTICATED' };
+ }
+ if (!userId) return { error: 'UNAUTHENTICATED' };
+
+ // currentUser answers for whatever workspace the presented token belongs to, and the route
+ // is open (isAuthRequired: false) with a caller-supplied header — so a token minted in any
+ // other workspace on the server would otherwise pass. Assert the audience here.
+ const appWorkspaceId = decodeJwtClaims(
+ process.env.TWENTY_APP_ACCESS_TOKEN ?? '',
+ ).workspaceId;
+ if (!appWorkspaceId || callerWorkspaceId !== appWorkspaceId) {
+ return { error: 'UNAUTHENTICATED' };
+ }
+
+ const resolved = await resolvePartnerByUserId(buildAppClient(), userId);
+ return resolved ?? { error: 'NO_PARTNER' };
+};
+
export type PartnerRouteError = { ok: false; reason: string };
export const errorResponse = (reason: string): PartnerRouteError => ({
diff --git a/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.test.ts b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.test.ts
new file mode 100644
index 00000000000..8093ce3a00e
--- /dev/null
+++ b/packages/twenty-apps/internal/twenty-partners/src/modules/shared/http/resolve-partner-from-request.test.ts
@@ -0,0 +1,200 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { coreQueryMock, metadataQueryMock } = vi.hoisted(() => ({
+ coreQueryMock: vi.fn(),
+ metadataQueryMock: vi.fn(),
+}));
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: vi.fn(function () {
+ return { query: coreQueryMock, mutation: vi.fn() };
+ }),
+}));
+
+vi.mock('twenty-client-sdk/metadata', () => ({
+ MetadataApiClient: vi.fn(function () {
+ return { query: metadataQueryMock };
+ }),
+}));
+
+import { MetadataApiClient } from 'twenty-client-sdk/metadata';
+
+import {
+ decodeJwtClaims,
+ errorResponse,
+ resolvePartnerFromForwardedToken,
+ resolvePartnerFromRequest,
+} from './resolve-partner-from-request.service';
+
+const makeToken = (payload: Record<string, unknown>): string => {
+ const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
+ return `header.${body}.sig`;
+};
+
+describe('decodeJwtClaims', () => {
+ it('decodes userId and userWorkspaceId from a base64url payload', () => {
+ const token = makeToken({ userId: 'u-1', userWorkspaceId: 'uw-1', extra: 'x' });
+ expect(decodeJwtClaims(token)).toMatchObject({ userId: 'u-1', userWorkspaceId: 'uw-1' });
+ });
+
+ it('returns {} for a garbage string', () => {
+ expect(decodeJwtClaims('not-a-jwt')).toEqual({});
+ });
+
+ it('returns {} for an empty string', () => {
+ expect(decodeJwtClaims('')).toEqual({});
+ });
+
+ it('returns {} when the payload segment is not valid JSON', () => {
+ expect(decodeJwtClaims('header.%%%.sig')).toEqual({});
+ });
+
+ it('returns {} when the payload decodes to a non-object (null)', () => {
+ const token = `header.${Buffer.from('null').toString('base64url')}.sig`;
+ expect(decodeJwtClaims(token)).toEqual({});
+ });
+});
+
+describe('resolvePartnerFromRequest guards (no network)', () => {
+ const original = process.env.TWENTY_APP_ACCESS_TOKEN;
+ afterEach(() => {
+ if (original === undefined) delete process.env.TWENTY_APP_ACCESS_TOKEN;
+ else process.env.TWENTY_APP_ACCESS_TOKEN = original;
+ });
+
+ it('returns UNAUTHENTICATED when userWorkspaceId is absent', async () => {
+ expect(await resolvePartnerFromRequest({})).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(await resolvePartnerFromRequest({ userWorkspaceId: null })).toEqual({
+ error: 'UNAUTHENTICATED',
+ });
+ });
+
+ it('returns UNAUTHENTICATED when no app token is present to decode', async () => {
+ delete process.env.TWENTY_APP_ACCESS_TOKEN;
+ expect(await resolvePartnerFromRequest({ userWorkspaceId: 'uw-1' })).toEqual({
+ error: 'UNAUTHENTICATED',
+ });
+ });
+
+ it('returns UNAUTHENTICATED when the token userWorkspaceId does not match the injected one', async () => {
+ process.env.TWENTY_APP_ACCESS_TOKEN = makeToken({
+ userId: 'u-1',
+ userWorkspaceId: 'uw-other',
+ });
+ expect(await resolvePartnerFromRequest({ userWorkspaceId: 'uw-1' })).toEqual({
+ error: 'UNAUTHENTICATED',
+ });
+ });
+});
+
+describe('errorResponse', () => {
+ it('wraps a reason in a failure envelope', () => {
+ expect(errorResponse('NO_PARTNER')).toEqual({ ok: false, reason: 'NO_PARTNER' });
+ });
+});
+
+describe('resolvePartnerFromForwardedToken', () => {
+ const USER_ID = 'user-1';
+ const WORKSPACE_MEMBER_ID = 'member-1';
+ const PARTNER_ID = 'partner-1';
+ const PARTNER_NAME = 'Acme Partners';
+ const WORKSPACE_ID = 'workspace-1';
+ const AUTHORIZATION = 'Bearer forwarded-token';
+
+ const originalAppToken = process.env.TWENTY_APP_ACCESS_TOKEN;
+ afterEach(() => {
+ if (originalAppToken === undefined) delete process.env.TWENTY_APP_ACCESS_TOKEN;
+ else process.env.TWENTY_APP_ACCESS_TOKEN = originalAppToken;
+ });
+
+ beforeEach(() => {
+ coreQueryMock.mockReset();
+ metadataQueryMock.mockReset();
+ process.env.TWENTY_APP_ACCESS_TOKEN = makeToken({ workspaceId: WORKSPACE_ID });
+ metadataQueryMock.mockResolvedValue({
+ currentUser: { id: USER_ID, currentWorkspace: { id: WORKSPACE_ID } },
+ });
+ coreQueryMock.mockImplementation((selection: Record<string, unknown>) => {
+ const key = Object.keys(selection)[0];
+ if (key === 'workspaceMembers') {
+ return Promise.resolve({
+ workspaceMembers: { edges: [{ node: { id: WORKSPACE_MEMBER_ID } }] },
+ });
+ }
+ return Promise.resolve({
+ partners: { edges: [{ node: { id: PARTNER_ID, name: PARTNER_NAME } }] },
+ });
+ });
+ });
+
+ it('returns UNAUTHENTICATED when there is no authorization header', async () => {
+ expect(await resolvePartnerFromForwardedToken({})).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(await resolvePartnerFromForwardedToken({ headers: {} })).toEqual({
+ error: 'UNAUTHENTICATED',
+ });
+ expect(metadataQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('returns UNAUTHENTICATED when the header has no Bearer prefix', async () => {
+ expect(
+ await resolvePartnerFromForwardedToken({ headers: { authorization: 'forwarded-token' } }),
+ ).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(metadataQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('returns UNAUTHENTICATED when the server rejects the forwarded token', async () => {
+ metadataQueryMock.mockRejectedValue(new Error('Unauthorized'));
+
+ expect(
+ await resolvePartnerFromForwardedToken({ headers: { authorization: AUTHORIZATION } }),
+ ).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(coreQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('returns UNAUTHENTICATED when currentUser carries no id', async () => {
+ metadataQueryMock.mockResolvedValue({ currentUser: null });
+
+ expect(
+ await resolvePartnerFromForwardedToken({ headers: { authorization: AUTHORIZATION } }),
+ ).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(coreQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('returns UNAUTHENTICATED when the token belongs to another workspace', async () => {
+ metadataQueryMock.mockResolvedValue({
+ currentUser: { id: USER_ID, currentWorkspace: { id: 'workspace-other' } },
+ });
+
+ expect(
+ await resolvePartnerFromForwardedToken({ headers: { authorization: AUTHORIZATION } }),
+ ).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(coreQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('returns UNAUTHENTICATED when the app token carries no workspace to compare against', async () => {
+ delete process.env.TWENTY_APP_ACCESS_TOKEN;
+
+ expect(
+ await resolvePartnerFromForwardedToken({ headers: { authorization: AUTHORIZATION } }),
+ ).toEqual({ error: 'UNAUTHENTICATED' });
+ expect(coreQueryMock).not.toHaveBeenCalled();
+ });
+
+ it('resolves the partner by verifying the token against currentUser', async () => {
+ const result = await resolvePartnerFromForwardedToken({
+ headers: { authorization: AUTHORIZATION },
+ });
+
+ expect(result).toEqual({
+ partnerId: PARTNER_ID,
+ partnerName: PARTNER_NAME,
+ workspaceMemberId: WORKSPACE_MEMBER_ID,
+ });
+ expect(metadataQueryMock).toHaveBeenCalledWith({
+ currentUser: { id: true, currentWorkspace: { id: true } },
+ });
+ expect(MetadataApiClient).toHaveBeenCalledWith({
+ headers: { Authorization: AUTHORIZATION },
+ });
+ });
+});