Rename serverlessFunction to logicFunction (#17494)

## Summary Rename "Serverless Function" to "Logic Function" across the codebase for clearer naming. ### Environment Variable Changes | Old | New | |-----|-----| | `SERVERLESS_TYPE` | `LOGIC_FUNCTION_TYPE` | | `SERVERLESS_LAMBDA_REGION` | `LOGIC_FUNCTION_LAMBDA_REGION` | | `SERVERLESS_LAMBDA_ROLE` | `LOGIC_FUNCTION_LAMBDA_ROLE` | | `SERVERLESS_LAMBDA_SUBHOSTING_URL` | `LOGIC_FUNCTION_LAMBDA_SUBHOSTING_URL` | | `SERVERLESS_LAMBDA_ACCESS_KEY_ID` | `LOGIC_FUNCTION_LAMBDA_ACCESS_KEY_ID` | | `SERVERLESS_LAMBDA_SECRET_ACCESS_KEY` | `LOGIC_FUNCTION_LAMBDA_SECRET_ACCESS_KEY` | ### Breaking Changes - Environment variables must be updated in production deployments - Database migration renames `serverlessFunction` → `logicFunction` tables
2026-01-28 01:42:19 +01:00
parent 59d123d2b1
commit da6f1bbef3
351 changed files with 5054 additions and 5139 deletions
@@ -27,7 +27,7 @@ export class RouteTriggerRestApiExceptionFilter implements ExceptionFilter {
      case RouteTriggerExceptionCode.WORKSPACE_NOT_FOUND:
      case RouteTriggerExceptionCode.ROUTE_NOT_FOUND:
      case RouteTriggerExceptionCode.TRIGGER_NOT_FOUND:
-      case RouteTriggerExceptionCode.SERVERLESS_FUNCTION_NOT_FOUND:
+      case RouteTriggerExceptionCode.LOGIC_FUNCTION_NOT_FOUND:
        return this.httpExceptionHandlerService.handleError(
          exception as CustomException,
          response,
@@ -39,7 +39,7 @@ export class RouteTriggerRestApiExceptionFilter implements ExceptionFilter {
          response,
          403,
        );
-      case RouteTriggerExceptionCode.SERVERLESS_FUNCTION_EXECUTION_ERROR:
+      case RouteTriggerExceptionCode.LOGIC_FUNCTION_EXECUTION_ERROR:
        return this.httpExceptionHandlerService.handleError(
          exception as CustomException,
          response,
@@ -8,11 +8,11 @@ export enum RouteTriggerExceptionCode {
  WORKSPACE_NOT_FOUND = 'WORKSPACE_NOT_FOUND',
  ROUTE_NOT_FOUND = 'ROUTE_NOT_FOUND',
  TRIGGER_NOT_FOUND = 'TRIGGER_NOT_FOUND',
-  SERVERLESS_FUNCTION_NOT_FOUND = 'SERVERLESS_FUNCTION_NOT_FOUND',
+  LOGIC_FUNCTION_NOT_FOUND = 'LOGIC_FUNCTION_NOT_FOUND',
  ROUTE_ALREADY_EXIST = 'ROUTE_ALREADY_EXIST',
  ROUTE_PATH_ALREADY_EXIST = 'ROUTE_PATH_ALREADY_EXIST',
  FORBIDDEN_EXCEPTION = 'FORBIDDEN_EXCEPTION',
-  SERVERLESS_FUNCTION_EXECUTION_ERROR = 'SERVERLESS_FUNCTION_EXECUTION_ERROR',
+  LOGIC_FUNCTION_EXECUTION_ERROR = 'LOGIC_FUNCTION_EXECUTION_ERROR',
 }

 const getRouteTriggerExceptionUserFriendlyMessage = (
@@ -25,16 +25,16 @@ const getRouteTriggerExceptionUserFriendlyMessage = (
      return msg`Route not found.`;
    case RouteTriggerExceptionCode.TRIGGER_NOT_FOUND:
      return msg`Trigger not found.`;
-    case RouteTriggerExceptionCode.SERVERLESS_FUNCTION_NOT_FOUND:
-      return msg`Serverless function not found.`;
+    case RouteTriggerExceptionCode.LOGIC_FUNCTION_NOT_FOUND:
+      return msg`Logic function not found.`;
    case RouteTriggerExceptionCode.ROUTE_ALREADY_EXIST:
      return msg`Route already exists.`;
    case RouteTriggerExceptionCode.ROUTE_PATH_ALREADY_EXIST:
      return msg`Route path already exists.`;
    case RouteTriggerExceptionCode.FORBIDDEN_EXCEPTION:
      return msg`You do not have permission to perform this action.`;
-    case RouteTriggerExceptionCode.SERVERLESS_FUNCTION_EXECUTION_ERROR:
-      return msg`Serverless function execution failed.`;
+    case RouteTriggerExceptionCode.LOGIC_FUNCTION_EXECUTION_ERROR:
+      return msg`Logic function execution failed.`;
    default:
      assertUnreachable(code);
  }
@@ -5,15 +5,15 @@ import { TokenModule } from 'src/engine/core-modules/auth/token/token.module';
 import { WorkspaceDomainsModule } from 'src/engine/core-modules/domain/workspace-domains/workspace-domains.module';
 import { RouteTriggerController } from 'src/engine/metadata-modules/route-trigger/route-trigger.controller';
 import { RouteTriggerService } from 'src/engine/metadata-modules/route-trigger/route-trigger.service';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { ServerlessFunctionModule } from 'src/engine/metadata-modules/serverless-function/serverless-function.module';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { LogicFunctionModule } from 'src/engine/metadata-modules/logic-function/logic-function.module';

@Module({
  imports: [
-    TypeOrmModule.forFeature([ServerlessFunctionEntity]),
+    TypeOrmModule.forFeature([LogicFunctionEntity]),
    TokenModule,
    WorkspaceDomainsModule,
-    ServerlessFunctionModule,
+    LogicFunctionModule,
  ],
  controllers: [RouteTriggerController],
  providers: [RouteTriggerService],
@@ -13,28 +13,28 @@ import {
  RouteTriggerException,
  RouteTriggerExceptionCode,
 } from 'src/engine/metadata-modules/route-trigger/exceptions/route-trigger.exception';
-import { buildServerlessFunctionEvent } from 'src/engine/metadata-modules/route-trigger/utils/build-serverless-function-event.util';
-import { ServerlessFunctionEntity } from 'src/engine/metadata-modules/serverless-function/serverless-function.entity';
-import { ServerlessFunctionService } from 'src/engine/metadata-modules/serverless-function/serverless-function.service';
+import { buildLogicFunctionEvent } from 'src/engine/metadata-modules/route-trigger/utils/build-logic-function-event.util';
+import { LogicFunctionEntity } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { LogicFunctionService } from 'src/engine/metadata-modules/logic-function/logic-function.service';

@Injectable()
 export class RouteTriggerService {
  constructor(
    private readonly accessTokenService: AccessTokenService,
-    private readonly serverlessFunctionService: ServerlessFunctionService,
+    private readonly logicFunctionService: LogicFunctionService,
    private readonly workspaceDomainsService: WorkspaceDomainsService,
-    @InjectRepository(ServerlessFunctionEntity)
-    private readonly serverlessFunctionRepository: Repository<ServerlessFunctionEntity>,
+    @InjectRepository(LogicFunctionEntity)
+    private readonly logicFunctionRepository: Repository<LogicFunctionEntity>,
  ) {}

-  private async getServerlessFunctionWithPathParamsOrFail({
+  private async getLogicFunctionWithPathParamsOrFail({
    request,
    httpMethod,
  }: {
    request: Request;
    httpMethod: HTTPMethod;
  }): Promise<{
-    serverlessFunction: ServerlessFunctionEntity;
+    logicFunction: LogicFunctionEntity;
    pathParams: Partial<Record<string, string | string[]>>;
  }> {
    const host = `${request.protocol}://${request.get('host')}`;
@@ -52,8 +52,8 @@ export class RouteTriggerService {
      ),
    );

-    const serverlessFunctionsWithHttpRouteTrigger =
-      await this.serverlessFunctionRepository.find({
+    const logicFunctionsWithHttpRouteTrigger =
+      await this.logicFunctionRepository.find({
        where: {
          workspaceId: workspace.id,
          httpRouteTriggerSettings: Not(IsNull()),
@@ -62,8 +62,8 @@ export class RouteTriggerService {

    const requestPath = request.path.replace(/^\/s\//, '/');

-    for (const serverlessFunction of serverlessFunctionsWithHttpRouteTrigger) {
-      const httpRouteSettings = serverlessFunction.httpRouteTriggerSettings;
+    for (const logicFunction of logicFunctionsWithHttpRouteTrigger) {
+      const httpRouteSettings = logicFunction.httpRouteTriggerSettings;

      if (
        !isDefined(httpRouteSettings) ||
@@ -79,7 +79,7 @@ export class RouteTriggerService {

      if (routeMatched) {
        return {
-          serverlessFunction,
+          logicFunction,
          pathParams: routeMatched.params,
        };
      }
@@ -125,34 +125,33 @@ export class RouteTriggerService {
    request: Request;
    httpMethod: HTTPMethod;
  }) {
-    const { serverlessFunction, pathParams } =
-      await this.getServerlessFunctionWithPathParamsOrFail({
+    const { logicFunction, pathParams } =
+      await this.getLogicFunctionWithPathParamsOrFail({
        request,
        httpMethod,
      });

-    const httpRouteSettings = serverlessFunction.httpRouteTriggerSettings;
+    const httpRouteSettings = logicFunction.httpRouteTriggerSettings;

    if (httpRouteSettings?.isAuthRequired) {
      await this.validateWorkspaceFromRequest({
        request,
-        workspaceId: serverlessFunction.workspaceId,
+        workspaceId: logicFunction.workspaceId,
      });
    }

-    const event = buildServerlessFunctionEvent({
+    const event = buildLogicFunctionEvent({
      request,
      pathParameters: pathParams,
      forwardedRequestHeaders: httpRouteSettings?.forwardedRequestHeaders ?? [],
    });

-    const result =
-      await this.serverlessFunctionService.executeOneServerlessFunction({
-        id: serverlessFunction.id,
-        workspaceId: serverlessFunction.workspaceId,
-        payload: event,
-        version: 'draft',
-      });
+    const result = await this.logicFunctionService.executeOneLogicFunction({
+      id: logicFunction.id,
+      workspaceId: logicFunction.workspaceId,
+      payload: event,
+      version: 'draft',
+    });

    if (!isDefined(result)) {
      return result;
@@ -161,7 +160,7 @@ export class RouteTriggerService {
    if (result.error) {
      throw new RouteTriggerException(
        result.error.errorMessage,
-        RouteTriggerExceptionCode.SERVERLESS_FUNCTION_EXECUTION_ERROR,
+        RouteTriggerExceptionCode.LOGIC_FUNCTION_EXECUTION_ERROR,
      );
    }

@@ -1,12 +1,12 @@
 import { type Request } from 'express';

 import {
-  buildServerlessFunctionEvent,
+  buildLogicFunctionEvent,
  extractBody,
  filterRequestHeaders,
  normalizePathParameters,
  normalizeQueryStringParameters,
-} from 'src/engine/metadata-modules/route-trigger/utils/build-serverless-function-event.util';
+} from 'src/engine/metadata-modules/route-trigger/utils/build-logic-function-event.util';

 describe('filterRequestHeaders', () => {
  it('should filter headers based on allowed names', () => {
@@ -272,7 +272,7 @@ describe('normalizePathParameters', () => {
  });
 });

-describe('buildServerlessFunctionEvent', () => {
+describe('buildLogicFunctionEvent', () => {
  const createMockRequest = (overrides: Partial<Request> = {}): Request =>
    ({
      headers: {},
@@ -296,7 +296,7 @@ describe('buildServerlessFunctionEvent', () => {
      path: '/s/users/123',
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: { id: '123' },
      forwardedRequestHeaders: ['content-type', 'authorization'],
@@ -325,7 +325,7 @@ describe('buildServerlessFunctionEvent', () => {
      path: '/s/api/users',
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {},
      forwardedRequestHeaders: [],
@@ -339,7 +339,7 @@ describe('buildServerlessFunctionEvent', () => {
      path: '/api/users',
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {},
      forwardedRequestHeaders: [],
@@ -355,7 +355,7 @@ describe('buildServerlessFunctionEvent', () => {
      body: undefined,
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {},
      forwardedRequestHeaders: [],
@@ -371,7 +371,7 @@ describe('buildServerlessFunctionEvent', () => {
      path: '/s/users/456',
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: { userId: '456' },
      forwardedRequestHeaders: [],
@@ -391,7 +391,7 @@ describe('buildServerlessFunctionEvent', () => {
      },
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {},
      forwardedRequestHeaders: ['x-api-key'],
@@ -407,7 +407,7 @@ describe('buildServerlessFunctionEvent', () => {
  it('should set isBase64Encoded to false', () => {
    const request = createMockRequest();

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {},
      forwardedRequestHeaders: [],
@@ -421,7 +421,7 @@ describe('buildServerlessFunctionEvent', () => {
      path: '/s/organizations/org1/users/user1/posts',
    });

-    const result = buildServerlessFunctionEvent({
+    const result = buildLogicFunctionEvent({
      request,
      pathParameters: {
        orgId: 'org1',
@@ -1,5 +1,5 @@
 import { type Request } from 'express';
-import { type ServerlessFunctionEvent } from 'twenty-shared/types';
+import { type LogicFunctionEvent } from 'twenty-shared/types';

 /**
 * Filters HTTP headers from Express request based on allowed header names
@@ -130,7 +130,7 @@ export const normalizePathParameters = (
 * Builds an AWS HTTP API v2 compatible event from an Express request
 * @see https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
 */
-export const buildServerlessFunctionEvent = ({
+export const buildLogicFunctionEvent = ({
  request,
  pathParameters,
  forwardedRequestHeaders,
@@ -138,7 +138,7 @@ export const buildServerlessFunctionEvent = ({
  request: Request;
  pathParameters: Record<string, string | string[] | undefined>;
  forwardedRequestHeaders: string[];
-}): ServerlessFunctionEvent => {
+}): LogicFunctionEvent => {
  return {
    headers: filterRequestHeaders({
      requestHeaders: request.headers,