The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
fix(server): backfill workflow rich text record fields (2.41 upgrade command) (#24965)
Charles Bochet77e9ead5e06d
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.tsindex 2ebc541bd43..7ae6d958dba 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts@@ -10,7 +10,9 @@ import { BackfillTimelineActivityMessageCampaignIndexesCommand } from 'src/databimport { MakeNotesAndTasksInheritTheirTargetsCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command';import { MoveMessageCampaignCommandsToCampaignFlagCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789468244000-move-message-campaign-commands-to-campaign-flag.command';import { RemoveSeeActiveVersionCommandMenuItemCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789470915878-remove-see-active-version-command-menu-item.command';+import { NormalizeWorkflowRecordCrudRichTextFieldsCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789482628000-normalize-workflow-record-crud-rich-text-fields.command';import { ApplicationModule } from 'src/engine/core-modules/application/application.module';+import { WorkflowVersionCoreModule } from 'src/engine/core-modules/workflow/workflow-version-core.module';import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';@@ -26,6 +28,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspaceWorkspaceMigrationModule,WorkspaceMigrationRunnerModule,WorkspaceSchemaManagerModule,+ WorkflowVersionCoreModule,],providers: [CorrectStandardFieldAcronymCasingCommand,@@ -36,6 +39,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspaceBackfillTimelineActivityMessageCampaignIndexesCommand,MoveMessageCampaignCommandsToCampaignFlagCommand,RemoveSeeActiveVersionCommandMenuItemCommand,+ NormalizeWorkflowRecordCrudRichTextFieldsCommand,],})export class V2_41_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789482628000-normalize-workflow-record-crud-rich-text-fields.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789482628000-normalize-workflow-record-crud-rich-text-fields.command.tsnew file mode 100644index 00000000000..686f35fac6e--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789482628000-normalize-workflow-record-crud-rich-text-fields.command.ts@@ -0,0 +1,180 @@+import { Command } from 'nest-commander';+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { FieldMetadataType } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';+import { normalizeRecordCrudRichTextFieldsInSteps } from 'src/database/commands/upgrade-version-command/2-41/utils/normalize-record-crud-rich-text-fields.util';+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { WorkflowVersionCoreSyncService } from 'src/engine/core-modules/workflow/services/workflow-version-core-sync.service';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';+import { findManyFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps.util';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { type WorkflowVersionWorkspaceEntity } from 'src/modules/workflow/common/standard-objects/workflow-version.workspace-entity';++@RegisteredWorkspaceCommand('2.41.0', 1789482628000)+@Command({+ name: 'upgrade:2-41:normalize-workflow-record-crud-rich-text-fields',+ description:+ 'Normalize bare-string rich text field values into the { blocknote, markdown } object shape in workflow create/update/upsert record steps, which otherwise throws at runtime',+})+export class NormalizeWorkflowRecordCrudRichTextFieldsCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly workspaceOrmManager: WorkspaceOrmManager,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workflowVersionCoreSyncService: WorkflowVersionCoreSyncService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ dataSource,+ }: RunOnWorkspaceArgs): Promise<void> {+ const isDryRun = options.dryRun ?? false;++ if (!isDefined(dataSource)) {+ this.logger.warn(+ `No data source for workspace ${workspaceId}, skipping backfill`,+ );++ return;+ }++ const { flatObjectMetadataMaps, flatFieldMetadataMaps } =+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ 'flatFieldMetadataMaps',+ ]);++ const workflowVersionObject =+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({+ flatEntityMaps: flatObjectMetadataMaps,+ universalIdentifier:+ STANDARD_OBJECTS.workflowVersion.universalIdentifier,+ });++ if (!isDefined(workflowVersionObject)) {+ return;+ }++ const richTextFieldNamesByObjectName =+ this.buildRichTextFieldNamesByObjectName({+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ });++ if (Object.keys(richTextFieldNamesByObjectName).length === 0) {+ return;+ }++ const workflowVersionRepository =+ await this.workspaceOrmManager.getRepository<WorkflowVersionWorkspaceEntity>(+ 'workflowVersion',+ { shouldBypassPermissionChecks: true },+ );++ const allVersions = await workflowVersionRepository.find();++ const versionsToSyncToCore: WorkflowVersionWorkspaceEntity[] = [];+ let rewrittenCount = 0;++ for (const version of allVersions) {+ const { value, hasChanged, isRecordCrudRichTextCandidate } =+ normalizeRecordCrudRichTextFieldsInSteps({+ steps: version.steps,+ richTextFieldNamesByObjectName,+ });++ if (!isRecordCrudRichTextCandidate) {+ continue;+ }++ versionsToSyncToCore.push({ ...version, steps: value });++ if (!hasChanged) {+ continue;+ }++ rewrittenCount += 1;++ if (!isDryRun) {+ await dataSource.query(+ `UPDATE "${getWorkspaceSchemaName(workspaceId)}"."workflowVersion" SET steps = $1::jsonb WHERE id = $2`,+ [JSON.stringify(value), version.id],+ );+ }+ }++ if (versionsToSyncToCore.length === 0) {+ return;+ }++ const hasCoreWorkflowVersionIdField = isDefined(+ flatFieldMetadataMaps.byUniversalIdentifier[+ STANDARD_OBJECTS.workflowVersion.fields.coreWorkflowVersionId+ .universalIdentifier+ ],+ );++ if (!hasCoreWorkflowVersionIdField) {+ this.logger.warn(+ `${isDryRun ? '[DRY RUN] ' : ''}Normalized rich text record fields in ${rewrittenCount} workflow version(s) for workspace ${workspaceId}; workflowVersion.coreWorkflowVersionId is missing, skipping the core sync`,+ );++ return;+ }++ if (!isDryRun) {+ await this.workflowVersionCoreSyncService.upsertToCore(+ workspaceId,+ versionsToSyncToCore,+ );+ }++ this.logger.log(+ `${isDryRun ? '[DRY RUN] ' : ''}Normalized rich text record fields in ${rewrittenCount} workflow version(s) and synced ${versionsToSyncToCore.length} to core for workspace ${workspaceId}`,+ );+ }++ private buildRichTextFieldNamesByObjectName({+ flatObjectMetadataMaps,+ flatFieldMetadataMaps,+ }: {+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;+ }): Record<string, string[]> {+ const richTextFieldNamesByObjectName: Record<string, string[]> = {};++ for (const flatObjectMetadata of Object.values(+ flatObjectMetadataMaps.byUniversalIdentifier,+ )) {+ if (!isDefined(flatObjectMetadata)) {+ continue;+ }++ const richTextFieldNames = findManyFlatEntityByIdInFlatEntityMaps({+ flatEntityIds: flatObjectMetadata.fieldIds,+ flatEntityMaps: flatFieldMetadataMaps,+ })+ .filter((field) => field.type === FieldMetadataType.RICH_TEXT)+ .map((field) => field.name);++ if (richTextFieldNames.length > 0) {+ richTextFieldNamesByObjectName[flatObjectMetadata.nameSingular] =+ richTextFieldNames;+ }+ }++ return richTextFieldNamesByObjectName;+ }+}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/__tests__/normalize-record-crud-rich-text-fields.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/__tests__/normalize-record-crud-rich-text-fields.util.spec.tsnew file mode 100644index 00000000000..be80ff1d12f--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/__tests__/normalize-record-crud-rich-text-fields.util.spec.ts@@ -0,0 +1,101 @@+import { normalizeRecordCrudRichTextFieldsInSteps } from 'src/database/commands/upgrade-version-command/2-41/utils/normalize-record-crud-rich-text-fields.util';++const richTextFieldNamesByObjectName = { person: ['relationshipSummary'] };++const buildStep = (+ objectRecord: Record<string, unknown>,+ type = 'CREATE_RECORD',+) => ({+ id: 'step-1',+ name: 'Create person',+ type,+ settings: { input: { objectName: 'person', objectRecord } },+});++describe('normalizeRecordCrudRichTextFieldsInSteps', () => {+ it.each(['CREATE_RECORD', 'UPDATE_RECORD', 'UPSERT_RECORD'])(+ 'wraps a bare-string rich text field into the markdown object shape in a %s step',+ (type) => {+ const steps = [+ buildStep(+ {+ name: 'Amina',+ relationshipSummary: 'Latest donation: {{trigger.body.amount}}',+ },+ type,+ ),+ ];++ const { value, hasChanged, isRecordCrudRichTextCandidate } =+ normalizeRecordCrudRichTextFieldsInSteps({+ steps,+ richTextFieldNamesByObjectName,+ });++ expect(hasChanged).toBe(true);+ expect(isRecordCrudRichTextCandidate).toBe(true);+ expect(value[0].settings.input.objectRecord).toEqual({+ name: 'Amina',+ relationshipSummary: {+ blocknote: null,+ markdown: 'Latest donation: {{trigger.body.amount}}',+ },+ });+ });++ it('leaves an already-object rich text value untouched but flags it as a candidate', () => {+ const steps = [+ buildStep({ relationshipSummary: { blocknote: '[]', markdown: null } }),+ ];++ const { value, hasChanged, isRecordCrudRichTextCandidate } =+ normalizeRecordCrudRichTextFieldsInSteps({+ steps,+ richTextFieldNamesByObjectName,+ });++ expect(hasChanged).toBe(false);+ expect(isRecordCrudRichTextCandidate).toBe(true);+ expect(value).toBe(steps);+ });++ it('does not touch non-rich-text string fields', () => {+ const steps = [buildStep({ name: 'Amina' })];++ const { hasChanged } = normalizeRecordCrudRichTextFieldsInSteps({+ steps,+ richTextFieldNamesByObjectName,+ });++ expect(hasChanged).toBe(false);+ });++ it('ignores steps that are not record-crud with an object record', () => {+ const steps = [+ {+ id: 'step-1',+ type: 'SEND_EMAIL',+ settings: { input: { relationshipSummary: 'not a record field' } },+ },+ ];++ const { hasChanged, isRecordCrudRichTextCandidate } =+ normalizeRecordCrudRichTextFieldsInSteps({+ steps,+ richTextFieldNamesByObjectName,+ });++ expect(hasChanged).toBe(false);+ expect(isRecordCrudRichTextCandidate).toBe(false);+ });++ it('returns steps unchanged when steps is not an array', () => {+ const { value, hasChanged } = normalizeRecordCrudRichTextFieldsInSteps({+ steps: null,+ richTextFieldNamesByObjectName,+ });++ expect(hasChanged).toBe(false);+ expect(value).toBeNull();+ });+});diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/normalize-record-crud-rich-text-fields.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/normalize-record-crud-rich-text-fields.util.tsnew file mode 100644index 00000000000..a736bff1f91--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/utils/normalize-record-crud-rich-text-fields.util.ts@@ -0,0 +1,89 @@+import { isNonEmptyArray, isString } from '@sniptt/guards';+import { WorkflowActionType } from 'twenty-shared/workflow';+import { z } from 'zod';++const recordCrudStepSchema = z.object({+ type: z.enum([+ WorkflowActionType.CREATE_RECORD,+ WorkflowActionType.UPDATE_RECORD,+ WorkflowActionType.UPSERT_RECORD,+ ]),+ settings: z.object({+ input: z.object({+ objectName: z.string(),+ objectRecord: z.record(z.string(), z.unknown()),+ }),+ }),+});++export const normalizeRecordCrudRichTextFieldsInSteps = <TSteps>({+ steps,+ richTextFieldNamesByObjectName,+}: {+ steps: TSteps;+ richTextFieldNamesByObjectName: Record<string, string[]>;+}): {+ value: TSteps;+ hasChanged: boolean;+ isRecordCrudRichTextCandidate: boolean;+} => {+ if (!Array.isArray(steps)) {+ return {+ value: steps,+ hasChanged: false,+ isRecordCrudRichTextCandidate: false,+ };+ }++ let hasChanged = false;+ let isRecordCrudRichTextCandidate = false;++ const nextSteps = steps.map((step) => {+ const parsedStep = recordCrudStepSchema.safeParse(step);++ if (!parsedStep.success) {+ return step;+ }++ const { objectName, objectRecord } = parsedStep.data.settings.input;+ const richTextFieldNames = richTextFieldNamesByObjectName[objectName];++ if (!isNonEmptyArray(richTextFieldNames)) {+ return step;+ }++ isRecordCrudRichTextCandidate = true;++ let hasStepChanged = false;+ const nextObjectRecord: Record<string, unknown> = { ...objectRecord };++ for (const fieldName of richTextFieldNames) {+ const value = nextObjectRecord[fieldName];++ if (isString(value)) {+ nextObjectRecord[fieldName] = { blocknote: null, markdown: value };+ hasStepChanged = true;+ }+ }++ if (!hasStepChanged) {+ return step;+ }++ hasChanged = true;++ return {+ ...step,+ settings: {+ ...step.settings,+ input: { ...step.settings.input, objectRecord: nextObjectRecord },+ },+ };+ });++ return {+ value: hasChanged ? (nextSteps as TSteps) : steps,+ hasChanged,+ isRecordCrudRichTextCandidate,+ };+};diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/utils/__tests__/resolve-rich-text-fields-in-record.util.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/utils/__tests__/resolve-rich-text-fields-in-record.util.spec.tsnew file mode 100644index 00000000000..50ff4f867b1--- /dev/null+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/utils/__tests__/resolve-rich-text-fields-in-record.util.spec.ts@@ -0,0 +1,117 @@+import { FieldMetadataType } from 'twenty-shared/types';++import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';+import { resolveRichTextFieldsInRecord } from 'src/modules/workflow/workflow-executor/utils/resolve-rich-text-fields-in-record.util';++const bodyField = getFlatFieldMetadataMock({+ id: 'body-field',+ universalIdentifier: 'body-universal-id',+ objectMetadataId: 'note-object',+ name: 'body',+ type: FieldMetadataType.RICH_TEXT,+});++const titleField = getFlatFieldMetadataMock({+ id: 'title-field',+ universalIdentifier: 'title-universal-id',+ objectMetadataId: 'note-object',+ name: 'title',+ type: FieldMetadataType.TEXT,+});++const flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata> = {+ byUniversalIdentifier: {+ [bodyField.universalIdentifier]: bodyField,+ [titleField.universalIdentifier]: titleField,+ },+ universalIdentifierById: {+ [bodyField.id]: bodyField.universalIdentifier,+ [titleField.id]: titleField.universalIdentifier,+ },+ universalIdentifiersByApplicationId: {},+};++const objectMetadataInfo = {+ flatObjectMetadata: getFlatObjectMetadataMock({+ id: 'note-object',+ universalIdentifier: 'note-universal-id',+ nameSingular: 'note',+ namePlural: 'notes',+ fieldIds: [bodyField.id, titleField.id],+ }),+ flatFieldMetadataMaps,+};++const context = {+ trigger: { body: { amount: 42, currency: 'EUR', meta: { source: 'form' } } },+};++describe('resolveRichTextFieldsInRecord', () => {+ it('keeps a markdown that is exactly one variable a string', () => {+ const resolved = resolveRichTextFieldsInRecord(+ { body: { markdown: '{{trigger.body.amount}}', blocknote: null } },+ objectMetadataInfo,+ context,+ );++ expect(resolved.body).toEqual({ markdown: '42', blocknote: null });+ });++ it('interpolates variables inside a markdown', () => {+ const resolved = resolveRichTextFieldsInRecord(+ {+ body: {+ markdown:+ 'Latest donation: {{trigger.body.amount}} {{trigger.body.currency}}',+ blocknote: null,+ },+ },+ objectMetadataInfo,+ context,+ );++ expect(resolved.body).toEqual({+ markdown: 'Latest donation: 42 EUR',+ blocknote: null,+ });+ });++ it('serializes an object resolved from a whole-string variable', () => {+ const resolved = resolveRichTextFieldsInRecord(+ { body: { markdown: '{{trigger.body.meta}}', blocknote: null } },+ objectMetadataInfo,+ context,+ );++ expect(resolved.body).toEqual({+ markdown: '{"source":"form"}',+ blocknote: null,+ });+ });++ it('leaves a value that is not a rich text object untouched', () => {+ const resolved = resolveRichTextFieldsInRecord(+ { body: 'legacy bare string {{trigger.body.amount}}', title: 'x' },+ objectMetadataInfo,+ context,+ );++ expect(resolved.body).toBe('legacy bare string {{trigger.body.amount}}');+ });++ it('does not touch fields that are not rich text', () => {+ const resolved = resolveRichTextFieldsInRecord(+ {+ title: '{{trigger.body.amount}}',+ body: { markdown: 'a', blocknote: null },+ },+ objectMetadataInfo,+ context,+ );++ expect(resolved.title).toBe('{{trigger.body.amount}}');+ });+});diff --git a/packages/twenty-server/src/modules/workflow/workflow-executor/utils/resolve-rich-text-fields-in-record.util.ts b/packages/twenty-server/src/modules/workflow/workflow-executor/utils/resolve-rich-text-fields-in-record.util.tsindex 4e35a7198ff..238bf8f1d58 100644--- a/packages/twenty-server/src/modules/workflow/workflow-executor/utils/resolve-rich-text-fields-in-record.util.ts+++ b/packages/twenty-server/src/modules/workflow/workflow-executor/utils/resolve-rich-text-fields-in-record.util.ts@@ -1,12 +1,19 @@-import { isString } from 'class-validator';-import { isDefined, resolveRichTextVariables } from 'twenty-shared/utils';+import { isString } from '@sniptt/guards';+import { richTextValueSchema } from 'twenty-shared/types';+import {+ resolveRichTextVariables,+ resolveStringTemplate,+} from 'twenty-shared/utils';import { type ObjectMetadataInfo } from 'src/modules/workflow/common/workspace-services/workflow-common.workspace-service';import { findRichTextFieldNames } from 'src/modules/workflow/workflow-executor/utils/find-rich-text-field-names.util';export const resolveRichTextFieldsInRecord = (objectRecord: Record<string, unknown>,- objectMetadataInfo: ObjectMetadataInfo,+ objectMetadataInfo: Pick<+ ObjectMetadataInfo,+ 'flatObjectMetadata' | 'flatFieldMetadataMaps'+ >,context: Record<string, unknown>,): Record<string, unknown> => {const richTextFieldNames = findRichTextFieldNames(objectMetadataInfo);@@ -14,20 +21,24 @@ export const resolveRichTextFieldsInRecord = (const resolvedRecord = { ...objectRecord };for (const fieldName of richTextFieldNames) {- const fieldValue = resolvedRecord[fieldName];-- if (- isDefined(fieldValue) &&- 'blocknote' in fieldValue &&- isString(fieldValue.blocknote)- ) {- const richTextValue = fieldValue as { blocknote: string };-- resolvedRecord[fieldName] = {- ...richTextValue,- blocknote: resolveRichTextVariables(richTextValue.blocknote, context),- };+ const parsedRichTextValue = richTextValueSchema.safeParse(+ resolvedRecord[fieldName],+ );++ if (!parsedRichTextValue.success) {+ continue;}++ const { blocknote, markdown } = parsedRichTextValue.data;++ resolvedRecord[fieldName] = {+ blocknote: isString(blocknote)+ ? resolveRichTextVariables(blocknote, context)+ : blocknote,+ markdown: isString(markdown)+ ? resolveStringTemplate(markdown, context)+ : markdown,+ };}return resolvedRecord;diff --git a/packages/twenty-shared/src/utils/__tests__/variable-resolver.test.ts b/packages/twenty-shared/src/utils/__tests__/variable-resolver.test.tsindex f8013e86a83..23f8cea8491 100644--- a/packages/twenty-shared/src/utils/__tests__/variable-resolver.test.ts+++ b/packages/twenty-shared/src/utils/__tests__/variable-resolver.test.ts@@ -1,4 +1,4 @@-import { resolveInput } from '../variable-resolver';+import { resolveInput, resolveStringTemplate } from '../variable-resolver';describe('resolveInput', () => {const context = {@@ -201,3 +201,32 @@ describe('resolveInput', () => {});});});++describe('resolveStringTemplate', () => {+ const context = { trigger: { amount: 42, meta: { source: 'form' } } };++ it('keeps a whole-string variable a string instead of its native type', () => {+ expect(resolveStringTemplate('{{trigger.amount}}', context)).toBe('42');+ expect(resolveInput('{{trigger.amount}}', context)).toBe(42);+ });++ it('interpolates variables inside text', () => {+ expect(+ resolveStringTemplate('Amount: {{trigger.amount}} EUR', context),+ ).toBe('Amount: 42 EUR');+ });++ it('serializes an object variable as JSON', () => {+ expect(resolveStringTemplate('{{trigger.meta}}', context)).toBe(+ '{"source":"form"}',+ );+ });++ it('serializes an array variable as JSON', () => {+ expect(+ resolveStringTemplate('IDs: {{trigger.ids}}', {+ trigger: { ids: [1, 2, 3] },+ }),+ ).toBe('IDs: [1,2,3]');+ });+});diff --git a/packages/twenty-shared/src/utils/index.ts b/packages/twenty-shared/src/utils/index.tsindex 3671233ac62..8887d77aa22 100644--- a/packages/twenty-shared/src/utils/index.ts+++ b/packages/twenty-shared/src/utils/index.ts@@ -317,6 +317,10 @@ export { isValidVariable } from './validation/isValidVariable';export { normalizeLocale } from './validation/normalizeLocale';export { getCountryCodesForCallingCode } from './validation/phones-value/getCountryCodesForCallingCode';export { isValidCountryCode } from './validation/phones-value/isValidCountryCode';-export { isVariableReference, resolveInput } from './variable-resolver';+export {+ isVariableReference,+ resolveInput,+ resolveStringTemplate,+} from './variable-resolver';export { getViewLayoutFromViewType } from './views/getViewLayoutFromViewType';export { isWidgetViewType } from './views/isWidgetViewType';diff --git a/packages/twenty-shared/src/utils/variable-resolver.ts b/packages/twenty-shared/src/utils/variable-resolver.tsindex 03b7b0d3d59..b9006790b37 100644--- a/packages/twenty-shared/src/utils/variable-resolver.ts+++ b/packages/twenty-shared/src/utils/variable-resolver.ts@@ -1,10 +1,8 @@+import { isObject, isString } from '@sniptt/guards';+import { evalFromContext } from '@/utils/evalFromContext';import { isDefined } from '@/utils/validation';-const isString = (value: unknown): value is string => {- return typeof value === 'string';-};-const VARIABLE_PATTERN = RegExp('\\{\\{([^{}]+)\\}\\}', 'g');export const isVariableReference = (input: unknown): boolean =>@@ -26,7 +24,7 @@ export const resolveInput = (return resolveArray(unresolvedInput, context);}- if (typeof unresolvedInput === 'object' && unresolvedInput !== null) {+ if (isObject(unresolvedInput)) {return resolveObject(unresolvedInput, context);}@@ -55,7 +53,7 @@ const resolveObject = (const resolvedKey = resolveInput(key, context);resolvedObject[- typeof resolvedKey === 'string' ? resolvedKey : String(resolvedKey)+ isString(resolvedKey) ? resolvedKey : String(resolvedKey)] = resolveInput(value, context);return resolvedObject;@@ -64,6 +62,21 @@ const resolveObject = ();};+export const resolveStringTemplate = (+ input: string,+ context: Record<string, unknown>,+): string => {+ return input.replace(VARIABLE_PATTERN, (matchedToken, _) => {+ const processedToken = evalFromContext(matchedToken, context);++ if (isObject(processedToken)) {+ return JSON.stringify(processedToken);+ }++ return String(processedToken);+ });+};+// Returns the resolved value itself when the whole string is one variable, so// `{{step.amount}}` keeps its type instead of being stringifiedconst resolveString = (@@ -80,13 +93,5 @@ const resolveString = (return evalFromContext(input, context);}- return input.replace(VARIABLE_PATTERN, (matchedToken, _) => {- const processedToken = evalFromContext(matchedToken, context);-- if (typeof processedToken === 'object' && processedToken !== null) {- return JSON.stringify(processedToken);- }-- return String(processedToken);- });+ return resolveStringTemplate(input, context);};