Skip to content

The open alternative to Salesforce, designed for AI.

Add Lambda driver integration tests against Floci (#28574)

neo77345a8b423fa73
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/logic-function-driver.factory.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/logic-function-driver.factory.ts
index cee72e8c686..ebcf85678a1 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/logic-function-driver.factory.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/logic-function-driver.factory.ts
@@ -101,6 +101,9 @@ export class LogicFunctionDriverFactory extends DriverFactoryBase<LogicFunctionD
? { accessKeyId, secretAccessKey }
: fromNodeProviderChain({ clientConfig: { region } }),
region,
+ endpoint: this.twentyConfigService.get(
+ 'LOGIC_FUNCTION_LAMBDA_ENDPOINT',
+ ),
lambdaRole,
subhostingRole,
layerBucket,
diff --git a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
index 87189714d08..c536b3f365c 100644
--- a/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
+++ b/packages/twenty-server/src/engine/core-modules/twenty-config/config-variables.ts
@@ -850,6 +850,18 @@ export class ConfigVariables {
@IsAWSRegion()
LOGIC_FUNCTION_LAMBDA_LAYER_BUCKET_REGION?: AwsRegion;
+ @ConfigVariablesMetadata({
+ group: ConfigVariablesGroup.LOGIC_FUNCTION_CONFIG,
+ description:
+ 'Custom Lambda endpoint URL. Optional, only needed for Lambda-compatible emulators (e.g. http://floci:4566). Omit for AWS Lambda, where the SDK resolves the endpoint from the region.',
+ type: ConfigVariableType.STRING,
+ })
+ @ValidateIf(
+ (env) => env.LOGIC_FUNCTION_TYPE === LogicFunctionDriverType.LAMBDA,
+ )
+ @IsOptional()
+ LOGIC_FUNCTION_LAMBDA_ENDPOINT?: string;
+
@ConfigVariablesMetadata({
group: ConfigVariablesGroup.CODE_INTERPRETER_CONFIG,
description:
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/constants/dependency-layer-fixture.constant.ts b/packages/twenty-server/test/integration/logic-function-lambda/constants/dependency-layer-fixture.constant.ts
new file mode 100644
index 00000000000..f789ec5b9c0
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/constants/dependency-layer-fixture.constant.ts
@@ -0,0 +1,4 @@
+export const DEPENDENCY_LAYER_FIXTURE = {
+ packageName: 'twenty-integration-test-dependency',
+ greeting: 'served from the dependency layer',
+} as const;
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/suites/lambda-logic-function-execution.integration-spec.ts b/packages/twenty-server/test/integration/logic-function-lambda/suites/lambda-logic-function-execution.integration-spec.ts
new file mode 100644
index 00000000000..46ccb3aa0f4
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/suites/lambda-logic-function-execution.integration-spec.ts
@@ -0,0 +1,391 @@
+import { randomUUID } from 'crypto';
+
+import { ResourceNotFoundException } from '@aws-sdk/client-lambda';
+import { DEPENDENCY_LAYER_FIXTURE } from 'test/integration/logic-function-lambda/constants/dependency-layer-fixture.constant';
+import { type FlociLambdaDriver } from 'test/integration/logic-function-lambda/types/floci-lambda-driver.type';
+import { getWorkspaceCustomFlatApplication } from 'test/integration/logic-function-lambda/utils/get-workspace-custom-flat-application.util';
+import { publishDependencyLayerFixture } from 'test/integration/logic-function-lambda/utils/publish-dependency-layer-fixture.util';
+import { switchToFlociLambdaDriver } from 'test/integration/logic-function-lambda/utils/switch-to-floci-lambda-driver.util';
+import { createOneLogicFunction } from 'test/integration/metadata/suites/logic-function/utils/create-logic-function.util';
+import { deleteLogicFunction } from 'test/integration/metadata/suites/logic-function/utils/delete-logic-function.util';
+import { executeLogicFunction } from 'test/integration/metadata/suites/logic-function/utils/execute-logic-function.util';
+import { updateLogicFunctionSource } from 'test/integration/metadata/suites/logic-function/utils/update-logic-function-source.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
+import { isDefined } from 'twenty-shared/utils';
+
+import { LAMBDA_PREBUILT_BUNDLE_CHECKSUM_TAG } from 'src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/constants/lambda-driver.constant';
+import { type LogicFunctionExecutorService } from 'src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service';
+import { type SdkClientGenerationService } from 'src/engine/core-modules/sdk-client/sdk-client-generation.service';
+import { LogicFunctionExecutionStatus } from 'src/engine/metadata-modules/logic-function/dtos/logic-function-execution-result.dto';
+import {
+ LogicFunctionEntity,
+ LogicFunctionExecutionMode,
+} from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const LAMBDA_TEST_TIMEOUT_MS = 300_000;
+
+const LAYER_PROBE_SOURCE = `import { createHash } from 'crypto';
+import { readFile } from 'fs/promises';
+import { greeting } from '${DEPENDENCY_LAYER_FIXTURE.packageName}';
+
+export const main = async (): Promise<object> => ({
+ greeting,
+ sdkClientCoreChecksum: createHash('sha256')
+ .update(await readFile('/opt/nodejs/node_modules/twenty-client-sdk/dist/core.mjs'))
+ .digest('hex'),
+});`;
+
+const THROWING_SOURCE = `export const main = async (): Promise<object> => {
+ throw new Error('Lambda handler failure');
+};`;
+
+const SLOW_SOURCE = `export const main = async (): Promise<object> => {
+ await new Promise((resolve) => setTimeout(resolve, 30_000));
+ return { finished: true };
+};`;
+
+const buildVersionedSource = (version: number) =>
+ `export const main = async (): Promise<object> => ({ version: ${version} });`;
+
+describe('Logic functions on the Lambda driver (integration)', () => {
+ let flociLambdaDriver: FlociLambdaDriver;
+ const createdLogicFunctionIds: string[] = [];
+
+ const createLogicFunction = async ({
+ sourceHandlerCode,
+ timeoutSeconds,
+ }: { sourceHandlerCode?: string; timeoutSeconds?: number } = {}) => {
+ const { data } = await createOneLogicFunction({
+ input: { name: `Lambda driver ${randomUUID()}`, timeoutSeconds },
+ expectToFail: false,
+ });
+ const logicFunctionId: string = data.createOneLogicFunction.id;
+
+ createdLogicFunctionIds.push(logicFunctionId);
+
+ if (isDefined(sourceHandlerCode)) {
+ await updateLogicFunctionSource({
+ input: { id: logicFunctionId, update: { sourceHandlerCode } },
+ expectToFail: false,
+ });
+ }
+
+ return logicFunctionId;
+ };
+
+ const runLogicFunction = async (logicFunctionId: string) => {
+ const { data } = await executeLogicFunction({
+ input: { id: logicFunctionId, payload: {} },
+ expectToFail: false,
+ });
+
+ return data.executeOneLogicFunction;
+ };
+
+ const runLayerProbe = async (logicFunctionId: string) => {
+ const result = await runLogicFunction(logicFunctionId);
+
+ if (result.status !== LogicFunctionExecutionStatus.SUCCESS) {
+ throw new Error(JSON.stringify(result.error, null, 2));
+ }
+
+ return result.data;
+ };
+
+ const getCurrentSdkClientCoreChecksum = async () =>
+ (await getWorkspaceCustomFlatApplication(SEED_APPLE_WORKSPACE_ID))
+ .sdkClientCoreChecksum;
+
+ const regenerateSdkClient = async () => {
+ const customFlatApplication = await getWorkspaceCustomFlatApplication(
+ SEED_APPLE_WORKSPACE_ID,
+ );
+
+ await getAppProviderByClassName<SdkClientGenerationService>(
+ 'SdkClientGenerationService',
+ ).generateSdkClientForApplication({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ applicationId: customFlatApplication.id,
+ applicationUniversalIdentifier: customFlatApplication.universalIdentifier,
+ });
+ };
+
+ beforeAll(async () => {
+ flociLambdaDriver = await switchToFlociLambdaDriver();
+
+ await publishDependencyLayerFixture({
+ lambdaClient: flociLambdaDriver.lambdaClient,
+ resourceNamespace: flociLambdaDriver.resourceNamespace,
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ });
+
+ await regenerateSdkClient();
+ }, LAMBDA_TEST_TIMEOUT_MS);
+
+ afterAll(async () => {
+ for (const logicFunctionId of createdLogicFunctionIds) {
+ await deleteLogicFunction({
+ input: { id: logicFunctionId },
+ expectToFail: false,
+ }).catch(() => undefined);
+ }
+
+ await waitForAllJobsToFinish();
+ await flociLambdaDriver?.restore();
+ }, LAMBDA_TEST_TIMEOUT_MS);
+
+ it(
+ 'runs a function with its dependency and SDK layers mounted',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: LAYER_PROBE_SOURCE,
+ });
+
+ expect(await runLayerProbe(logicFunctionId)).toEqual({
+ greeting: DEPENDENCY_LAYER_FIXTURE.greeting,
+ sdkClientCoreChecksum: await getCurrentSdkClientCoreChecksum(),
+ });
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'runs the new code once the source is updated',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: buildVersionedSource(1),
+ });
+
+ expect((await runLogicFunction(logicFunctionId)).data).toEqual({
+ version: 1,
+ });
+
+ await updateLogicFunctionSource({
+ input: {
+ id: logicFunctionId,
+ update: { sourceHandlerCode: buildVersionedSource(2) },
+ },
+ expectToFail: false,
+ });
+
+ expect((await runLogicFunction(logicFunctionId)).data).toEqual({
+ version: 2,
+ });
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'reports the error thrown by the handler',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: THROWING_SOURCE,
+ });
+
+ const result = await runLogicFunction(logicFunctionId);
+
+ expect(result.status).toBe(LogicFunctionExecutionStatus.ERROR);
+ expect(result.data).toBeNull();
+ expect(result.error).toMatchObject({
+ errorType: 'Error',
+ errorMessage: expect.stringContaining('Lambda handler failure'),
+ });
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'stops waiting for a handler that runs past its timeout',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: SLOW_SOURCE,
+ timeoutSeconds: 2,
+ });
+
+ const result = await runLogicFunction(logicFunctionId);
+
+ expect(result.status).toBe(LogicFunctionExecutionStatus.ERROR);
+ expect(result.error).toMatchObject({ errorType: 'TimeoutError' });
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'rebuilds its Lambda on the run after it was deleted outside of Twenty',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: buildVersionedSource(1),
+ });
+
+ await runLogicFunction(logicFunctionId);
+ await runLogicFunction(logicFunctionId);
+ await flociLambdaDriver.lambdaClient.deleteFunction({
+ FunctionName: logicFunctionId,
+ });
+
+ const { errors } = await executeLogicFunction({
+ input: { id: logicFunctionId, payload: {} },
+ expectToFail: true,
+ });
+
+ expect(errors).toBeDefined();
+
+ const result = await runLogicFunction(logicFunctionId);
+
+ expect(result.status).toBe(LogicFunctionExecutionStatus.SUCCESS);
+ expect(result.data).toEqual({ version: 1 });
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'moves every function of the application to a regenerated SDK client',
+ async () => {
+ const firstLogicFunctionId = await createLogicFunction({
+ sourceHandlerCode: LAYER_PROBE_SOURCE,
+ });
+ const siblingLogicFunctionId = await createLogicFunction({
+ sourceHandlerCode: LAYER_PROBE_SOURCE,
+ });
+
+ const previousSdkClientCoreChecksum =
+ await getCurrentSdkClientCoreChecksum();
+
+ expect(await runLayerProbe(firstLogicFunctionId)).toMatchObject({
+ sdkClientCoreChecksum: previousSdkClientCoreChecksum,
+ });
+ expect(await runLayerProbe(siblingLogicFunctionId)).toMatchObject({
+ sdkClientCoreChecksum: previousSdkClientCoreChecksum,
+ });
+
+ const { data } = await createOneObjectMetadata({
+ input: {
+ nameSingular: 'lambdaSdkRegenerationProbe',
+ namePlural: 'lambdaSdkRegenerationProbes',
+ labelSingular: 'Lambda SDK regeneration probe',
+ labelPlural: 'Lambda SDK regeneration probes',
+ icon: 'IconCode',
+ },
+ expectToFail: false,
+ });
+ const objectMetadataId: string = data.createOneObject.id;
+
+ try {
+ await regenerateSdkClient();
+
+ const regeneratedSdkClientCoreChecksum =
+ await getCurrentSdkClientCoreChecksum();
+
+ expect(regeneratedSdkClientCoreChecksum).not.toBe(
+ previousSdkClientCoreChecksum,
+ );
+ expect(await runLayerProbe(firstLogicFunctionId)).toMatchObject({
+ sdkClientCoreChecksum: regeneratedSdkClientCoreChecksum,
+ });
+ expect(await runLayerProbe(siblingLogicFunctionId)).toMatchObject({
+ sdkClientCoreChecksum: regeneratedSdkClientCoreChecksum,
+ });
+ } finally {
+ await updateOneObjectMetadata({
+ input: {
+ idToUpdate: objectMetadataId,
+ updatePayload: { isActive: false },
+ },
+ expectToFail: false,
+ });
+ await deleteOneObjectMetadata({
+ input: { idToDelete: objectMetadataId },
+ });
+ }
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'installs a prebuilt bundle once and serves later runs from it',
+ async () => {
+ const { lambdaClient } = flociLambdaDriver;
+ const logicFunctionId = await createLogicFunction();
+ const logicFunctionRepository =
+ getCoreRepository<LogicFunctionEntity>(LogicFunctionEntity);
+
+ await logicFunctionRepository.update(
+ { id: logicFunctionId },
+ { executionMode: LogicFunctionExecutionMode.PREBUILT },
+ );
+ await getAppProviderByClassName<WorkspaceCacheService>(
+ 'WorkspaceCacheService',
+ ).invalidateAndRecompute(SEED_APPLE_WORKSPACE_ID, [
+ 'flatLogicFunctionMaps',
+ ]);
+
+ const runPrebuilt = () =>
+ getAppProviderByClassName<LogicFunctionExecutorService>(
+ 'LogicFunctionExecutorService',
+ ).execute({
+ logicFunctionId,
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ payload: { a: 'prebuilt', b: 1 },
+ });
+
+ expect(await runPrebuilt()).toMatchObject({
+ status: LogicFunctionExecutionStatus.SUCCESS,
+ data: { message: 'Hello, input: prebuilt and 1' },
+ });
+
+ const { checksum } = await logicFunctionRepository.findOneByOrFail({
+ id: logicFunctionId,
+ });
+ const installedLambda = await lambdaClient.getFunction({
+ FunctionName: logicFunctionId,
+ });
+
+ expect(installedLambda.Tags?.[LAMBDA_PREBUILT_BUNDLE_CHECKSUM_TAG]).toBe(
+ checksum,
+ );
+
+ expect(await runPrebuilt()).toMatchObject({
+ status: LogicFunctionExecutionStatus.SUCCESS,
+ });
+ expect(
+ (await lambdaClient.getFunction({ FunctionName: logicFunctionId }))
+ .Configuration?.LastModified,
+ ).toBe(installedLambda.Configuration?.LastModified);
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+
+ it(
+ 'deletes its Lambda when the logic function is deleted',
+ async () => {
+ const logicFunctionId = await createLogicFunction({
+ sourceHandlerCode: buildVersionedSource(1),
+ });
+
+ await runLogicFunction(logicFunctionId);
+ await deleteLogicFunction({
+ input: { id: logicFunctionId },
+ expectToFail: false,
+ });
+ createdLogicFunctionIds.splice(
+ createdLogicFunctionIds.indexOf(logicFunctionId),
+ 1,
+ );
+ await waitForAllJobsToFinish();
+
+ await expect(
+ flociLambdaDriver.lambdaClient.getFunction({
+ FunctionName: logicFunctionId,
+ }),
+ ).rejects.toThrow(ResourceNotFoundException);
+ },
+ LAMBDA_TEST_TIMEOUT_MS,
+ );
+});
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/types/floci-lambda-driver.type.ts b/packages/twenty-server/test/integration/logic-function-lambda/types/floci-lambda-driver.type.ts
new file mode 100644
index 00000000000..bf0060cd026
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/types/floci-lambda-driver.type.ts
@@ -0,0 +1,7 @@
+import { type Lambda } from '@aws-sdk/client-lambda';
+
+export type FlociLambdaDriver = {
+ lambdaClient: Lambda;
+ resourceNamespace: string;
+ restore: () => Promise<void>;
+};
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/utils/get-workspace-custom-flat-application.util.ts b/packages/twenty-server/test/integration/logic-function-lambda/utils/get-workspace-custom-flat-application.util.ts
new file mode 100644
index 00000000000..8d4ba05f8c1
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/utils/get-workspace-custom-flat-application.util.ts
@@ -0,0 +1,39 @@
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { isDefined } from 'twenty-shared/utils';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+export const getWorkspaceCustomFlatApplication = async (
+ workspaceId: string,
+): Promise<FlatApplication> => {
+ const { workspaceCustomApplicationId } =
+ await getCoreRepository<WorkspaceEntity>(WorkspaceEntity).findOneByOrFail({
+ id: workspaceId,
+ });
+
+ const workspaceCacheService =
+ getAppProviderByClassName<WorkspaceCacheService>('WorkspaceCacheService');
+
+ await workspaceCacheService.invalidateAndRecompute(workspaceId, [
+ 'flatApplicationMaps',
+ ]);
+
+ const { flatApplicationMaps } = await workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['flatApplicationMaps'],
+ );
+
+ const flatApplication =
+ flatApplicationMaps.byId[workspaceCustomApplicationId];
+
+ if (!isDefined(flatApplication)) {
+ throw new Error(
+ `Custom application ${workspaceCustomApplicationId} not found in workspace ${workspaceId}`,
+ );
+ }
+
+ return flatApplication;
+};
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/utils/publish-dependency-layer-fixture.util.ts b/packages/twenty-server/test/integration/logic-function-lambda/utils/publish-dependency-layer-fixture.util.ts
new file mode 100644
index 00000000000..48cb49de5f5
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/utils/publish-dependency-layer-fixture.util.ts
@@ -0,0 +1,58 @@
+import { type Lambda } from '@aws-sdk/client-lambda';
+import { promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { DEPENDENCY_LAYER_FIXTURE } from 'test/integration/logic-function-lambda/constants/dependency-layer-fixture.constant';
+import { getWorkspaceCustomFlatApplication } from 'test/integration/logic-function-lambda/utils/get-workspace-custom-flat-application.util';
+
+import { getLambdaDepsLayerName } from 'src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/utils/get-lambda-deps-layer-name.util';
+import { createZipFile } from 'src/engine/core-modules/logic-function/logic-function-drivers/utils/create-zip-file';
+import { LogicFunctionRuntime } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+
+export const publishDependencyLayerFixture = async ({
+ lambdaClient,
+ resourceNamespace,
+ workspaceId,
+}: {
+ lambdaClient: Lambda;
+ resourceNamespace: string;
+ workspaceId: string;
+}): Promise<void> => {
+ const flatApplication = await getWorkspaceCustomFlatApplication(workspaceId);
+ const buildDirectory = await fs.mkdtemp(join(tmpdir(), 'deps-layer-'));
+ const packageDirectory = join(
+ buildDirectory,
+ 'layer/nodejs/node_modules',
+ DEPENDENCY_LAYER_FIXTURE.packageName,
+ );
+ const zipPath = join(buildDirectory, 'layer.zip');
+
+ try {
+ await fs.mkdir(packageDirectory, { recursive: true });
+ await fs.writeFile(
+ join(packageDirectory, 'package.json'),
+ JSON.stringify({
+ name: DEPENDENCY_LAYER_FIXTURE.packageName,
+ type: 'module',
+ main: 'index.js',
+ }),
+ );
+ await fs.writeFile(
+ join(packageDirectory, 'index.js'),
+ `export const greeting = ${JSON.stringify(DEPENDENCY_LAYER_FIXTURE.greeting)};`,
+ );
+ await createZipFile(join(buildDirectory, 'layer'), zipPath);
+
+ await lambdaClient.publishLayerVersion({
+ LayerName: getLambdaDepsLayerName({
+ flatApplication,
+ namespace: resourceNamespace,
+ }),
+ Content: { ZipFile: await fs.readFile(zipPath) },
+ CompatibleRuntimes: [LogicFunctionRuntime.NODE22],
+ });
+ } finally {
+ await fs.rm(buildDirectory, { recursive: true, force: true });
+ }
+};
diff --git a/packages/twenty-server/test/integration/logic-function-lambda/utils/switch-to-floci-lambda-driver.util.ts b/packages/twenty-server/test/integration/logic-function-lambda/utils/switch-to-floci-lambda-driver.util.ts
new file mode 100644
index 00000000000..a40062ba805
--- /dev/null
+++ b/packages/twenty-server/test/integration/logic-function-lambda/utils/switch-to-floci-lambda-driver.util.ts
@@ -0,0 +1,49 @@
+import { Lambda } from '@aws-sdk/client-lambda';
+
+import { type FlociLambdaDriver } from 'test/integration/logic-function-lambda/types/floci-lambda-driver.type';
+import { deleteConfigVariable } from 'test/integration/twenty-config/utils/delete-config-variable.util';
+import { updateConfigVariable } from 'test/integration/twenty-config/utils/update-config-variable.util';
+import { startFlociContainer } from 'test/integration/utils/start-floci-container.util';
+
+import { getLambdaResourceNamespace } from 'src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/utils/get-lambda-resource-namespace.util';
+import { LogicFunctionDriverType } from 'src/engine/core-modules/logic-function/logic-function-drivers/interfaces/logic-function-driver.interface';
+
+const LAMBDA_REGION = 'us-east-1';
+const LAMBDA_ROLE = 'arn:aws:iam::000000000000:role/twenty-integration-test';
+const FLOCI_CREDENTIALS = { accessKeyId: 'test', secretAccessKey: 'test' };
+
+export const switchToFlociLambdaDriver =
+ async (): Promise<FlociLambdaDriver> => {
+ const floci = await startFlociContainer();
+ const lambdaDriverConfigVariables: Record<string, string> = {
+ LOGIC_FUNCTION_TYPE: LogicFunctionDriverType.LAMBDA,
+ LOGIC_FUNCTION_LAMBDA_REGION: LAMBDA_REGION,
+ LOGIC_FUNCTION_LAMBDA_ENDPOINT: floci.endpoint,
+ LOGIC_FUNCTION_LAMBDA_ROLE: LAMBDA_ROLE,
+ LOGIC_FUNCTION_LAMBDA_ACCESS_KEY_ID: FLOCI_CREDENTIALS.accessKeyId,
+ LOGIC_FUNCTION_LAMBDA_SECRET_ACCESS_KEY:
+ FLOCI_CREDENTIALS.secretAccessKey,
+ };
+
+ for (const [key, value] of Object.entries(lambdaDriverConfigVariables)) {
+ await updateConfigVariable({ input: { key, value } });
+ }
+
+ return {
+ lambdaClient: new Lambda({
+ region: LAMBDA_REGION,
+ credentials: FLOCI_CREDENTIALS,
+ endpoint: floci.endpoint,
+ }),
+ resourceNamespace: getLambdaResourceNamespace({
+ lambdaRoleArn: LAMBDA_ROLE,
+ }),
+ restore: async () => {
+ for (const key of Object.keys(lambdaDriverConfigVariables)) {
+ await deleteConfigVariable({ input: { key } }).catch(() => undefined);
+ }
+
+ await floci.stop();
+ },
+ };
+ };
diff --git a/packages/twenty-server/test/integration/utils/start-floci-container.util.ts b/packages/twenty-server/test/integration/utils/start-floci-container.util.ts
new file mode 100644
index 00000000000..e00e441ff5b
--- /dev/null
+++ b/packages/twenty-server/test/integration/utils/start-floci-container.util.ts
@@ -0,0 +1,39 @@
+import { randomUUID } from 'crypto';
+
+import {
+ GenericContainer,
+ type StartedTestContainer,
+ Wait,
+} from 'testcontainers';
+
+const FLOCI_IMAGE =
+ 'floci/floci:2.3.0@sha256:e0b292df4dc9559b7b1bf4f51bdda4bb8e269276236438cd03cae661260ea8a9';
+const FLOCI_PORT = 4566;
+const DOCKER_SOCKET_PATH = '/var/run/docker.sock';
+
+type FlociServer = {
+ endpoint: string;
+ stop: () => Promise<void>;
+};
+
+export const startFlociContainer = async (): Promise<FlociServer> => {
+ const container: StartedTestContainer = await new GenericContainer(
+ FLOCI_IMAGE,
+ )
+ .withEnvironment({
+ FLOCI_DOCKER_RESOURCE_NAMESPACE: `twenty-test-${randomUUID().slice(0, 8)}`,
+ })
+ .withBindMounts([
+ { source: DOCKER_SOCKET_PATH, target: DOCKER_SOCKET_PATH, mode: 'rw' },
+ ])
+ .withExposedPorts(FLOCI_PORT)
+ .withWaitStrategy(Wait.forHttp('/_floci/health', FLOCI_PORT))
+ .start();
+
+ return {
+ endpoint: `http://${container.getHost()}:${container.getMappedPort(FLOCI_PORT)}`,
+ stop: async () => {
+ await container.stop();
+ },
+ };
+};