Skip to content

The open alternative to Salesforce, designed for AI.

Reject bare select filter values and rewrite stored ones (#28339)

Charles Bochetc598453ba459
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-upgrade-version-command.module.ts
index f4e8b61eabb..c1d16eab7e5 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-upgrade-version-command.module.ts
@@ -3,6 +3,7 @@ import { Module } from '@nestjs/common';
import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/workspace-iterator.module';
import { BackfillMemberRoleUniversalIdentifierCommand } from 'src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792413669590-backfill-member-role-universal-identifier.command';
import { AddTimelineActivityLinkedRecordIdIndexCommand } from 'src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792423420000-add-timeline-activity-linked-record-id-index.command';
+import { WrapBareSelectFilterValuesCommand } from 'src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792423785749-wrap-bare-select-filter-values.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { RoleModule } from 'src/engine/metadata-modules/role/role.module';
import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';
@@ -21,6 +22,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
providers: [
BackfillMemberRoleUniversalIdentifierCommand,
AddTimelineActivityLinkedRecordIdIndexCommand,
+ WrapBareSelectFilterValuesCommand,
],
})
export class V2_50_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792423785749-wrap-bare-select-filter-values.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792423785749-wrap-bare-select-filter-values.command.ts
new file mode 100644
index 00000000000..e7d5fb0d9d8
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/2-50-workspace-command-1792423785749-wrap-bare-select-filter-values.command.ts
@@ -0,0 +1,272 @@
+import { Command } from 'nest-commander';
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+import { isDefined } from 'twenty-shared/utils';
+import { type DataSource } from 'typeorm';
+
+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 {
+ wrapBareSelectRecordFilterValue,
+ wrapBareSelectValuesOfChartConfiguration,
+ wrapBareSelectValuesOfFindRecordsSteps,
+} from 'src/database/commands/upgrade-version-command/2-50/utils/wrap-bare-select-filter-values.util';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+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 { 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 { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+
+const REWRITE_BATCH_SIZE = 100;
+
+type StoredJsonbRow = { id: string; value: unknown };
+
+type StoredRecordFilterRow = StoredJsonbRow & {
+ fieldMetadataId: string;
+ relationTargetFieldMetadataId?: string | null;
+ operand: string;
+ subFieldName: string | null;
+};
+
+type RewriteRowsArgs<TRow extends StoredJsonbRow> = {
+ dataSource: DataSource;
+ isDryRun: boolean;
+ tableName: string;
+ columnName: string;
+ selectedColumns?: string;
+ whereClause: string;
+ whereParameters: unknown[];
+ mapRow: (row: TRow) => {
+ value: unknown;
+ hasChanged: boolean;
+ };
+};
+
+@RegisteredWorkspaceCommand('2.50.0', 1792423785749)
+@Command({
+ name: 'upgrade:2-50:wrap-bare-select-filter-values',
+ description:
+ 'Store SELECT and MULTI_SELECT filter values of views, row level permission predicates, chart widgets and workflow Find Records steps as a stringified array of options, replacing a bare option value',
+})
+export class WrapBareSelectFilterValuesCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ dataSource,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.warn(
+ `No data source for workspace ${workspaceId}, skipping select filter value rewrite`,
+ );
+
+ return;
+ }
+
+ const isDryRun = options.dryRun ?? false;
+
+ const { flatFieldMetadataMaps, flatObjectMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatFieldMetadataMaps',
+ 'flatObjectMetadataMaps',
+ ]);
+
+ const mapStoredRecordFilterRow = ({
+ value,
+ ...recordFilter
+ }: StoredRecordFilterRow) => {
+ const mappedValue = wrapBareSelectRecordFilterValue({
+ recordFilter: { ...recordFilter, value },
+ flatFieldMetadataMaps,
+ }).value;
+
+ return { value: mappedValue, hasChanged: mappedValue !== value };
+ };
+
+ const viewFilterCount = await this.rewriteRows<StoredRecordFilterRow>({
+ dataSource,
+ isDryRun,
+ tableName: 'core."viewFilter"',
+ columnName: 'value',
+ selectedColumns:
+ '"fieldMetadataId", "relationTargetFieldMetadataId", operand, "subFieldName"',
+ whereClause: `"workspaceId" = $1 AND jsonb_typeof(value) = 'string'`,
+ whereParameters: [workspaceId],
+ mapRow: mapStoredRecordFilterRow,
+ });
+
+ const rowLevelPermissionPredicateCount =
+ await this.rewriteRows<StoredRecordFilterRow>({
+ dataSource,
+ isDryRun,
+ tableName: 'core."rowLevelPermissionPredicate"',
+ columnName: 'value',
+ selectedColumns: '"fieldMetadataId", operand, "subFieldName"',
+ whereClause: `"workspaceId" = $1 AND jsonb_typeof(value) = 'string' AND "workspaceMemberFieldMetadataId" IS NULL`,
+ whereParameters: [workspaceId],
+ mapRow: mapStoredRecordFilterRow,
+ });
+
+ const chartWidgetCount = await this.rewriteRows({
+ dataSource,
+ isDryRun,
+ tableName: 'core."pageLayoutWidget"',
+ columnName: 'configuration',
+ whereClause: `"workspaceId" = $1 AND configuration -> 'filter' -> 'recordFilters' IS NOT NULL`,
+ whereParameters: [workspaceId],
+ mapRow: ({ value }) =>
+ wrapBareSelectValuesOfChartConfiguration({
+ configuration: value,
+ flatFieldMetadataMaps,
+ }),
+ });
+
+ const coreWorkflowVersionCount = await this.rewriteRows({
+ dataSource,
+ isDryRun,
+ tableName: 'core."workflowVersion"',
+ columnName: 'steps',
+ whereClause: `"workspaceId" = $1 AND steps @> '[{"type":"FIND_RECORDS"}]'`,
+ whereParameters: [workspaceId],
+ mapRow: ({ value }) =>
+ wrapBareSelectValuesOfFindRecordsSteps({
+ steps: value,
+ flatFieldMetadataMaps,
+ }),
+ });
+
+ const workspaceWorkflowVersionCount =
+ await this.rewriteWorkspaceWorkflowVersions({
+ dataSource,
+ isDryRun,
+ workspaceId,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ });
+
+ if (
+ !isDryRun &&
+ viewFilterCount +
+ rowLevelPermissionPredicateCount +
+ chartWidgetCount +
+ coreWorkflowVersionCount >
+ 0
+ ) {
+ await this.workspaceCacheService.invalidateAndRecompute(workspaceId, [
+ 'flatViewFilterMaps',
+ 'flatRowLevelPermissionPredicateMaps',
+ 'flatPageLayoutWidgetMaps',
+ 'flatWorkflowVersionMaps',
+ ]);
+ }
+
+ if (
+ viewFilterCount +
+ rowLevelPermissionPredicateCount +
+ chartWidgetCount +
+ coreWorkflowVersionCount +
+ workspaceWorkflowVersionCount >
+ 0
+ ) {
+ this.logger.log(
+ `${isDryRun ? '[DRY RUN] ' : ''}Wrapped bare select filter values in workspace ${workspaceId}: ${viewFilterCount} view filter(s), ${rowLevelPermissionPredicateCount} row level permission predicate(s), ${chartWidgetCount} chart widget(s), ${coreWorkflowVersionCount} core workflow version(s), ${workspaceWorkflowVersionCount} workflow version(s)`,
+ );
+ }
+ }
+
+ private async rewriteWorkspaceWorkflowVersions({
+ dataSource,
+ isDryRun,
+ workspaceId,
+ flatObjectMetadataMaps,
+ flatFieldMetadataMaps,
+ }: {
+ dataSource: DataSource;
+ isDryRun: boolean;
+ workspaceId: string;
+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+ }): Promise<number> {
+ const workflowVersionFlatObjectMetadata =
+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({
+ flatEntityMaps: flatObjectMetadataMaps,
+ universalIdentifier:
+ STANDARD_OBJECTS.workflowVersion.universalIdentifier,
+ });
+
+ if (!isDefined(workflowVersionFlatObjectMetadata)) {
+ return 0;
+ }
+
+ return this.rewriteRows({
+ dataSource,
+ isDryRun,
+ tableName: `"${getWorkspaceSchemaName(workspaceId)}"."workflowVersion"`,
+ columnName: 'steps',
+ whereClause: `steps @> '[{"type":"FIND_RECORDS"}]'`,
+ whereParameters: [],
+ mapRow: ({ value }) =>
+ wrapBareSelectValuesOfFindRecordsSteps({
+ steps: value,
+ flatFieldMetadataMaps,
+ }),
+ });
+ }
+
+ private async rewriteRows<TRow extends StoredJsonbRow>({
+ dataSource,
+ isDryRun,
+ tableName,
+ columnName,
+ selectedColumns,
+ whereClause,
+ whereParameters,
+ mapRow,
+ }: RewriteRowsArgs<TRow>): Promise<number> {
+ let rewrittenRowCount = 0;
+ let afterRowId: string | undefined;
+
+ while (true) {
+ const parameters = isDefined(afterRowId)
+ ? [...whereParameters, afterRowId]
+ : whereParameters;
+
+ const rows: TRow[] = await dataSource.query(
+ `SELECT id, ${columnName} AS value${isDefined(selectedColumns) ? `, ${selectedColumns}` : ''} FROM ${tableName} WHERE (${whereClause})${isDefined(afterRowId) ? ` AND id > $${parameters.length}` : ''} ORDER BY id LIMIT ${REWRITE_BATCH_SIZE}`,
+ parameters,
+ );
+
+ const rewrites = rows.flatMap((row) => {
+ const { value, hasChanged } = mapRow(row);
+
+ return hasChanged ? [{ id: row.id, from: row.value, to: value }] : [];
+ });
+
+ if (isDryRun) {
+ rewrittenRowCount += rewrites.length;
+ } else if (rewrites.length > 0) {
+ // Compare-and-set so a row edited since it was read is left as is
+ const [, updatedRowCount]: [unknown, number] = await dataSource.query(
+ `UPDATE ${tableName} AS target SET ${columnName} = rewrite."to" FROM jsonb_to_recordset($1::jsonb) AS rewrite(id uuid, "from" jsonb, "to" jsonb) WHERE target.id = rewrite.id AND target.${columnName} = rewrite."from"`,
+ [JSON.stringify(rewrites)],
+ );
+
+ rewrittenRowCount += updatedRowCount;
+ }
+
+ if (rows.length < REWRITE_BATCH_SIZE) {
+ return rewrittenRowCount;
+ }
+
+ afterRowId = rows[rows.length - 1].id;
+ }
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/__tests__/wrap-bare-select-filter-values.util.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/__tests__/wrap-bare-select-filter-values.util.spec.ts
new file mode 100644
index 00000000000..e329cc94183
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/__tests__/wrap-bare-select-filter-values.util.spec.ts
@@ -0,0 +1,127 @@
+import { FieldMetadataType, ViewFilterOperand } from 'twenty-shared/types';
+
+import {
+ wrapBareSelectFilterValue,
+ wrapBareSelectRecordFilterValue,
+ wrapBareSelectValuesOfFindRecordsSteps,
+} from 'src/database/commands/upgrade-version-command/2-50/utils/wrap-bare-select-filter-values.util';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+
+const OBJECT_ID = '33333333-3333-4333-8333-333333333333';
+const STAGE_FIELD_ID = '44444444-4444-4444-8444-444444444444';
+const NAME_FIELD_ID = '55555555-5555-4555-8555-555555555555';
+
+const flatFieldMetadataMaps = [
+ { id: STAGE_FIELD_ID, type: FieldMetadataType.SELECT },
+ { id: NAME_FIELD_ID, type: FieldMetadataType.TEXT },
+].reduce(
+ (flatEntityMaps, { id, type }) =>
+ addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: getFlatFieldMetadataMock({
+ id,
+ universalIdentifier: id,
+ objectMetadataId: OBJECT_ID,
+ type,
+ }),
+ flatEntityMaps,
+ }),
+ createEmptyFlatEntityMaps(),
+);
+
+describe('wrapBareSelectFilterValue', () => {
+ it.each([
+ ['WON', '["WON"]'],
+ ['"WON"', '["WON"]'],
+ ['123', '["123"]'],
+ ])('wraps %s into %s', (value, expected) => {
+ expect(wrapBareSelectFilterValue(value)).toBe(expected);
+ });
+
+ it.each(['["WON"]', '', '{{trigger.stage}}', '{"unit":"DAY"}', '[1]'])(
+ 'leaves %s unchanged',
+ (value) => {
+ expect(wrapBareSelectFilterValue(value)).toBe(value);
+ },
+ );
+});
+
+describe('wrapBareSelectRecordFilterValue', () => {
+ it('wraps the value of a select filter', () => {
+ expect(
+ wrapBareSelectRecordFilterValue({
+ recordFilter: {
+ fieldMetadataId: STAGE_FIELD_ID,
+ operand: ViewFilterOperand.IS,
+ value: 'WON',
+ },
+ flatFieldMetadataMaps,
+ }),
+ ).toMatchObject({ value: '["WON"]' });
+ });
+
+ it('leaves a text filter unchanged', () => {
+ const recordFilter = {
+ fieldMetadataId: NAME_FIELD_ID,
+ operand: ViewFilterOperand.CONTAINS,
+ value: 'WON',
+ };
+
+ expect(
+ wrapBareSelectRecordFilterValue({ recordFilter, flatFieldMetadataMaps }),
+ ).toBe(recordFilter);
+ });
+
+ it('leaves a value-less operand unchanged', () => {
+ const recordFilter = {
+ fieldMetadataId: STAGE_FIELD_ID,
+ operand: ViewFilterOperand.IS_EMPTY,
+ value: 'WON',
+ };
+
+ expect(
+ wrapBareSelectRecordFilterValue({ recordFilter, flatFieldMetadataMaps }),
+ ).toBe(recordFilter);
+ });
+});
+
+describe('wrapBareSelectValuesOfFindRecordsSteps', () => {
+ const buildSteps = (value: string) => [
+ {
+ id: 'step-1',
+ type: 'FIND_RECORDS',
+ settings: {
+ input: {
+ objectName: 'opportunity',
+ filter: {
+ recordFilters: [
+ {
+ fieldMetadataId: STAGE_FIELD_ID,
+ operand: ViewFilterOperand.IS,
+ value,
+ },
+ ],
+ },
+ },
+ },
+ },
+ ];
+
+ it('wraps bare values of Find Records filters', () => {
+ expect(
+ wrapBareSelectValuesOfFindRecordsSteps({
+ steps: buildSteps('WON'),
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual({ value: buildSteps('["WON"]'), hasChanged: true });
+ });
+
+ it('reports no change for canonical values', () => {
+ const steps = buildSteps('["WON"]');
+
+ expect(
+ wrapBareSelectValuesOfFindRecordsSteps({ steps, flatFieldMetadataMaps }),
+ ).toEqual({ value: steps, hasChanged: false });
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/wrap-bare-select-filter-values.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/wrap-bare-select-filter-values.util.ts
new file mode 100644
index 00000000000..2c46488aad7
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-50/utils/wrap-bare-select-filter-values.util.ts
@@ -0,0 +1,222 @@
+import { isNonEmptyString, isString } from '@sniptt/guards';
+import { FieldMetadataType } from 'twenty-shared/types';
+import {
+ arrayOfStringsOrVariablesSchema,
+ isDefined,
+ isPlainObject,
+ isRecordFilterOperandExpectingValue,
+} from 'twenty-shared/utils';
+import { recordFilterSchema } from 'twenty-shared/workflow';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-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 { getEffectiveFilterFieldType } from 'src/engine/metadata-modules/flat-field-metadata/utils/get-effective-filter-field-type.util';
+
+type StoredRecordFilter = Record<string, unknown>;
+
+type MappedValue = { value: unknown; hasChanged: boolean };
+
+const parseJson = (value: string): { parsed: unknown } | undefined => {
+ try {
+ return { parsed: JSON.parse(value) };
+ } catch {
+ return undefined;
+ }
+};
+
+export const wrapBareSelectFilterValue = (value: string): string => {
+ if (
+ value === '' ||
+ arrayOfStringsOrVariablesSchema.safeParse(value).success
+ ) {
+ return value;
+ }
+
+ const json = parseJson(value);
+
+ if (!isDefined(json)) {
+ return JSON.stringify([value]);
+ }
+
+ if (isString(json.parsed)) {
+ return JSON.stringify([json.parsed]);
+ }
+
+ if (typeof json.parsed === 'number' || typeof json.parsed === 'boolean') {
+ return JSON.stringify([value]);
+ }
+
+ return value;
+};
+
+const isSelectRecordFilter = ({
+ recordFilter,
+ flatFieldMetadataMaps,
+}: {
+ recordFilter: StoredRecordFilter;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): boolean => {
+ const { fieldMetadataId, relationTargetFieldMetadataId } = recordFilter;
+
+ const parsedOperand = recordFilterSchema.shape.operand.safeParse(
+ recordFilter.operand,
+ );
+
+ if (
+ !isString(fieldMetadataId) ||
+ !parsedOperand.success ||
+ isNonEmptyString(recordFilter.subFieldName) ||
+ !isRecordFilterOperandExpectingValue(parsedOperand.data)
+ ) {
+ return false;
+ }
+
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(flatFieldMetadata)) {
+ return false;
+ }
+
+ const relationTargetFlatFieldMetadata = isString(
+ relationTargetFieldMetadataId,
+ )
+ ? findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: relationTargetFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ })
+ : undefined;
+
+ const effectiveFieldType = getEffectiveFilterFieldType({
+ fieldType: flatFieldMetadata.type,
+ relationTargetFieldType: relationTargetFlatFieldMetadata?.type,
+ });
+
+ return (
+ effectiveFieldType === FieldMetadataType.SELECT ||
+ effectiveFieldType === FieldMetadataType.MULTI_SELECT
+ );
+};
+
+export const wrapBareSelectRecordFilterValue = ({
+ recordFilter,
+ flatFieldMetadataMaps,
+}: {
+ recordFilter: StoredRecordFilter;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): StoredRecordFilter => {
+ const { value } = recordFilter;
+
+ if (
+ !isString(value) ||
+ !isSelectRecordFilter({ recordFilter, flatFieldMetadataMaps })
+ ) {
+ return recordFilter;
+ }
+
+ const wrappedValue = wrapBareSelectFilterValue(value);
+
+ return wrappedValue === value
+ ? recordFilter
+ : { ...recordFilter, value: wrappedValue };
+};
+
+const wrapRecordFiltersOfFilter = ({
+ filter,
+ flatFieldMetadataMaps,
+}: {
+ filter: unknown;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): unknown => {
+ if (!isPlainObject(filter) || !Array.isArray(filter.recordFilters)) {
+ return filter;
+ }
+
+ return {
+ ...filter,
+ recordFilters: filter.recordFilters.map((recordFilter) =>
+ isPlainObject(recordFilter)
+ ? wrapBareSelectRecordFilterValue({
+ recordFilter,
+ flatFieldMetadataMaps,
+ })
+ : recordFilter,
+ ),
+ };
+};
+
+const toMappedValue = ({
+ original,
+ mapped,
+}: {
+ original: unknown;
+ mapped: unknown;
+}): MappedValue =>
+ JSON.stringify(original) === JSON.stringify(mapped)
+ ? { value: original, hasChanged: false }
+ : { value: mapped, hasChanged: true };
+
+export const wrapBareSelectValuesOfFindRecordsSteps = ({
+ steps,
+ flatFieldMetadataMaps,
+}: {
+ steps: unknown;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): MappedValue => {
+ if (!Array.isArray(steps)) {
+ return { value: steps, hasChanged: false };
+ }
+
+ const mappedSteps = steps.map((step) => {
+ if (
+ !isPlainObject(step) ||
+ step.type !== 'FIND_RECORDS' ||
+ !isPlainObject(step.settings) ||
+ !isPlainObject(step.settings.input)
+ ) {
+ return step;
+ }
+
+ return {
+ ...step,
+ settings: {
+ ...step.settings,
+ input: {
+ ...step.settings.input,
+ filter: wrapRecordFiltersOfFilter({
+ filter: step.settings.input.filter,
+ flatFieldMetadataMaps,
+ }),
+ },
+ },
+ };
+ });
+
+ return toMappedValue({ original: steps, mapped: mappedSteps });
+};
+
+export const wrapBareSelectValuesOfChartConfiguration = ({
+ configuration,
+ flatFieldMetadataMaps,
+}: {
+ configuration: unknown;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): MappedValue => {
+ if (!isPlainObject(configuration) || !('filter' in configuration)) {
+ return { value: configuration, hasChanged: false };
+ }
+
+ return toMappedValue({
+ original: configuration,
+ mapped: {
+ ...configuration,
+ filter: wrapRecordFiltersOfFilter({
+ filter: configuration.filter,
+ flatFieldMetadataMaps,
+ }),
+ },
+ });
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/get-invalid-select-filter-option-values.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/get-invalid-select-filter-option-values.util.spec.ts
index b132e61c7e9..b99b7d00e01 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/get-invalid-select-filter-option-values.util.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/get-invalid-select-filter-option-values.util.spec.ts
@@ -70,16 +70,6 @@ describe('getInvalidSelectFilterOptionValues', () => {
).toEqual(['NOPE']);
});
- it('treats a non-JSON plain string as a single option value', () => {
- expect(
- getInvalidSelectFilterOptionValues({
- fieldMetadata: selectField,
- operand: ViewFilterOperand.IS,
- value: 'WON',
- }),
- ).toEqual([]);
- });
-
it('ignores value-less operands like IS_EMPTY', () => {
expect(
getInvalidSelectFilterOptionValues({
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/recompute-view-filters-on-flat-field-metadata-options-update.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/recompute-view-filters-on-flat-field-metadata-options-update.util.spec.ts
index fb39531cbf2..675d3b9dbf3 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/recompute-view-filters-on-flat-field-metadata-options-update.util.spec.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/__tests__/recompute-view-filters-on-flat-field-metadata-options-update.util.spec.ts
@@ -34,6 +34,32 @@ const toOptions = [
},
];
+const buildViewFilter = ({
+ operand,
+ value,
+}: Pick<FlatViewFilter, 'operand' | 'value'>): FlatViewFilter => ({
+ id: FILTER_ID,
+ universalIdentifier: FILTER_ID,
+ workspaceId: '55555555-5555-4555-8555-555555555555',
+ applicationId: '66666666-6666-4666-8666-666666666666',
+ applicationUniversalIdentifier: '66666666-6666-4666-8666-666666666666',
+ viewId: '77777777-7777-4777-8777-777777777777',
+ viewUniversalIdentifier: '77777777-7777-4777-8777-777777777777',
+ fieldMetadataId: fromFlatFieldMetadata.id,
+ fieldMetadataUniversalIdentifier: fromFlatFieldMetadata.universalIdentifier,
+ operand,
+ value,
+ subFieldName: null,
+ viewFilterGroupId: null,
+ viewFilterGroupUniversalIdentifier: null,
+ positionInViewFilterGroup: null,
+ relationTargetFieldMetadataId: null,
+ relationTargetFieldMetadataUniversalIdentifier: null,
+ createdAt: '2024-01-01T00:00:00.000Z',
+ updatedAt: '2024-01-01T00:00:00.000Z',
+ deletedAt: null,
+});
+
const recomputeForViewFilter = (viewFilter: FlatViewFilter) =>
recomputeViewFiltersOnFlatFieldMetadataOptionsUpdate({
fromFlatFieldMetadata,
@@ -45,14 +71,11 @@ const recomputeForViewFilter = (viewFilter: FlatViewFilter) =>
});
describe('recomputeViewFiltersOnFlatFieldMetadataOptionsUpdate', () => {
- it('updates a legacy scalar select filter value', () => {
- const viewFilter = {
- id: FILTER_ID,
- universalIdentifier: FILTER_ID,
+ it('updates a stringified select filter value', () => {
+ const viewFilter = buildViewFilter({
operand: ViewFilterOperand.IS,
- subFieldName: null,
- value: 'SHORTLISTED',
- } as FlatViewFilter;
+ value: '["SHORTLISTED"]',
+ });
expect(recomputeForViewFilter(viewFilter)).toEqual({
flatViewFiltersToDelete: [],
@@ -60,14 +83,23 @@ describe('recomputeViewFiltersOnFlatFieldMetadataOptionsUpdate', () => {
});
});
+ it('leaves a filter whose value is not an array of options unchanged', () => {
+ const viewFilter = buildViewFilter({
+ operand: ViewFilterOperand.IS,
+ value: 'SHORTLISTED',
+ });
+
+ expect(recomputeForViewFilter(viewFilter)).toEqual({
+ flatViewFiltersToDelete: [],
+ flatViewFiltersToUpdate: [],
+ });
+ });
+
it('leaves a value-less select filter unchanged', () => {
- const viewFilter = {
- id: FILTER_ID,
- universalIdentifier: FILTER_ID,
+ const viewFilter = buildViewFilter({
operand: ViewFilterOperand.IS_NOT_EMPTY,
- subFieldName: null,
value: '',
- } as FlatViewFilter;
+ });
expect(recomputeForViewFilter(viewFilter)).toEqual({
flatViewFiltersToDelete: [],
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util.ts
index 07aadec6597..5e6066fc3a8 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util.ts
@@ -1,6 +1,7 @@
import { isArray, isNonEmptyString } from '@sniptt/guards';
import { FieldMetadataType, type ViewFilterOperand } from 'twenty-shared/types';
import {
+ arrayOfStringsOrVariablesSchema,
isDefined,
isRecordFilterOperandExpectingValue,
} from 'twenty-shared/utils';
@@ -8,11 +9,9 @@ import {
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { type ViewFilterValue } from 'src/engine/metadata-modules/view-filter/types/view-filter-value.type';
-export const normalizeSelectFilterValues = (
+export const parseSelectFilterValues = (
value: ViewFilterValue | null,
-): string[] => {
- // TODO: Remove legacy scalar/stringified-value support after all view filter
- // values have been migrated to their canonical JSON representation.
+): string[] | undefined => {
if (isArray(value)) {
return value.filter(isNonEmptyString);
}
@@ -21,17 +20,11 @@ export const normalizeSelectFilterValues = (
return [];
}
- try {
- const parsedValue: unknown = JSON.parse(value);
+ const parsedValue = arrayOfStringsOrVariablesSchema.safeParse(value);
- if (isArray(parsedValue)) {
- return parsedValue.filter(isNonEmptyString);
- }
- } catch {
- // Not a JSON-stringified array — treat the raw string as a single value.
- }
-
- return [value];
+ return parsedValue.success
+ ? parsedValue.data.filter(isNonEmptyString)
+ : undefined;
};
export const getInvalidSelectFilterOptionValues = ({
@@ -58,9 +51,9 @@ export const getInvalidSelectFilterOptionValues = ({
return [];
}
- const filterValues = normalizeSelectFilterValues(value);
+ const filterValues = parseSelectFilterValues(value);
- if (filterValues.length === 0) {
+ if (!isDefined(filterValues) || filterValues.length === 0) {
return [];
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/recompute-view-filters-on-flat-field-metadata-options-update.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/recompute-view-filters-on-flat-field-metadata-options-update.util.ts
index 17f032ca28a..58e567c334e 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/recompute-view-filters-on-flat-field-metadata-options-update.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/utils/recompute-view-filters-on-flat-field-metadata-options-update.util.ts
@@ -9,7 +9,7 @@ import { type AllFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/
import { findManyFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps-or-throw.util';
import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';
import { compareTwoFlatFieldMetadataEnumOptions } from 'src/engine/metadata-modules/flat-field-metadata/utils/compare-two-flat-field-metadata-enum-options.util';
-import { normalizeSelectFilterValues } from 'src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util';
+import { parseSelectFilterValues } from 'src/engine/metadata-modules/flat-field-metadata/utils/get-invalid-select-filter-option-values.util';
import { type FlatViewFilter } from 'src/engine/metadata-modules/flat-view-filter/types/flat-view-filter.type';
type RecomputeViewFiltersOnFlatFieldMetadataOptionsUpdateArgs = {
@@ -63,7 +63,11 @@ export const recomputeViewFiltersOnFlatFieldMetadataOptionsUpdate = ({
continue;
}
- const viewFilterValue = normalizeSelectFilterValues(rawViewFilterValue);
+ const viewFilterValue = parseSelectFilterValues(rawViewFilterValue);
+
+ if (!isDefined(viewFilterValue)) {
+ continue;
+ }
const viewFilterOptions = viewFilterValue
.flatMap((value) => {
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/__tests__/get-find-records-filter-value-issues.util.spec.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/__tests__/get-find-records-filter-value-issues.util.spec.ts
new file mode 100644
index 00000000000..616249ac4d7
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/__tests__/get-find-records-filter-value-issues.util.spec.ts
@@ -0,0 +1,81 @@
+import { FieldMetadataType, ViewFilterOperand } from 'twenty-shared/types';
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';
+import { getFindRecordsFilterValueIssues } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/get-find-records-filter-value-issues.util';
+import { type WorkflowFindRecordsAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+
+const STAGE_FIELD_ID = '22222222-2222-4222-8222-222222222222';
+
+const flatFieldMetadataMaps = addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: getFlatFieldMetadataMock({
+ id: STAGE_FIELD_ID,
+ universalIdentifier: STAGE_FIELD_ID,
+ objectMetadataId: '33333333-3333-4333-8333-333333333333',
+ type: FieldMetadataType.SELECT,
+ name: 'stage',
+ }),
+ flatEntityMaps: createEmptyFlatEntityMaps(),
+});
+
+const buildFindRecordsStep = (value: string): WorkflowFindRecordsAction => ({
+ id: 'step-1',
+ name: 'Find Opportunities',
+ type: WorkflowActionType.FIND_RECORDS,
+ valid: true,
+ settings: {
+ outputSchema: {},
+ errorHandlingOptions: {
+ retryOnFailure: { value: 0 },
+ continueOnFailure: { value: false },
+ },
+ input: {
+ objectName: 'opportunity',
+ filter: {
+ recordFilters: [
+ {
+ fieldMetadataId: STAGE_FIELD_ID,
+ operand: ViewFilterOperand.IS,
+ value,
+ },
+ ],
+ },
+ },
+ },
+});
+
+describe('getFindRecordsFilterValueIssues', () => {
+ it('accepts a stringified array of options', () => {
+ expect(
+ getFindRecordsFilterValueIssues({
+ step: buildFindRecordsStep('["WON"]'),
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual([]);
+ });
+
+ it('flags a bare option value on a select field', () => {
+ expect(
+ getFindRecordsFilterValueIssues({
+ step: buildFindRecordsStep('WON'),
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual([
+ expect.objectContaining({
+ code: 'INVALID_RECORD_FILTER_VALUE',
+ stepId: 'step-1',
+ }),
+ ]);
+ });
+
+ it('skips values holding a variable', () => {
+ expect(
+ getFindRecordsFilterValueIssues({
+ step: buildFindRecordsStep('{{trigger.object.stage}}'),
+ flatFieldMetadataMaps,
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-find-records-filter-value-issues.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-find-records-filter-value-issues.util.ts
new file mode 100644
index 00000000000..dbb95db28d3
--- /dev/null
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-find-records-filter-value-issues.util.ts
@@ -0,0 +1,83 @@
+import { isNonEmptyString } from '@sniptt/guards';
+import { getFilterValueValidationIssue, isDefined } from 'twenty-shared/utils';
+import {
+ CAPTURE_ALL_VARIABLE_TAG_INNER_REGEX,
+ recordFilterSchema,
+ type WorkflowValidationIssue,
+} from 'twenty-shared/workflow';
+
+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';
+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-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 { getEffectiveFilterFieldType } from 'src/engine/metadata-modules/flat-field-metadata/utils/get-effective-filter-field-type.util';
+import { type WorkflowFindRecordsAction } from 'src/modules/workflow/workflow-executor/workflow-actions/types/workflow-action.type';
+
+export const getFindRecordsFilterValueIssues = ({
+ step,
+ flatFieldMetadataMaps,
+}: {
+ step: Pick<WorkflowFindRecordsAction, 'id' | 'name' | 'settings'>;
+ flatFieldMetadataMaps: FlatEntityMaps<FlatFieldMetadata>;
+}): WorkflowValidationIssue[] =>
+ (step.settings.input.filter?.recordFilters ?? []).flatMap(
+ (rawRecordFilter: unknown): WorkflowValidationIssue[] => {
+ const parsedRecordFilter = recordFilterSchema.safeParse(rawRecordFilter);
+
+ if (!parsedRecordFilter.success) {
+ return [];
+ }
+
+ const recordFilter = parsedRecordFilter.data;
+ const { value } = recordFilter;
+
+ // Variables are only resolved when the step runs
+ if (
+ !isNonEmptyString(value) ||
+ isDefined(value.match(CAPTURE_ALL_VARIABLE_TAG_INNER_REGEX))
+ ) {
+ return [];
+ }
+
+ const flatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: recordFilter.fieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ });
+
+ if (!isDefined(flatFieldMetadata)) {
+ return [];
+ }
+
+ const relationTargetFlatFieldMetadata = isDefined(
+ recordFilter.relationTargetFieldMetadataId,
+ )
+ ? findFlatEntityByIdInFlatEntityMaps({
+ flatEntityId: recordFilter.relationTargetFieldMetadataId,
+ flatEntityMaps: flatFieldMetadataMaps,
+ })
+ : undefined;
+
+ const issue = getFilterValueValidationIssue({
+ fieldType: getEffectiveFilterFieldType({
+ fieldType: flatFieldMetadata.type,
+ relationTargetFieldType: relationTargetFlatFieldMetadata?.type,
+ }),
+ operand: recordFilter.operand,
+ subFieldName: recordFilter.subFieldName,
+ value,
+ });
+
+ if (!isDefined(issue)) {
+ return [];
+ }
+
+ return [
+ {
+ severity: 'error',
+ code: 'INVALID_RECORD_FILTER_VALUE',
+ message:
+ `Step "${step.name ?? step.id}" filters "${flatFieldMetadata.name}" with value "${issue.stringifiedValue}", which is not valid for operand "${issue.operand}" on field type "${issue.filterType}". ${issue.hint}`.trim(),
+ stepId: step.id,
+ },
+ ];
+ },
+ );
diff --git a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-workflow-record-step-metadata-issues.util.ts b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-workflow-record-step-metadata-issues.util.ts
index 926067ee2d0..d9b7b0e37ef 100644
--- a/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-workflow-record-step-metadata-issues.util.ts
+++ b/packages/twenty-server/src/modules/workflow/workflow-builder/workflow-validation/utils/get-workflow-record-step-metadata-issues.util.ts
@@ -9,6 +9,7 @@ import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/typ
import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-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 { getFindRecordsFilterValueIssues } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/get-find-records-filter-value-issues.util';
import { OBJECT_TARGETING_ACTION_TYPES } from 'src/modules/workflow/workflow-builder/workflow-validation/constants/object-targeting-action-types.constant';
import { getPickRecordLoadBalanceConfigError } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/get-pick-record-load-balance-config-error.util';
import { getRecordCrudRichTextIssues } from 'src/modules/workflow/workflow-builder/workflow-validation/utils/get-record-crud-rich-text-issues.util';
@@ -85,6 +86,12 @@ export const getWorkflowRecordStepMetadataIssues = ({
}
}
+ if (step.type === WorkflowActionType.FIND_RECORDS) {
+ issues.push(
+ ...getFindRecordsFilterValueIssues({ step, flatFieldMetadataMaps }),
+ );
+ }
+
const objectRecord =
RECORD_CRUD_ACTION_TYPES_WITH_OBJECT_RECORD.has(step.type) &&
isObject(input) &&
diff --git a/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata-view-filters-side-effect-v2.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata-view-filters-side-effect-v2.integration-spec.ts
index e0a82984c89..b0b6dd14000 100644
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata-view-filters-side-effect-v2.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata-view-filters-side-effect-v2.integration-spec.ts
@@ -307,54 +307,24 @@ describe('update-one-field-metadata-view-filters-side-effect-v2', () => {
},
);
- it('should update a related view filter with a scalar option value', async () => {
+ it('should reject a view filter with a bare option value', async () => {
const { createOneField, createdView } =
await createObjectSelectFieldAndView({
options: ALL_OPTIONS,
type: fieldType,
});
- const {
- data: { createViewFilter: createdViewFilter },
- } = await createOneViewFilter({
+ const { errors } = await createOneViewFilter({
input: {
viewId: createdView.id,
fieldMetadataId: createOneField.id,
operand: operandForFieldType,
value: ALL_OPTIONS[0].value,
},
- expectToFail: false,
- gqlFields: `
- id
- `,
- });
-
- const optionsWithIds = createOneField.options;
-
- if (!isDefined(optionsWithIds)) {
- throw new Error('optionsWithIds is not defined');
- }
-
- const updatedOption = fakeOptionUpdate(optionsWithIds[0]);
-
- await updateOneFieldMetadata({
- expectToFail: false,
- input: {
- idToUpdate: createOneField.id,
- updatePayload: {
- options: [updatedOption, ...optionsWithIds.slice(1)],
- },
- },
- gqlFields: `
- id
- `,
+ expectToFail: true,
});
- const updatedViewFilter = await findViewFilterWithRestApi(
- createdViewFilter.id,
- );
-
- expect(updatedViewFilter?.value).toEqual([updatedOption.value]);
+ expect(errors).toHaveLength(1);
});
it('should leave a value-less view filter unchanged', async () => {
diff --git a/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts b/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
index f0424f7654b..4bd2fc679e7 100644
--- a/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/__tests__/getFilterValueSchema.test.ts
@@ -149,9 +149,9 @@ describe('getFilterValueSchema', () => {
});
it.each(['OPTION_0', '{bad json'])(
- 'should accept %s as a legacy scalar option value',
+ 'should reject %s, which is not a stringified array',
(value) => {
- expectAccepted(
+ expectRejected(
{ filterType: 'SELECT', operand: ViewFilterOperand.IS },
value,
);
diff --git a/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts b/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
index f8f9d1c3238..92b61e9a997 100644
--- a/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/validation-schemas/filterValueSchemasMap.ts
@@ -58,21 +58,8 @@ const relationFilterValueSchema = jsonRelationFilterValueSchema
),
);
-// Mirrors normalizeSelectFilterValues: a value that is not JSON is a legacy scalar option.
const selectFilterValueSchema = nonEmptyStringFilterValueSchema.refine(
- (value) => {
- if (arrayOfStringsOrVariablesSchema.safeParse(value).success) {
- return true;
- }
-
- try {
- JSON.parse(value);
- } catch {
- return true;
- }
-
- return false;
- },
+ (value) => arrayOfStringsOrVariablesSchema.safeParse(value).success,
'Expected an array of option values',
);
diff --git a/packages/twenty-shared/src/workflow/validation/constants/non-activable-workflow-validation-issue-codes.constant.ts b/packages/twenty-shared/src/workflow/validation/constants/non-activable-workflow-validation-issue-codes.constant.ts
index 0a4c511b1cd..f5837fd5562 100644
--- a/packages/twenty-shared/src/workflow/validation/constants/non-activable-workflow-validation-issue-codes.constant.ts
+++ b/packages/twenty-shared/src/workflow/validation/constants/non-activable-workflow-validation-issue-codes.constant.ts
@@ -10,6 +10,7 @@ export const NON_ACTIVABLE_WORKFLOW_VALIDATION_ISSUE_CODES: ReadonlySet<Workflow
'IF_ELSE_INSUFFICIENT_BRANCHES',
'ITERATOR_MISSING_LOOP_BODY',
'INCOMPLETE_PICK_RECORD_CONFIG',
+ 'INVALID_RECORD_FILTER_VALUE',
'AI_AGENT_MISSING_AGENT',
'CONVERSATION_MISSING_KEY',
'CLASSIFY_MISSING_STATE',
diff --git a/packages/twenty-shared/src/workflow/validation/types/WorkflowValidation.ts b/packages/twenty-shared/src/workflow/validation/types/WorkflowValidation.ts
index f4ca317246f..296e265af5f 100644
--- a/packages/twenty-shared/src/workflow/validation/types/WorkflowValidation.ts
+++ b/packages/twenty-shared/src/workflow/validation/types/WorkflowValidation.ts
@@ -24,6 +24,7 @@ export type WorkflowValidationIssueCode =
| 'INVALID_RICH_TEXT_FIELD'
| 'OBJECT_NOT_FOUND'
| 'INCOMPLETE_PICK_RECORD_CONFIG'
+ | 'INVALID_RECORD_FILTER_VALUE'
| 'IF_ELSE_INSUFFICIENT_BRANCHES'
| 'IF_ELSE_BRANCH_HAS_NO_NEXT_STEP'
| 'ITERATOR_MISSING_LOOP_BODY'