@adminforth/dashboard 1.3.0 → 1.4.1

package/dist/services/widgetDataService.js

@@ -8,17 +8,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Filters, Sorts } from 'adminforth';
-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,
+};
 export function getWidgetData(adminforth_1, widget_1) {
     return __awaiter(this, arguments, void 0, function* (adminforth, widget, options = {}) {
+        var _a, _b;
         if (!('query' in widget)) {
             return null;
         }
         const data = 'steps' in widget.query
-            ? yield getFunnelWidgetData(adminforth, widget.query)
-            : yield getQueryWidgetData(adminforth, widget.query);
+            ? yield getFunnelWidgetData(adminforth, widget.query, (_a = options.variables) !== null && _a !== void 0 ? _a : {})
+            : yield getQueryWidgetData(adminforth, widget.query, (_b = options.variables) !== null && _b !== void 0 ? _b : {});
         if (widget.target !== 'table' || !options.pagination) {
             return data;
         }
@@ -33,29 +47,41 @@ export function getWidgetData(adminforth_1, widget_1) {
             } });
     });
 }
-function getFunnelWidgetData(adminforth, query) {
+function getFunnelWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const rows = yield Promise.all(query.steps.map((step) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             const valueField = step.metric.as;
-            const sourceRows = yield getResourceRows(adminforth, step.resource, step.filters);
-            return {
+            const [values = {}] = yield getAggregateRows(adminforth, step.resource, step.filters, [step.metric], []);
+            const row = {
                 name: step.name,
-                [valueField]: calculateAggregate(sourceRows, step.metric),
+                resource: step.resource,
+                [valueField]: (_a = values[valueField]) !== null && _a !== void 0 ? _a : 0,
             };
+            for (const calc of (_b = query.calcs) !== null && _b !== void 0 ? _b : []) {
+                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)))],
+            columns: [
+                'name',
+                ...Array.from(new Set(query.steps.map((step) => step.metric.as))),
+                ...Array.from(new Set(((_a = query.calcs) !== null && _a !== void 0 ? _a : []).map((calc) => calc.as))),
+            ],
             rows,
         };
     });
 }
-function getQueryWidgetData(adminforth, query) {
+function getQueryWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;
-        const rows = yield getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.orderBy));
-        const selectedRows = buildQueryRows(rows, query);
-        const orderedRows = sortRows(selectedRows, query.orderBy);
+        const selectedRows = isAggregateQuery(query)
+            ? yield buildAggregateQueryRows(adminforth, query, variables)
+            : buildPlainQueryRows(yield 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((_a = query.offset) !== null && _a !== void 0 ? _a : 0, ((_b = query.offset) !== null && _b !== void 0 ? _b : 0) + query.limit)
             : orderedRows.slice((_c = query.offset) !== null && _c !== void 0 ? _c : 0);
@@ -73,58 +99,61 @@ function getQueryWidgetData(adminforth, query) {
 }
 function getResourceRows(adminforth, resourceId, filters, sort) {
     return __awaiter(this, void 0, void 0, function* () {
-        return adminforth.resource(resourceId).list(normalizeFilters(filters), undefined, 0, sort);
+        return adminforth.resource(resourceId).list(getAdminForthFilters(filters), undefined, 0, sort);
     });
 }
-function buildQueryRows(rows, query) {
-    var _a, _b;
+function buildPlainQueryRows(rows, query, variables) {
+    var _a;
     const select = (_a = query.select) !== null && _a !== void 0 ? _a : getDefaultSelect(rows);
-    const groupBy = (_b = query.groupBy) !== null && _b !== void 0 ? _b : [];
-    if (isAggregateQuery(query)) {
-        return buildGroupedRows(rows, select, groupBy, query.calcs);
-    }
-    return rows.map((row) => buildPlainRow(row, select, query.calcs));
+    return rows.map((row) => buildPlainRow(row, select, query.calcs, variables));
 }
-function buildGroupedRows(rows, select, groupBy, calcs = []) {
-    var _a;
-    const groups = new Map();
-    const effectiveGroupBy = groupBy.length
-        ? groupBy
-        : select.filter(isFieldSelectItem).map((item) => ({ field: item.field, as: item.as, grain: item.grain }));
-    if (!effectiveGroupBy.length) {
-        const values = calculateGroupValues(rows, select, calcs);
-        return Object.keys(values).length ? [values] : [];
-    }
-    for (const row of rows) {
-        const values = Object.fromEntries(effectiveGroupBy.map((item) => {
-            const field = getGroupByField(item);
-            const alias = getGroupByAlias(item);
-            const grain = getGroupByGrain(item);
-            return [alias, formatGroupValue(row[field], grain)];
-        }));
-        const key = JSON.stringify(values);
-        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : { values, rows: [] };
-        group.rows.push(row);
-        groups.set(key, group);
-    }
-    return Array.from(groups.values()).map((group) => (Object.assign(Object.assign({}, group.values), calculateGroupValues(group.rows, select, calcs))));
+function buildAggregateQueryRows(adminforth, query, variables) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const select = (_a = query.select) !== null && _a !== void 0 ? _a : [];
+        const effectiveGroupBy = getEffectiveGroupBy(query.group_by, select);
+        const aggregateSelect = select.filter(isAggregateSelectItem);
+        const rows = yield getAggregateRows(adminforth, query.resource, query.filters, aggregateSelect, effectiveGroupBy);
+        return rows.map((row) => buildCalculatedRow(row, select, query.calcs, variables));
+    });
 }
-function calculateGroupValues(rows, select, calcs) {
-    const values = {};
-    for (const item of select) {
-        if (isAggregateSelectItem(item)) {
-            const filteredRows = item.filters
-                ? rows.filter((row) => matchesFilterExpression(row, item.filters))
-                : rows;
-            values[item.as] = calculateAggregate(filteredRows, item);
+function getAggregateRows(adminforth, resourceId, baseFilters, select, groupBy) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const resource = adminforth.resource(resourceId);
+        const groups = new Map();
+        const groupByRules = groupBy.length ? groupBy.map(toAggregateGroupByRule) : undefined;
+        const aggregateSelectGroups = groupAggregateSelectItems(select);
+        if (groupBy.length) {
+            const groupSeedAlias = getHiddenAggregateAlias(groupBy, select);
+            const groupSeedRows = yield resource.aggregate(getAdminForthFilters(baseFilters), { [groupSeedAlias]: { operation: 'count' } }, groupByRules);
+            for (const row of groupSeedRows) {
+                ensureAggregateGroup(groups, row, groupBy);
+            }
         }
-    }
+        for (const filterGroup of aggregateSelectGroups) {
+            const rows = yield resource.aggregate(mergeFilters(baseFilters, filterGroup.filters), Object.fromEntries(filterGroup.items.map((item) => [item.as, toAggregationRule(item)])), groupByRules);
+            for (const row of rows) {
+                const values = ensureAggregateGroup(groups, row, groupBy);
+                for (const item of filterGroup.items) {
+                    values[item.as] = (_a = row[item.as]) !== null && _a !== void 0 ? _a : 0;
+                }
+            }
+        }
+        if (!groups.size && !groupBy.length && select.length) {
+            groups.set(JSON.stringify({}), {});
+        }
+        return Array.from(groups.values(), (row) => applyAggregateDefaults(row, select));
+    });
+}
+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);
+        values[item.as] = evaluateCalc(item.calc, values, variables);
     }
     return values;
 }
-function buildPlainRow(row, select, calcs = []) {
+function buildPlainRow(row, select, calcs = [], variables) {
     var _a;
     const values = {};
     for (const item of select) {
@@ -135,52 +164,33 @@ function buildPlainRow(row, select, calcs = []) {
         }
     }
     for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
-        values[item.as] = evaluateCalc(item.calc, values);
+        values[item.as] = evaluateCalc(item.calc, values, variables);
     }
     return values;
 }
-function calculateAggregate(rows, item) {
-    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.agg}`);
-    }
-}
-function aggregateNumbers(rows, field, aggregate) {
-    return aggregate(rows.map((row) => toFiniteNumber(row[field])).filter(Number.isFinite));
-}
-function calculateMedian(values) {
-    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, values) {
-    const expression = calc.replace(CALC_IDENTIFIER_RE, (name) => String(toFiniteNumber(values[name])));
+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;
@@ -213,7 +223,7 @@ function getBackendSort(orderBy) {
 function getColumns(rows, query) {
     var _a, _b, _c, _d;
     const selectColumns = [
-        ...((_a = query.groupBy) !== null && _a !== void 0 ? _a : []).map(getGroupByAlias),
+        ...((_a = query.group_by) !== null && _a !== void 0 ? _a : []).map(getGroupByAlias),
         ...((_b = query.select) !== null && _b !== void 0 ? _b : []).map(getSelectAlias),
         ...((_c = query.calcs) !== null && _c !== void 0 ? _c : []).map((item) => item.as),
     ].filter(Boolean);
@@ -225,7 +235,7 @@ function getDefaultSelect(rows) {
 }
 function isAggregateQuery(query) {
     var _a, _b;
-    return Boolean(((_a = query.groupBy) === null || _a === void 0 ? void 0 : _a.length)
+    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 isFieldSelectItem(item) {
@@ -244,15 +254,133 @@ function getSelectAlias(item) {
     }
     return item.as;
 }
-function getGroupByField(item) {
-    return typeof item === 'string' ? item : item.field;
-}
 function getGroupByAlias(item) {
     var _a;
     return typeof item === 'string' ? item : (_a = item.as) !== null && _a !== void 0 ? _a : item.field;
 }
-function getGroupByGrain(item) {
-    return typeof item === 'string' ? undefined : item.grain;
+function getEffectiveGroupBy(groupBy, select) {
+    if (groupBy === null || groupBy === void 0 ? void 0 : groupBy.length) {
+        return groupBy.map((item) => normalizeGroupByItem(item));
+    }
+    return select
+        .filter(isFieldSelectItem)
+        .map((item) => normalizeGroupByItem({ field: item.field, as: item.as, grain: item.grain }));
+}
+function normalizeGroupByItem(item) {
+    var _a;
+    if (typeof item === 'string') {
+        return { field: item, as: item };
+    }
+    return {
+        field: item.field,
+        as: (_a = item.as) !== null && _a !== void 0 ? _a : item.field,
+        grain: item.grain,
+        timezone: 'timezone' in item ? item.timezone : undefined,
+    };
+}
+function toAggregateGroupByRule(item) {
+    if (item.grain) {
+        return {
+            type: 'date_trunc',
+            field: item.field,
+            truncation: item.grain,
+            timezone: item.timezone,
+            as: item.as,
+        };
+    }
+    return {
+        type: 'field',
+        field: item.field,
+        as: item.as,
+    };
+}
+function toAggregationRule(item) {
+    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 };
+    }
+}
+function extractAggregateGroupValues(row, groupBy) {
+    return Object.fromEntries(groupBy.map((item) => [
+        item.as,
+        formatGroupValue(row[item.as], item.grain),
+    ]));
+}
+function ensureAggregateGroup(groups, row, groupBy) {
+    const groupValues = groupBy.length ? extractAggregateGroupValues(row, groupBy) : {};
+    const key = JSON.stringify(groupValues);
+    const existingGroup = groups.get(key);
+    if (existingGroup) {
+        return existingGroup;
+    }
+    groups.set(key, groupValues);
+    return groupValues;
+}
+function applyAggregateDefaults(values, select) {
+    for (const item of select) {
+        if (typeof values[item.as] === 'undefined') {
+            values[item.as] = 0;
+        }
+    }
+    return values;
+}
+function groupAggregateSelectItems(select) {
+    var _a;
+    const groups = new Map();
+    for (const item of select) {
+        const filters = getAdminForthFilters(item.filters);
+        const key = getFilterCacheKey(filters);
+        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : { filters, items: [] };
+        group.items.push(item);
+        groups.set(key, group);
+    }
+    return Array.from(groups.values());
+}
+function getFilterCacheKey(filters) {
+    if (Array.isArray(filters) && !filters.length) {
+        return '__base__';
+    }
+    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),
+        ...select.map((item) => item.as),
+    ]);
+    let alias = '__adminforth_dashboard_group_seed__';
+    while (usedAliases.has(alias)) {
+        alias = `_${alias}`;
+    }
+    return alias;
 }
 function formatGroupValue(value, grain) {
     if (!grain) {
@@ -265,9 +393,6 @@ function formatGroupValue(value, grain) {
     if (grain === 'year') {
         return `${date.getUTCFullYear()}`;
     }
-    if (grain === 'quarter') {
-        return `${date.getUTCFullYear()}-Q${Math.floor(date.getUTCMonth() / 3) + 1}`;
-    }
     const month = String(date.getUTCMonth() + 1).padStart(2, '0');
     if (grain === 'month') {
         return `${date.getUTCFullYear()}-${month}`;
@@ -281,123 +406,58 @@ function formatGroupValue(value, grain) {
     if (grain === 'day') {
         return `${date.getUTCFullYear()}-${month}-${day}`;
     }
-    const hour = String(date.getUTCHours()).padStart(2, '0');
-    return `${date.getUTCFullYear()}-${month}-${day}T${hour}:00:00.000Z`;
+    return value;
 }
-function normalizeFilters(filters) {
+function getAdminForthFilters(filters) {
     if (Array.isArray(filters)) {
-        return filters.map((filter) => normalizeFilterNode(filter));
-    }
-    if (isRecord(filters)) {
-        return normalizeFilterNode(filters);
-    }
-    return [];
-}
-function normalizeFilterNode(filter) {
-    if (!isRecord(filter)) {
-        return filter;
-    }
-    if (Array.isArray(filter.and)) {
-        return Filters.AND(filter.and.map((item) => normalizeFilterNode(item)));
+        return filters.map((filter) => isDashboardFilterExpression(filter)
+            ? toAdminForthFilter(filter)
+            : filter);
     }
-    if (Array.isArray(filter.or)) {
-        return Filters.OR(filter.or.map((item) => normalizeFilterNode(item)));
+    if (isDashboardFilterExpression(filters)) {
+        return toAdminForthFilter(filters);
     }
-    if (typeof filter.field === 'string') {
-        if (Object.prototype.hasOwnProperty.call(filter, 'eq')) {
-            return Filters.EQ(filter.field, normalizeFilterValue(filter.eq));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'neq')) {
-            return Filters.NEQ(filter.field, normalizeFilterValue(filter.neq));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'gt')) {
-            return Filters.GT(filter.field, normalizeFilterValue(filter.gt));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'gte')) {
-            return Filters.GTE(filter.field, normalizeFilterValue(filter.gte));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'lt')) {
-            return Filters.LT(filter.field, normalizeFilterValue(filter.lt));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'lte')) {
-            return Filters.LTE(filter.field, normalizeFilterValue(filter.lte));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'in')) {
-            return Filters.IN(filter.field, normalizeFilterValue(filter.in));
-        }
-        if (Object.prototype.hasOwnProperty.call(filter, 'not_in')) {
-            return Filters.NOT_IN(filter.field, normalizeFilterValue(filter.not_in));
-        }
+    if (filters) {
+        return filters;
     }
-    return filter;
+    return [];
 }
-function matchesFilterExpression(row, filter) {
-    var _a, _b, _c, _d;
+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 filter.every((item) => matchesFilterExpression(row, item));
+        return Filters.AND(filter.map((item) => toAdminForthFilter(item)));
     }
     if ('and' in filter) {
-        return filter.and.every((item) => matchesFilterExpression(row, item));
+        return Filters.AND(filter.and.map((item) => toAdminForthFilter(item)));
     }
     if ('or' in filter) {
-        return filter.or.some((item) => matchesFilterExpression(row, item));
-    }
-    const value = row[filter.field];
-    if (Object.prototype.hasOwnProperty.call(filter, 'eq')) {
-        return value === normalizeFilterValue(filter.eq);
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'neq')) {
-        return value !== normalizeFilterValue(filter.neq);
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'gt')) {
-        return compareComparableValues(value, normalizeFilterValue(filter.gt)) > 0;
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'gte')) {
-        return compareComparableValues(value, normalizeFilterValue(filter.gte)) >= 0;
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'lt')) {
-        return compareComparableValues(value, normalizeFilterValue(filter.lt)) < 0;
+        return Filters.OR(filter.or.map((item) => toAdminForthFilter(item)));
     }
-    if (Object.prototype.hasOwnProperty.call(filter, 'lte')) {
-        return compareComparableValues(value, normalizeFilterValue(filter.lte)) <= 0;
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'in')) {
-        return (_b = (_a = filter.in) === null || _a === void 0 ? void 0 : _a.includes(value)) !== null && _b !== void 0 ? _b : false;
-    }
-    if (Object.prototype.hasOwnProperty.call(filter, 'not_in')) {
-        return !((_d = (_c = filter.not_in) === null || _c === void 0 ? void 0 : _c.includes(value)) !== null && _d !== void 0 ? _d : false);
-    }
-    return true;
-}
-function compareComparableValues(left, right) {
-    const leftNumber = Number(left);
-    const rightNumber = Number(right);
-    if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
-        return leftNumber - rightNumber;
-    }
-    return String(left !== null && left !== void 0 ? left : '').localeCompare(String(right !== null && right !== void 0 ? right : ''));
-}
-function normalizeFilterValue(value) {
-    if (!isRecord(value) || typeof value.now_minus !== 'string') {
-        return value;
-    }
-    const match = value.now_minus.match(NOW_MINUS_RE);
-    if (!match) {
-        return value;
-    }
-    const amount = Number(match[1]);
-    const unit = match[2];
-    const date = new Date();
-    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]);
+        }
     }
-    return date.toISOString();
+    return Filters.AND([]);
 }
 function toFiniteNumber(value) {
     const numberValue = typeof value === 'number' ? value : Number(value);

package/endpoint/dashboard.ts

@@ -1,10 +1,20 @@
-import type { IHttpServer } from 'adminforth';
-import { DashboardApiResponseSchema, SlugRequestSchema } from '../schema/api.js';
-import type { DashboardRecord } from '../services/dashboardConfigService.js';
-import { buildDashboardResponse } from '../services/dashboardConfigService.js';
+import type { AdminUser, IHttpServer } from 'adminforth';
+import type { DashboardConfig } from '../custom/model/dashboard.types.js';
+import {
+  DashboardApiResponseSchema,
+  SetDashboardConfigRequestSchema,
+  SlugRequestSchema,
+} from '../schema/api.js';
+import type { DashboardRecord, PersistedDashboardResponse } from '../services/dashboardConfigService.js';
 
 type DashboardEndpointsContext = {
+  canEditDashboard: (adminUser: AdminUser) => boolean;
   getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+  parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
+  persistDashboardConfig: (
+    dashboard: DashboardRecord,
+    config: DashboardConfig,
+  ) => Promise<PersistedDashboardResponse>;
 };
 
 export function registerDashboardEndpoints(
@@ -18,15 +28,45 @@ export function registerDashboardEndpoints(
     request_schema: SlugRequestSchema,
     response_schema: DashboardApiResponseSchema,
     handler: async ({ body, response }) => {
-      const slug = String(body?.slug || 'default');
-      const dashboard = await ctx.getDashboardRecord(slug);
+      const dashboard = await ctx.getDashboardRecord(body.slug);
 
       if (!dashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      return buildDashboardResponse(dashboard);
+      return {
+        id: dashboard.id,
+        slug: dashboard.slug,
+        label: dashboard.label,
+        revision: dashboard.revision,
+        config: ctx.parseStoredDashboardConfig(dashboard.config),
+      };
+    },
+  });
+
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/set_dashboard_config',
+    description: 'Replaces one dashboard configuration, including groups and widgets. Superadmin only.',
+    request_schema: SetDashboardConfigRequestSchema,
+    response_schema: DashboardApiResponseSchema,
+    handler: async ({ body, adminUser, response }) => {
+      if (!ctx.canEditDashboard(adminUser)) {
+        response.setStatus(403);
+        return { error: 'Dashboard edit is not allowed' };
+      }
+
+      const dashboard = await ctx.getDashboardRecord(body.slug);
+
+      if (!dashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
+      }
+
+      const config = body.config as DashboardConfig;
+
+      return ctx.persistDashboardConfig(dashboard, config);
     },
   });
 }