@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/aql/columnFilterQl.js

@@ -0,0 +1,516 @@
+import { asQlGroup, colRef, collectQueryBuilderOperatorNames, getFunctionDef, getOperatorsForSubjectType, getSubjectArgCount, isQlArgPredicate, isQlColRef, isQlFieldRef, isQlFnCall, isQlGroup, isQlList, isQlLiteral, isQlPredicateError, isQlPrimitive, literalForRawValue, literalOrPathArg, isQlPredicateComplete as isAqlPredicateComplete, getQlPredicateSymbol, mapExpressionToQlPredicate, mapQlPredicateToExpression, operatorHasSubject, pruneToCompletePredicates as pruneAqlToCompletePredicates, qlPrimitive, readRhsSlots, resolveOperandSlots, writeRhsSlots, } from "../../vendor/aql/index.js";
+import { mapColumnDataTypeToExpressionFunctionType } from './adaptableQlUtils';
+import * as ModuleConstants from '../Utilities/Constants/ModuleConstants';
+import { resolveValueOrFunction } from '../Utilities/Helpers/ValueOrFunctionHelper';
+import { resolveOperatorIcon, resolveOperatorLabel, } from './resolveOperatorPresentation';
+import { systemScalarExpressionFunctions as scalarExpressionFunctions } from './systemExpressionFunctions';
+import { getSystemFunctionDef, } from '../components/aql/QueryBuilder/utils';
+const SYSTEM_FUNCTION_POOL = {
+    scalarFunctions: scalarExpressionFunctions,
+};
+const getColumnFilterFunctionPool = (api) => {
+    const functions = api.internalApi
+        .getQueryLanguageService()
+        .getModuleExpressionFunctionsMap(ModuleConstants.ColumnFilterModuleId);
+    return { scalarFunctions: functions.scalarFunctions ?? {} };
+};
+const resolveColumnFilterSubjectType = (api) => (subject) => {
+    if (isQlColRef(subject)) {
+        const dataType = api.columnApi.getColumnDataTypeForColumnId(subject.columnId);
+        return dataType
+            ? mapColumnDataTypeToExpressionFunctionType(dataType)
+            : undefined;
+    }
+    if (isQlFieldRef(subject)) {
+        const dataType = api.expressionApi.internalApi.getFieldType(subject.fieldName);
+        return dataType
+            ? mapColumnDataTypeToExpressionFunctionType(dataType)
+            : undefined;
+    }
+    return undefined;
+};
+export const isQlPredicateComplete = (api, predicate) => isAqlPredicateComplete(predicate, getColumnFilterFunctionPool(api), resolveColumnFilterSubjectType(api));
+export const pruneToCompletePredicates = (api, group) => pruneAqlToCompletePredicates(group, getColumnFilterFunctionPool(api), resolveColumnFilterSubjectType(api));
+export const asColumnFilterGroup = asQlGroup;
+export const getColumnFilterOperatorValue = (def) => def.operator;
+export const getColumnFilterOperatorLabel = (operator, subjectType) => resolveOperatorLabel(getSystemFunctionDef(operator), operator, subjectType);
+export const getColumnFilterOperators = (api, column) => {
+    const pool = api.internalApi
+        .getQueryLanguageService()
+        .getModuleExpressionFunctionsMap(ModuleConstants.ColumnFilterModuleId);
+    const availableNames = collectQueryBuilderOperatorNames(pool);
+    const isAutoGroupColumn = api.columnApi.isAutoRowGroupColumnForSingle(column.columnId);
+    const subjectType = mapColumnDataTypeToExpressionFunctionType(column.dataType);
+    const operators = getOperatorsForSubjectType(subjectType, availableNames, pool).filter((name) => {
+        if (isAutoGroupColumn && (name === 'IS_BLANK' || name === 'IS_NOT_BLANK')) {
+            return false;
+        }
+        if (name === 'IS_NUMERIC') {
+            return false;
+        }
+        const fn = getFunctionDef(name, pool);
+        if (fn && !operatorHasSubject(fn)) {
+            return false;
+        }
+        return true;
+    });
+    const isAvailable = api.optionsApi.getExpressionOptions().isExpressionFunctionAvailable;
+    if (typeof isAvailable !== 'function') {
+        return operators;
+    }
+    const baseContext = api.internalApi.buildBaseContext();
+    const columnScope = { ColumnIds: [column.columnId] };
+    return operators.filter((operator) => {
+        const fn = getFunctionDef(operator, pool);
+        if (!fn) {
+            return true;
+        }
+        return (isAvailable({
+            ...baseContext,
+            module: ModuleConstants.ColumnFilterModuleId,
+            functionName: operator,
+            functionType: 'scalar',
+            expressionFunction: fn,
+            isCustom: !getSystemFunctionDef(operator),
+            column,
+            columnScope,
+            defaultAvailability: true,
+        }) !== false);
+    });
+};
+export const getColumnFilterOperatorDef = (api, operator, column) => {
+    const pool = api.internalApi
+        .getQueryLanguageService()
+        .getModuleExpressionFunctionsMap(ModuleConstants.ColumnFilterModuleId);
+    const fn = getFunctionDef(operator, pool);
+    if (!fn) {
+        return null;
+    }
+    const subjectType = mapColumnDataTypeToExpressionFunctionType(column.dataType);
+    const shortcuts = getOperatorShortcuts(api, operator);
+    return {
+        operator,
+        label: resolveOperatorLabel(fn, operator, subjectType),
+        icon: resolveOperatorIcon(fn, subjectType),
+        slots: resolveOperandSlots(fn, subjectType),
+        shortcuts,
+    };
+};
+export const getColumnFilterOperatorDefs = (api, column) => {
+    const defs = getColumnFilterOperators(api, column)
+        .map((operator) => getColumnFilterOperatorDef(api, operator, column))
+        .filter(Boolean);
+    const inDef = defs.find((def) => def.operator === 'IN');
+    const notInDef = defs.find((def) => def.operator === 'NOT_IN');
+    if (!inDef && !notInDef) {
+        return defs;
+    }
+    const otherDefs = defs.filter((def) => def.operator !== 'IN' && def.operator !== 'NOT_IN');
+    return [inDef, notInDef, ...otherDefs].filter(Boolean);
+};
+export const getOperatorShortcuts = (api, operator) => {
+    const wildcards = api.optionsApi.getFilterOptions().columnFilterOptions.quickFilterWildcards;
+    const override = wildcards?.[operator];
+    if (Array.isArray(override)) {
+        return override;
+    }
+    return getSystemFunctionDef(operator)?.shortcuts ?? [];
+};
+export const findOperatorByShortcut = (api, column, key) => getColumnFilterOperators(api, column).find((operator) => getOperatorShortcuts(api, operator)?.includes(key));
+export const buildColumnFilterExpression = (qlPredicate) => mapQlPredicateToExpression(qlPredicate);
+export const expressionForColumnFilterChangedEvent = (api, group) => {
+    if (isQlPredicateComplete(api, group)) {
+        return buildColumnFilterExpression(group);
+    }
+    const completeGroup = pruneToCompletePredicates(api, group);
+    if (completeGroup.children.length > 0) {
+        return buildColumnFilterExpression(completeGroup);
+    }
+    return undefined;
+};
+export const createColumnFilterPrimitive = (operator, columnId) => {
+    if (!operator) {
+        return qlPrimitive(undefined, [colRef(columnId)]);
+    }
+    const fn = getSystemFunctionDef(operator);
+    const hasSubject = fn ? operatorHasSubject(fn) : true;
+    return qlPrimitive(operator, hasSubject ? [colRef(columnId)] : []);
+};
+export const findColumnFilterOperatorDef = (defs, child) => {
+    if (!child || !isQlPrimitive(child) || !child.operator) {
+        return null;
+    }
+    return defs.find((def) => def.operator === child.operator) ?? null;
+};
+export const getEditableColumnFilterPrimitive = (child) => (child && isQlPrimitive(child) ? child : null);
+export const getPrimitiveRhsArgs = (primitiveNode) => primitiveNode.args.slice(getSubjectArgCount(primitiveNode.operator, SYSTEM_FUNCTION_POOL));
+export const primitiveHasNonEditableRhs = (primitiveNode) => getPrimitiveRhsArgs(primitiveNode).some((arg) => isQlColRef(arg) || isQlFieldRef(arg) || isQlFnCall(arg) || isQlArgPredicate(arg));
+const literalToRawValue = (arg) => {
+    if (!arg) {
+        return undefined;
+    }
+    if (isQlLiteral(arg)) {
+        return arg.value;
+    }
+    if (isQlList(arg)) {
+        return arg.items.map(literalToRawValue);
+    }
+    if (isQlFnCall(arg) && arg.operator === 'TO_ARRAY') {
+        return arg.args.map(literalToRawValue);
+    }
+    return undefined;
+};
+const resolveSlotsForOperator = (operator) => {
+    const fn = operator ? getSystemFunctionDef(operator) : undefined;
+    return fn ? resolveOperandSlots(fn, undefined) : [];
+};
+export const getColumnFilterInListValues = (columnFilter) => {
+    if (!columnFilter?.Expression) {
+        return [];
+    }
+    const parsed = mapExpressionToQlPredicate(columnFilter.Expression, SYSTEM_FUNCTION_POOL);
+    if (!parsed || isQlPredicateError(parsed)) {
+        return [];
+    }
+    return collectInListValues(parsed);
+};
+const collectInListValues = (predicate) => {
+    if (isQlGroup(predicate)) {
+        return predicate.children.flatMap(collectInListValues);
+    }
+    if (!isQlPrimitive(predicate) || !predicate.operator) {
+        return [];
+    }
+    if (predicate.operator === 'NOT') {
+        const inner = predicate.args?.[0];
+        return isQlArgPredicate(inner) ? collectInListValues(inner) : [];
+    }
+    if (predicate.operator !== 'IN' && predicate.operator !== 'NOT_IN') {
+        return [];
+    }
+    const rhs = predicate.args.slice(getSubjectArgCount(predicate.operator, SYSTEM_FUNCTION_POOL));
+    const items = rhs.length === 1 && isQlList(rhs[0]) ? rhs[0].items : rhs;
+    return items
+        .map(literalToRawValue)
+        .filter((value) => value !== undefined);
+};
+export const getPrimitiveInputValues = (primitiveNode, slots = resolveSlotsForOperator(primitiveNode.operator)) => readRhsSlots(primitiveNode, slots, 1).map(literalToRawValue);
+export const withPrimitiveInputValues = (primitiveNode, values, slots) => {
+    const isValueEmpty = (value) => value === undefined || value === null || (typeof value === 'number' && isNaN(value));
+    const slotValues = slots.map((slot, index) => {
+        const value = values[index];
+        if (isValueEmpty(value)) {
+            return undefined;
+        }
+        if (slot.multi || slot.type.includes('[]')) {
+            const itemType = slot.type.replace('[]', '');
+            const items = (Array.isArray(value) ? value : [value]).map((item) => literalOrPathArg(item, itemType));
+            return { kind: 'list', items };
+        }
+        return literalForRawValue(value, slot.type);
+    });
+    return writeRhsSlots(primitiveNode, slotValues, slots, getSubjectArgCount(primitiveNode.operator, SYSTEM_FUNCTION_POOL));
+};
+export const isColumnFilterPrimitiveEmpty = (primitiveNode, def) => {
+    if (!primitiveNode?.operator) {
+        return true;
+    }
+    if (!def || def.slots.length === 0) {
+        return false;
+    }
+    const values = getPrimitiveInputValues(primitiveNode, def.slots);
+    return (values.length === 0 ||
+        values.every((value) => value === undefined ||
+            value === null ||
+            value === '' ||
+            (Array.isArray(value) && value.length === 0)));
+};
+const IN_FILTER_FUNCTION_TOKEN_PREFIX = '__ab_in_fn__:';
+export const encodeInFilterFunctionToken = (functionName) => `${IN_FILTER_FUNCTION_TOKEN_PREFIX}${functionName}`;
+export const isInFilterFunctionToken = (value) => typeof value === 'string' && value.startsWith(IN_FILTER_FUNCTION_TOKEN_PREFIX);
+export const decodeInFilterFunctionToken = (value) => isInFilterFunctionToken(value)
+    ? value.slice(IN_FILTER_FUNCTION_TOKEN_PREFIX.length)
+    : null;
+export const isNoInputBooleanFunction = (name) => {
+    const fn = getSystemFunctionDef(name);
+    if (!fn || fn.returnType !== 'boolean') {
+        return false;
+    }
+    const overloads = fn.operands ?? [];
+    return overloads.length > 0 && overloads.every((overload) => overload.length === 1);
+};
+export const isInFilterFunctionApplicableToColumn = (name, column) => {
+    const fn = getSystemFunctionDef(name);
+    if (!fn || !isNoInputBooleanFunction(name)) {
+        return false;
+    }
+    const columnType = mapColumnDataTypeToExpressionFunctionType(column.dataType);
+    return (fn.operands ?? []).some((overload) => {
+        const operandType = overload[0];
+        return operandType === 'any' || operandType === columnType;
+    });
+};
+export const getInFilterContext = (columnId, group) => {
+    if (!group || group.children.length === 0) {
+        return null;
+    }
+    if (group.children.length > 1 && group.combinator !== 'OR') {
+        return null;
+    }
+    let inPrimitive = null;
+    const functionNames = [];
+    for (const child of group.children) {
+        if (!isQlPrimitive(child) || !child.operator) {
+            return null;
+        }
+        const subject = child.args?.[0];
+        if (!isQlColRef(subject) || subject.columnId !== columnId) {
+            return null;
+        }
+        if (child.operator === 'IN' || child.operator === 'NOT_IN') {
+            if (inPrimitive) {
+                return null;
+            }
+            inPrimitive = child;
+            continue;
+        }
+        if (isNoInputBooleanFunction(child.operator) && getPrimitiveRhsArgs(child).length === 0) {
+            functionNames.push(child.operator);
+            continue;
+        }
+        return null;
+    }
+    if (!inPrimitive) {
+        return null;
+    }
+    return { inPrimitive, operator: inPrimitive.operator, functionNames };
+};
+export const buildInFilterGroup = (columnId, operator, literals, functionNames, slots) => {
+    const children = [
+        withPrimitiveInputValues(createColumnFilterPrimitive(operator, columnId), [literals.length ? literals : undefined], slots),
+    ];
+    functionNames.forEach((functionName) => {
+        children.push(createColumnFilterPrimitive(functionName, columnId));
+    });
+    return { kind: 'group', combinator: 'OR', children };
+};
+const readInPrimitiveListValues = (primitive, slots) => {
+    const raw = getPrimitiveInputValues(primitive, slots)[0];
+    return Array.isArray(raw) ? raw : raw != null ? [raw] : [];
+};
+export const foldInFilterFunctionsForEditing = (columnId, group, operatorDefs) => {
+    const ctx = getInFilterContext(columnId, group);
+    if (!ctx || ctx.operator !== 'IN' || ctx.functionNames.length === 0) {
+        return group;
+    }
+    const def = operatorDefs.find((d) => d.operator === 'IN');
+    if (!def) {
+        return group;
+    }
+    const literals = readInPrimitiveListValues(ctx.inPrimitive, def.slots);
+    const tokens = ctx.functionNames.map(encodeInFilterFunctionToken);
+    const foldedPrimitive = withPrimitiveInputValues(createColumnFilterPrimitive('IN', columnId), [[...literals, ...tokens]], def.slots);
+    return { kind: 'group', combinator: 'OR', children: [foldedPrimitive] };
+};
+export const unfoldInFilterFunctionsFromEditing = (columnId, group, operatorDefs) => {
+    if (!group || group.children.length === 0) {
+        return group;
+    }
+    let changed = false;
+    const newChildren = [];
+    for (const child of group.children) {
+        if (isQlPrimitive(child) && child.operator === 'IN') {
+            const def = operatorDefs.find((d) => d.operator === 'IN');
+            if (def) {
+                const list = readInPrimitiveListValues(child, def.slots);
+                const literals = [];
+                const functionNames = [];
+                list.forEach((value) => {
+                    const functionName = decodeInFilterFunctionToken(value);
+                    if (functionName) {
+                        functionNames.push(functionName);
+                    }
+                    else {
+                        literals.push(value);
+                    }
+                });
+                if (functionNames.length > 0) {
+                    changed = true;
+                    newChildren.push(withPrimitiveInputValues(createColumnFilterPrimitive('IN', columnId), [literals.length ? literals : undefined], def.slots));
+                    functionNames.forEach((functionName) => {
+                        newChildren.push(createColumnFilterPrimitive(functionName, columnId));
+                    });
+                    continue;
+                }
+            }
+        }
+        newChildren.push(child);
+    }
+    if (!changed) {
+        return group;
+    }
+    return {
+        ...group,
+        combinator: group.children.length === 1 ? 'OR' : group.combinator,
+        children: newChildren,
+    };
+};
+const getOperatorDisplaySymbol = (operator, defs) => {
+    const symbol = getQlPredicateSymbol(operator);
+    if (symbol !== operator) {
+        return symbol;
+    }
+    const def = defs.find((d) => d.operator === operator);
+    return def?.label ?? getColumnFilterOperatorLabel(operator);
+};
+const qlArgToLabel = (arg, defs) => {
+    if (!arg) {
+        return '';
+    }
+    if (isQlColRef(arg)) {
+        return `[${arg.columnId}]`;
+    }
+    if (isQlFieldRef(arg)) {
+        return `[${arg.fieldName}]`;
+    }
+    if (isQlLiteral(arg)) {
+        if (arg.type === 'null') {
+            return 'NULL';
+        }
+        if (arg.value === undefined || arg.value === null || arg.value === '') {
+            return '';
+        }
+        return String(arg.value);
+    }
+    if (isQlList(arg)) {
+        const items = arg.items.map((item) => qlArgToLabel(item, defs)).filter((item) => item !== '');
+        return items.length > 0 ? `(${items.join(', ')})` : '';
+    }
+    if (isQlFnCall(arg)) {
+        return `${arg.operator}(${arg.args
+            .map((item) => qlArgToLabel(item, defs))
+            .filter((item) => item !== '')
+            .join(', ')})`;
+    }
+    if (isQlArgPredicate(arg)) {
+        return qlPredicateToLabel(arg, defs);
+    }
+    return '';
+};
+export const qlGroupToLabel = (group, defs) => {
+    const childLabels = group.children
+        .map((child) => qlPredicateToLabel(child, defs))
+        .filter((label) => label !== '');
+    return childLabels.join(` ${group.combinator} `);
+};
+const qlPredicateToLabel = (node, defs) => {
+    if (isQlGroup(node)) {
+        return `(${qlGroupToLabel(node, defs)})`;
+    }
+    if (!node.operator) {
+        return '';
+    }
+    if (node.operator === 'NOT') {
+        const inner = node.args[0];
+        if (inner && isQlArgPredicate(inner)) {
+            return `Not ${qlPredicateToLabel(inner, defs)}`;
+        }
+        return 'Not';
+    }
+    const operatorLabel = getOperatorDisplaySymbol(node.operator, defs);
+    const rhsLabel = getPrimitiveRhsArgs(node)
+        .map((arg) => qlArgToLabel(arg, defs))
+        .filter((label) => label !== '')
+        .join(', ');
+    return rhsLabel ? `${operatorLabel} ${rhsLabel}` : operatorLabel;
+};
+export const isKnownPreferredFilter = (value) => Boolean(value && getSystemFunctionDef(value));
+export const resolvePreferredFilterFromGroup = (_api, _columnId, group) => {
+    const child = group.children?.[0];
+    if (!child || !isQlPrimitive(child) || !child.operator) {
+        return null;
+    }
+    return isKnownPreferredFilter(child.operator) ? child.operator : null;
+};
+const withoutFilterPayload = (existing, columnId) => {
+    if (!existing) {
+        return { ColumnId: columnId };
+    }
+    const { Expression: _expression, PreferredFilter: _preferred, ...rest } = existing;
+    return { ...rest, ColumnId: columnId };
+};
+const buildDefaultSeedPrimitive = (operatorName, columnId) => {
+    if (!operatorName || !getSystemFunctionDef(operatorName)) {
+        return null;
+    }
+    return createColumnFilterPrimitive(operatorName, columnId);
+};
+const resolveDefaultColumnFilterOption = (api, column, filterComponent) => {
+    const columnFilterOptions = api.optionsApi.getFilterOptions().columnFilterOptions;
+    const context = {
+        column,
+        filterComponent,
+        ...api.internalApi.buildBaseContext(),
+    };
+    switch (column.dataType) {
+        case 'number':
+            return (resolveValueOrFunction(columnFilterOptions.defaultNumericColumnFilter, context) ?? 'EQ');
+        case 'text':
+            return (resolveValueOrFunction(columnFilterOptions.defaultTextColumnFilter, context) ?? 'CONTAINS');
+        case 'date':
+            return (resolveValueOrFunction(columnFilterOptions.defaultDateColumnFilter, context) ?? 'IS_SAME_DAY');
+        case 'boolean':
+            return 'EQ';
+        case 'textArray':
+        case 'numberArray':
+            return resolveValueOrFunction(columnFilterOptions.defaultArrayColumnFilter, context) ?? 'IN';
+        case 'groupColumn':
+            return 'IN';
+        default:
+            return null;
+    }
+};
+export const deriveColumnFilterGroup = (api, column, columnFilter, mapper, filterComponent) => {
+    if (!column) {
+        return asColumnFilterGroup(null);
+    }
+    if (columnFilter?.Expression) {
+        const parsed = mapper.parse(columnFilter.Expression);
+        if (parsed && !isQlPredicateError(parsed)) {
+            return asColumnFilterGroup(parsed);
+        }
+    }
+    if (isKnownPreferredFilter(columnFilter?.PreferredFilter)) {
+        const preferredPrimitive = buildDefaultSeedPrimitive(columnFilter.PreferredFilter, column.columnId);
+        if (preferredPrimitive) {
+            return asColumnFilterGroup(preferredPrimitive);
+        }
+    }
+    const defaultOptionValue = resolveDefaultColumnFilterOption(api, column, filterComponent);
+    const defaultPrimitive = buildDefaultSeedPrimitive(defaultOptionValue, column.columnId);
+    return asColumnFilterGroup(defaultPrimitive ?? createColumnFilterPrimitive(undefined, column.columnId));
+};
+export const buildColumnFilterFromGroup = (api, existing, columnId, group) => {
+    const completeGroup = pruneToCompletePredicates(api, group);
+    if (completeGroup.children.length > 0) {
+        return {
+            ...withoutFilterPayload(existing, columnId),
+            Expression: buildColumnFilterExpression(completeGroup),
+        };
+    }
+    const preferredFilter = resolvePreferredFilterFromGroup(api, columnId, group);
+    if (preferredFilter) {
+        const preferredUnchanged = !existing?.Expression && existing?.PreferredFilter === preferredFilter;
+        if (preferredUnchanged) {
+            return null;
+        }
+        return {
+            ...withoutFilterPayload(existing, columnId),
+            PreferredFilter: preferredFilter,
+        };
+    }
+    if (existing?.Expression || existing?.PreferredFilter) {
+        return 'clear';
+    }
+    return null;
+};

package/src/aql/createAdaptableAqlHost.d.ts

@@ -0,0 +1,19 @@
+import type { AqlCalendarHost, AqlCellChange, AqlHost, ValueDataType } from "../../vendor/aql/index.js";
+import type { AdaptableApi } from '../Api/AdaptableApi';
+import type { AdaptableColumnDataType } from '../AdaptableState/Common/AdaptableColumn';
+import type { CellDataChangedInfo } from '../AdaptableState/Common/CellDataChangedInfo';
+/**
+ * Adaptable data types are richer than the language's. Array columns collapse
+ * to `array`; `object` / `unknown` have no language meaning, so they resolve to
+ * `undefined` rather than being forced into a wrong type.
+ */
+export declare const toValueDataType: (dataType: AdaptableColumnDataType) => ValueDataType | undefined;
+export declare const createCalendarHost: (api: AdaptableApi) => AqlCalendarHost;
+/** Maps Adaptable's cell-change event to the aql shape, keeping the original. */
+export declare const toAqlCellChange: (change: CellDataChangedInfo) => AqlCellChange;
+/**
+ * Implements the aql host ports over `AdaptableApi` — the single place that
+ * knows about AG Grid row nodes and Adaptable services. Every evaluation
+ * (`QueryLanguageService`) runs the aql function packs against this host.
+ */
+export declare const createAdaptableAqlHost: (api: AdaptableApi) => AqlHost;

package/src/aql/createAdaptableAqlHost.js

@@ -0,0 +1,121 @@
+import { AG_GRID_GROUPED_COLUMN } from '../Utilities/Constants/GeneralConstants';
+import { matchGroupColumnPaths, normalizeInHaystackToPaths, } from '../agGrid/AgGridGroupColumnPathMatching';
+export const toValueDataType = (dataType) => {
+    switch (dataType) {
+        case 'number':
+        case 'text':
+        case 'date':
+        case 'boolean':
+            return dataType;
+        case 'textArray':
+        case 'numberArray':
+        case 'tupleArray':
+        case 'objectArray':
+            return 'array';
+        case 'groupColumn':
+            return 'text';
+        default:
+            return undefined;
+    }
+};
+const asRowNode = (rowRef) => rowRef;
+export const createCalendarHost = (api) => ({
+    isToday: (date) => api.calendarApi.isToday(date),
+    isYesterday: (date) => api.calendarApi.isYesterday(date),
+    isTomorrow: (date) => api.calendarApi.isTomorrow(date),
+    isSameDay: (first, second) => api.calendarApi.isSameDay(first, second),
+    isHoliday: (date) => api.calendarApi.isHoliday(date),
+    isWorkingDay: (date) => api.calendarApi.isWorkingDay(date),
+    getNextWorkingDay: (from) => api.calendarApi.getNextWorkingDay(from),
+    getPreviousWorkingDay: (from) => api.calendarApi.getPreviousWorkingDay(from),
+    getWeekStartsOn: () => api.calendarApi.getWeekStartsOn(),
+});
+export const toAqlCellChange = (change) => ({
+    changedAt: change.changedAt,
+    columnId: change.column?.columnId,
+    oldValue: change.oldValue,
+    newValue: change.newValue,
+    rowRef: change.rowNode,
+    primaryKeyValue: change.primaryKeyValue,
+    trigger: change.trigger,
+    hostEvent: change,
+});
+export const createAdaptableAqlHost = (api) => {
+    let columnInfoSource;
+    let columnInfoCache = new Map();
+    const getColumn = (columnId) => {
+        const columns = api.columnApi.getColumns();
+        if (columnInfoSource !== columns) {
+            columnInfoSource = columns;
+            columnInfoCache = new Map();
+        }
+        if (columnInfoCache.has(columnId)) {
+            return columnInfoCache.get(columnId);
+        }
+        const column = api.columnApi.getColumnWithColumnId(columnId, false);
+        const info = column
+            ? {
+                columnId: column.columnId,
+                dataType: toValueDataType(column.dataType),
+                queryable: column.queryable,
+                isGroupColumn: column.columnId === AG_GRID_GROUPED_COLUMN,
+                isCalculated: column.isCalculatedColumn === true,
+            }
+            : undefined;
+        columnInfoCache.set(columnId, info);
+        return info;
+    };
+    return {
+        getRowData: (rowRef) => asRowNode(rowRef)?.data,
+        getColumnValue: (rowRef, columnId) => api.gridApi.getNormalisedValueFromRowNode(asRowNode(rowRef), columnId),
+        getFieldValue: (rowRef, field) => api.internalApi.getValueUsingField(asRowNode(rowRef)?.data, field),
+        getColumn,
+        isTextComparisonCaseSensitive: () => api.expressionApi.useCaseSensitivity(),
+        values: {
+            getRawColumnValue: (rowRef, columnId) => api.gridApi.getRawValueFromRowNode(asRowNode(rowRef), columnId),
+            getDisplayValue: (rowRef, columnId) => api.gridApi.getDisplayValueFromRowNode(asRowNode(rowRef), columnId),
+        },
+        rows: {
+            getRowRefs: (config) => api.gridApi.getAllRowNodes(config?.filterFn ? { filterFn: (rowNode) => config.filterFn(rowNode) } : undefined),
+            getFirstRowRef: () => api.gridApi.getFirstRowNode(),
+            getRowId: (rowRef) => asRowNode(rowRef)?.id,
+            getPrimaryKeyValue: (rowRef) => api.gridApi.getPrimaryKeyValueForRowNode(asRowNode(rowRef)),
+            getCellRawValue: (primaryKeyValue, columnId) => api.gridApi.getCellRawValue(primaryKeyValue, columnId),
+        },
+        grouping: {
+            matchGroupColumnPaths: ({ rowRef, columnId, value, haystack }) => {
+                const column = api.columnApi.getColumnWithColumnId(columnId);
+                return matchGroupColumnPaths({
+                    node: asRowNode(rowRef),
+                    value,
+                    selectedPaths: normalizeInHaystackToPaths(haystack),
+                    isTreeColumn: column?.isTreeColumn,
+                });
+            },
+        },
+        comparison: {
+            getColumnIds: () => api.columnApi.getColumns().map((column) => column.columnId),
+            getFieldDataType: (field) => {
+                const fieldDef = api.expressionApi.internalApi
+                    .getAvailableFields()
+                    ?.find((availableField) => availableField.name === field);
+                return fieldDef ? toValueDataType(fieldDef.dataType) ?? null : null;
+            },
+            shouldEvaluateDatesUsingTime: (columnId) => api.expressionApi.shouldEvaluateDatesUsingTime(columnId),
+        },
+        calendar: createCalendarHost(api),
+        namedQueries: {
+            getNamedQueryExpression: (name) => api.namedQueryApi.getNamedQueryByName(name)?.Expression,
+            getNamedQueryReturnType: (name) => {
+                const namedQuery = api.namedQueryApi.getNamedQueryByName(name);
+                if (!namedQuery) {
+                    return undefined;
+                }
+                return namedQuery.ReturnType ?? 'boolean';
+            },
+        },
+        variables: {
+            getQueryVariable: (name, args) => api.internalApi.getQueryLanguageService().evaluateQueryVariable(name, args),
+        },
+    };
+};

package/src/aql/createExternalDataAqlHost.d.ts

@@ -0,0 +1,17 @@
+import { type AqlHost } from "../../vendor/aql/index.js";
+import type { AdaptableApi } from '../Api/AdaptableApi';
+import type { ExternalDataColumn } from './ExpressionEvaluation';
+export interface ExternalDataAqlHostConfig {
+    rows: Record<string, unknown>[];
+    columns?: ExternalDataColumn[];
+}
+/**
+ * Implements `AqlHost` over a caller-supplied array of plain objects.
+ *
+ * Generic row iteration / identity comes from aql's `createObjectDataHost`.
+ * Column metadata is resolved `columns` override → live grid column →
+ * unknown. Values are read via field path (`column.field` when the column
+ * exists, else `columnId`). Calendar, named queries, `VAR` and comparison
+ * semantics still delegate to the live `AdaptableApi`.
+ */
+export declare const createExternalDataAqlHost: (api: AdaptableApi, config: ExternalDataAqlHostConfig) => AqlHost;