@adminforth/dashboard 1.2.0 → 1.4.0

package/dist/services/widgetDataService.js

@@ -7,124 +7,431 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Aggregates, GroupBy, Sorts } from 'adminforth';
+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]+$/;
 export function getWidgetData(adminforth_1, widget_1) {
     return __awaiter(this, arguments, void 0, function* (adminforth, widget, options = {}) {
-        const dataSource = getWidgetDataSource(widget.dataSource);
-        if (!dataSource) {
+        var _a, _b;
+        if (!('query' in widget)) {
             return null;
         }
-        if (dataSource.type === 'aggregate') {
-            return getAggregateWidgetData(adminforth, dataSource);
+        const data = 'steps' in 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;
         }
-        return getResourceWidgetData(adminforth, dataSource, options);
+        const page = options.pagination.page;
+        const pageSize = options.pagination.pageSize;
+        const offset = (page - 1) * pageSize;
+        return Object.assign(Object.assign({}, data), { rows: data.rows.slice(offset, offset + pageSize), pagination: {
+                page,
+                pageSize,
+                total: data.rows.length,
+                totalPages: Math.max(Math.ceil(data.rows.length / pageSize), 1),
+            } });
     });
 }
-function getResourceWidgetData(adminforth, dataSource, options) {
+function getFunnelWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const resource = adminforth.resource(dataSource.resourceId);
-        const filters = normalizeFilters(dataSource.filters);
-        const sort = normalizeSort(dataSource.sort);
-        const pagination = options.pagination;
-        const offset = pagination ? (pagination.page - 1) * pagination.pageSize : 0;
-        const limit = pagination ? pagination.pageSize : undefined;
-        const rows = yield resource.list(filters, limit !== null && limit !== void 0 ? limit : undefined, offset, sort);
-        const columns = (_a = dataSource.columns) !== null && _a !== void 0 ? _a : Object.keys((_b = rows[0]) !== null && _b !== void 0 ? _b : {});
-        const total = pagination ? yield resource.count(filters) : 0;
-        return Object.assign({ columns, rows: rows.map((row) => (Object.fromEntries(columns.map((column) => [column, row[column]])))) }, (pagination ? {
-            pagination: {
-                page: pagination.page,
-                pageSize: pagination.pageSize,
-                total,
-                totalPages: Math.max(Math.ceil(total / pagination.pageSize), 1),
-            },
-        } : {}));
+        var _a;
+        const rows = yield Promise.all(query.steps.map((step) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const valueField = step.metric.as;
+            const sourceRows = yield getResourceRows(adminforth, step.resource, step.filters);
+            const row = {
+                name: step.name,
+                resource: step.resource,
+                [valueField]: calculateAggregate(sourceRows, step.metric),
+            };
+            for (const calc of (_a = query.calcs) !== null && _a !== void 0 ? _a : []) {
+                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(((_a = query.calcs) !== null && _a !== void 0 ? _a : []).map((calc) => calc.as))),
+            ],
+            rows,
+        };
     });
 }
-function getAggregateWidgetData(adminforth, dataSource) {
+function getQueryWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const resource = adminforth.resource(dataSource.resourceId);
-        const rows = yield resource.aggregate(normalizeFilters(dataSource.filters), Object.fromEntries(Object.entries(dataSource.aggregations).map(([alias, rule]) => [
-            alias,
-            createAggregationRule(rule),
-        ])), dataSource.groupBy ? createGroupByRule(dataSource.groupBy) : undefined);
-        const columns = Object.keys((_a = rows[0]) !== null && _a !== void 0 ? _a : {});
-        if (!dataSource.groupBy) {
-            const values = (_b = rows[0]) !== null && _b !== void 0 ? _b : {};
-            return {
-                kind: 'aggregate',
-                columns: Object.keys(values),
-                rows: Object.keys(values).length ? [values] : [],
-                values,
-            };
+        var _a, _b, _c;
+        const rows = yield getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.orderBy));
+        const selectedRows = buildQueryRows(rows, query, variables);
+        const orderedRows = sortRows(selectedRows, query.orderBy);
+        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);
+        const columns = getColumns(slicedRows, query);
+        if (isAggregateQuery(query)) {
+            const values = slicedRows.length === 1 ? slicedRows[0] : undefined;
+            return Object.assign({ kind: 'aggregate', columns, rows: slicedRows }, (values ? { values } : {}));
         }
         return {
-            kind: 'aggregate',
+            kind: 'table',
             columns,
-            rows,
+            rows: slicedRows,
         };
     });
 }
-function getWidgetDataSource(dataSource) {
-    if (isWidgetDataSource(dataSource)) {
-        return dataSource;
-    }
-    return undefined;
+function getResourceRows(adminforth, resourceId, filters, sort) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return adminforth.resource(resourceId).list(normalizeFilters(filters), undefined, 0, sort);
+    });
 }
-function isWidgetDataSource(value) {
-    return isRecord(value)
-        && (value.type === 'resource' || value.type === 'aggregate')
-        && typeof value.resourceId === 'string';
+function buildQueryRows(rows, query, variables) {
+    var _a, _b;
+    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, variables, query.calcs);
+    }
+    return rows.map((row) => buildPlainRow(row, select, query.calcs, variables));
 }
-function normalizeFilters(filters) {
-    if (Array.isArray(filters)) {
-        return filters;
+function buildGroupedRows(rows, select, groupBy, variables, 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, variables);
+        return Object.keys(values).length ? [values] : [];
     }
-    if (isRecord(filters)) {
-        return filters;
+    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 [];
+    return Array.from(groups.values()).map((group) => (Object.assign(Object.assign({}, group.values), calculateGroupValues(group.rows, select, calcs, variables, group.values))));
 }
-function normalizeSort(sort) {
-    if (Array.isArray(sort)) {
-        return sort;
+function calculateGroupValues(rows, select, calcs, variables, baseValues = {}) {
+    const values = Object.assign({}, baseValues);
+    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);
+        }
     }
-    if (!isRecord(sort) || typeof sort.field !== 'string') {
-        return undefined;
+    for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
+        values[item.as] = evaluateCalc(item.calc, values, variables);
     }
-    if (sort.direction === 'asc') {
-        return [Sorts.ASC(sort.field)];
+    return values;
+}
+function buildPlainRow(row, select, calcs = [], variables) {
+    var _a;
+    const values = {};
+    for (const item of select) {
+        if (isFieldSelectItem(item)) {
+            values[(_a = item.as) !== null && _a !== void 0 ? _a : item.field] = item.grain
+                ? formatGroupValue(row[item.field], item.grain)
+                : row[item.field];
+        }
     }
-    if (sort.direction === 'desc') {
-        return [Sorts.DESC(sort.field)];
+    for (const item of [...select.filter(isCalcSelectItem), ...calcs]) {
+        values[item.as] = evaluateCalc(item.calc, values, variables);
     }
-    return sort;
+    return values;
 }
-function createAggregationRule(rule) {
-    switch (rule.operation) {
-        case 'sum':
-            return Aggregates.sum(rule.field);
+function calculateAggregate(rows, item) {
+    switch (item.agg) {
         case 'count':
-            return Aggregates.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 Aggregates.avg(rule.field);
+            return aggregateNumbers(rows, item.field, (values) => values.length
+                ? values.reduce((sum, value) => sum + value, 0) / values.length
+                : 0);
         case 'min':
-            return Aggregates.min(rule.field);
+            return aggregateNumbers(rows, item.field, (values) => values.length ? Math.min(...values) : 0);
         case 'max':
-            return Aggregates.max(rule.field);
+            return aggregateNumbers(rows, item.field, (values) => values.length ? Math.max(...values) : 0);
         case 'median':
-            return Aggregates.median(rule.field);
+            return aggregateNumbers(rows, item.field, calculateMedian);
         default:
-            throw new Error(`Unsupported aggregation operation: ${rule.operation}`);
+            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, 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;
+    }
+    return [...rows].sort((left, right) => {
+        for (const order of orderBy) {
+            const direction = order.direction === 'asc' ? 1 : -1;
+            const result = compareValues(left[order.field], right[order.field]);
+            if (result !== 0) {
+                return result * direction;
+            }
+        }
+        return 0;
+    });
+}
+function compareValues(left, right) {
+    if (typeof left === 'number' && typeof right === 'number') {
+        return left - right;
+    }
+    return String(left !== null && left !== void 0 ? left : '').localeCompare(String(right !== null && right !== void 0 ? right : ''));
+}
+function getBackendSort(orderBy) {
+    if (!(orderBy === null || orderBy === void 0 ? void 0 : orderBy.length)) {
+        return undefined;
+    }
+    return orderBy.map((order) => order.direction === 'asc'
+        ? Sorts.ASC(order.field)
+        : Sorts.DESC(order.field));
+}
+function getColumns(rows, query) {
+    var _a, _b, _c, _d;
+    const selectColumns = [
+        ...((_a = query.groupBy) !== 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);
+    return Array.from(new Set(selectColumns.length ? selectColumns : Object.keys((_d = rows[0]) !== null && _d !== void 0 ? _d : {})));
+}
+function getDefaultSelect(rows) {
+    var _a;
+    return Object.keys((_a = rows[0]) !== null && _a !== void 0 ? _a : {}).map((field) => ({ field }));
+}
+function isAggregateQuery(query) {
+    var _a, _b;
+    return Boolean(((_a = query.groupBy) === 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) {
+    return 'field' in item && !('agg' in item);
+}
+function isAggregateSelectItem(item) {
+    return 'agg' in item;
+}
+function isCalcSelectItem(item) {
+    return 'calc' in item;
+}
+function getSelectAlias(item) {
+    var _a;
+    if (isFieldSelectItem(item)) {
+        return (_a = item.as) !== null && _a !== void 0 ? _a : item.field;
+    }
+    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 formatGroupValue(value, grain) {
+    if (!grain) {
+        return value;
+    }
+    const date = new Date(String(value));
+    if (!Number.isFinite(date.getTime())) {
+        return value;
+    }
+    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}`;
+    }
+    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 (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`;
 }
-function createGroupByRule(rule) {
-    if (rule.type === 'field') {
-        return GroupBy.Field(rule.field);
+function normalizeFilters(filters) {
+    if (Array.isArray(filters)) {
+        return filters.map((filter) => normalizeFilterNode(filter));
     }
-    return GroupBy.DateTrunc(rule.field, rule.truncation, rule.timezone);
+    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)));
+    }
+    if (Array.isArray(filter.or)) {
+        return Filters.OR(filter.or.map((item) => normalizeFilterNode(item)));
+    }
+    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));
+        }
+    }
+    return filter;
+}
+function matchesFilterExpression(row, filter) {
+    var _a, _b, _c, _d;
+    if (Array.isArray(filter)) {
+        return filter.every((item) => matchesFilterExpression(row, item));
+    }
+    if ('and' in filter) {
+        return filter.and.every((item) => matchesFilterExpression(row, 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;
+    }
+    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);
+    }
+    return date.toISOString();
+}
+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;

package/endpoint/dashboard.ts

@@ -1,12 +1,35 @@
-import type { IHttpServer } from 'adminforth';
-import { DashboardApiResponseSchema, SlugRequestSchema } from '../schema/api.js';
-import type { DashboardRecord } from '../services/dashboardConfigService.js';
+import type { AdminUser, IHttpServer } from 'adminforth';
+import { normalizeDashboardConfig } from '../custom/model/dashboard.types.js';
+import type { DashboardConfig, DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
+import {
+  DashboardApiResponseSchema,
+  DashboardConfigZodSchema,
+  SetDashboardConfigRequestSchema,
+  SlugRequestSchema,
+} from '../schema/api.js';
+import type { DashboardWidgetConfigValidationError } from '../schema/widget.js';
+import type { DashboardRecord, PersistedDashboardResponse } from '../services/dashboardConfigService.js';
 import { buildDashboardResponse } from '../services/dashboardConfigService.js';
 
 type DashboardEndpointsContext = {
+  canEditDashboard: (adminUser: AdminUser) => boolean;
   getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+  persistDashboardConfig: (
+    dashboard: DashboardRecord,
+    config: DashboardConfig,
+  ) => Promise<PersistedDashboardResponse>;
+  validateDashboardWidgetApiConfig: (
+    widget: DashboardWidgetConfig,
+  ) => DashboardWidgetConfigValidationError[];
 };
 
+function formatDashboardConfigValidationErrors(error: { issues: { path: PropertyKey[], message: string }[] }) {
+  return error.issues.map((issue) => ({
+    field: issue.path.length ? issue.path.map(String).join('.') : 'config',
+    message: issue.message,
+  }));
+}
+
 export function registerDashboardEndpoints(
   server: IHttpServer,
   ctx: DashboardEndpointsContext,
@@ -29,4 +52,54 @@ export function registerDashboardEndpoints(
       return buildDashboardResponse(dashboard);
     },
   });
-}
+
+  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 slug = String(body?.slug || 'default');
+      const dashboard = await ctx.getDashboardRecord(slug);
+
+      if (!dashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
+      }
+
+      const normalizedConfig = normalizeDashboardConfig(body?.config);
+      const parsedConfig = DashboardConfigZodSchema.safeParse(normalizedConfig);
+
+      if (!parsedConfig.success) {
+        response.setStatus(422);
+        return {
+          error: 'Invalid dashboard config',
+          validationErrors: formatDashboardConfigValidationErrors(parsedConfig.error),
+        };
+      }
+
+      const widgetValidationErrors = parsedConfig.data.widgets.flatMap((widget, index) => (
+        ctx.validateDashboardWidgetApiConfig(widget as DashboardWidgetConfig).map((error) => ({
+          ...error,
+          field: `widgets.${index}.${error.field}`,
+        }))
+      ));
+
+      if (widgetValidationErrors.length) {
+        response.setStatus(422);
+        return {
+          error: 'Invalid dashboard config',
+          validationErrors: widgetValidationErrors,
+        };
+      }
+
+      return ctx.persistDashboardConfig(dashboard, parsedConfig.data as DashboardConfig);
+    },
+  });
+}

package/endpoint/widgets.ts

@@ -3,7 +3,7 @@ import { randomUUID } from 'crypto';
 import {
   normalizeDashboardWidgetConfig,
 } from '../custom/model/dashboard.types.js';
-import type { DashboardConfig, DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
+import type { DashboardConfig, DashboardVariables, DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
 import {
   DashboardApiResponseSchema,
   DashboardWidgetDataResponseSchema,
@@ -31,7 +31,10 @@ type WidgetEndpointsContext = {
   ) => DashboardWidgetConfigValidationError[];
   getWidgetData: (
     widget: DashboardWidgetConfig,
-    options?: { pagination?: { page: number, pageSize: number } },
+    options?: {
+      pagination?: { page: number, pageSize: number },
+      variables?: DashboardVariables,
+    },
   ) => Promise<unknown>;
 };
 
@@ -53,10 +56,13 @@ function formatWidgetConfigFieldPath(field: string) {
   const fieldAliases = new Map([
     ['minWidth', 'min_width'],
     ['maxWidth', 'max_width'],
-    ['dataSource', 'data_source'],
-    ['resourceId', 'resource_id'],
     ['groupBy', 'group_by'],
+    ['orderBy', 'order_by'],
     ['pageSize', 'page_size'],
+    ['timeSeries', 'time_series'],
+    ['valueField', 'value_field'],
+    ['targetValue', 'target_value'],
+    ['targetField', 'target_field'],
   ]);
 
   return field
@@ -298,6 +304,7 @@ export function registerWidgetEndpoints(
         widget,
         data: await ctx.getWidgetData(widget, {
           pagination: body?.pagination,
+          variables: widget.variables,
         }),
       };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/dashboard",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",