The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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();+ },+ };+};