@adaptabletools/adaptable 24.0.0-canary.9 → 24.0.1

package/src/migration/VersionUpgrade24.js

@@ -9,6 +9,13 @@ import { badgePredicateToBooleanExpression, columnFilterPredicatesToExpression,
 import { migrateGreenfieldExpressionTexts } from './migrateGreenfieldExpressionTexts';
 import { isAdaptableSharedEntity } from '../AdaptableState/TeamSharingState';
 import { migrateLayoutTagsToRegistry } from './migrateLayoutTagsToRegistry';
+const UNCONVERTED_PREDICATE_OUTCOME = {
+    'Column Filter': 'they keep their legacy Predicates, which are ignored, so the filter is inactive',
+    Alert: 'their Rule becomes empty, so the Alert never fires',
+    'Flashing Cell': 'their Rule becomes empty, so the Flashing Cell never flashes',
+    'Format Column': 'their Rule is removed, so the format applies to every cell in Scope',
+    'Badge Style': 'the Badge has no Rule, so it is shown as the fallback (always) Badge',
+};
 const NEEDS_MIGRATION_SUFFIX = ' (needs migration)';
 const LEGACY_SOURCE_PATTERN = new RegExp(`\\b(${[...LEGACY_OBSERVABLE_SOURCE_NAMES].join('|')})\\s*[({]`);
 export class VersionUpgrade24 extends VersionUpgrade {
@@ -17,13 +24,19 @@ export class VersionUpgrade24 extends VersionUpgrade {
         super(logger);
         this.options = options;
     }
+    customFunctionUsages = new Map();
+    percentChangeObjects = [];
     migrateState(state) {
+        this.customFunctionUsages.clear();
+        this.percentChangeObjects = [];
         this.migrateNoteTimestamps(state);
         this.migrateColumnFilters(state);
         this.migrateAlertRules(state);
         this.migrateFlashingCellRules(state);
         this.migrateFormatColumnRules(state);
         this.migrateBadgeStyleRules(state);
+        this.logCustomPredicateFunctions();
+        this.logPercentChangeApproximations();
         this.migrateExpressionQueryKeys(state);
         this.migrateNamedQueries(state);
         this.migrateCalculatedColumnTypes(state);
@@ -92,13 +105,14 @@ export class VersionUpgrade24 extends VersionUpgrade {
             return;
         }
         let migratedCount = 0;
-        let preservedCount = 0;
+        const preserved = [];
         for (const layout of layouts) {
             const filters = layout.ColumnFilters;
             if (!filters?.length) {
                 continue;
             }
             for (const filter of filters) {
+                const label = `Column Filter '${filter.ColumnId}' (Layout '${layout.Name}')`;
                 if (filter.Expression) {
                     delete filter.Predicates;
                     delete filter.PredicatesOperator;
@@ -108,12 +122,15 @@ export class VersionUpgrade24 extends VersionUpgrade {
                 if (!filter.Predicates?.length) {
                     continue;
                 }
-                const expression = columnFilterPredicatesToExpression(filter);
+                const customCalls = [];
+                const expression = columnFilterPredicatesToExpression(filter, customCalls);
                 if (expression != null) {
                     filter.Expression = expression;
+                    this.recordPercentChange(filter.Predicates, label);
                     delete filter.PreferredFilter;
                     delete filter.Predicates;
                     delete filter.PredicatesOperator;
+                    this.recordCustomFunctionCalls(customCalls, label);
                     migratedCount++;
                     continue;
                 }
@@ -126,10 +143,10 @@ export class VersionUpgrade24 extends VersionUpgrade {
                     migratedCount++;
                     continue;
                 }
-                preservedCount++;
+                preserved.push(this.describePredicates(label, filter.Predicates));
             }
         }
-        this.logPredicateMigrationSummary('Column Filter', migratedCount, preservedCount);
+        this.logPredicateMigrationSummary('Column Filter', migratedCount, preserved);
     }
     migrateAlertRules(state) {
         this.migratePredicateRulesInDefinitions(state.Alert?.AlertDefinitions, 'Alert', (definition) => definition.Rule);
@@ -146,51 +163,58 @@ export class VersionUpgrade24 extends VersionUpgrade {
             return;
         }
         let migratedCount = 0;
-        let preservedCount = 0;
+        const preserved = [];
         for (const styledColumn of columns) {
             const badges = styledColumn.BadgeStyle?.Badges;
             if (!badges?.length) {
                 continue;
             }
-            for (const badge of badges) {
+            badges.forEach((badge, index) => {
                 const legacyExpression = badge.Expression;
                 if (badge.Rule?.Expression || legacyExpression?.Expression || legacyExpression?.BooleanExpression) {
                     delete badge.Predicate;
-                    continue;
+                    return;
                 }
                 if (!badge.Predicate?.PredicateId) {
-                    continue;
+                    return;
                 }
-                const expression = badgePredicateToBooleanExpression(badge.Predicate, styledColumn.ColumnId);
+                const label = `Badge ${index + 1} of Styled Column '${styledColumn.Name ?? styledColumn.ColumnId}'`;
+                const customCalls = [];
+                const expression = badgePredicateToBooleanExpression(badge.Predicate, styledColumn.ColumnId, customCalls);
                 if (expression == null) {
-                    preservedCount++;
-                    continue;
+                    preserved.push(this.describePredicates(label, [badge.Predicate]));
+                    return;
                 }
                 badge.Rule = { Expression: expression };
+                this.recordPercentChange([badge.Predicate], label);
                 delete badge.Predicate;
+                this.recordCustomFunctionCalls(customCalls, label);
                 migratedCount++;
-            }
+            });
         }
-        this.logPredicateMigrationSummary('Badge Style', migratedCount, preservedCount);
+        this.logPredicateMigrationSummary('Badge Style', migratedCount, preserved);
     }
     migratePredicateRulesInDefinitions(definitions, moduleLabel, getRule) {
         if (!definitions?.length) {
             return;
         }
         let migratedCount = 0;
-        let preservedCount = 0;
-        for (const definition of definitions) {
-            const result = this.migratePredicateRule(getRule(definition));
+        const preserved = [];
+        definitions.forEach((definition, index) => {
+            const name = definition.Name;
+            const label = `${moduleLabel} '${typeof name === 'string' && name ? name : `#${index + 1}`}'`;
+            const rule = getRule(definition);
+            const result = this.migratePredicateRule(rule, label);
             if (result === 'migrated') {
                 migratedCount++;
             }
             if (result === 'preserved') {
-                preservedCount++;
+                preserved.push(this.describePredicates(label, rule?.Predicates));
             }
-        }
-        this.logPredicateMigrationSummary(moduleLabel, migratedCount, preservedCount);
+        });
+        this.logPredicateMigrationSummary(moduleLabel, migratedCount, preserved);
     }
-    migratePredicateRule(rule) {
+    migratePredicateRule(rule, label) {
         if (!isLegacyAdaptableQuery(rule)) {
             return 'skip';
         }
@@ -209,12 +233,15 @@ export class VersionUpgrade24 extends VersionUpgrade {
         if (!rule.Predicates?.length) {
             return 'skip';
         }
-        const expression = rulePredicatesToBooleanExpression(rule.Predicates);
+        const customCalls = [];
+        const expression = rulePredicatesToBooleanExpression(rule.Predicates, customCalls);
         if (expression == null) {
             return 'preserved';
         }
+        this.recordPercentChange(rule.Predicates, label);
         delete rule.Predicates;
         rule.Expression = expression;
+        this.recordCustomFunctionCalls(customCalls, label);
         return 'migrated';
     }
     migrateExpressionQueryKeys(state) {
@@ -397,12 +424,57 @@ export class VersionUpgrade24 extends VersionUpgrade {
         if (migrated > 0) {
             this.logger.info(`Migrated ${migrated} ${module} predicate rule(s) to AdaptableQL Expression (v24).`);
         }
-        if (preserved > 0) {
-            this.logger.warn(`Left ${preserved} ${module} predicate rule(s) unchanged (no lossless AdaptableQL ` +
-                `equivalent — e.g. a custom predicate or PercentChange); they continue to ` +
-                `evaluate via the legacy predicate path.`);
+        if (preserved.length > 0) {
+            this.logger.warn(`Could not convert ${preserved.length} ${module} predicate rule(s) to an AdaptableQL ` +
+                `Expression (v24): ${preserved.join('; ')}. Predicates are not evaluated in v24: ` +
+                `${UNCONVERTED_PREDICATE_OUTCOME[module]}. Re-author them as Expressions.`);
+        }
+    }
+    describePredicates(label, predicates) {
+        const ids = (predicates ?? []).map((predicate) => predicate?.PredicateId ?? '?');
+        return ids.length ? `${label} (${ids.join(', ')})` : label;
+    }
+    recordCustomFunctionCalls(calls, label) {
+        for (const call of calls) {
+            let usage = this.customFunctionUsages.get(call.functionName);
+            if (!usage) {
+                usage = { predicateIds: new Set(), maxInputCount: 0, objects: [] };
+                this.customFunctionUsages.set(call.functionName, usage);
+            }
+            usage.predicateIds.add(call.predicateId);
+            usage.maxInputCount = Math.max(usage.maxInputCount, call.inputCount);
+            if (!usage.objects.includes(label)) {
+                usage.objects.push(label);
+            }
+        }
+    }
+    recordPercentChange(predicates, label) {
+        if (predicates?.some((predicate) => predicate?.PredicateId === 'PercentChange') &&
+            !this.percentChangeObjects.includes(label)) {
+            this.percentChangeObjects.push(label);
         }
     }
+    logPercentChangeApproximations() {
+        if (!this.percentChangeObjects.length) {
+            return;
+        }
+        this.logger.warn(`PercentChange Predicate migrated to PERCENT_CHANGE(...) > n in: ${this.percentChangeObjects.join(', ')} (v24). ` +
+            `PERCENT_CHANGE divides the change by the previous value; PercentChange divided it by the smaller ` +
+            `of the previous and new values. Rises give the same percentage, but falls give a smaller one ` +
+            `(a fall from 100 to 94 was 6.38% and is now 6%), so these rules can fire less often on falls; ` +
+            `lower the threshold if needed.`);
+    }
+    logCustomPredicateFunctions() {
+        this.customFunctionUsages.forEach((usage, functionName) => {
+            const ids = [...usage.predicateIds].map((id) => `'${id}'`).join(', ');
+            const args = usage.maxInputCount > 0
+                ? `args[0] is the Column value, args[1..${usage.maxInputCount}] are the former Predicate Inputs`
+                : 'args[0] is the Column value';
+            this.logger.info(`Custom Predicate ${ids} migrated to ${functionName}(...) in: ${usage.objects.join(', ')} (v24). ` +
+                `Define ${functionName} in expressionOptions.customStandardFunctions with returnType ` +
+                `'boolean'; ${args}. Until it is defined these rules are invalid and are not applied.`);
+        });
+    }
     migrateQueryWrappersToStrings(state) {
         let migratedCount = 0;
         const textOf = (value) => {

package/src/migration/legacyPredicateLowering.d.ts

@@ -13,7 +13,7 @@ export type LegacyPredicate = {
 /**
  * Maps a legacy predicate id + raw inputs to the equivalent AQL
  * `QlPredicate` (primitive or AND/OR group). Returns `null` for custom
- * defs and `PercentChange`.
+ * defs (lowered to custom function calls by `predicateExpressionMigration`).
  */
 export declare const predicateIdToQlPredicate: (predicateId: string, inputs: unknown[] | undefined, column: LegacyPredicateColumn) => QlPredicate | null;
 /**

package/src/migration/legacyPredicateLowering.js

@@ -134,6 +134,8 @@ export const predicateIdToQlPredicate = (predicateId, inputs, column) => {
         }
         case 'AnyChange':
             return qlPrimitive('ANY_CHANGE', [col]);
+        case 'PercentChange':
+            return qlPrimitive('GT', [qlPrimitive('PERCENT_CHANGE', [col]), ...literals.slice(0, 1)]);
         default:
             return null;
     }

package/src/migration/predicateExpressionMigration.d.ts

@@ -16,14 +16,23 @@
  *     (they evaluate against the scoped column at runtime, exactly what
  *     `$SCOPE` resolves to).
  *
+ * Custom predicate ids (user `customPredicateDefs`) lower to a call to the
+ * custom function that replaces them in v24: the id in UPPER_SNAKE form,
+ * the subject first and the stored `Inputs` after it
+ * (`largeNotional` → `LARGE_NOTIONAL([notional])`). The function itself is
+ * not checked — it must be defined in `customStandardFunctions` at runtime,
+ * otherwise the rule is invalid (logged, never applied).
+ *
  * Every helper is **all-or-nothing**: if any predicate in the set cannot
- * be lowered to a complete AQL primitive (custom predicate defs,
- * `PercentChange` — AQL `PERCENT_CHANGE` is number-returning — or an
- * incomplete/empty predicate) the helper returns `null` and the caller
- * must leave the legacy predicate representation intact. This preserves
- * the runtime fallback and keeps the migration idempotent.
+ * be lowered to a complete AQL primitive (a custom id with no valid or
+ * non-clashing function name, or an incomplete/empty predicate) the helper
+ * returns `null` and the caller must leave the legacy predicate
+ * representation intact. This keeps the migration idempotent.
  *
- * `AnyChange` lowers to `ANY_CHANGE([col])` / `ANY_CHANGE($SCOPE)`.
+ * `AnyChange` lowers to `ANY_CHANGE([col])` / `ANY_CHANGE($SCOPE)`;
+ * `PercentChange` to `PERCENT_CHANGE([col]) > n`, which divides the change
+ * by the previous value where the predicate divided it by the smaller of
+ * the previous and new values.
  */
 import { ColumnFilter } from '../AdaptableState/Common/ColumnFilter';
 import { LegacyPredicate } from './legacyPredicateLowering';
@@ -32,15 +41,37 @@ import { QlPredicate, QlPrimitive } from "../../vendor/aql/index.js";
 type LegacyColumnPredicate = LegacyPredicate & {
     ColumnId?: string;
 };
+/**
+ * A custom predicate that was lowered to a call to the custom function
+ * replacing it.
+ */
+export interface CustomPredicateFunctionCall {
+    predicateId: string;
+    functionName: string;
+    /** Number of stored `Inputs`, passed after the subject (`args[1..]`). */
+    inputCount: number;
+}
+/**
+ * The custom function name a custom predicate id migrates to: the id in
+ * UPPER_SNAKE form (`largeNotional` → `LARGE_NOTIONAL`, `isUSDTrade` →
+ * `IS_USD_TRADE`, `top-tier` → `TOP_TIER`).
+ *
+ * @returns the name, or `null` when the id is a v23 system predicate, the
+ *   name is not a valid AQL function name, or it clashes with a system
+ *   function (the rule would silently call the system function).
+ */
+export declare const customPredicateIdToFunctionName: (predicateId: string) => string | null;
 /**
  * Lowers a single legacy predicate to a complete AQL `QlPredicate`.
  *
  * @param subjectColumnId the column the predicate applies to, or `null`
  *   to emit a `$SCOPE` subject (rule predicate without a `ColumnId`).
- * @returns the predicate, or `null` when the predicate has no lossless
- *   AQL equivalent or is incomplete.
+ * @param customCalls receives the custom function call when the predicate
+ *   is a custom predicate.
+ * @returns the predicate, or `null` when the predicate has no AQL
+ *   equivalent or is incomplete.
  */
-export declare const lowerPredicateToQlPredicate: (predicate: LegacyPredicate, subjectColumnId: string | null) => QlPredicate | null;
+export declare const lowerPredicateToQlPredicate: (predicate: LegacyPredicate, subjectColumnId: string | null, customCalls?: CustomPredicateFunctionCall[]) => QlPredicate | null;
 /** @deprecated Use {@link lowerPredicateToQlPredicate} — range predicates lower to groups. */
 export declare const lowerPredicateToPrimitive: (predicate: LegacyPredicate, subjectColumnId: string | null) => QlPrimitive | null;
 /**
@@ -50,8 +81,10 @@ export declare const lowerPredicateToPrimitive: (predicate: LegacyPredicate, sub
  *
  * Returns `null` when the filter has no predicates or any predicate is
  * unconvertible — the caller keeps the legacy `Predicates`.
+ *
+ * @param customCalls receives the custom function calls of a converted filter.
  */
-export declare const columnFilterPredicatesToExpression: (columnFilter: ColumnFilter) => string | null;
+export declare const columnFilterPredicatesToExpression: (columnFilter: ColumnFilter, customCalls?: CustomPredicateFunctionCall[]) => string | null;
 /**
  * Converts a single incomplete ColumnFilter Predicate (empty Inputs —
  * operator seed only) to a `PreferredFilter` AQL operator name.
@@ -67,11 +100,15 @@ export declare const columnFilterPredicatesToPreferredFilter: (columnFilter: Col
  * predicate uses its own `ColumnId`, or `$SCOPE` when absent.
  *
  * Returns `null` when there are no predicates or any is unconvertible.
+ *
+ * @param customCalls receives the custom function calls of a converted rule.
  */
-export declare const rulePredicatesToBooleanExpression: (predicates: LegacyColumnPredicate[] | undefined) => string | null;
+export declare const rulePredicatesToBooleanExpression: (predicates: LegacyColumnPredicate[] | undefined, customCalls?: CustomPredicateFunctionCall[]) => string | null;
 /**
  * Lowers a single Badge Style `Predicate` (subject = the styled column)
  * to a `BooleanExpression`. Returns `null` when unconvertible.
+ *
+ * @param customCalls receives the custom function call of a converted badge.
  */
-export declare const badgePredicateToBooleanExpression: (predicate: LegacyPredicate, columnId: string) => string | null;
+export declare const badgePredicateToBooleanExpression: (predicate: LegacyPredicate, columnId: string, customCalls?: CustomPredicateFunctionCall[]) => string | null;
 export {};

package/src/migration/predicateExpressionMigration.js

@@ -1,6 +1,6 @@
-import { systemScalarExpressionFunctions as scalarExpressionFunctions } from '../aql/systemExpressionFunctions';
+import { systemAggregatedExpressionFunctions, systemAggregationClauseFunctions, systemObservableExpressionFunctions, systemScalarExpressionFunctions as scalarExpressionFunctions, } from '../aql/systemExpressionFunctions';
 import { predicateIdToQlPredicate, } from './legacyPredicateLowering';
-import { isQlColRef, isQlPredicateComplete, mapQlPredicateToExpression, migrateExpression, } from "../../vendor/aql/index.js";
+import { AGGREGATION_ONLY_NAMES, colRef, DUAL_AGGREGATION_NAMES, isAST_Function, isQlColRef, isQlPredicateComplete, LEGACY_OBSERVABLE_MARKER_NAMES, LEGACY_OBSERVABLE_SOURCE_NAMES, literalForRawValue, mapQlPredicateToExpression, migrateExpression, OBSERVABLE_SOURCE_NAMES, OPERAND_CLAUSE_NAMES, parse, qlPrimitive, } from "../../vendor/aql/index.js";
 const MIGRATION_FUNCTION_POOL = {
     scalarFunctions: scalarExpressionFunctions,
 };
@@ -33,12 +33,14 @@ const NUMBER_PREDICATE_IDS = new Set([
     'Positive',
     'Negative',
     'Zero',
+    'PercentChange',
 ]);
 const NUMERIC_INPUT_PREDICATE_IDS = new Set([
     'GreaterThan',
     'LessThan',
     'Between',
     'NotBetween',
+    'PercentChange',
 ]);
 const BOOLEAN_PREDICATE_IDS = new Set(['True', 'False', 'BooleanToggle']);
 const SCOPE_REF = { kind: 'scope' };
@@ -92,14 +94,139 @@ const withScopeSubject = (predicate) => {
         }),
     };
 };
-export const lowerPredicateToQlPredicate = (predicate, subjectColumnId) => {
+const SYSTEM_PREDICATE_IDS = new Set([
+    'After',
+    'AnyChange',
+    'Before',
+    'Between',
+    'Blanks',
+    'BooleanToggle',
+    'Contains',
+    'EndsWith',
+    'Equals',
+    'False',
+    'GreaterThan',
+    'GreaterThanOrEqual',
+    'Holiday',
+    'In',
+    'InFuture',
+    'InPast',
+    'InRange',
+    'Is',
+    'IsNot',
+    'LastWorkDay',
+    'LessThan',
+    'LessThanOrEqual',
+    'Negative',
+    'NextWorkDay',
+    'NonBlanks',
+    'NotBetween',
+    'NotContains',
+    'NotEquals',
+    'NotIn',
+    'NotOn',
+    'On',
+    'OnOrAfter',
+    'OnOrBefore',
+    'PercentChange',
+    'Positive',
+    'Range',
+    'Regex',
+    'StartsWith',
+    'ThisMonth',
+    'ThisQuarter',
+    'ThisWeek',
+    'ThisYear',
+    'Today',
+    'Tomorrow',
+    'True',
+    'WorkDay',
+    'Yesterday',
+    'Zero',
+]);
+let systemFunctionNames;
+const getSystemFunctionNames = () => {
+    if (!systemFunctionNames) {
+        systemFunctionNames = new Set([
+            ...Object.keys(scalarExpressionFunctions),
+            ...Object.keys(systemAggregatedExpressionFunctions),
+            ...Object.keys(systemAggregationClauseFunctions),
+            ...Object.keys(systemObservableExpressionFunctions),
+            ...AGGREGATION_ONLY_NAMES,
+            ...DUAL_AGGREGATION_NAMES,
+            ...OBSERVABLE_SOURCE_NAMES,
+            ...LEGACY_OBSERVABLE_SOURCE_NAMES,
+            ...LEGACY_OBSERVABLE_MARKER_NAMES,
+            ...OPERAND_CLAUSE_NAMES,
+        ]);
+    }
+    return systemFunctionNames;
+};
+const FUNCTION_NAME_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+const parsesAsFunctionCall = (name) => {
+    try {
+        const { ast } = parse(`${name}(1)`);
+        return ast.length === 1 && isAST_Function(ast[0]) && ast[0].type === name;
+    }
+    catch {
+        return false;
+    }
+};
+export const customPredicateIdToFunctionName = (predicateId) => {
+    if (!predicateId || SYSTEM_PREDICATE_IDS.has(predicateId)) {
+        return null;
+    }
+    const name = predicateId
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
+    if (!FUNCTION_NAME_PATTERN.test(name) || getSystemFunctionNames().has(name)) {
+        return null;
+    }
+    return parsesAsFunctionCall(name) ? name : null;
+};
+const lowerCustomPredicate = (predicate, subjectColumnId) => {
+    const functionName = customPredicateIdToFunctionName(predicate.PredicateId);
+    if (!functionName) {
+        return null;
+    }
+    const inputs = (predicate.Inputs ?? []).filter((input) => input !== undefined);
+    const isScalarInput = (input) => typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean';
+    if (!inputs.every(isScalarInput)) {
+        return null;
+    }
+    const subject = subjectColumnId == null ? SCOPE_REF : colRef(subjectColumnId);
+    const qlPredicate = qlPrimitive(functionName, [
+        subject,
+        ...inputs.map((input) => literalForRawValue(input)),
+    ]);
+    if (!isQlPredicateComplete(qlPredicate, MIGRATION_FUNCTION_POOL)) {
+        return null;
+    }
+    return {
+        qlPredicate,
+        call: { predicateId: predicate.PredicateId, functionName, inputCount: inputs.length },
+    };
+};
+export const lowerPredicateToQlPredicate = (predicate, subjectColumnId, customCalls) => {
     const predicateId = predicate.PredicateId;
     const column = {
         columnId: subjectColumnId ?? '__scope__',
         dataType: inferDataType(predicateId, predicate.Inputs),
     };
     const qlPredicate = predicateIdToQlPredicate(predicateId, coerceInputs(predicateId, predicate.Inputs), column);
-    if (!qlPredicate || !isQlPredicateComplete(qlPredicate, MIGRATION_FUNCTION_POOL)) {
+    if (!qlPredicate) {
+        const custom = lowerCustomPredicate(predicate, subjectColumnId);
+        if (!custom) {
+            return null;
+        }
+        customCalls?.push(custom.call);
+        return custom.qlPredicate;
+    }
+    if (!isQlPredicateComplete(qlPredicate, MIGRATION_FUNCTION_POOL)) {
         return null;
     }
     return subjectColumnId == null ? withScopeSubject(qlPredicate) : qlPredicate;
@@ -119,20 +246,22 @@ const toGroupExpression = (children, combinator) => {
     const group = { kind: 'group', combinator, children };
     return toCanonicalExpression(mapQlPredicateToExpression(group));
 };
-export const columnFilterPredicatesToExpression = (columnFilter) => {
+export const columnFilterPredicatesToExpression = (columnFilter, customCalls) => {
     const legacy = columnFilter;
     const predicates = legacy.Predicates ?? [];
     if (!predicates.length) {
         return null;
     }
+    const calls = [];
     const children = [];
     for (const predicate of predicates) {
-        const qlPredicate = lowerPredicateToQlPredicate(predicate, columnFilter.ColumnId);
+        const qlPredicate = lowerPredicateToQlPredicate(predicate, columnFilter.ColumnId, calls);
         if (!qlPredicate) {
             return null;
         }
         children.push(qlPredicate);
     }
+    customCalls?.push(...calls);
     const combinator = legacy.PredicatesOperator === 'OR' ? 'OR' : 'AND';
     return toGroupExpression(children, combinator);
 };
@@ -178,22 +307,24 @@ export const columnFilterPredicatesToPreferredFilter = (columnFilter) => {
     }
     return operator;
 };
-export const rulePredicatesToBooleanExpression = (predicates) => {
+export const rulePredicatesToBooleanExpression = (predicates, customCalls) => {
     if (!predicates?.length) {
         return null;
     }
+    const calls = [];
     const children = [];
     for (const predicate of predicates) {
-        const qlPredicate = lowerPredicateToQlPredicate(predicate, predicate.ColumnId ?? null);
+        const qlPredicate = lowerPredicateToQlPredicate(predicate, predicate.ColumnId ?? null, calls);
         if (!qlPredicate) {
             return null;
         }
         children.push(qlPredicate);
     }
+    customCalls?.push(...calls);
     return toGroupExpression(children, 'AND');
 };
-export const badgePredicateToBooleanExpression = (predicate, columnId) => {
-    const qlPredicate = lowerPredicateToQlPredicate(predicate, columnId);
+export const badgePredicateToBooleanExpression = (predicate, columnId, customCalls) => {
+    const qlPredicate = lowerPredicateToQlPredicate(predicate, columnId, customCalls);
     if (!qlPredicate) {
         return null;
     }