@adminforth/dashboard 1.0.0

package/dist/schema/widget.js

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+const DashboardWidgetSizeSchema = z.enum([
+    'small',
+    'medium',
+    'large',
+    'wide',
+    'full',
+]);
+const WidgetBaseSchema = z.object({
+    id: z.string().optional(),
+    group_id: z.string().optional(),
+    label: z.string().optional(),
+    size: DashboardWidgetSizeSchema.optional(),
+    width: z.number().positive('Width must be greater than 0').optional(),
+    height: z.number().positive('Height must be greater than 0').optional(),
+    minWidth: z.number().nonnegative('Min width must be a non-negative number').optional(),
+    maxWidth: z.number().nonnegative('Max width must be a non-negative number').nullable().optional(),
+    order: z.number().optional(),
+});
+const ChartBaseSchema = z.object({
+    title: z.string().optional(),
+});
+const ChartBucketSchema = z.object({
+    label: z.string().min(1, 'Bucket label is required'),
+    min: z.number().optional(),
+    max: z.number().optional(),
+});
+const ChartSeriesSchema = z.object({
+    name: z.string().min(1, 'Series name is required'),
+    field: z.string().min(1, 'Series field is required'),
+    color: z.string().optional(),
+});
+const LineChartSchema = ChartBaseSchema.extend({
+    type: z.literal('line'),
+    x_field: z.string().optional(),
+    y_field: z.string().optional(),
+    series_name: z.string().optional(),
+    color: z.string().optional(),
+});
+const BarChartSchema = ChartBaseSchema.extend({
+    type: z.literal('bar'),
+    label_field: z.string().optional(),
+    value_field: z.string().optional(),
+    bucket_field: z.string().optional(),
+    buckets: z.array(ChartBucketSchema).optional(),
+    color: z.string().optional(),
+});
+const StackedBarChartSchema = ChartBaseSchema.extend({
+    type: z.literal('stacked_bar'),
+    x_field: z.string().optional(),
+    series: z.array(ChartSeriesSchema).optional(),
+    colors: z.array(z.string()).optional(),
+});
+const PieChartSchema = ChartBaseSchema.extend({
+    type: z.literal('pie'),
+    label_field: z.string().optional(),
+    value_field: z.string().optional(),
+    colors: z.array(z.string()).optional(),
+});
+const HistogramChartSchema = ChartBaseSchema.extend({
+    type: z.literal('histogram'),
+    label_field: z.string().optional(),
+    value_field: z.string().optional(),
+    bucket_field: z.string().optional(),
+    buckets: z.array(ChartBucketSchema).optional(),
+    color: z.string().optional(),
+});
+const FunnelChartSchema = ChartBaseSchema.extend({
+    type: z.literal('funnel'),
+    label_field: z.string().optional(),
+    value_field: z.string().optional(),
+    colors: z.array(z.string()).optional(),
+});
+export const ChartConfigSchema = z.discriminatedUnion('type', [
+    LineChartSchema,
+    BarChartSchema,
+    StackedBarChartSchema,
+    PieChartSchema,
+    HistogramChartSchema,
+    FunnelChartSchema,
+]);
+export const DashboardWidgetQuerySchema = z.object({
+    resource: z.string().min(1, 'Query resource must be a non-empty string'),
+    select: z.array(z.string()).optional(),
+    order: z.object({
+        field: z.string().min(1, 'Order field is required'),
+        direction: z.enum(['asc', 'desc']),
+    }).optional(),
+    limit: z.number().optional(),
+});
+export const EmptyWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('empty'),
+});
+const TableWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('table'),
+    table: z.unknown().optional(),
+    query: DashboardWidgetQuerySchema.optional(),
+});
+const ChartWidgetTargetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('chart'),
+    chart: ChartConfigSchema,
+    query: DashboardWidgetQuerySchema,
+});
+const KpiCardWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('kpi_card'),
+    kpi_card: z.unknown().optional(),
+    query: DashboardWidgetQuerySchema.optional(),
+});
+const GaugeCardWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('gauge_card'),
+    gauge_card: z.unknown().optional(),
+    query: DashboardWidgetQuerySchema.optional(),
+});
+const PivotTableWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('pivot_table'),
+    pivot_table: z.unknown().optional(),
+    query: DashboardWidgetQuerySchema.optional(),
+});
+export const WidgetConfigSchema = z.discriminatedUnion('target', [
+    TableWidgetConfigSchema,
+    ChartWidgetTargetConfigSchema,
+    KpiCardWidgetConfigSchema,
+    GaugeCardWidgetConfigSchema,
+    PivotTableWidgetConfigSchema,
+]);
+export const StoredWidgetConfigSchema = z.discriminatedUnion('target', [
+    EmptyWidgetConfigSchema,
+    TableWidgetConfigSchema,
+    ChartWidgetTargetConfigSchema,
+    KpiCardWidgetConfigSchema,
+    GaugeCardWidgetConfigSchema,
+    PivotTableWidgetConfigSchema,
+]);

package/dist/services/dashboardConfigService.d.ts

@@ -0,0 +1,35 @@
+import type { IAdminForth } from 'adminforth';
+import type { DashboardConfig } from '../custom/model/dashboard.types.js';
+export type DashboardRecord = {
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: unknown;
+};
+export declare function parseStoredDashboardConfig(config: unknown): DashboardConfig;
+export declare function buildDashboardResponse(dashboard: DashboardRecord): {
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: DashboardConfig;
+};
+export type PersistedDashboardResponse = {
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: DashboardConfig;
+};
+export declare function dashboardConfigUpdatedTopic(slug: string): string;
+export declare function normalizeDashboardOrder(config: DashboardConfig): DashboardConfig;
+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 type DashboardConfigService = {
+    getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+    parseStoredDashboardConfig: typeof parseStoredDashboardConfig;
+    persistDashboardConfig: (dashboard: DashboardRecord, config: DashboardConfig) => Promise<PersistedDashboardResponse>;
+    buildDashboardResponse: typeof buildDashboardResponse;
+};
+export declare function createDashboardConfigService(adminforth: IAdminForth, dashboardConfigsResourceId: string): DashboardConfigService;

package/dist/services/dashboardConfigService.js

@@ -0,0 +1,79 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Filters } from 'adminforth';
+import { normalizeDashboardConfig } from '../custom/model/dashboard.types.js';
+const DASHBOARD_CONFIG_UPDATED_TOPIC_PREFIX = '/opentopic/dashboard-config-updated';
+export function parseStoredDashboardConfig(config) {
+    if (typeof config === 'string') {
+        return normalizeDashboardConfig(JSON.parse(config));
+    }
+    return normalizeDashboardConfig(config);
+}
+export function buildDashboardResponse(dashboard) {
+    return {
+        id: dashboard.id,
+        slug: dashboard.slug,
+        label: dashboard.label,
+        revision: dashboard.revision,
+        config: parseStoredDashboardConfig(dashboard.config),
+    };
+}
+export function dashboardConfigUpdatedTopic(slug) {
+    return `${DASHBOARD_CONFIG_UPDATED_TOPIC_PREFIX}/${slug}`;
+}
+export function normalizeDashboardOrder(config) {
+    var _a;
+    const widgetsByGroupId = new Map();
+    for (const widget of config.widgets) {
+        const groupWidgets = (_a = widgetsByGroupId.get(widget.group_id)) !== null && _a !== void 0 ? _a : [];
+        groupWidgets.push(widget);
+        widgetsByGroupId.set(widget.group_id, groupWidgets);
+    }
+    for (const [groupId, widgets] of widgetsByGroupId.entries()) {
+        widgetsByGroupId.set(groupId, [...widgets].sort((a, b) => a.order - b.order));
+    }
+    return Object.assign(Object.assign({}, config), { groups: config.groups.map((group, index) => (Object.assign(Object.assign({}, group), { order: index + 1 }))), widgets: config.widgets.map((widget) => (Object.assign(Object.assign({}, widget), { order: widgetsByGroupId.get(widget.group_id).findIndex((item) => item.id === widget.id) + 1 }))) });
+}
+export function getDashboardRecord(adminforth, dashboardConfigsResourceId, slug) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dashboardConfigs = adminforth.resource(dashboardConfigsResourceId);
+        const dashboard = yield dashboardConfigs.get(Filters.EQ('slug', slug));
+        return dashboard || null;
+    });
+}
+export function persistDashboardConfig(adminforth, dashboardConfigsResourceId, dashboard, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const normalizedConfig = normalizeDashboardOrder(config);
+        yield adminforth.resource(dashboardConfigsResourceId).update(dashboard.id, {
+            config: normalizedConfig,
+            revision: dashboard.revision + 1,
+        });
+        yield adminforth.websocket.publish(dashboardConfigUpdatedTopic(dashboard.slug), {
+            id: dashboard.id,
+            slug: dashboard.slug,
+            revision: dashboard.revision + 1,
+        });
+        return {
+            id: dashboard.id,
+            slug: dashboard.slug,
+            label: dashboard.label,
+            revision: dashboard.revision + 1,
+            config: normalizedConfig,
+        };
+    });
+}
+export function createDashboardConfigService(adminforth, dashboardConfigsResourceId) {
+    return {
+        getDashboardRecord: (slug) => getDashboardRecord(adminforth, dashboardConfigsResourceId, slug),
+        parseStoredDashboardConfig,
+        persistDashboardConfig: (dashboard, config) => persistDashboardConfig(adminforth, dashboardConfigsResourceId, dashboard, config),
+        buildDashboardResponse,
+    };
+}

package/dist/services/widgetConfigValidator.d.ts

@@ -0,0 +1,8 @@
+import type { IAdminForth } from 'adminforth';
+import type { DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
+import type { DashboardWidgetConfigValidationError } from '../schema/widget.js';
+export type WidgetConfigValidatorService = {
+    validateDashboardWidgetApiConfig: (widget: DashboardWidgetConfig) => DashboardWidgetConfigValidationError[];
+};
+export declare function validateDashboardWidgetApiConfig(adminforth: IAdminForth, widget: DashboardWidgetConfig): DashboardWidgetConfigValidationError[];
+export declare function createWidgetConfigValidatorService(adminforth: IAdminForth): WidgetConfigValidatorService;

package/dist/services/widgetConfigValidator.js

@@ -0,0 +1,65 @@
+export function validateDashboardWidgetApiConfig(adminforth, widget) {
+    var _a, _b;
+    if (widget.target !== 'chart') {
+        return [];
+    }
+    const errors = [];
+    if (!widget.query) {
+        errors.push({
+            field: 'query',
+            message: 'Chart widget must have query config',
+        });
+        return errors;
+    }
+    if (!widget.chart) {
+        errors.push({
+            field: 'chart',
+            message: 'Chart widget must have chart config',
+        });
+        return errors;
+    }
+    const query = widget.query;
+    const chart = widget.chart;
+    const resource = adminforth.config.resources.find((item) => item.resourceId === query.resource);
+    if (!resource) {
+        errors.push({
+            field: 'query.resource',
+            message: `Resource "${query.resource}" is not registered`,
+        });
+        return errors;
+    }
+    if (!query.select) {
+        return errors;
+    }
+    const resourceFields = resource.columns.map((column) => column.name);
+    for (const field of query.select) {
+        if (!resourceFields.includes(field)) {
+            errors.push({
+                field: 'query.select',
+                message: `Field "${field}" is not in resource "${query.resource}"`,
+            });
+        }
+    }
+    const chartFields = [
+        chart.x_field,
+        chart.y_field,
+        chart.label_field,
+        chart.value_field,
+        chart.bucket_field,
+        ...((_b = (_a = chart.series) === null || _a === void 0 ? void 0 : _a.map((series) => series.field)) !== null && _b !== void 0 ? _b : []),
+    ].filter((field) => typeof field === 'string');
+    for (const field of chartFields) {
+        if (!query.select.includes(field)) {
+            errors.push({
+                field: 'query.select',
+                message: `Query select must include chart field "${field}"`,
+            });
+        }
+    }
+    return errors;
+}
+export function createWidgetConfigValidatorService(adminforth) {
+    return {
+        validateDashboardWidgetApiConfig: (widget) => validateDashboardWidgetApiConfig(adminforth, widget),
+    };
+}

package/dist/services/widgetDataService.d.ts

@@ -0,0 +1,20 @@
+import type { IAdminForth } from 'adminforth';
+import type { DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
+export type DashboardWidgetQueryConfig = {
+    resource: string;
+    select?: string[];
+    order?: {
+        field: string;
+        direction: 'asc' | 'desc';
+    };
+    limit?: number;
+};
+export type DashboardWidgetData = {
+    columns: string[];
+    rows: Record<string, unknown>[];
+};
+export type WidgetDataService = {
+    getWidgetData: (widget: DashboardWidgetConfig) => Promise<DashboardWidgetData | null>;
+};
+export declare function getWidgetData(adminforth: IAdminForth, widget: DashboardWidgetConfig): Promise<DashboardWidgetData | null>;
+export declare function createWidgetDataService(adminforth: IAdminForth): WidgetDataService;

package/dist/services/widgetDataService.js

@@ -0,0 +1,32 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Sorts } from 'adminforth';
+export function getWidgetData(adminforth, widget) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!widget.query) {
+            return null;
+        }
+        const query = widget.query;
+        const rows = yield adminforth.resource(query.resource).list([], query.limit, 0, query.order
+            ? [query.order.direction === 'desc' ? Sorts.DESC(query.order.field) : Sorts.ASC(query.order.field)]
+            : undefined);
+        const columns = (_a = query.select) !== null && _a !== void 0 ? _a : Object.keys((_b = rows[0]) !== null && _b !== void 0 ? _b : {});
+        return {
+            columns,
+            rows: rows.map((row) => (Object.fromEntries(columns.map((column) => [column, row[column]])))),
+        };
+    });
+}
+export function createWidgetDataService(adminforth) {
+    return {
+        getWidgetData: (widget) => getWidgetData(adminforth, widget),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+export type PluginOptions = {
+    /**
+     * ResourceId of a resource that stores dashboard configs.
+     *
+     * Expected columns: id, slug, label, revision, config (JSON).
+     */
+    dashboardConfigsResourceId: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/endpoint/dashboard.ts

@@ -0,0 +1,32 @@
+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';
+
+type DashboardEndpointsContext = {
+  getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+};
+
+export function registerDashboardEndpoints(
+  server: IHttpServer,
+  ctx: DashboardEndpointsContext,
+) {
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/get-config',
+    description: 'Loads one dashboard configuration by slug for rendering or editing.',
+    request_schema: SlugRequestSchema,
+    response_schema: DashboardApiResponseSchema,
+    handler: async ({ body, response }) => {
+      const slug = String(body?.slug || 'default');
+      const dashboard = await ctx.getDashboardRecord(slug);
+
+      if (!dashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
+      }
+
+      return buildDashboardResponse(dashboard);
+    },
+  });
+}

package/endpoint/groups.ts

@@ -0,0 +1,213 @@
+import type { AdminUser, IHttpServer } from 'adminforth';
+import { randomUUID } from 'crypto';
+import type {
+  DashboardConfig,
+  DashboardGroupConfig,
+} from '../custom/model/dashboard.types.js';
+import {
+  DashboardApiResponseSchema,
+  GroupIdRequestSchema,
+  MoveGroupRequestSchema,
+  SetGroupConfigRequestSchema,
+  SlugRequestSchema,
+} from '../schema/api.js';
+
+type DashboardRecord = {
+  id: string;
+  slug: string;
+  label: string;
+  revision: number;
+  config: unknown;
+};
+
+type GroupEndpointsContext = {
+  canEditDashboard: (adminUser: AdminUser) => boolean;
+  getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+  parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
+  persistDashboardConfig: (
+    dashboard: DashboardRecord,
+    config: DashboardConfig,
+  ) => Promise<{
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: DashboardConfig;
+  }>;
+  buildDashboardResponse: (dashboard: DashboardRecord) => {
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: DashboardConfig;
+  };
+};
+
+export function registerGroupEndpoints(
+  server: IHttpServer,
+  ctx: GroupEndpointsContext,
+) {
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/add_dashboard_group',
+    description: 'Adds a new group to a dashboard configuration. Superadmin only.',
+    request_schema: SlugRequestSchema,
+    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 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],
+      });
+    },
+  });
+
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/set_dashboard_group_config',
+    description: 'Replaces editable JSON configuration for a dashboard group while preserving group id and order. Superadmin only.',
+    request_schema: SetGroupConfigRequestSchema,
+    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 groupId = String(body?.groupId || '');
+      const dashboard = await ctx.getDashboardRecord(slug);
+
+      if (!dashboard) {
+        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) {
+        response.setStatus(404);
+        return { error: 'Dashboard group not found' };
+      }
+
+      return ctx.persistDashboardConfig(dashboard, {
+        ...config,
+        groups: config.groups.map((item) => item.id === groupId
+          ? {
+              ...(body.config as DashboardGroupConfig),
+              id: group.id,
+              order: group.order,
+            }
+          : item),
+      });
+    },
+  });
+  
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/move_dashboard_group',
+    description: 'Moves a dashboard group up or down in its dashboard. Superadmin only.',
+    request_schema: MoveGroupRequestSchema,
+    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 groupId = String(body?.groupId || '');
+      const direction = body?.direction === 'down' ? 'down' : 'up';
+      const dashboard = await ctx.getDashboardRecord(slug);
+
+      if (!dashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
+      }
+
+      const config = ctx.parseStoredDashboardConfig(dashboard.config);
+      const sortedGroups = [...config.groups].sort((a, b) => a.order - b.order);
+      const currentIndex = sortedGroups.findIndex((group) => group.id === groupId);
+
+      if (currentIndex === -1) {
+        response.setStatus(404);
+        return { error: 'Dashboard group not found' };
+      }
+
+      const targetIndex = direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+
+      if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
+        return ctx.buildDashboardResponse(dashboard);
+      }
+
+      const reorderedGroups = [...sortedGroups];
+      const [group] = reorderedGroups.splice(currentIndex, 1);
+      reorderedGroups.splice(targetIndex, 0, group);
+
+      return ctx.persistDashboardConfig(dashboard, {
+        ...config,
+        groups: reorderedGroups,
+      });
+    },
+  });
+
+  server.endpoint({
+    method: 'POST',
+    path: '/dashboard/remove_dashboard_group',
+    description: 'Removes a dashboard group and all widgets inside it. Superadmin only.',
+    request_schema: GroupIdRequestSchema,
+    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 groupId = String(body?.groupId || '');
+      const dashboard = await ctx.getDashboardRecord(slug);
+
+      if (!dashboard) {
+        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) {
+        response.setStatus(404);
+        return { error: 'Dashboard group not found' };
+      }
+
+      return ctx.persistDashboardConfig(dashboard, {
+        ...config,
+        groups: nextGroups,
+        widgets: config.widgets.filter((widget) => widget.group_id !== groupId),
+      });
+    },
+  });
+
+}