@adminforth/dashboard 1.4.2 → 1.6.0

package/dist/schema/widgets/table.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const TableViewConfigSchema: z.ZodObject<{
+    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            number: "number";
+            integer: "integer";
+            compact_number: "compact_number";
+            currency: "currency";
+            percent: "percent";
+            percent_delta: "percent_delta";
+            number_delta: "number_delta";
+            currency_delta: "currency_delta";
+        }>>;
+    }, z.core.$strict>>>;
+    pagination: z.ZodOptional<z.ZodBoolean>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const TableWidgetConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    group_id: z.ZodString;
+    order: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    size: z.ZodOptional<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+        wide: "wide";
+        full: "full";
+    }>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    min_width: z.ZodOptional<z.ZodNumber>;
+    max_width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    target: z.ZodLiteral<"table">;
+    table: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodEnum<{
+                number: "number";
+                integer: "integer";
+                compact_number: "compact_number";
+                currency: "currency";
+                percent: "percent";
+                percent_delta: "percent_delta";
+                number_delta: "number_delta";
+                currency_delta: "currency_delta";
+            }>>;
+        }, z.core.$strict>>>;
+        pagination: z.ZodOptional<z.ZodBoolean>;
+        page_size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    query: z.ZodObject<{
+        resource: z.ZodString;
+        select: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            grain: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            agg: z.ZodEnum<{
+                sum: "sum";
+                count: "count";
+                count_distinct: "count_distinct";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                median: "median";
+            }>;
+            field: z.ZodOptional<z.ZodString>;
+            as: z.ZodString;
+            filters: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            calc: z.ZodString;
+            as: z.ZodString;
+        }, z.core.$strict>]>>>;
+        sparkline: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            grain: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            as: z.ZodString;
+            fill_missing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        filters: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        group_by: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            field: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            grain: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>>;
+            timezone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>>;
+        order_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            direction: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        bucket: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            buckets: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        calcs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            calc: z.ZodString;
+            as: z.ZodString;
+        }, z.core.$strict>>>;
+        formatting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schema/widgets/table.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { ChartFieldRefSchema, QueryConfigSchema, WidgetBaseSchema, } from './common.js';
+export const TableViewConfigSchema = z.object({
+    columns: z.array(ChartFieldRefSchema).optional(),
+    pagination: z.boolean().optional(),
+    page_size: z.number().int().positive().optional(),
+}).strict();
+export const TableWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('table'),
+    table: TableViewConfigSchema.optional(),
+    query: QueryConfigSchema,
+});

package/dist/services/dashboardConfigService.d.ts

@@ -15,11 +15,15 @@ export type PersistedDashboardResponse = {
     revision: number;
     config: DashboardConfig;
 };
+type DashboardConfigMutator = (config: DashboardConfig, dashboard: DashboardRecord) => DashboardConfig | null | Promise<DashboardConfig | null>;
 export declare function getDashboardRecord(adminforth: IAdminForth, dashboardConfigsResourceId: string, slug: string): Promise<DashboardRecord | null>;
 export declare function persistDashboardConfig(adminforth: IAdminForth, dashboardConfigsResourceId: string, dashboard: DashboardRecord, config: DashboardConfig): Promise<PersistedDashboardResponse>;
+export declare function updateDashboardConfig(adminforth: IAdminForth, dashboardConfigsResourceId: string, slug: string, mutateConfig: DashboardConfigMutator): Promise<PersistedDashboardResponse | null>;
 export type DashboardConfigService = {
     getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
     parseStoredDashboardConfig: typeof parseStoredDashboardConfig;
     persistDashboardConfig: (dashboard: DashboardRecord, config: DashboardConfig) => Promise<PersistedDashboardResponse>;
+    updateDashboardConfig: (slug: string, mutateConfig: DashboardConfigMutator) => Promise<PersistedDashboardResponse | null>;
 };
 export declare function createDashboardConfigService(adminforth: IAdminForth, dashboardConfigsResourceId: string): DashboardConfigService;
+export {};

package/dist/services/dashboardConfigService.js

@@ -14,6 +14,29 @@ export function parseStoredDashboardConfig(config) {
     const parsedConfig = typeof config === 'string' ? JSON.parse(config) : config;
     return DashboardConfigZodSchema.parse(parsedConfig);
 }
+const dashboardConfigUpdateQueues = new Map();
+function runDashboardConfigUpdateQueued(dashboardSlug, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const previousUpdate = (_a = dashboardConfigUpdateQueues.get(dashboardSlug)) !== null && _a !== void 0 ? _a : Promise.resolve();
+        let releaseCurrentUpdate;
+        const currentUpdate = new Promise((resolve) => {
+            releaseCurrentUpdate = resolve;
+        });
+        const queuedUpdate = previousUpdate.then(() => currentUpdate, () => currentUpdate);
+        dashboardConfigUpdateQueues.set(dashboardSlug, queuedUpdate);
+        yield previousUpdate.catch(() => undefined);
+        try {
+            return yield callback();
+        }
+        finally {
+            releaseCurrentUpdate();
+            if (dashboardConfigUpdateQueues.get(dashboardSlug) === queuedUpdate) {
+                dashboardConfigUpdateQueues.delete(dashboardSlug);
+            }
+        }
+    });
+}
 function normalizeDashboardOrder(config) {
     var _a;
     const widgetsByGroupId = new Map();
@@ -55,10 +78,33 @@ export function persistDashboardConfig(adminforth, dashboardConfigsResourceId, d
         };
     });
 }
+export function updateDashboardConfig(adminforth, dashboardConfigsResourceId, slug, mutateConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runDashboardConfigUpdateQueued(slug, () => __awaiter(this, void 0, void 0, function* () {
+            const dashboard = yield getDashboardRecord(adminforth, dashboardConfigsResourceId, slug);
+            if (!dashboard) {
+                return null;
+            }
+            const config = parseStoredDashboardConfig(dashboard.config);
+            const nextConfig = yield mutateConfig(config, dashboard);
+            if (nextConfig === null) {
+                return {
+                    id: dashboard.id,
+                    slug: dashboard.slug,
+                    label: dashboard.label,
+                    revision: dashboard.revision,
+                    config,
+                };
+            }
+            return persistDashboardConfig(adminforth, dashboardConfigsResourceId, dashboard, nextConfig);
+        }));
+    });
+}
 export function createDashboardConfigService(adminforth, dashboardConfigsResourceId) {
     return {
         getDashboardRecord: (slug) => getDashboardRecord(adminforth, dashboardConfigsResourceId, slug),
         parseStoredDashboardConfig,
         persistDashboardConfig: (dashboard, config) => persistDashboardConfig(adminforth, dashboardConfigsResourceId, dashboard, config),
+        updateDashboardConfig: (slug, mutateConfig) => updateDashboardConfig(adminforth, dashboardConfigsResourceId, slug, mutateConfig),
     };
 }

package/dist/services/widgetDataService.js

@@ -11,7 +11,8 @@ 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 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,
@@ -78,6 +79,10 @@ function getFunnelWidgetData(adminforth, query, variables) {
 function getQueryWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;
+        const metricSelect = getSingleAggregateMetricSelect(query);
+        if (metricSelect) {
+            return getMetricWidgetData(adminforth, query, metricSelect);
+        }
         const selectedRows = isAggregateQuery(query)
             ? yield buildAggregateQueryRows(adminforth, query, variables)
             : buildPlainQueryRows(yield getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.order_by)), query, variables);
@@ -97,6 +102,43 @@ function getQueryWidgetData(adminforth, query, variables) {
         };
     });
 }
+function getMetricWidgetData(adminforth, query, metric) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const [currentValues = {}] = yield getAggregateRows(adminforth, query.resource, query.filters, [metric], []);
+        const values = {
+            [metric.as]: (_a = currentValues[metric.as]) !== null && _a !== void 0 ? _a : 0,
+        };
+        const rows = query.sparkline
+            ? yield getMetricSparklineRows(adminforth, query, metric, getAdminForthFilters(query.filters))
+            : [values];
+        const columns = Array.from(new Set([
+            metric.as,
+            ...(query.sparkline ? [query.sparkline.as] : []),
+        ]));
+        return {
+            kind: 'aggregate',
+            columns,
+            rows,
+            values,
+        };
+    });
+}
+function getMetricSparklineRows(adminforth, query, metric, filters) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sparkline = query.sparkline;
+        const groupBy = [{
+                field: sparkline.field,
+                as: sparkline.as,
+                grain: sparkline.grain,
+            }];
+        const rows = yield getAggregateRows(adminforth, query.resource, filters, [metric], 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));
+        });
+    });
+}
 function getResourceRows(adminforth, resourceId, filters, sort) {
     return __awaiter(this, void 0, void 0, function* () {
         return adminforth.resource(resourceId).list(getAdminForthFilters(filters), undefined, 0, sort);
@@ -238,6 +280,18 @@ 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) {
+    var _a, _b;
+    if ((_a = query.group_by) === null || _a === void 0 ? void 0 : _a.length) {
+        return undefined;
+    }
+    const select = (_b = query.select) !== null && _b !== void 0 ? _b : [];
+    const aggregateItems = select.filter(isAggregateSelectItem);
+    if (aggregateItems.length !== 1 || aggregateItems.length !== select.length) {
+        return undefined;
+    }
+    return aggregateItems[0];
+}
 function isFieldSelectItem(item) {
     return 'field' in item && !('agg' in item);
 }
@@ -454,11 +508,51 @@ function toAdminForthFilter(filter) {
     }
     for (const [operator, createFilter] of Object.entries(FILTER_OPERATORS)) {
         if (Object.prototype.hasOwnProperty.call(filter, operator)) {
-            return createFilter(filter.field, 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;

package/endpoint/dashboard.ts

@@ -1,20 +1,14 @@
-import type { AdminUser, IHttpServer } from 'adminforth';
+import type { 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';
+import type { DashboardRecord } 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(
@@ -44,29 +38,4 @@ export function registerDashboardEndpoints(
       };
     },
   });
-
-  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);
-    },
-  });
 }

package/endpoint/groups.ts

@@ -22,6 +22,10 @@ type GroupEndpointsContext = {
     dashboard: DashboardRecord,
     config: DashboardConfig,
   ) => Promise<PersistedDashboardResponse>;
+  updateDashboardConfig: (
+    slug: string,
+    mutateConfig: (config: DashboardConfig, dashboard: DashboardRecord) => DashboardConfig | null | Promise<DashboardConfig | null>,
+  ) => Promise<PersistedDashboardResponse | null>;
 };
 
 export function registerGroupEndpoints(
@@ -40,26 +44,26 @@ export function registerGroupEndpoints(
         return { error: 'Dashboard edit is not allowed' };
       }
 
-      const dashboard = await ctx.getDashboardRecord(body.slug);
+      const updatedDashboard = await ctx.updateDashboardConfig(body.slug, (config) => {
+        const nextOrder = config.groups.length + 1;
+        const group: DashboardGroupConfig = {
+          id: `group_${randomUUID()}`,
+          label: 'New group',
+          order: nextOrder,
+        };
+
+        return {
+          ...config,
+          groups: [...config.groups, group],
+        };
+      });
 
-      if (!dashboard) {
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const nextOrder = config.groups.length + 1;
-
-      const group: DashboardGroupConfig = {
-        id: `group_${randomUUID()}`,
-        label: 'New group',
-        order: nextOrder,
-      };
-
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        groups: [...config.groups, group],
-      });
+      return updatedDashboard;
     },
   });
 
@@ -76,33 +80,40 @@ export function registerGroupEndpoints(
       }
 
       const groupId = body.groupId;
-      const dashboard = await ctx.getDashboardRecord(body.slug);
+      let mutationError: string | null = null;
+      const updatedDashboard = await ctx.updateDashboardConfig(body.slug, (config) => {
+        const group = config.groups.find((item) => item.id === groupId);
+
+        if (!group) {
+          mutationError = 'Dashboard group not found';
+          return null;
+        }
+
+        const nextGroup: DashboardGroupConfig = {
+          ...(body.config as EditableDashboardGroupConfig),
+          id: group.id,
+          order: group.order,
+        };
 
-      if (!dashboard) {
+        return {
+          ...config,
+          groups: config.groups.map((item) => item.id === groupId
+            ? nextGroup
+            : item),
+        };
+      });
+
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const group = config.groups.find((item) => item.id === groupId);
-
-      if (!group) {
+      if (mutationError) {
         response.setStatus(404);
-        return { error: 'Dashboard group not found' };
+        return { error: mutationError };
       }
 
-      const nextGroup: DashboardGroupConfig = {
-        ...(body.config as EditableDashboardGroupConfig),
-        id: group.id,
-        order: group.order,
-      };
-
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        groups: config.groups.map((item) => item.id === groupId
-          ? nextGroup
-          : item),
-      });
+      return updatedDashboard;
     },
   });
   
@@ -118,42 +129,43 @@ export function registerGroupEndpoints(
         return { error: 'Dashboard edit is not allowed' };
       }
 
-      const dashboard = await ctx.getDashboardRecord(body.slug);
+      let mutationError: string | null = null;
+      const updatedDashboard = await ctx.updateDashboardConfig(body.slug, (config) => {
+        const sortedGroups = [...config.groups].sort((a, b) => a.order - b.order);
+        const currentIndex = sortedGroups.findIndex((group) => group.id === body.groupId);
 
-      if (!dashboard) {
-        response.setStatus(404);
-        return { error: 'Dashboard not found' };
-      }
+        if (currentIndex === -1) {
+          mutationError = 'Dashboard group not found';
+          return null;
+        }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const sortedGroups = [...config.groups].sort((a, b) => a.order - b.order);
-      const currentIndex = sortedGroups.findIndex((group) => group.id === body.groupId);
+        const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
 
-      if (currentIndex === -1) {
-        response.setStatus(404);
-        return { error: 'Dashboard group not found' };
-      }
+        if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
+          return null;
+        }
 
-      const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+        const reorderedGroups = [...sortedGroups];
+        const [group] = reorderedGroups.splice(currentIndex, 1);
+        reorderedGroups.splice(targetIndex, 0, group);
 
-      if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
         return {
-          id: dashboard.id,
-          slug: dashboard.slug,
-          label: dashboard.label,
-          revision: dashboard.revision,
-          config: ctx.parseStoredDashboardConfig(dashboard.config),
+          ...config,
+          groups: reorderedGroups,
         };
+      });
+
+      if (!updatedDashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
       }
 
-      const reorderedGroups = [...sortedGroups];
-      const [group] = reorderedGroups.splice(currentIndex, 1);
-      reorderedGroups.splice(targetIndex, 0, group);
+      if (mutationError) {
+        response.setStatus(404);
+        return { error: mutationError };
+      }
 
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        groups: reorderedGroups,
-      });
+      return updatedDashboard;
     },
   });
 
@@ -170,26 +182,33 @@ export function registerGroupEndpoints(
       }
 
       const groupId = body.groupId;
-      const dashboard = await ctx.getDashboardRecord(body.slug);
+      let mutationError: string | null = null;
+      const updatedDashboard = await ctx.updateDashboardConfig(body.slug, (config) => {
+        const nextGroups = config.groups.filter((group) => group.id !== groupId);
+
+        if (nextGroups.length === config.groups.length) {
+          mutationError = 'Dashboard group not found';
+          return null;
+        }
+
+        return {
+          ...config,
+          groups: nextGroups,
+          widgets: config.widgets.filter((widget) => widget.group_id !== groupId),
+        };
+      });
 
-      if (!dashboard) {
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const nextGroups = config.groups.filter((group) => group.id !== groupId);
-
-      if (nextGroups.length === config.groups.length) {
+      if (mutationError) {
         response.setStatus(404);
-        return { error: 'Dashboard group not found' };
+        return { error: mutationError };
       }
 
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        groups: nextGroups,
-        widgets: config.widgets.filter((widget) => widget.group_id !== groupId),
-      });
+      return updatedDashboard;
     },
   });