@adminforth/dashboard 1.7.0 → 1.9.0

package/services/widgetDataService.ts

@@ -1,15 +1,12 @@
-import { Filters, Sorts } from 'adminforth';
+import { Sorts } from 'adminforth';
 import type {
   IAdminForth,
-  IAdminForthAndOrFilter,
-  IAdminForthSingleFilter,
   IAdminForthSort,
 } from 'adminforth';
 import type {
   DashboardWidgetConfig,
   DashboardWidgetData,
   DashboardVariables,
-  FunnelQueryConfig,
   FilterExpression,
   QueryAggregateSelectItem,
   QueryCalcSelectItem,
@@ -17,9 +14,17 @@ import type {
   QueryFieldSelectItem,
   QueryGroupByItem,
   QueryOrderByItem,
+  ResourceQueryConfig,
+  StepsQueryStepConfig,
   QuerySelectItem,
   TimeGrain,
 } from '../custom/model/dashboard.types.js';
+import {
+  getAdminForthFilters,
+  mergeFilters,
+  type DashboardQueryFilters,
+} from './dashboardFilterService.js';
+import { evaluateCalc } from './calc-evaluator.js';
 
 export type DashboardWidgetDataOptions = {
   pagination?: {
@@ -29,11 +34,6 @@ export type DashboardWidgetDataOptions = {
   variables?: DashboardVariables;
 };
 
-type DashboardWidgetFilters =
-  | IAdminForthSingleFilter
-  | IAdminForthAndOrFilter
-  | Array<IAdminForthSingleFilter | IAdminForthAndOrFilter>;
-
 type AggregateRule =
   | { operation: 'count' }
   | { operation: Exclude<QueryAggregateSelectItem['agg'], 'count'>; field: string };
@@ -54,7 +54,7 @@ type AggregateGroupByRule =
 
 type AggregateResource = {
   aggregate: (
-    filters: DashboardWidgetFilters,
+    filters: DashboardQueryFilters,
     aggregations: Record<string, AggregateRule>,
     groupBy?: AggregateGroupByRule | AggregateGroupByRule[],
   ) => Promise<Record<string, unknown>[]>;
@@ -67,24 +67,6 @@ type EffectiveGroupByItem = {
   timezone?: string;
 };
 
-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 RELATIVE_DURATION_RE = /^(\d+)(h|d|w|mo|y)$/;
-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>;
 };
@@ -98,9 +80,7 @@ export async function getWidgetData(
     return null;
   }
 
-  const data = 'steps' in widget.query
-    ? await getFunnelWidgetData(adminforth, widget.query, options.variables ?? {})
-    : await getQueryWidgetData(adminforth, widget.query, options.variables ?? {});
+  const data = await getQueryWidgetData(adminforth, widget.query, options.variables ?? {});
 
   if (widget.target !== 'table' || !options.pagination) {
     return data;
@@ -122,54 +102,19 @@ export async function getWidgetData(
   };
 }
 
-async function getFunnelWidgetData(
-  adminforth: IAdminForth,
-  query: FunnelQueryConfig,
-  variables: DashboardVariables,
-): Promise<DashboardWidgetData> {
-  const rows = await Promise.all(query.steps.map(async (step) => {
-    const valueField = step.metric.as;
-    const [values = {}] = await getAggregateRows(
-      adminforth,
-      step.resource,
-      step.filters,
-      [step.metric],
-      [],
-    );
-
-    const row: Record<string, unknown> = {
-      name: step.name,
-      resource: step.resource,
-      [valueField]: values[valueField] ?? 0,
-    };
-
-    for (const calc of query.calcs ?? []) {
-      row[calc.as] = evaluateCalc(calc.calc, row, variables);
-    }
-
-    return row;
-  }));
-
-  return {
-    kind: 'aggregate',
-    columns: [
-      'name',
-      ...Array.from(new Set(query.steps.map((step) => step.metric.as))),
-      ...Array.from(new Set((query.calcs ?? []).map((calc) => calc.as))),
-    ],
-    rows,
-  };
-}
-
 async function getQueryWidgetData(
   adminforth: IAdminForth,
   query: QueryConfig,
   variables: DashboardVariables,
 ): Promise<DashboardWidgetData> {
-  const metricSelect = getSingleAggregateMetricSelect(query);
+  if (isStepsQuery(query)) {
+    return getStepsQueryData(adminforth, query, variables);
+  }
+
+  const singleAggregateSelect = getSingleAggregateSelectItem(query);
 
-  if (metricSelect) {
-    return getMetricWidgetData(adminforth, query, metricSelect);
+  if (singleAggregateSelect) {
+    return getSingleAggregateWidgetData(adminforth, query, singleAggregateSelect);
   }
 
   const selectedRows = isAggregateQuery(query)
@@ -203,27 +148,67 @@ async function getQueryWidgetData(
   };
 }
 
-async function getMetricWidgetData(
+async function getStepsQueryData(
   adminforth: IAdminForth,
-  query: QueryConfig,
-  metric: QueryAggregateSelectItem,
+  query: Extract<QueryConfig, { source: 'steps' }>,
+  variables: DashboardVariables,
+): Promise<DashboardWidgetData> {
+  const rows = await Promise.all(query.steps.map(async (step) => {
+    const select = getStepSelect(step);
+    const [values = {}] = await getAggregateRows(
+      adminforth,
+      step.resource,
+      step.filters,
+      select,
+      [],
+    );
+    const row = buildCalculatedRow({
+      name: step.name,
+      resource: step.resource,
+      ...values,
+    }, select, query.calcs, variables);
+
+    return row;
+  }));
+  const orderedRows = sortRows(rows, query.order_by);
+  const slicedRows = typeof query.limit === 'number'
+    ? orderedRows.slice(query.offset ?? 0, (query.offset ?? 0) + query.limit)
+    : orderedRows.slice(query.offset ?? 0);
+  const columns = Array.from(new Set([
+    'name',
+    'resource',
+    ...query.steps.flatMap((step) => getStepSelect(step).map((item) => item.as)),
+    ...(query.calcs ?? []).map((item) => item.as),
+  ]));
+
+  return {
+    kind: 'aggregate',
+    columns,
+    rows: slicedRows,
+  };
+}
+
+async function getSingleAggregateWidgetData(
+  adminforth: IAdminForth,
+  query: ResourceQueryConfig,
+  aggregate: QueryAggregateSelectItem,
 ): Promise<DashboardWidgetData> {
   const [currentValues = {}] = await getAggregateRows(
     adminforth,
     query.resource,
     query.filters,
-    [metric],
+    [aggregate],
     [],
   );
   const values: Record<string, unknown> = {
-    [metric.as]: currentValues[metric.as] ?? 0,
+    [aggregate.as]: currentValues[aggregate.as] ?? 0,
   };
 
   const rows = query.sparkline
-    ? await getMetricSparklineRows(adminforth, query, metric, getAdminForthFilters(query.filters))
+    ? await getSingleAggregateSparklineRows(adminforth, query, aggregate, getAdminForthFilters(query.filters))
     : [values];
   const columns = Array.from(new Set([
-    metric.as,
+    aggregate.as,
     ...(query.sparkline ? [query.sparkline.as] : []),
   ]));
 
@@ -235,11 +220,11 @@ async function getMetricWidgetData(
   };
 }
 
-async function getMetricSparklineRows(
+async function getSingleAggregateSparklineRows(
   adminforth: IAdminForth,
-  query: QueryConfig,
-  metric: QueryAggregateSelectItem,
-  filters: DashboardWidgetFilters,
+  query: ResourceQueryConfig,
+  aggregate: QueryAggregateSelectItem,
+  filters: DashboardQueryFilters,
 ) {
   const sparkline = query.sparkline!;
   const groupBy = [{
@@ -251,7 +236,7 @@ async function getMetricSparklineRows(
     adminforth,
     query.resource,
     filters,
-    [metric],
+    [aggregate],
     groupBy,
   );
 
@@ -275,14 +260,14 @@ async function getResourceRows(
   );
 }
 
-function buildPlainQueryRows(rows: Record<string, unknown>[], query: QueryConfig, variables: DashboardVariables) {
+function buildPlainQueryRows(rows: Record<string, unknown>[], query: ResourceQueryConfig, variables: DashboardVariables) {
   const select = query.select ?? getDefaultSelect(rows);
   return rows.map((row) => buildPlainRow(row, select, query.calcs, variables));
 }
 
 async function buildAggregateQueryRows(
   adminforth: IAdminForth,
-  query: QueryConfig,
+  query: ResourceQueryConfig,
   variables: DashboardVariables,
 ) {
   const select = query.select ?? [];
@@ -302,7 +287,7 @@ async function buildAggregateQueryRows(
 async function getAggregateRows(
   adminforth: IAdminForth,
   resourceId: string,
-  baseFilters: FilterExpression | DashboardWidgetFilters | undefined,
+  baseFilters: FilterExpression | DashboardQueryFilters | undefined,
   select: QueryAggregateSelectItem[],
   groupBy: EffectiveGroupByItem[],
 ) {
@@ -356,7 +341,7 @@ function buildCalculatedRow(
   const values: Record<string, unknown> = { ...baseValues };
 
   for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
-    values[item.as] = evaluateCalc(item.calc, values, variables);
+    values[item.as] = evaluateCalc(item.calc, values);
   }
 
   return values;
@@ -379,39 +364,12 @@ function buildPlainRow(
   }
 
   for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
-    values[item.as] = evaluateCalc(item.calc, values, variables);
+    values[item.as] = evaluateCalc(item.calc, values);
   }
 
   return values;
 }
 
-function evaluateCalc(calc: string, values: Record<string, unknown>, variables: DashboardVariables) {
-  const expression = calc
-    .replace(LOOKUP_CALL_RE, (_match, path: string, keyField: string, defaultValue: string) => {
-      const map = resolveVariablePath(variables, path);
-      const key = String(values[keyField] ?? '');
-
-      return String(toFiniteNumber(isRecord(map) && Object.prototype.hasOwnProperty.call(map, key)
-        ? map[key]
-        : Number(defaultValue)));
-    })
-    .replace(CALC_IDENTIFIER_RE, (name) => String(toFiniteNumber(values[name])));
-
-  if (!SAFE_CALC_EXPRESSION_RE.test(expression)) {
-    throw new Error(`Unsupported calc expression: ${calc}`);
-  }
-
-  return Function(`"use strict"; return (${expression});`)();
-}
-
-function resolveVariablePath(variables: DashboardVariables, path: string) {
-  return path
-    .replace(VARIABLE_PATH_PREFIX_RE, '')
-    .split('.')
-    .filter(Boolean)
-    .reduce<unknown>((current, segment) => isRecord(current) ? current[segment] : undefined, variables);
-}
-
 function sortRows(rows: Record<string, unknown>[], orderBy: QueryOrderByItem[] = []) {
   if (!orderBy.length) {
     return rows;
@@ -449,7 +407,7 @@ function getBackendSort(orderBy: QueryOrderByItem[] | undefined) {
     : Sorts.DESC(order.field));
 }
 
-function getColumns(rows: Record<string, unknown>[], query: QueryConfig) {
+function getColumns(rows: Record<string, unknown>[], query: ResourceQueryConfig) {
   const selectColumns = [
     ...(query.group_by ?? []).map(getGroupByAlias),
     ...(query.select ?? []).map(getSelectAlias),
@@ -463,14 +421,14 @@ function getDefaultSelect(rows: Record<string, unknown>[]): QuerySelectItem[] {
   return Object.keys(rows[0] ?? {}).map((field) => ({ field }));
 }
 
-function isAggregateQuery(query: QueryConfig) {
+function isAggregateQuery(query: ResourceQueryConfig) {
   return Boolean(
     query.group_by?.length
     || query.select?.some((item) => isAggregateSelectItem(item)),
   );
 }
 
-function getSingleAggregateMetricSelect(query: QueryConfig) {
+function getSingleAggregateSelectItem(query: ResourceQueryConfig) {
   if (query.group_by?.length) {
     return undefined;
   }
@@ -485,6 +443,14 @@ function getSingleAggregateMetricSelect(query: QueryConfig) {
   return aggregateItems[0];
 }
 
+function isStepsQuery(query: QueryConfig): query is Extract<QueryConfig, { source: 'steps' }> {
+  return query.source === 'steps';
+}
+
+function getStepSelect(step: StepsQueryStepConfig): QueryAggregateSelectItem[] {
+  return step.select;
+}
+
 function isFieldSelectItem(item: QuerySelectItem): item is QueryFieldSelectItem {
   return 'field' in item && !('agg' in item);
 }
@@ -605,7 +571,7 @@ function applyAggregateDefaults(values: Record<string, unknown>, select: QueryAg
 
 function groupAggregateSelectItems(select: QueryAggregateSelectItem[]) {
   const groups = new Map<string, {
-    filters: DashboardWidgetFilters;
+    filters: DashboardQueryFilters;
     items: QueryAggregateSelectItem[];
   }>();
 
@@ -621,7 +587,7 @@ function groupAggregateSelectItems(select: QueryAggregateSelectItem[]) {
   return Array.from(groups.values());
 }
 
-function getFilterCacheKey(filters: DashboardWidgetFilters) {
+function getFilterCacheKey(filters: DashboardQueryFilters) {
   if (Array.isArray(filters) && !filters.length) {
     return '__base__';
   }
@@ -629,29 +595,6 @@ function getFilterCacheKey(filters: DashboardWidgetFilters) {
   return JSON.stringify(filters);
 }
 
-function mergeFilters(...filters: Array<FilterExpression | DashboardWidgetFilters | undefined>) {
-  const merged: Array<IAdminForthSingleFilter | IAdminForthAndOrFilter> = [];
-
-  for (const filter of filters) {
-    const normalized = getAdminForthFilters(filter);
-
-    if (Array.isArray(normalized)) {
-      merged.push(...normalized);
-      continue;
-    }
-
-    if (normalized) {
-      merged.push(normalized);
-    }
-  }
-
-  if (!merged.length) {
-    return [] as DashboardWidgetFilters;
-  }
-
-  return merged.length === 1 ? merged[0] : merged;
-}
-
 function getHiddenAggregateAlias(groupBy: EffectiveGroupByItem[], select: QueryAggregateSelectItem[]) {
   const usedAliases = new Set([
     ...groupBy.map((item) => item.as),
@@ -702,124 +645,6 @@ function formatGroupValue(value: unknown, grain: TimeGrain | undefined) {
   return value;
 }
 
-function getAdminForthFilters(filters: FilterExpression | DashboardWidgetFilters | undefined): DashboardWidgetFilters {
-  if (Array.isArray(filters)) {
-    return filters.map((filter) => isDashboardFilterExpression(filter)
-      ? toAdminForthFilter(filter)
-      : filter);
-  }
-
-  if (isDashboardFilterExpression(filters)) {
-    return toAdminForthFilter(filters);
-  }
-
-  if (filters) {
-    return filters;
-  }
-
-  return [];
-}
-
-function isDashboardFilterExpression(value: unknown): value is FilterExpression {
-  if (Array.isArray(value)) {
-    return true;
-  }
-
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  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 toAdminForthFilter(filter: FilterExpression): IAdminForthSingleFilter | IAdminForthAndOrFilter {
-  if (Array.isArray(filter)) {
-    return Filters.AND(filter.map((item) => toAdminForthFilter(item)));
-  }
-
-  if ('and' in filter) {
-    return Filters.AND(filter.and.map((item) => toAdminForthFilter(item)));
-  }
-
-  if ('or' in filter) {
-    return Filters.OR(filter.or.map((item) => toAdminForthFilter(item)));
-  }
-
-  for (const [operator, createFilter] of Object.entries(FILTER_OPERATORS)) {
-    if (Object.prototype.hasOwnProperty.call(filter, operator)) {
-      return createFilter(filter.field, resolveFilterValue(filter[operator as keyof typeof FILTER_OPERATORS]));
-    }
-  }
-
-  return Filters.AND([]);
-}
-
-function resolveFilterValue(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map((item) => resolveFilterValue(item));
-  }
-
-  if (!isRecord(value)) {
-    return value;
-  }
-
-  if (value.now === true) {
-    return new Date().toISOString();
-  }
-
-  if (typeof value.now_minus === 'string') {
-    return subtractDuration(new Date(), value.now_minus).toISOString();
-  }
-
-  return value;
-}
-
-function subtractDuration(now: Date, duration: string) {
-  const match = duration.match(RELATIVE_DURATION_RE);
-
-  if (!match) {
-    throw new Error(`Unsupported relative date duration: ${duration}`);
-  }
-
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const date = new Date(now);
-
-  if (unit === 'h') {
-    date.setUTCHours(date.getUTCHours() - amount);
-  } else if (unit === 'd') {
-    date.setUTCDate(date.getUTCDate() - amount);
-  } else if (unit === 'w') {
-    date.setUTCDate(date.getUTCDate() - amount * 7);
-  } else if (unit === 'mo') {
-    date.setUTCMonth(date.getUTCMonth() - amount);
-  } else if (unit === 'y') {
-    date.setUTCFullYear(date.getUTCFullYear() - amount);
-  }
-
-  return date;
-}
-
-function toFiniteNumber(value: unknown) {
-  const numberValue = typeof value === 'number' ? value : Number(value);
-  return Number.isFinite(numberValue) ? numberValue : 0;
-}
-
-function isRecord(value: unknown): value is Record<string, any> {
-  return typeof value === 'object' && value !== null;
-}
-
 export function createWidgetDataService(adminforth: IAdminForth): WidgetDataService {
   return {
     getWidgetData: (widget, options) => getWidgetData(adminforth, widget, options),