Skip to content

The open alternative to Salesforce, designed for AI.

feat(server): run newly installed packaged application logic functions in prebuilt mode (#25119)

martmullc296afe8fe4d
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest-migration.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest-migration.service.ts
index e9696ba467e..2f6cda813b2 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest-migration.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/application-manifest-migration.service.ts
@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
import { type Manifest } from 'twenty-shared/application';
import { ALL_METADATA_NAME } from 'twenty-shared/metadata';
+import { FeatureFlagKey } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { ComputeApplicationManifestAllUniversalFlatEntityMapsService } from 'src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service';
@@ -111,6 +112,11 @@ export class ApplicationManifestMigrationService {
this.computeManifestFlatEntityMapsService.compute({
manifest: preInstallOnlyManifest,
ownerFlatApplication,
+ fromAllFlatEntityMaps,
+ isLogicFunctionPrebuiltModeEnabled:
+ featureFlagsMap[
+ FeatureFlagKey.IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED
+ ],
now,
workspaceId,
});
@@ -190,8 +196,7 @@ export class ApplicationManifestMigrationService {
ApplicationManifestMigrationService.name,
);
- const { featureFlagsMap: _featureFlagsMap, ...existingAllFlatEntityMaps } =
- cacheResult;
+ const { featureFlagsMap, ...existingAllFlatEntityMaps } = cacheResult;
const fromAllFlatEntityMaps = getApplicationSubAllFlatEntityMaps({
applicationIds: [ownerFlatApplication.id],
@@ -202,6 +207,11 @@ export class ApplicationManifestMigrationService {
this.computeManifestFlatEntityMapsService.compute({
manifest,
ownerFlatApplication,
+ fromAllFlatEntityMaps,
+ isLogicFunctionPrebuiltModeEnabled:
+ featureFlagsMap[
+ FeatureFlagKey.IS_LOGIC_FUNCTION_PREBUILT_MODE_ENABLED
+ ],
now,
workspaceId,
});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-logic-function-manifest-to-universal-flat-logic-function.util.spec.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-logic-function-manifest-to-universal-flat-logic-function.util.spec.ts
new file mode 100644
index 00000000000..a9d88e71dd9
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/__tests__/from-logic-function-manifest-to-universal-flat-logic-function.util.spec.ts
@@ -0,0 +1,163 @@
+import { type LogicFunctionManifest } from 'twenty-shared/application';
+
+import { fromLogicFunctionManifestToUniversalFlatLogicFunction } from 'src/engine/core-modules/application/application-manifest/converters/from-logic-function-manifest-to-universal-flat-logic-function.util';
+import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { LogicFunctionExecutionMode } from 'src/engine/metadata-modules/logic-function/logic-function.entity';
+import { type FlatLogicFunction } from 'src/engine/metadata-modules/logic-function/types/flat-logic-function.type';
+
+describe('fromLogicFunctionManifestToUniversalFlatLogicFunction', () => {
+ const now = '2026-01-01T00:00:00.000Z';
+ const applicationUniversalIdentifier = 'app-uuid-1';
+ const logicFunctionUniversalIdentifier = 'fn-uuid-1';
+
+ const buildLogicFunctionManifest = (
+ overrides: Partial<LogicFunctionManifest> = {},
+ ): LogicFunctionManifest => ({
+ universalIdentifier: logicFunctionUniversalIdentifier,
+ name: 'My Function',
+ handlerName: 'handler',
+ sourceHandlerPath: 'src/my-function.ts',
+ builtHandlerPath: 'dist/my-function.mjs',
+ builtHandlerChecksum: 'checksum-1',
+ ...overrides,
+ });
+
+ const emptyFlatLogicFunctionMaps =
+ createEmptyFlatEntityMaps() as AllFlatEntityMaps['flatLogicFunctionMaps'];
+
+ const buildFlatLogicFunctionMaps = (
+ executionMode: LogicFunctionExecutionMode,
+ ): AllFlatEntityMaps['flatLogicFunctionMaps'] =>
+ ({
+ ...emptyFlatLogicFunctionMaps,
+ byUniversalIdentifier: {
+ [logicFunctionUniversalIdentifier]: {
+ universalIdentifier: logicFunctionUniversalIdentifier,
+ executionMode,
+ } as FlatLogicFunction,
+ },
+ }) as AllFlatEntityMaps['flatLogicFunctionMaps'];
+
+ const convert = ({
+ logicFunctionManifest = buildLogicFunctionManifest(),
+ applicationSourceType,
+ existingFlatLogicFunctionMaps = emptyFlatLogicFunctionMaps,
+ isPrebuiltModeEnabled = true,
+ }: {
+ logicFunctionManifest?: LogicFunctionManifest;
+ applicationSourceType: ApplicationRegistrationSourceType;
+ existingFlatLogicFunctionMaps?: AllFlatEntityMaps['flatLogicFunctionMaps'];
+ isPrebuiltModeEnabled?: boolean;
+ }) =>
+ fromLogicFunctionManifestToUniversalFlatLogicFunction({
+ logicFunctionManifest,
+ applicationUniversalIdentifier,
+ applicationSourceType,
+ existingFlatLogicFunctionMaps,
+ isPrebuiltModeEnabled,
+ now,
+ });
+
+ it.each([
+ ApplicationRegistrationSourceType.TARBALL,
+ ApplicationRegistrationSourceType.NPM,
+ ])(
+ 'should set PREBUILT execution mode for a new function of a %s application',
+ (applicationSourceType) => {
+ const result = convert({ applicationSourceType });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.PREBUILT);
+ expect(result.checksum).toBe('checksum-1');
+ expect(result.isBuildUpToDate).toBe(true);
+ },
+ );
+
+ it.each([
+ ApplicationRegistrationSourceType.LOCAL,
+ ApplicationRegistrationSourceType.OAUTH_ONLY,
+ ])(
+ 'should keep LIVE execution mode for a new function of a %s application',
+ (applicationSourceType) => {
+ const result = convert({ applicationSourceType });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.LIVE);
+ },
+ );
+
+ it.each([['empty', ''] as const, ['undefined', undefined] as const])(
+ 'should fall back to LIVE for a packaged application with an %s checksum',
+ (_label, builtHandlerChecksum) => {
+ const result = convert({
+ logicFunctionManifest: buildLogicFunctionManifest({
+ builtHandlerChecksum,
+ }),
+ applicationSourceType: ApplicationRegistrationSourceType.NPM,
+ });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.LIVE);
+ },
+ );
+
+ it('should keep LIVE execution mode when prebuilt mode is disabled', () => {
+ const result = convert({
+ applicationSourceType: ApplicationRegistrationSourceType.NPM,
+ isPrebuiltModeEnabled: false,
+ });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.LIVE);
+ });
+
+ it('should keep the execution mode of an already synced function', () => {
+ const result = convert({
+ applicationSourceType: ApplicationRegistrationSourceType.NPM,
+ existingFlatLogicFunctionMaps: buildFlatLogicFunctionMaps(
+ LogicFunctionExecutionMode.LIVE,
+ ),
+ });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.LIVE);
+ });
+
+ it('should keep PREBUILT on an already synced function even when prebuilt mode is disabled', () => {
+ const result = convert({
+ applicationSourceType: ApplicationRegistrationSourceType.NPM,
+ existingFlatLogicFunctionMaps: buildFlatLogicFunctionMaps(
+ LogicFunctionExecutionMode.PREBUILT,
+ ),
+ isPrebuiltModeEnabled: false,
+ });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.PREBUILT);
+ });
+
+ it.each([['empty', ''] as const, ['undefined', undefined] as const])(
+ 'should demote an already synced PREBUILT function to LIVE when the manifest has an %s checksum',
+ (_label, builtHandlerChecksum) => {
+ const result = convert({
+ logicFunctionManifest: buildLogicFunctionManifest({
+ builtHandlerChecksum,
+ }),
+ applicationSourceType: ApplicationRegistrationSourceType.NPM,
+ existingFlatLogicFunctionMaps: buildFlatLogicFunctionMaps(
+ LogicFunctionExecutionMode.PREBUILT,
+ ),
+ });
+
+ expect(result.executionMode).toBe(LogicFunctionExecutionMode.LIVE);
+ },
+ );
+
+ it('should derive the name from the handler when the manifest has no name', () => {
+ const result = convert({
+ logicFunctionManifest: buildLogicFunctionManifest({
+ name: undefined,
+ handlerName: 'myHandler',
+ }),
+ applicationSourceType: ApplicationRegistrationSourceType.LOCAL,
+ });
+
+ expect(result.name).toBe('myHandler');
+ });
+});
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-logic-function-manifest-to-universal-flat-logic-function.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-logic-function-manifest-to-universal-flat-logic-function.util.ts
index 9a0e36caf15..d63dcbb95a0 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-logic-function-manifest-to-universal-flat-logic-function.util.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/converters/from-logic-function-manifest-to-universal-flat-logic-function.util.ts
@@ -1,20 +1,71 @@
import { parse } from 'path';
+import { isNonEmptyString } from '@sniptt/guards';
import { type LogicFunctionManifest } from 'twenty-shared/application';
+import { isDefined } from 'twenty-shared/utils';
+import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+import { isPackagedApplicationSource } from 'src/engine/core-modules/application/application-registration/utils/is-packaged-application-source.util';
+import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/all-flat-entity-maps.type';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import {
LogicFunctionExecutionMode,
LogicFunctionRuntime,
} from 'src/engine/metadata-modules/logic-function/logic-function.entity';
import { type UniversalFlatLogicFunction } from 'src/engine/workspace-manager/workspace-migration/universal-flat-entity/types/universal-flat-logic-function.type';
+const resolveExecutionMode = ({
+ logicFunctionManifest,
+ applicationSourceType,
+ existingFlatLogicFunctionMaps,
+ isPrebuiltModeEnabled,
+}: {
+ logicFunctionManifest: LogicFunctionManifest;
+ applicationSourceType: ApplicationRegistrationSourceType;
+ existingFlatLogicFunctionMaps: AllFlatEntityMaps['flatLogicFunctionMaps'];
+ isPrebuiltModeEnabled: boolean;
+}): LogicFunctionExecutionMode => {
+ const existingFlatLogicFunction = findFlatEntityByUniversalIdentifier({
+ flatEntityMaps: existingFlatLogicFunctionMaps,
+ universalIdentifier: logicFunctionManifest.universalIdentifier,
+ });
+
+ if (isDefined(existingFlatLogicFunction)) {
+ if (
+ existingFlatLogicFunction.executionMode ===
+ LogicFunctionExecutionMode.PREBUILT &&
+ !isNonEmptyString(logicFunctionManifest.builtHandlerChecksum)
+ ) {
+ return LogicFunctionExecutionMode.LIVE;
+ }
+
+ return existingFlatLogicFunction.executionMode;
+ }
+
+ if (
+ isPrebuiltModeEnabled &&
+ isPackagedApplicationSource(applicationSourceType) &&
+ isNonEmptyString(logicFunctionManifest.builtHandlerChecksum)
+ ) {
+ return LogicFunctionExecutionMode.PREBUILT;
+ }
+
+ return LogicFunctionExecutionMode.LIVE;
+};
+
export const fromLogicFunctionManifestToUniversalFlatLogicFunction = ({
logicFunctionManifest,
applicationUniversalIdentifier,
+ applicationSourceType,
+ existingFlatLogicFunctionMaps,
+ isPrebuiltModeEnabled,
now,
}: {
logicFunctionManifest: LogicFunctionManifest;
applicationUniversalIdentifier: string;
+ applicationSourceType: ApplicationRegistrationSourceType;
+ existingFlatLogicFunctionMaps: AllFlatEntityMaps['flatLogicFunctionMaps'];
+ isPrebuiltModeEnabled: boolean;
now: string;
}): UniversalFlatLogicFunction => {
const name =
@@ -42,7 +93,12 @@ export const fromLogicFunctionManifestToUniversalFlatLogicFunction = ({
workflowActionTriggerSettings:
logicFunctionManifest.workflowActionTriggerSettings ?? null,
isBuildUpToDate: true,
- executionMode: LogicFunctionExecutionMode.LIVE,
+ executionMode: resolveExecutionMode({
+ logicFunctionManifest,
+ applicationSourceType,
+ existingFlatLogicFunctionMaps,
+ isPrebuiltModeEnabled,
+ }),
createdAt: now,
updatedAt: now,
deletedAt: null,
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service.ts b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service.ts
index 1fc73599076..86809d69330 100644
--- a/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/application-manifest/services/compute-application-manifest-all-universal-flat-entity-maps.service.ts
@@ -55,18 +55,24 @@ export class ComputeApplicationManifestAllUniversalFlatEntityMapsService {
compute({
manifest,
ownerFlatApplication,
+ fromAllFlatEntityMaps,
+ isLogicFunctionPrebuiltModeEnabled,
now,
workspaceId,
}: {
manifest: Manifest;
ownerFlatApplication: FlatApplication;
+ fromAllFlatEntityMaps: AllFlatEntityMaps;
+ isLogicFunctionPrebuiltModeEnabled: boolean;
now: string;
workspaceId: string;
}): AllFlatEntityMaps {
const allUniversalFlatEntityMaps = createEmptyAllFlatEntityMaps();
- const { universalIdentifier: applicationUniversalIdentifier } =
- ownerFlatApplication;
+ const {
+ universalIdentifier: applicationUniversalIdentifier,
+ sourceType: applicationSourceType,
+ } = ownerFlatApplication;
for (const objectManifest of manifest.objects) {
const flatObjectMetadata =
@@ -194,6 +200,10 @@ export class ComputeApplicationManifestAllUniversalFlatEntityMapsService {
fromLogicFunctionManifestToUniversalFlatLogicFunction({
logicFunctionManifest,
applicationUniversalIdentifier,
+ applicationSourceType,
+ existingFlatLogicFunctionMaps:
+ fromAllFlatEntityMaps.flatLogicFunctionMaps,
+ isPrebuiltModeEnabled: isLogicFunctionPrebuiltModeEnabled,
now,
}),
universalFlatEntityMapsToMutate:
diff --git a/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-packaged-application-source.util.ts b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-packaged-application-source.util.ts
new file mode 100644
index 00000000000..0a01f8fd83f
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/application-registration/utils/is-packaged-application-source.util.ts
@@ -0,0 +1,7 @@
+import { ApplicationRegistrationSourceType } from 'src/engine/core-modules/application/application-registration/enums/application-registration-source-type.enum';
+
+export const isPackagedApplicationSource = (
+ sourceType: ApplicationRegistrationSourceType,
+): boolean =>
+ sourceType === ApplicationRegistrationSourceType.TARBALL ||
+ sourceType === ApplicationRegistrationSourceType.NPM;
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/services/lambda-executor-manager.service.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/services/lambda-executor-manager.service.ts
index 529ea8d598c..d88cffad511 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/services/lambda-executor-manager.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/lambda/services/lambda-executor-manager.service.ts
@@ -192,6 +192,13 @@ export class LambdaExecutorManagerService {
await this.cacheLockService.withLock(
async () => {
+ if (
+ (await this.getInstalledBundleChecksum(flatLogicFunction)) ===
+ checksum
+ ) {
+ return;
+ }
+
const compiledCode =
await this.logicFunctionResourceService.getBuiltCode({
workspaceId: flatLogicFunction.workspaceId,
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/local/services/local-prebuilt-bundle.service.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/local/services/local-prebuilt-bundle.service.ts
index e69cb2cbea0..483528af2d1 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/local/services/local-prebuilt-bundle.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-drivers/drivers/local/services/local-prebuilt-bundle.service.ts
@@ -44,6 +44,13 @@ export class LocalPrebuiltBundleService {
await this.cacheLockService.withLock(
async () => {
+ if (
+ (await this.getInstalledBundleChecksum(flatLogicFunction)) ===
+ checksum
+ ) {
+ return;
+ }
+
const prebuiltDir = getLocalPrebuiltBundleDir(flatLogicFunction);
await fs.mkdir(prebuiltDir, { recursive: true });
diff --git a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
index b9a7221d502..ff7b864dcb8 100644
--- a/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/logic-function/logic-function-executor/logic-function-executor.service.ts
@@ -165,9 +165,10 @@ export class LogicFunctionExecutorService {
});
if (effectiveExecutionMode === LogicFunctionExecutionMode.PREBUILT) {
- await this.assertPrebuiltBundleInstalled({
+ await this.ensurePrebuiltBundleInstalled({
driver,
flatLogicFunction,
+ flatApplication,
});
}
@@ -233,21 +234,41 @@ export class LogicFunctionExecutorService {
return flatLogicFunction.executionMode ?? LogicFunctionExecutionMode.LIVE;
}
- private async assertPrebuiltBundleInstalled({
+ private async ensurePrebuiltBundleInstalled({
driver,
flatLogicFunction,
+ flatApplication,
}: {
driver: ReturnType<LogicFunctionDriverFactory['getCurrentDriver']>;
flatLogicFunction: FlatLogicFunction;
+ flatApplication: FlatApplication;
}): Promise<void> {
const installedChecksum =
await driver.getInstalledBundleChecksum(flatLogicFunction);
- if (installedChecksum !== flatLogicFunction.checksum) {
+ if (installedChecksum === flatLogicFunction.checksum) {
+ return;
+ }
+
+ try {
+ await driver.installPrebuiltBundle({
+ flatLogicFunction,
+ flatApplication,
+ applicationUniversalIdentifier: flatApplication.universalIdentifier,
+ });
+ } catch (error) {
+ const cause = error instanceof Error ? error.message : String(error);
+
+ this.logger.error(
+ `Failed to install prebuilt bundle on-demand for function '${flatLogicFunction.id}' ` +
+ `(installed=${installedChecksum ?? 'none'}, expected=${flatLogicFunction.checksum ?? 'none'}): ` +
+ `${cause}`,
+ error instanceof Error ? error.stack : undefined,
+ );
throw new LogicFunctionException(
- `Prebuilt bundle is not installed for function '${flatLogicFunction.id}' ` +
- `(installed=${installedChecksum ?? 'none'}, expected=${flatLogicFunction.checksum ?? 'none'}). ` +
- `Rebuild and try again.`,
+ `Failed to install the prebuilt bundle for function '${flatLogicFunction.id}' ` +
+ `(installed=${installedChecksum ?? 'none'}, expected=${flatLogicFunction.checksum ?? 'none'}): ` +
+ `${cause}`,
LogicFunctionExceptionCode.LOGIC_FUNCTION_PREBUILT_BUNDLE_NOT_INSTALLED,
);
}