@adminforth/dashboard 1.4.2 → 1.5.0

package/dist/schema/api.js

@@ -41,10 +41,6 @@ export const DashboardWidgetDataResponseZodSchema = z.union([
 export const SlugRequestZodSchema = z.object({
     slug: z.string(),
 }).strict();
-export const SetDashboardConfigRequestZodSchema = z.object({
-    slug: z.string(),
-    config: DashboardConfigZodSchema,
-}).strict();
 export const GroupIdRequestZodSchema = z.object({
     slug: z.string(),
     groupId: z.string(),
@@ -91,7 +87,6 @@ export const DashboardResponseSchema = toAdminForthJsonSchema(DashboardResponseZ
 export const DashboardApiResponseSchema = toAdminForthJsonSchema(DashboardApiResponseZodSchema);
 export const DashboardWidgetDataResponseSchema = toAdminForthJsonSchema(DashboardWidgetDataResponseZodSchema);
 export const SlugRequestSchema = toAdminForthJsonSchema(SlugRequestZodSchema);
-export const SetDashboardConfigRequestSchema = toAdminForthJsonSchema(SetDashboardConfigRequestZodSchema);
 export const GroupIdRequestSchema = toAdminForthJsonSchema(GroupIdRequestZodSchema);
 export const MoveGroupRequestSchema = toAdminForthJsonSchema(MoveGroupRequestZodSchema);
 export const SetGroupConfigRequestSchema = toAdminForthJsonSchema(SetGroupConfigRequestZodSchema);

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/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;
     },
   });
 

package/endpoint/widgets.ts

@@ -25,6 +25,10 @@ type WidgetEndpointsContext = {
     dashboard: DashboardRecord,
     config: DashboardConfig,
   ) => Promise<PersistedDashboardResponse>;
+  updateDashboardConfig: (
+    slug: string,
+    mutateConfig: (config: DashboardConfig, dashboard: DashboardRecord) => DashboardConfig | null | Promise<DashboardConfig | null>,
+  ) => Promise<PersistedDashboardResponse | null>;
   getWidgetData: (
     widget: DashboardWidgetConfig,
     options?: {
@@ -50,35 +54,42 @@ export function registerWidgetEndpoints(
         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 group = config.groups.find((item) => item.id === body.groupId);
+
+        if (!group) {
+          mutationError = 'Dashboard group not found';
+          return null;
+        }
+
+        const nextOrder = config.widgets.filter((item) => item.group_id === body.groupId).length + 1;
+        const widget: DashboardWidgetConfig = {
+          id: `widget_${randomUUID()}`,
+          group_id: body.groupId,
+          label: 'New widget',
+          size: 'small',
+          order: nextOrder,
+          target: 'empty',
+        };
 
-      if (!dashboard) {
+        return {
+          ...config,
+          widgets: [...config.widgets, widget],
+        };
+      });
+
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const group = config.groups.find((item) => item.id === body.groupId);
-
-      if (!group) {
+      if (mutationError) {
         response.setStatus(404);
-        return { error: 'Dashboard group not found' };
+        return { error: mutationError };
       }
 
-      const nextOrder = config.widgets.filter((item) => item.group_id === body.groupId).length + 1;
-      const widget: DashboardWidgetConfig = {
-        id: `widget_${randomUUID()}`,
-        group_id: body.groupId,
-        label: 'New widget',
-        size: 'small',
-        order: nextOrder,
-        target: 'empty',
-      };
-
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: [...config.widgets, widget],
-      });
+      return updatedDashboard;
     },
   });
 
@@ -94,49 +105,50 @@ export function registerWidgetEndpoints(
         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 widget = config.widgets.find((item) => item.id === body.widgetId);
 
-      if (!dashboard) {
-        response.setStatus(404);
-        return { error: 'Dashboard not found' };
-      }
+        if (!widget) {
+          mutationError = 'Dashboard widget not found';
+          return null;
+        }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const widget = config.widgets.find((item) => item.id === body.widgetId);
+        const sortedWidgets = config.widgets
+          .filter((item) => item.group_id === widget.group_id)
+          .sort((a, b) => a.order - b.order);
+        const currentIndex = sortedWidgets.findIndex((item) => item.id === body.widgetId);
+        const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
 
-      if (!widget) {
-        response.setStatus(404);
-        return { error: 'Dashboard widget not found' };
-      }
+        if (targetIndex < 0 || targetIndex >= sortedWidgets.length) {
+          return null;
+        }
 
-      const sortedWidgets = config.widgets
-        .filter((item) => item.group_id === widget.group_id)
-        .sort((a, b) => a.order - b.order);
-      const currentIndex = sortedWidgets.findIndex((item) => item.id === body.widgetId);
-      const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+        const reorderedWidgets = [...sortedWidgets];
+        const [movedWidget] = reorderedWidgets.splice(currentIndex, 1);
+        reorderedWidgets.splice(targetIndex, 0, movedWidget);
+        const reorderedWidgetIds = new Map(reorderedWidgets.map((item, index) => [item.id, index + 1]));
 
-      if (targetIndex < 0 || targetIndex >= sortedWidgets.length) {
         return {
-          id: dashboard.id,
-          slug: dashboard.slug,
-          label: dashboard.label,
-          revision: dashboard.revision,
-          config: ctx.parseStoredDashboardConfig(dashboard.config),
+          ...config,
+          widgets: config.widgets.map((item) => ({
+            ...item,
+            order: reorderedWidgetIds.get(item.id) ?? item.order,
+          })),
         };
+      });
+
+      if (!updatedDashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
       }
 
-      const reorderedWidgets = [...sortedWidgets];
-      const [movedWidget] = reorderedWidgets.splice(currentIndex, 1);
-      reorderedWidgets.splice(targetIndex, 0, movedWidget);
-      const reorderedWidgetIds = new Map(reorderedWidgets.map((item, index) => [item.id, index + 1]));
-
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: config.widgets.map((item) => ({
-          ...item,
-          order: reorderedWidgetIds.get(item.id) ?? item.order,
-        })),
-      });
+      if (mutationError) {
+        response.setStatus(404);
+        return { error: mutationError };
+      }
+
+      return updatedDashboard;
     },
   });
 
@@ -152,25 +164,32 @@ export function registerWidgetEndpoints(
         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 nextWidgets = config.widgets.filter((item) => item.id !== body.widgetId);
 
-      if (!dashboard) {
+        if (nextWidgets.length === config.widgets.length) {
+          mutationError = 'Dashboard widget not found';
+          return null;
+        }
+
+        return {
+          ...config,
+          widgets: nextWidgets,
+        };
+      });
+
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const nextWidgets = config.widgets.filter((item) => item.id !== body.widgetId);
-
-      if (nextWidgets.length === config.widgets.length) {
+      if (mutationError) {
         response.setStatus(404);
-        return { error: 'Dashboard widget not found' };
+        return { error: mutationError };
       }
 
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: nextWidgets,
-      });
+      return updatedDashboard;
     },
   });
 
@@ -186,36 +205,43 @@ export function registerWidgetEndpoints(
         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 widget = config.widgets.find((item) => item.id === body.widgetId);
 
-      if (!dashboard) {
+        if (!widget) {
+          mutationError = 'Dashboard widget not found';
+          return null;
+        }
+
+        const typedWidgetConfig = body.config as EditableDashboardWidgetConfig;
+
+        const nextWidget: DashboardWidgetConfig = {
+          ...typedWidgetConfig,
+          id: widget.id,
+          group_id: widget.group_id,
+          order: widget.order,
+        };
+
+        return {
+          ...config,
+          widgets: config.widgets.map((item) => item.id === body.widgetId
+            ? nextWidget
+            : item),
+        };
+      });
+
+      if (!updatedDashboard) {
         response.setStatus(404);
         return { error: 'Dashboard not found' };
       }
 
-      const config = ctx.parseStoredDashboardConfig(dashboard.config);
-      const widget = config.widgets.find((item) => item.id === body.widgetId);
-
-      if (!widget) {
+      if (mutationError) {
         response.setStatus(404);
-        return { error: 'Dashboard widget not found' };
+        return { error: mutationError };
       }
 
-      const typedWidgetConfig = body.config as EditableDashboardWidgetConfig;
-
-      const nextWidget: DashboardWidgetConfig = {
-        ...typedWidgetConfig,
-        id: widget.id,
-        group_id: widget.group_id,
-        order: widget.order,
-      };
-
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: config.widgets.map((item) => item.id === body.widgetId
-          ? nextWidget
-          : item),
-      });
+      return updatedDashboard;
     },
   });
 

package/package.json

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

package/schema/api.ts

@@ -50,11 +50,6 @@ export const SlugRequestZodSchema = z.object({
   slug: z.string(),
 }).strict()
 
-export const SetDashboardConfigRequestZodSchema = z.object({
-  slug: z.string(),
-  config: DashboardConfigZodSchema,
-}).strict()
-
 export const GroupIdRequestZodSchema = z.object({
   slug: z.string(),
   groupId: z.string(),
@@ -109,7 +104,6 @@ export const DashboardResponseSchema = toAdminForthJsonSchema(DashboardResponseZ
 export const DashboardApiResponseSchema = toAdminForthJsonSchema(DashboardApiResponseZodSchema)
 export const DashboardWidgetDataResponseSchema = toAdminForthJsonSchema(DashboardWidgetDataResponseZodSchema)
 export const SlugRequestSchema = toAdminForthJsonSchema(SlugRequestZodSchema)
-export const SetDashboardConfigRequestSchema = toAdminForthJsonSchema(SetDashboardConfigRequestZodSchema)
 export const GroupIdRequestSchema = toAdminForthJsonSchema(GroupIdRequestZodSchema)
 export const MoveGroupRequestSchema = toAdminForthJsonSchema(MoveGroupRequestZodSchema)
 export const SetGroupConfigRequestSchema = toAdminForthJsonSchema(SetGroupConfigRequestZodSchema)