@adminforth/dashboard 1.8.0 → 1.9.0

package/dist/services/dashboardFilterService.d.ts

@@ -0,0 +1,5 @@
+import type { IAdminForthAndOrFilter, IAdminForthSingleFilter } from 'adminforth';
+import type { FilterExpression } from '../custom/model/dashboard.types.js';
+export type DashboardQueryFilters = IAdminForthSingleFilter | IAdminForthAndOrFilter | Array<IAdminForthSingleFilter | IAdminForthAndOrFilter>;
+export declare function getAdminForthFilters(filters: FilterExpression | DashboardQueryFilters | undefined): DashboardQueryFilters;
+export declare function mergeFilters(...filters: Array<FilterExpression | DashboardQueryFilters | undefined>): DashboardQueryFilters;

package/dist/services/dashboardFilterService.js

@@ -0,0 +1,125 @@
+import { Filters } from 'adminforth';
+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,
+};
+export function getAdminForthFilters(filters) {
+    if (Array.isArray(filters)) {
+        return filters.map((filter) => isDashboardFilterExpression(filter)
+            ? toAdminForthFilter(filter)
+            : filter);
+    }
+    if (isDashboardFilterExpression(filters)) {
+        return toAdminForthFilter(filters);
+    }
+    if (filters) {
+        return filters;
+    }
+    return [];
+}
+export function mergeFilters(...filters) {
+    const merged = [];
+    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 [];
+    }
+    return merged.length === 1 ? merged[0] : merged;
+}
+function isDashboardFilterExpression(value) {
+    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) {
+    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]));
+        }
+    }
+    return Filters.AND([]);
+}
+function resolveFilterValue(value) {
+    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, duration) {
+    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 isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/services/widgetDataService.js

@@ -7,24 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Filters, Sorts } from 'adminforth';
-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,
-};
+import { Sorts } from 'adminforth';
+import { getAdminForthFilters, mergeFilters, } from './dashboardFilterService.js';
+import { evaluateCalc } from './calc-evaluator.js';
 export function getWidgetData(adminforth_1, widget_1) {
     return __awaiter(this, arguments, void 0, function* (adminforth, widget, options = {}) {
         var _a;
@@ -52,9 +37,9 @@ function getQueryWidgetData(adminforth, query, variables) {
         if (isStepsQuery(query)) {
             return getStepsQueryData(adminforth, query, variables);
         }
-        const metricSelect = getSingleAggregateMetricSelect(query);
-        if (metricSelect) {
-            return getMetricWidgetData(adminforth, query, metricSelect);
+        const singleAggregateSelect = getSingleAggregateSelectItem(query);
+        if (singleAggregateSelect) {
+            return getSingleAggregateWidgetData(adminforth, query, singleAggregateSelect);
         }
         const selectedRows = isAggregateQuery(query)
             ? yield buildAggregateQueryRows(adminforth, query, variables)
@@ -101,18 +86,18 @@ function getStepsQueryData(adminforth, query, variables) {
         };
     });
 }
-function getMetricWidgetData(adminforth, query, metric) {
+function getSingleAggregateWidgetData(adminforth, query, aggregate) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
-        const [currentValues = {}] = yield getAggregateRows(adminforth, query.resource, query.filters, [metric], []);
+        const [currentValues = {}] = yield getAggregateRows(adminforth, query.resource, query.filters, [aggregate], []);
         const values = {
-            [metric.as]: (_a = currentValues[metric.as]) !== null && _a !== void 0 ? _a : 0,
+            [aggregate.as]: (_a = currentValues[aggregate.as]) !== null && _a !== void 0 ? _a : 0,
         };
         const rows = query.sparkline
-            ? yield getMetricSparklineRows(adminforth, query, metric, getAdminForthFilters(query.filters))
+            ? yield getSingleAggregateSparklineRows(adminforth, query, aggregate, getAdminForthFilters(query.filters))
             : [values];
         const columns = Array.from(new Set([
-            metric.as,
+            aggregate.as,
             ...(query.sparkline ? [query.sparkline.as] : []),
         ]));
         return {
@@ -123,7 +108,7 @@ function getMetricWidgetData(adminforth, query, metric) {
         };
     });
 }
-function getMetricSparklineRows(adminforth, query, metric, filters) {
+function getSingleAggregateSparklineRows(adminforth, query, aggregate, filters) {
     return __awaiter(this, void 0, void 0, function* () {
         const sparkline = query.sparkline;
         const groupBy = [{
@@ -131,7 +116,7 @@ function getMetricSparklineRows(adminforth, query, metric, filters) {
                 as: sparkline.as,
                 grain: sparkline.grain,
             }];
-        const rows = yield getAggregateRows(adminforth, query.resource, filters, [metric], groupBy);
+        const rows = yield getAggregateRows(adminforth, query.resource, filters, [aggregate], groupBy);
         return rows.map((row) => {
             var _a;
             return (Object.assign(Object.assign({}, (_a = query.sparkline) === null || _a === void 0 ? void 0 : _a.fill_missing), row));
@@ -190,7 +175,7 @@ function getAggregateRows(adminforth, resourceId, baseFilters, select, groupBy)
 function buildCalculatedRow(baseValues, select, calcs = [], variables) {
     const values = Object.assign({}, 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;
 }
@@ -205,33 +190,10 @@ function buildPlainRow(row, select, calcs = [], variables) {
         }
     }
     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, values, variables) {
-    const expression = calc
-        .replace(LOOKUP_CALL_RE, (_match, path, keyField, defaultValue) => {
-        var _a;
-        const map = resolveVariablePath(variables, path);
-        const key = String((_a = values[keyField]) !== null && _a !== void 0 ? _a : '');
-        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, path) {
-    return path
-        .replace(VARIABLE_PATH_PREFIX_RE, '')
-        .split('.')
-        .filter(Boolean)
-        .reduce((current, segment) => isRecord(current) ? current[segment] : undefined, variables);
-}
 function sortRows(rows, orderBy = []) {
     if (!orderBy.length) {
         return rows;
@@ -279,7 +241,7 @@ function isAggregateQuery(query) {
     return Boolean(((_a = query.group_by) === null || _a === void 0 ? void 0 : _a.length)
         || ((_b = query.select) === null || _b === void 0 ? void 0 : _b.some((item) => isAggregateSelectItem(item))));
 }
-function getSingleAggregateMetricSelect(query) {
+function getSingleAggregateSelectItem(query) {
     var _a, _b;
     if ((_a = query.group_by) === null || _a === void 0 ? void 0 : _a.length) {
         return undefined;
@@ -295,7 +257,7 @@ function isStepsQuery(query) {
     return query.source === 'steps';
 }
 function getStepSelect(step) {
-    return 'select' in step ? step.select : [step.metric];
+    return step.select;
 }
 function isFieldSelectItem(item) {
     return 'field' in item && !('agg' in item);
@@ -413,23 +375,6 @@ function getFilterCacheKey(filters) {
     }
     return JSON.stringify(filters);
 }
-function mergeFilters(...filters) {
-    const merged = [];
-    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 [];
-    }
-    return merged.length === 1 ? merged[0] : merged;
-}
 function getHiddenAggregateAlias(groupBy, select) {
     const usedAliases = new Set([
         ...groupBy.map((item) => item.as),
@@ -467,104 +412,6 @@ function formatGroupValue(value, grain) {
     }
     return value;
 }
-function getAdminForthFilters(filters) {
-    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) {
-    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) {
-    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]));
-        }
-    }
-    return Filters.AND([]);
-}
-function resolveFilterValue(value) {
-    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, duration) {
-    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) {
-    const numberValue = typeof value === 'number' ? value : Number(value);
-    return Number.isFinite(numberValue) ? numberValue : 0;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 export function createWidgetDataService(adminforth) {
     return {
         getWidgetData: (widget, options) => getWidgetData(adminforth, widget, options),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/dashboard",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -56,6 +56,7 @@
     }
   ],
   "dependencies": {
+    "expr-eval-fork": "^3.0.3",
     "vue": "^3.5.34",
     "vue-router": "^5.0.7",
     "yaml": "^2.9.0",

package/schema/widgets/common.ts

@@ -160,13 +160,6 @@ const ResourceQueryConfigSchema = z.object({
   formatting: z.record(z.string(), z.unknown()).optional(),
 }).strict()
 
-const StepsQueryMetricStepSchema = z.object({
-  name: z.string(),
-  resource: z.string(),
-  metric: QueryAggregateSelectItemSchema,
-  filters: FilterExpressionSchema.optional(),
-}).strict()
-
 const StepsQuerySelectStepSchema = z.object({
   name: z.string(),
   resource: z.string(),
@@ -178,10 +171,7 @@ export const QueryConfigSchema = z.union([
   ResourceQueryConfigSchema,
   z.object({
     source: z.literal('steps'),
-    steps: z.array(z.union([
-      StepsQueryMetricStepSchema,
-      StepsQuerySelectStepSchema,
-    ])).min(1),
+    steps: z.array(StepsQuerySelectStepSchema).min(1),
     calcs: z.array(QueryCalcItemSchema).optional(),
     order_by: z.array(QueryOrderByItemSchema).optional(),
     limit: z.number().int().positive().optional(),

package/services/calc-evaluator.ts

@@ -0,0 +1,33 @@
+import { Parser } from 'expr-eval-fork';
+
+const CALC_PARSER_OPTIONS = {
+  allowMemberAccess: false,
+  operators: {
+    assignment: false,
+    concatenate: false,
+    conditional: true,
+    comparison: true,
+    fndef: false,
+    in: false,
+    logical: true,
+    random: false,
+  },
+} as const;
+
+const CALC_PARSER = new Parser(CALC_PARSER_OPTIONS);
+
+export function evaluateCalc(calc: string, values: Record<string, unknown>) {
+  return CALC_PARSER.parse(calc).evaluate(normalizeCalcValues(values));
+}
+
+function normalizeCalcValues(values: Record<string, unknown>) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    typeof value === 'string' ? value : toFiniteNumber(value),
+  ]));
+}
+
+function toFiniteNumber(value: unknown) {
+  const numberValue = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}

package/services/dashboardFilterService.ts

@@ -0,0 +1,162 @@
+import { Filters } from 'adminforth';
+import type {
+  IAdminForthAndOrFilter,
+  IAdminForthSingleFilter,
+} from 'adminforth';
+import type { FilterExpression } from '../custom/model/dashboard.types.js';
+
+export type DashboardQueryFilters =
+  | IAdminForthSingleFilter
+  | IAdminForthAndOrFilter
+  | Array<IAdminForthSingleFilter | IAdminForthAndOrFilter>;
+
+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 function getAdminForthFilters(filters: FilterExpression | DashboardQueryFilters | undefined): DashboardQueryFilters {
+  if (Array.isArray(filters)) {
+    return filters.map((filter) => isDashboardFilterExpression(filter)
+      ? toAdminForthFilter(filter)
+      : filter);
+  }
+
+  if (isDashboardFilterExpression(filters)) {
+    return toAdminForthFilter(filters);
+  }
+
+  if (filters) {
+    return filters;
+  }
+
+  return [];
+}
+
+export function mergeFilters(...filters: Array<FilterExpression | DashboardQueryFilters | 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 DashboardQueryFilters;
+  }
+
+  return merged.length === 1 ? merged[0] : merged;
+}
+
+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 isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null;
+}