@adminforth/dashboard 1.4.0 → 1.4.2

package/services/widgetDataService.ts

@@ -9,9 +9,8 @@ import type {
   DashboardWidgetConfig,
   DashboardWidgetData,
   DashboardVariables,
-  FilterExpression,
   FunnelQueryConfig,
-  QueryAggregateOperation,
+  FilterExpression,
   QueryAggregateSelectItem,
   QueryCalcSelectItem,
   QueryConfig,
@@ -35,16 +34,55 @@ type DashboardWidgetFilters =
   | IAdminForthAndOrFilter
   | Array<IAdminForthSingleFilter | IAdminForthAndOrFilter>;
 
-type QueryRowGroup = {
-  rows: Record<string, unknown>[];
-  values: Record<string, unknown>;
+type AggregateRule =
+  | { operation: 'count' }
+  | { operation: Exclude<QueryAggregateSelectItem['agg'], 'count'>; field: string };
+
+type AggregateGroupByRule =
+  | {
+      type: 'date_trunc';
+      field: string;
+      truncation: TimeGrain;
+      timezone?: string;
+      as: string;
+    }
+  | {
+      type: 'field';
+      field: string;
+      as: string;
+    };
+
+type AggregateResource = {
+  aggregate: (
+    filters: DashboardWidgetFilters,
+    aggregations: Record<string, AggregateRule>,
+    groupBy?: AggregateGroupByRule | AggregateGroupByRule[],
+  ) => Promise<Record<string, unknown>[]>;
+};
+
+type EffectiveGroupByItem = {
+  field: string;
+  as: string;
+  grain?: TimeGrain;
+  timezone?: string;
 };
 
-const NOW_MINUS_RE = /^(\d+)([dhw])$/;
 const CALC_IDENTIFIER_RE = /\b[a-zA-Z_][a-zA-Z0-9_]*\b/g;
 const LOOKUP_CALL_RE = /lookup\(\s*(\$variables(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*,\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/g;
 const VARIABLE_PATH_PREFIX_RE = /^\$variables\.?/;
 const SAFE_CALC_EXPRESSION_RE = /^[\d+\-*/().\s]+$/;
+const FILTER_OPERATORS = {
+  eq: Filters.EQ,
+  neq: Filters.NEQ,
+  gt: Filters.GT,
+  gte: Filters.GTE,
+  lt: Filters.LT,
+  lte: Filters.LTE,
+  in: Filters.IN,
+  not_in: Filters.NOT_IN,
+  like: Filters.LIKE,
+  ilike: Filters.ILIKE,
+} as const;
 
 export type WidgetDataService = {
   getWidgetData: (widget: DashboardWidgetConfig, options?: DashboardWidgetDataOptions) => Promise<DashboardWidgetData | null>;
@@ -90,12 +128,18 @@ async function getFunnelWidgetData(
 ): Promise<DashboardWidgetData> {
   const rows = await Promise.all(query.steps.map(async (step) => {
     const valueField = step.metric.as;
-    const sourceRows = await getResourceRows(adminforth, step.resource, step.filters);
+    const [values = {}] = await getAggregateRows(
+      adminforth,
+      step.resource,
+      step.filters,
+      [step.metric],
+      [],
+    );
 
     const row: Record<string, unknown> = {
       name: step.name,
       resource: step.resource,
-      [valueField]: calculateAggregate(sourceRows, step.metric),
+      [valueField]: values[valueField] ?? 0,
     };
 
     for (const calc of query.calcs ?? []) {
@@ -121,9 +165,14 @@ async function getQueryWidgetData(
   query: QueryConfig,
   variables: DashboardVariables,
 ): Promise<DashboardWidgetData> {
-  const rows = await getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.orderBy));
-  const selectedRows = buildQueryRows(rows, query, variables);
-  const orderedRows = sortRows(selectedRows, query.orderBy);
+  const selectedRows = isAggregateQuery(query)
+    ? await buildAggregateQueryRows(adminforth, query, variables)
+    : buildPlainQueryRows(
+      await getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.order_by)),
+      query,
+      variables,
+    );
+  const orderedRows = sortRows(selectedRows, query.order_by);
   const slicedRows = typeof query.limit === 'number'
     ? orderedRows.slice(query.offset ?? 0, (query.offset ?? 0) + query.limit)
     : orderedRows.slice(query.offset ?? 0);
@@ -150,85 +199,97 @@ async function getQueryWidgetData(
 async function getResourceRows(
   adminforth: IAdminForth,
   resourceId: string,
-  filters: unknown,
+  filters: FilterExpression | undefined,
   sort?: IAdminForthSort | IAdminForthSort[],
 ) {
   return adminforth.resource(resourceId).list(
-    normalizeFilters(filters),
+    getAdminForthFilters(filters),
     undefined,
     0,
     sort,
   );
 }
 
-function buildQueryRows(rows: Record<string, unknown>[], query: QueryConfig, variables: DashboardVariables) {
+function buildPlainQueryRows(rows: Record<string, unknown>[], query: QueryConfig, variables: DashboardVariables) {
   const select = query.select ?? getDefaultSelect(rows);
-  const groupBy = query.groupBy ?? [];
-
-  if (isAggregateQuery(query)) {
-    return buildGroupedRows(rows, select, groupBy, variables, query.calcs);
-  }
-
   return rows.map((row) => buildPlainRow(row, select, query.calcs, variables));
 }
 
-function buildGroupedRows(
-  rows: Record<string, unknown>[],
-  select: QuerySelectItem[],
-  groupBy: QueryGroupByItem[],
+async function buildAggregateQueryRows(
+  adminforth: IAdminForth,
+  query: QueryConfig,
   variables: DashboardVariables,
-  calcs: QueryCalcSelectItem[] = [],
 ) {
-  const groups = new Map<string, QueryRowGroup>();
-  const effectiveGroupBy = groupBy.length
-    ? groupBy
-    : select.filter(isFieldSelectItem).map((item) => ({ field: item.field, as: item.as, grain: item.grain }));
+  const select = query.select ?? [];
+  const effectiveGroupBy = getEffectiveGroupBy(query.group_by, select);
+  const aggregateSelect = select.filter(isAggregateSelectItem);
+  const rows = await getAggregateRows(
+    adminforth,
+    query.resource,
+    query.filters,
+    aggregateSelect,
+    effectiveGroupBy,
+  );
+
+  return rows.map((row) => buildCalculatedRow(row, select, query.calcs, variables));
+}
 
-  if (!effectiveGroupBy.length) {
-    const values = calculateGroupValues(rows, select, calcs, variables);
-    return Object.keys(values).length ? [values] : [];
+async function getAggregateRows(
+  adminforth: IAdminForth,
+  resourceId: string,
+  baseFilters: FilterExpression | undefined,
+  select: QueryAggregateSelectItem[],
+  groupBy: EffectiveGroupByItem[],
+) {
+  const resource = adminforth.resource(resourceId) as unknown as AggregateResource;
+  const groups = new Map<string, Record<string, unknown>>();
+  const groupByRules = groupBy.length ? groupBy.map(toAggregateGroupByRule) : undefined;
+  const aggregateSelectGroups = groupAggregateSelectItems(select);
+
+  if (groupBy.length) {
+    const groupSeedAlias = getHiddenAggregateAlias(groupBy, select);
+    const groupSeedRows = await resource.aggregate(
+      getAdminForthFilters(baseFilters),
+      { [groupSeedAlias]: { operation: 'count' } },
+      groupByRules,
+    );
+
+    for (const row of groupSeedRows) {
+      ensureAggregateGroup(groups, row, groupBy);
+    }
   }
 
-  for (const row of rows) {
-    const values = Object.fromEntries(effectiveGroupBy.map((item) => {
-      const field = getGroupByField(item);
-      const alias = getGroupByAlias(item);
-      const grain = getGroupByGrain(item);
+  for (const filterGroup of aggregateSelectGroups) {
+    const rows = await resource.aggregate(
+      mergeFilters(baseFilters, filterGroup.filters),
+      Object.fromEntries(filterGroup.items.map((item) => [item.as, toAggregationRule(item)])),
+      groupByRules,
+    );
 
-      return [alias, formatGroupValue(row[field], grain)];
-    }));
-    const key = JSON.stringify(values);
-    const group = groups.get(key) ?? { values, rows: [] };
+    for (const row of rows) {
+      const values = ensureAggregateGroup(groups, row, groupBy);
 
-    group.rows.push(row);
-    groups.set(key, group);
+      for (const item of filterGroup.items) {
+        values[item.as] = row[item.as] ?? 0;
+      }
+    }
   }
 
-  return Array.from(groups.values()).map((group) => ({
-    ...group.values,
-    ...calculateGroupValues(group.rows, select, calcs, variables, group.values),
-  }));
+  if (!groups.size && !groupBy.length && select.length) {
+    groups.set(JSON.stringify({}), {});
+  }
+
+  return Array.from(groups.values(), (row) => applyAggregateDefaults(row, select));
 }
 
-function calculateGroupValues(
-  rows: Record<string, unknown>[],
+function buildCalculatedRow(
+  baseValues: Record<string, unknown>,
   select: QuerySelectItem[],
-  calcs: QueryCalcSelectItem[],
+  calcs: QueryCalcSelectItem[] = [],
   variables: DashboardVariables,
-  baseValues: Record<string, unknown> = {},
 ) {
   const values: Record<string, unknown> = { ...baseValues };
 
-  for (const item of select) {
-    if (isAggregateSelectItem(item)) {
-      const filteredRows = item.filters
-        ? rows.filter((row) => matchesFilterExpression(row, item.filters as FilterExpression))
-        : rows;
-
-      values[item.as] = calculateAggregate(filteredRows, item);
-    }
-  }
-
   for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
     values[item.as] = evaluateCalc(item.calc, values, variables);
   }
@@ -259,50 +320,6 @@ function buildPlainRow(
   return values;
 }
 
-function calculateAggregate(rows: Record<string, unknown>[], item: QueryAggregateSelectItem) {
-  switch (item.agg) {
-    case 'count':
-      return rows.length;
-    case 'count_distinct':
-      return new Set(rows.map((row) => row[item.field!])).size;
-    case 'sum':
-      return aggregateNumbers(rows, item.field!, (values) => values.reduce((sum, value) => sum + value, 0));
-    case 'avg':
-      return aggregateNumbers(rows, item.field!, (values) => values.length
-        ? values.reduce((sum, value) => sum + value, 0) / values.length
-        : 0);
-    case 'min':
-      return aggregateNumbers(rows, item.field!, (values) => values.length ? Math.min(...values) : 0);
-    case 'max':
-      return aggregateNumbers(rows, item.field!, (values) => values.length ? Math.max(...values) : 0);
-    case 'median':
-      return aggregateNumbers(rows, item.field!, calculateMedian);
-    default:
-      throw new Error(`Unsupported aggregation operation: ${(item as { agg: QueryAggregateOperation }).agg}`);
-  }
-}
-
-function aggregateNumbers(
-  rows: Record<string, unknown>[],
-  field: string,
-  aggregate: (values: number[]) => number,
-) {
-  return aggregate(rows.map((row) => toFiniteNumber(row[field])).filter(Number.isFinite));
-}
-
-function calculateMedian(values: number[]) {
-  if (!values.length) {
-    return 0;
-  }
-
-  const sorted = [...values].sort((left, right) => left - right);
-  const middle = Math.floor(sorted.length / 2);
-
-  return sorted.length % 2
-    ? sorted[middle]
-    : (sorted[middle - 1] + sorted[middle]) / 2;
-}
-
 function evaluateCalc(calc: string, values: Record<string, unknown>, variables: DashboardVariables) {
   const expression = calc
     .replace(LOOKUP_CALL_RE, (_match, path: string, keyField: string, defaultValue: string) => {
@@ -369,7 +386,7 @@ function getBackendSort(orderBy: QueryOrderByItem[] | undefined) {
 
 function getColumns(rows: Record<string, unknown>[], query: QueryConfig) {
   const selectColumns = [
-    ...(query.groupBy ?? []).map(getGroupByAlias),
+    ...(query.group_by ?? []).map(getGroupByAlias),
     ...(query.select ?? []).map(getSelectAlias),
     ...(query.calcs ?? []).map((item) => item.as),
   ].filter(Boolean);
@@ -383,7 +400,7 @@ function getDefaultSelect(rows: Record<string, unknown>[]): QuerySelectItem[] {
 
 function isAggregateQuery(query: QueryConfig) {
   return Boolean(
-    query.groupBy?.length
+    query.group_by?.length
     || query.select?.some((item) => isAggregateSelectItem(item)),
   );
 }
@@ -408,206 +425,264 @@ function getSelectAlias(item: QuerySelectItem) {
   return item.as;
 }
 
-function getGroupByField(item: QueryGroupByItem) {
-  return typeof item === 'string' ? item : item.field;
-}
-
 function getGroupByAlias(item: QueryGroupByItem) {
   return typeof item === 'string' ? item : item.as ?? item.field;
 }
 
-function getGroupByGrain(item: QueryGroupByItem) {
-  return typeof item === 'string' ? undefined : item.grain;
-}
-
-function formatGroupValue(value: unknown, grain: TimeGrain | undefined) {
-  if (!grain) {
-    return value;
+function getEffectiveGroupBy(groupBy: QueryGroupByItem[] | undefined, select: QuerySelectItem[]) {
+  if (groupBy?.length) {
+    return groupBy.map((item) => normalizeGroupByItem(item));
   }
 
-  const date = new Date(String(value));
+  return select
+    .filter(isFieldSelectItem)
+    .map((item) => normalizeGroupByItem({ field: item.field, as: item.as, grain: item.grain }));
+}
 
-  if (!Number.isFinite(date.getTime())) {
-    return value;
+function normalizeGroupByItem(item: QueryGroupByItem | Pick<QueryFieldSelectItem, 'field' | 'as' | 'grain'>): EffectiveGroupByItem {
+  if (typeof item === 'string') {
+    return { field: item, as: item };
   }
 
-  if (grain === 'year') {
-    return `${date.getUTCFullYear()}`;
-  }
+  return {
+    field: item.field,
+    as: item.as ?? item.field,
+    grain: item.grain,
+    timezone: 'timezone' in item ? item.timezone : undefined,
+  };
+}
 
-  if (grain === 'quarter') {
-    return `${date.getUTCFullYear()}-Q${Math.floor(date.getUTCMonth() / 3) + 1}`;
+function toAggregateGroupByRule(item: EffectiveGroupByItem): AggregateGroupByRule {
+  if (item.grain) {
+    return {
+      type: 'date_trunc',
+      field: item.field,
+      truncation: item.grain,
+      timezone: item.timezone,
+      as: item.as,
+    };
   }
 
-  const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+  return {
+    type: 'field',
+    field: item.field,
+    as: item.as,
+  };
+}
 
-  if (grain === 'month') {
-    return `${date.getUTCFullYear()}-${month}`;
+function toAggregationRule(item: QueryAggregateSelectItem): AggregateRule {
+  switch (item.agg) {
+    case 'count':
+      return { operation: 'count' };
+    case 'count_distinct':
+      return { operation: 'count_distinct', field: item.field! };
+    case 'sum':
+      return { operation: 'sum', field: item.field! };
+    case 'avg':
+      return { operation: 'avg', field: item.field! };
+    case 'min':
+      return { operation: 'min', field: item.field! };
+    case 'max':
+      return { operation: 'max', field: item.field! };
+    case 'median':
+      return { operation: 'median', field: item.field! };
   }
+}
 
-  const day = String(date.getUTCDate()).padStart(2, '0');
+function extractAggregateGroupValues(row: Record<string, unknown>, groupBy: EffectiveGroupByItem[]) {
+  return Object.fromEntries(groupBy.map((item) => [
+    item.as,
+    formatGroupValue(row[item.as], item.grain),
+  ]));
+}
 
-  if (grain === 'week') {
-    const weekStart = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
-    weekStart.setUTCDate(weekStart.getUTCDate() - weekStart.getUTCDay());
-    return weekStart.toISOString().slice(0, 10);
-  }
+function ensureAggregateGroup(
+  groups: Map<string, Record<string, unknown>>,
+  row: Record<string, unknown>,
+  groupBy: EffectiveGroupByItem[],
+) {
+  const groupValues = groupBy.length ? extractAggregateGroupValues(row, groupBy) : {};
+  const key = JSON.stringify(groupValues);
+  const existingGroup = groups.get(key);
 
-  if (grain === 'day') {
-    return `${date.getUTCFullYear()}-${month}-${day}`;
+  if (existingGroup) {
+    return existingGroup;
   }
 
-  const hour = String(date.getUTCHours()).padStart(2, '0');
-  return `${date.getUTCFullYear()}-${month}-${day}T${hour}:00:00.000Z`;
+  groups.set(key, groupValues);
+  return groupValues;
 }
 
-function normalizeFilters(filters: unknown): DashboardWidgetFilters {
-  if (Array.isArray(filters)) {
-    return filters.map((filter) => normalizeFilterNode(filter)) as DashboardWidgetFilters;
-  }
-
-  if (isRecord(filters)) {
-    return normalizeFilterNode(filters);
+function applyAggregateDefaults(values: Record<string, unknown>, select: QueryAggregateSelectItem[]) {
+  for (const item of select) {
+    if (typeof values[item.as] === 'undefined') {
+      values[item.as] = 0;
+    }
   }
 
-  return [];
+  return values;
 }
 
-function normalizeFilterNode(filter: unknown): IAdminForthSingleFilter | IAdminForthAndOrFilter {
-  if (!isRecord(filter)) {
-    return filter as IAdminForthSingleFilter;
-  }
+function groupAggregateSelectItems(select: QueryAggregateSelectItem[]) {
+  const groups = new Map<string, {
+    filters: DashboardWidgetFilters;
+    items: QueryAggregateSelectItem[];
+  }>();
 
-  if (Array.isArray(filter.and)) {
-    return Filters.AND(filter.and.map((item) => normalizeFilterNode(item)));
-  }
+  for (const item of select) {
+    const filters = getAdminForthFilters(item.filters);
+    const key = getFilterCacheKey(filters);
+    const group = groups.get(key) ?? { filters, items: [] };
 
-  if (Array.isArray(filter.or)) {
-    return Filters.OR(filter.or.map((item) => normalizeFilterNode(item)));
+    group.items.push(item);
+    groups.set(key, group);
   }
 
-  if (typeof filter.field === 'string') {
-    if (Object.prototype.hasOwnProperty.call(filter, 'eq')) {
-      return Filters.EQ(filter.field, normalizeFilterValue(filter.eq));
-    }
+  return Array.from(groups.values());
+}
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'neq')) {
-      return Filters.NEQ(filter.field, normalizeFilterValue(filter.neq));
-    }
+function getFilterCacheKey(filters: DashboardWidgetFilters) {
+  if (Array.isArray(filters) && !filters.length) {
+    return '__base__';
+  }
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'gt')) {
-      return Filters.GT(filter.field, normalizeFilterValue(filter.gt));
-    }
+  return JSON.stringify(filters);
+}
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'gte')) {
-      return Filters.GTE(filter.field, normalizeFilterValue(filter.gte));
-    }
+function mergeFilters(...filters: Array<FilterExpression | DashboardWidgetFilters | undefined>) {
+  const merged: Array<IAdminForthSingleFilter | IAdminForthAndOrFilter> = [];
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'lt')) {
-      return Filters.LT(filter.field, normalizeFilterValue(filter.lt));
-    }
+  for (const filter of filters) {
+    const normalized = getAdminForthFilters(filter);
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'lte')) {
-      return Filters.LTE(filter.field, normalizeFilterValue(filter.lte));
+    if (Array.isArray(normalized)) {
+      merged.push(...normalized);
+      continue;
     }
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'in')) {
-      return Filters.IN(filter.field, normalizeFilterValue(filter.in));
+    if (normalized) {
+      merged.push(normalized);
     }
+  }
 
-    if (Object.prototype.hasOwnProperty.call(filter, 'not_in')) {
-      return Filters.NOT_IN(filter.field, normalizeFilterValue(filter.not_in));
-    }
+  if (!merged.length) {
+    return [] as DashboardWidgetFilters;
   }
 
-  return filter as IAdminForthSingleFilter | IAdminForthAndOrFilter;
+  return merged.length === 1 ? merged[0] : merged;
 }
 
-function matchesFilterExpression(row: Record<string, unknown>, filter: FilterExpression): boolean {
-  if (Array.isArray(filter)) {
-    return filter.every((item) => matchesFilterExpression(row, item));
-  }
+function getHiddenAggregateAlias(groupBy: EffectiveGroupByItem[], select: QueryAggregateSelectItem[]) {
+  const usedAliases = new Set([
+    ...groupBy.map((item) => item.as),
+    ...select.map((item) => item.as),
+  ]);
+  let alias = '__adminforth_dashboard_group_seed__';
 
-  if ('and' in filter) {
-    return filter.and.every((item) => matchesFilterExpression(row, item));
+  while (usedAliases.has(alias)) {
+    alias = `_${alias}`;
   }
 
-  if ('or' in filter) {
-    return filter.or.some((item) => matchesFilterExpression(row, item));
+  return alias;
+}
+
+function formatGroupValue(value: unknown, grain: TimeGrain | undefined) {
+  if (!grain) {
+    return value;
   }
 
-  const value = row[filter.field];
+  const date = new Date(String(value));
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'eq')) {
-    return value === normalizeFilterValue(filter.eq);
+  if (!Number.isFinite(date.getTime())) {
+    return value;
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'neq')) {
-    return value !== normalizeFilterValue(filter.neq);
+  if (grain === 'year') {
+    return `${date.getUTCFullYear()}`;
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'gt')) {
-    return compareComparableValues(value, normalizeFilterValue(filter.gt)) > 0;
+  const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+
+  if (grain === 'month') {
+    return `${date.getUTCFullYear()}-${month}`;
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'gte')) {
-    return compareComparableValues(value, normalizeFilterValue(filter.gte)) >= 0;
+  const day = String(date.getUTCDate()).padStart(2, '0');
+
+  if (grain === 'week') {
+    const weekStart = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+    weekStart.setUTCDate(weekStart.getUTCDate() - weekStart.getUTCDay());
+    return weekStart.toISOString().slice(0, 10);
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'lt')) {
-    return compareComparableValues(value, normalizeFilterValue(filter.lt)) < 0;
+  if (grain === 'day') {
+    return `${date.getUTCFullYear()}-${month}-${day}`;
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'lte')) {
-    return compareComparableValues(value, normalizeFilterValue(filter.lte)) <= 0;
+  return value;
+}
+
+function getAdminForthFilters(filters: FilterExpression | DashboardWidgetFilters | undefined): DashboardWidgetFilters {
+  if (Array.isArray(filters)) {
+    return filters.map((filter) => isDashboardFilterExpression(filter)
+      ? toAdminForthFilter(filter)
+      : filter);
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'in')) {
-    return filter.in?.includes(value) ?? false;
+  if (isDashboardFilterExpression(filters)) {
+    return toAdminForthFilter(filters);
   }
 
-  if (Object.prototype.hasOwnProperty.call(filter, 'not_in')) {
-    return !(filter.not_in?.includes(value) ?? false);
+  if (filters) {
+    return filters;
   }
 
-  return true;
+  return [];
 }
 
-function compareComparableValues(left: unknown, right: unknown) {
-  const leftNumber = Number(left);
-  const rightNumber = Number(right);
+function isDashboardFilterExpression(value: unknown): value is FilterExpression {
+  if (Array.isArray(value)) {
+    return true;
+  }
 
-  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
-    return leftNumber - rightNumber;
+  if (!isRecord(value)) {
+    return false;
   }
 
-  return String(left ?? '').localeCompare(String(right ?? ''));
+  return 'and' in value
+    || 'or' in value
+    || 'eq' in value
+    || 'neq' in value
+    || 'gt' in value
+    || 'gte' in value
+    || 'lt' in value
+    || 'lte' in value
+    || 'in' in value
+    || 'not_in' in value
+    || 'like' in value
+    || 'ilike' in value;
 }
 
-function normalizeFilterValue(value: unknown) {
-  if (!isRecord(value) || typeof value.now_minus !== 'string') {
-    return value;
+function toAdminForthFilter(filter: FilterExpression): IAdminForthSingleFilter | IAdminForthAndOrFilter {
+  if (Array.isArray(filter)) {
+    return Filters.AND(filter.map((item) => toAdminForthFilter(item)));
   }
 
-  const match = value.now_minus.match(NOW_MINUS_RE);
-
-  if (!match) {
-    return value;
+  if ('and' in filter) {
+    return Filters.AND(filter.and.map((item) => toAdminForthFilter(item)));
   }
 
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const date = new Date();
+  if ('or' in filter) {
+    return Filters.OR(filter.or.map((item) => toAdminForthFilter(item)));
+  }
 
-  if (unit === 'h') {
-    date.setHours(date.getHours() - amount);
-  } else if (unit === 'w') {
-    date.setDate(date.getDate() - amount * 7);
-  } else {
-    date.setDate(date.getDate() - amount);
+  for (const [operator, createFilter] of Object.entries(FILTER_OPERATORS)) {
+    if (Object.prototype.hasOwnProperty.call(filter, operator)) {
+      return createFilter(filter.field, filter[operator as keyof typeof FILTER_OPERATORS]);
+    }
   }
 
-  return date.toISOString();
+  return Filters.AND([]);
 }
 
 function toFiniteNumber(value: unknown) {