Skip to content

The open alternative to Salesforce, designed for AI.

fix(twenty-shared): honor underscore wildcard in string like and ilike filters (#25489)

Abdellatif Anaflous177339567f78
diff --git a/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingStringFilter.test.ts b/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingStringFilter.test.ts
index 8590d6df7b8..861a245502f 100644
--- a/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingStringFilter.test.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/__tests__/isMatchingStringFilter.test.ts
@@ -38,44 +38,81 @@ describe('isMatchingStringFilter', () => {
});
});
- describe('like', () => {
- it('value matches like pattern', () => {
- expect(
- isMatchingStringFilter({
- stringFilter: { like: 'te%' },
- value: 'test',
- }),
- ).toBe(true);
- });
+ describe.each(['like', 'ilike'])('%s', (operator) => {
+ it.each([
+ { pattern: 'te%', value: 'test', expected: true },
+ { pattern: 'ab%', value: 'test', expected: false },
+ { pattern: '', value: '', expected: true },
+ { pattern: '', value: '\n', expected: false },
+ { pattern: '%', value: '', expected: true },
+ { pattern: '_', value: '', expected: false },
+ { pattern: 'a_c', value: 'abc', expected: true },
+ { pattern: 'a_c', value: 'ac', expected: false },
+ { pattern: 'a_c', value: 'abxc', expected: false },
+ { pattern: 'a_c', value: 'abc\n', expected: false },
+ { pattern: 'a_c', value: 'a\nc', expected: true },
+ { pattern: 'a_c', value: 'a\rc', expected: true },
+ { pattern: 'a_c', value: 'a\u2028c', expected: true },
+ { pattern: 'a_c', value: 'a\u{1F600}c', expected: true },
+ { pattern: 'a__c', value: 'a\u{1F600}c', expected: false },
+ { pattern: 'a__c', value: 'a\u{1F600}\u{1F600}c', expected: true },
+ { pattern: 'a%c', value: 'ac', expected: true },
+ { pattern: 'a%c', value: 'a\nc', expected: true },
+ { pattern: 'a%c', value: 'a\u{1F600}c', expected: true },
+ { pattern: 'a%c', value: 'a\nc\n', expected: false },
+ { pattern: '50\\%', value: '50%', expected: true },
+ { pattern: '50\\%', value: '50\n', expected: false },
+ { pattern: 'a\\_c', value: 'a_c', expected: true },
+ { pattern: 'a\\_c', value: 'axc', expected: false },
+ { pattern: 'a\\bc', value: 'abc', expected: true },
+ { pattern: 'a\\_%', value: 'a_b\nc', expected: true },
+ { pattern: 'a\\\\', value: 'a\\', expected: true },
+ { pattern: 'a\\\\%', value: 'a\\bc', expected: true },
+ { pattern: 'a\\\nc', value: 'a\nc', expected: true },
+ { pattern: 'a\\😀c', value: 'a😀c', expected: true },
+ { pattern: '.*+?^${}()|[]', value: '.*+?^${}()|[]', expected: true },
+ { pattern: 'a.c', value: 'abc', expected: false },
+ ])(
+ 'matches $pattern against $value: $expected',
+ ({ pattern, value, expected }) => {
+ expect(
+ isMatchingStringFilter({
+ stringFilter: { [operator]: pattern },
+ value,
+ }),
+ ).toBe(expected);
+ },
+ );
+
+ it.each(['\\', 'a\\', 'a\\\\\\'])(
+ 'rejects dangling escape in %s',
+ (pattern) => {
+ expect(() =>
+ isMatchingStringFilter({
+ stringFilter: { [operator]: pattern },
+ value: pattern,
+ }),
+ ).toThrow('LIKE pattern must not end with escape character');
+ },
+ );
+ });
- it('value does not match like pattern', () => {
- expect(
- isMatchingStringFilter({
- stringFilter: { like: 'ab%' },
- value: 'test',
- }),
- ).toBe(false);
- });
+ it('keeps LIKE case sensitive', () => {
+ expect(
+ isMatchingStringFilter({ stringFilter: { like: 'A_C' }, value: 'abc' }),
+ ).toBe(false);
});
- describe('ilike', () => {
- it('value matches ilike pattern case insensitively', () => {
- expect(
- isMatchingStringFilter({
- stringFilter: { ilike: 'TE%' },
- value: 'test',
- }),
- ).toBe(true);
- });
+ it('matches ILIKE case insensitively', () => {
+ expect(
+ isMatchingStringFilter({ stringFilter: { ilike: 'A_C' }, value: 'abC' }),
+ ).toBe(true);
+ });
- it('value does not match ilike pattern', () => {
- expect(
- isMatchingStringFilter({
- stringFilter: { ilike: 'AB%' },
- value: 'test',
- }),
- ).toBe(false);
- });
+ it('does not broaden ILIKE matching with Unicode case folding', () => {
+ expect(
+ isMatchingStringFilter({ stringFilter: { ilike: 's' }, value: 'ſ' }),
+ ).toBe(false);
});
describe('in', () => {
diff --git a/packages/twenty-shared/src/utils/filter/utils/convertLikePatternToRegexOrThrow.ts b/packages/twenty-shared/src/utils/filter/utils/convertLikePatternToRegexOrThrow.ts
new file mode 100644
index 00000000000..f1eae6e7e20
--- /dev/null
+++ b/packages/twenty-shared/src/utils/filter/utils/convertLikePatternToRegexOrThrow.ts
@@ -0,0 +1,36 @@
+import { CustomError } from '@/utils/errors/CustomError';
+import escapeRegExp from 'lodash.escaperegexp';
+
+export const convertLikePatternToRegexOrThrow = ({
+ pattern,
+ isCaseInsensitive = false,
+}: {
+ pattern: string;
+ isCaseInsensitive?: boolean;
+}): RegExp => {
+ const regexPattern = pattern.replace(/\\[\s\S]|[\s\S]/gu, (character) => {
+ if (character === '\\') {
+ throw new CustomError(
+ 'LIKE pattern must not end with escape character',
+ 'INVALID_LIKE_PATTERN',
+ );
+ }
+
+ if (character.startsWith('\\')) {
+ return escapeRegExp(character.slice(1));
+ }
+
+ if (character === '%') {
+ return '[\\s\\S]*';
+ }
+
+ if (character === '_') {
+ // Match a code point without the extra case folding introduced by the iu flags.
+ return '(?:[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[^\\uD800-\\uDFFF])';
+ }
+
+ return escapeRegExp(character);
+ });
+
+ return new RegExp(`^${regexPattern}$`, isCaseInsensitive ? 'i' : '');
+};
diff --git a/packages/twenty-shared/src/utils/filter/utils/isMatchingStringFilter.ts b/packages/twenty-shared/src/utils/filter/utils/isMatchingStringFilter.ts
index c4da94efab6..954f9d33020 100644
--- a/packages/twenty-shared/src/utils/filter/utils/isMatchingStringFilter.ts
+++ b/packages/twenty-shared/src/utils/filter/utils/isMatchingStringFilter.ts
@@ -1,5 +1,5 @@
import { type StringFilter } from '@/types';
-import escapeRegExp from 'lodash.escaperegexp';
+import { convertLikePatternToRegexOrThrow } from '@/utils/filter/utils/convertLikePatternToRegexOrThrow';
export const isMatchingStringFilter = ({
stringFilter,
@@ -28,16 +28,17 @@ export const isMatchingStringFilter = ({
return value <= stringFilter.lte;
}
case stringFilter.like !== undefined: {
- const escapedPattern = escapeRegExp(stringFilter.like);
- const regexPattern = escapedPattern.replace(/%/g, '.*');
- const regexCaseSensitive = new RegExp(`^${regexPattern}$`);
+ const regexCaseSensitive = convertLikePatternToRegexOrThrow({
+ pattern: stringFilter.like,
+ });
return regexCaseSensitive.test(value);
}
case stringFilter.ilike !== undefined: {
- const escapedPattern = escapeRegExp(stringFilter.ilike);
- const regexPattern = escapedPattern.replace(/%/g, '.*');
- const regexCaseInsensitive = new RegExp(`^${regexPattern}$`, 'i');
+ const regexCaseInsensitive = convertLikePatternToRegexOrThrow({
+ pattern: stringFilter.ilike,
+ isCaseInsensitive: true,
+ });
return regexCaseInsensitive.test(value);
}
diff --git a/packages/twenty-shared/src/utils/index.ts b/packages/twenty-shared/src/utils/index.ts
index 14c4e8ab4bb..32291476362 100644
--- a/packages/twenty-shared/src/utils/index.ts
+++ b/packages/twenty-shared/src/utils/index.ts
@@ -133,6 +133,7 @@ export { combineFilters } from './filter/utils/combineFilters';
export { compareSelectOptionValues } from './filter/utils/compareSelectOptionValues';
export { COMPOSITE_FIELD_FILTER_OPERANDS_MAP } from './filter/utils/compositeFieldFilterOperandsMap';
export { convertViewFilterOperandToCoreOperand } from './filter/utils/convert-view-filter-operand-to-core-operand.util';
+export { convertLikePatternToRegexOrThrow } from './filter/utils/convertLikePatternToRegexOrThrow';
export { convertViewFilterValueToString } from './filter/utils/convertViewFilterValueToString';
export { createAnyFieldRecordFilterBaseProperties } from './filter/utils/createAnyFieldRecordFilterBaseProperties';
export {