Skip to content

The open alternative to Salesforce, designed for AI.

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.ts
index 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/datab
import { 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/workspace
WorkspaceMigrationModule,
WorkspaceMigrationRunnerModule,
WorkspaceSchemaManagerModule,
+ WorkflowVersionCoreModule,
],
providers: [
CorrectStandardFieldAcronymCasingCommand,
@@ -36,6 +39,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
BackfillTimelineActivityMessageCampaignIndexesCommand,
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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 stringified
const 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);
};