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

packages/twenty-server/test/integration/route-trigger/suites/__snapshots__/route-trigger-suspended-workspace.integration-spec.ts.snap

@@ -0,0 +1,15 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`RouteTrigger suspended workspace (integration) GET /s/suspended-workspace-route rejects the route trigger with 403 once the workspace is suspended 1`] = `
+{
+  "body": {
+    "code": "WORKSPACE_SUSPENDED",
+    "error": "Error",
+    "messages": [
+      "Workspace is suspended",
+    ],
+    "statusCode": 403,
+  },
+  "status": 403,
+}
+`;

packages/twenty-server/test/integration/route-trigger/suites/route-trigger-suspended-workspace.integration-spec.ts

@@ -0,0 +1,247 @@
+import request from 'supertest';
+import { findManyApplications } from 'test/integration/graphql/utils/find-many-applications.util';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import { generateApplicationToken } from 'test/integration/metadata/suites/application/utils/generate-application-token.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { uploadApplicationFile } from 'test/integration/metadata/suites/application/utils/upload-application-file.util';
+import { expectOneNotInternalServerErrorHttpResponseSnapshot } from 'test/integration/utils/expect-one-not-internal-server-error-http-response-snapshot.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { type LogicFunctionManifest } from 'twenty-shared/application';
+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
+
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const APP_UNIVERSAL_IDENTIFIER = '6a6f983f-5c1a-4c60-a3c8-7d0e2a4a66a6';
+const ROLE_UNIVERSAL_IDENTIFIER = '7b7f983f-5c1a-4c60-a3c8-7d0e2a4a77b7';
+const ROUTE_FUNCTION_UNIVERSAL_IDENTIFIER =
+  '8c8f983f-5c1a-4c60-a3c8-7d0e2a4a88c8';
+const AUTHENTICATED_ROUTE_FUNCTION_UNIVERSAL_IDENTIFIER =
+  '9d9f983f-5c1a-4c60-a3c8-7d0e2a4a99d9';
+
+const ROUTE_FUNCTION_RESPONSE = { greeting: 'hello from route function' };
+
+const UNSAFE_JS_CHAR_MAP: Record<string, string> = {
+  '<': '\\u003C',
+  '>': '\\u003E',
+  '/': '\\u002F',
+  '\\': '\\\\',
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t',
+  '\0': '\\0',
+  '\u2028': '\\u2028',
+  '\u2029': '\\u2029',
+};
+
+const escapeUnsafeChars = (value: string): string =>
+  value.replace(/[<>/\\\b\f\n\r\t\0\u2028\u2029]/g, (char) => {
+    return UNSAFE_JS_CHAR_MAP[char] ?? char;
+  });
+
+const ROUTE_BUILT_HANDLER_CODE = `export const main = async () => (${escapeUnsafeChars(
+  JSON.stringify(ROUTE_FUNCTION_RESPONSE),
+)});
+`;
+
+const routeFunctionManifest: LogicFunctionManifest = {
+  universalIdentifier: ROUTE_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: 'suspended-workspace-route',
+  handlerName: 'main',
+  sourceHandlerPath: 'src/suspended-workspace-route.ts',
+  builtHandlerPath: 'dist/suspended-workspace-route.mjs',
+  builtHandlerChecksum: 'checksum-suspended-workspace-route',
+  httpRouteTriggerSettings: {
+    path: '/suspended-workspace-route',
+    httpMethod: 'GET',
+    isAuthRequired: false,
+  },
+};
+
+const authenticatedRouteFunctionManifest: LogicFunctionManifest = {
+  universalIdentifier: AUTHENTICATED_ROUTE_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: 'authenticated-workspace-route',
+  handlerName: 'main',
+  sourceHandlerPath: 'src/authenticated-workspace-route.ts',
+  builtHandlerPath: 'dist/authenticated-workspace-route.mjs',
+  builtHandlerChecksum: 'checksum-authenticated-workspace-route',
+  httpRouteTriggerSettings: {
+    path: '/authenticated-workspace-route',
+    httpMethod: 'GET',
+    isAuthRequired: true,
+  },
+};
+
+const uploadBuiltHandlerFile = async ({
+  builtHandlerPath,
+  builtHandlerCode,
+}: {
+  builtHandlerPath: string;
+  builtHandlerCode: string;
+}) => {
+  jest.useRealTimers();
+
+  await uploadApplicationFile({
+    applicationUniversalIdentifier: APP_UNIVERSAL_IDENTIFIER,
+    fileFolder: 'BuiltLogicFunction',
+    filePath: builtHandlerPath,
+    fileBuffer: Buffer.from(builtHandlerCode),
+    filename: builtHandlerPath.split('/').pop() as string,
+    contentType: 'application/javascript',
+    expectToFail: false,
+  });
+
+  jest.useFakeTimers();
+};
+
+describe('RouteTrigger suspended workspace (integration)', () => {
+  const baseUrl = `http://localhost:${APP_PORT}`;
+  const bareHost = `localhost:${APP_PORT}`;
+  const workspaceHost = `apple.localhost:${APP_PORT}`;
+  let applicationAccessToken: string;
+
+  beforeAll(async () => {
+    await setupApplicationForSync({
+      applicationUniversalIdentifier: APP_UNIVERSAL_IDENTIFIER,
+      name: 'Route Trigger Suspended Workspace Test App',
+      description: 'App for testing route triggers on a suspended workspace',
+      sourcePath: 'route-trigger-suspended-workspace-test-app',
+    });
+
+    await uploadBuiltHandlerFile({
+      builtHandlerPath: 'dist/suspended-workspace-route.mjs',
+      builtHandlerCode: ROUTE_BUILT_HANDLER_CODE,
+    });
+
+    await uploadBuiltHandlerFile({
+      builtHandlerPath: 'dist/authenticated-workspace-route.mjs',
+      builtHandlerCode: ROUTE_BUILT_HANDLER_CODE,
+    });
+
+    await syncApplication({
+      manifest: buildBaseManifest({
+        appId: APP_UNIVERSAL_IDENTIFIER,
+        roleId: ROLE_UNIVERSAL_IDENTIFIER,
+        overrides: {
+          logicFunctions: [
+            routeFunctionManifest,
+            authenticatedRouteFunctionManifest,
+          ],
+        },
+      }),
+      expectToFail: false,
+    });
+
+    const { data: applicationsData } = await findManyApplications({
+      expectToFail: false,
+    });
+    const routeTriggerApplication = applicationsData.findManyApplications.find(
+      (application) =>
+        application.universalIdentifier === APP_UNIVERSAL_IDENTIFIER,
+    );
+
+    expect(routeTriggerApplication).toBeDefined();
+
+    const { data: applicationTokenData } = await generateApplicationToken({
+      applicationId: routeTriggerApplication!.id,
+      expectToFail: false,
+    });
+
+    applicationAccessToken =
+      applicationTokenData.generateApplicationToken.applicationAccessToken
+        .token;
+
+    jest.useRealTimers();
+  }, 60000);
+
+  afterAll(async () => {
+    await getCoreRepository<WorkspaceEntity>(WorkspaceEntity).update(
+      SEED_APPLE_WORKSPACE_ID,
+      {
+        activationStatus: WorkspaceActivationStatus.ACTIVE,
+        suspendedAt: null,
+      },
+    );
+
+    await cleanupApplicationAndAppRegistration({
+      applicationUniversalIdentifier: APP_UNIVERSAL_IDENTIFIER,
+    });
+  }, 60000);
+
+  describe('GET /s/authenticated-workspace-route', () => {
+    it('should serve an authenticated route when the bearer token resolves the workspace', async () => {
+      const response = await request(baseUrl)
+        .get('/s/authenticated-workspace-route')
+        .set('Host', bareHost)
+        .set('Authorization', `Bearer ${applicationAccessToken}`);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(ROUTE_FUNCTION_RESPONSE);
+    }, 60000);
+  });
+
+  describe('GET /s/suspended-workspace-route', () => {
+    it('should return WORKSPACE_NOT_FOUND when neither host nor token identifies a workspace', async () => {
+      const response = await request(baseUrl)
+        .get('/s/suspended-workspace-route')
+        .set('Host', bareHost);
+
+      expect(response.status).toBe(404);
+      expect(response.body.code).toBe('WORKSPACE_NOT_FOUND');
+    }, 60000);
+
+    it('should return WORKSPACE_NOT_FOUND when the bearer token is invalid on an unresolved host', async () => {
+      const response = await request(baseUrl)
+        .get('/s/suspended-workspace-route')
+        .set('Host', bareHost)
+        .set('Authorization', 'Bearer invalid-token');
+
+      expect(response.status).toBe(404);
+      expect(response.body.code).toBe('WORKSPACE_NOT_FOUND');
+    }, 60000);
+
+    it('should resolve the workspace from the bearer token when the host names none', async () => {
+      const response = await request(baseUrl)
+        .get('/s/suspended-workspace-route')
+        .set('Host', bareHost)
+        .set('Authorization', `Bearer ${applicationAccessToken}`);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(ROUTE_FUNCTION_RESPONSE);
+    }, 60000);
+
+    it('serves the route trigger while the workspace is active', async () => {
+      const response = await request(baseUrl)
+        .get('/s/suspended-workspace-route')
+        .set('Host', workspaceHost);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(ROUTE_FUNCTION_RESPONSE);
+    }, 60000);
+
+    it('rejects the route trigger with 403 once the workspace is suspended', async () => {
+      await getCoreRepository<WorkspaceEntity>(WorkspaceEntity).update(
+        SEED_APPLE_WORKSPACE_ID,
+        {
+          activationStatus: WorkspaceActivationStatus.SUSPENDED,
+          suspendedAt: new Date(),
+        },
+      );
+
+      const response = await request(baseUrl)
+        .get('/s/suspended-workspace-route')
+        .set('Host', workspaceHost);
+
+      expect(response.status).toBe(403);
+      expect(response.body.code).toBe('WORKSPACE_SUSPENDED');
+      expectOneNotInternalServerErrorHttpResponseSnapshot({
+        status: response.status,
+        body: response.body,
+      });
+    }, 60000);
+  });
+});