@adminforth/dashboard 1.4.2 → 1.6.0

package/endpoint/widgets.ts

@@ -1,12 +1,26 @@
 import type { AdminUser, IHttpServer } from 'adminforth';
 import { randomUUID } from 'crypto';
 import type {
+  ChartDashboardWidgetConfig,
   DashboardConfig,
   DashboardVariables,
   DashboardWidgetConfig,
-  EditableDashboardWidgetConfig,
+  GaugeCardWidgetConfig,
+  KpiCardWidgetConfig,
+  PivotTableWidgetConfig,
+  TableWidgetConfig,
 } from '../custom/model/dashboard.types.js';
 import {
+  ConfigureBarChartWidgetRequestSchema,
+  ConfigureFunnelChartWidgetRequestSchema,
+  ConfigureGaugeCardWidgetRequestSchema,
+  ConfigureHistogramChartWidgetRequestSchema,
+  ConfigureKpiCardWidgetRequestSchema,
+  ConfigureLineChartWidgetRequestSchema,
+  ConfigurePieChartWidgetRequestSchema,
+  ConfigurePivotTableWidgetRequestSchema,
+  ConfigureStackedBarChartWidgetRequestSchema,
+  ConfigureTableWidgetRequestSchema,
   DashboardApiResponseSchema,
   DashboardWidgetDataResponseSchema,
   GroupIdRequestSchema,
@@ -17,6 +31,21 @@ import {
 } from '../schema/api.js';
 import type { DashboardRecord, PersistedDashboardResponse } from '../services/dashboardConfigService.js';
 
+type ConfigurableWidgetConfig =
+  | Omit<TableWidgetConfig, 'id' | 'group_id' | 'order'>
+  | Omit<KpiCardWidgetConfig, 'id' | 'group_id' | 'order'>
+  | Omit<GaugeCardWidgetConfig, 'id' | 'group_id' | 'order'>
+  | Omit<ChartDashboardWidgetConfig, 'id' | 'group_id' | 'order'>
+  | Omit<PivotTableWidgetConfig, 'id' | 'group_id' | 'order'>;
+
+type ConfigureWidgetRequest = {
+  slug: string;
+  widgetId: string;
+  config: ConfigurableWidgetConfig;
+};
+
+type EndpointRequestSchema = Parameters<IHttpServer['endpoint']>[0]['request_schema'];
+
 type WidgetEndpointsContext = {
   canEditDashboard: (adminUser: AdminUser) => boolean;
   getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
@@ -25,6 +54,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?: {
@@ -34,6 +67,86 @@ type WidgetEndpointsContext = {
   ) => Promise<unknown>;
 };
 
+async function replaceWidgetConfig(
+  ctx: WidgetEndpointsContext,
+  slug: string,
+  widgetId: string,
+  widgetConfig: ConfigurableWidgetConfig,
+) {
+  let mutationError: string | null = null;
+  const updatedDashboard = await ctx.updateDashboardConfig(slug, (config) => {
+    const widget = config.widgets.find((item) => item.id === widgetId);
+
+    if (!widget) {
+      mutationError = 'Dashboard widget not found';
+      return null;
+    }
+
+    const nextWidget: DashboardWidgetConfig = {
+      ...widgetConfig,
+      id: widget.id,
+      group_id: widget.group_id,
+      order: widget.order,
+    } as DashboardWidgetConfig;
+
+    return {
+      ...config,
+      widgets: config.widgets.map((item) => item.id === widgetId
+        ? nextWidget
+        : item),
+    };
+  });
+
+  return {
+    updatedDashboard,
+    mutationError,
+  };
+}
+
+function registerConfigureWidgetEndpoint(
+  server: IHttpServer,
+  ctx: WidgetEndpointsContext,
+  options: {
+    path: string;
+    description: string;
+    requestSchema: EndpointRequestSchema;
+  },
+) {
+  server.endpoint({
+    method: 'POST',
+    path: options.path,
+    description: options.description,
+    request_schema: options.requestSchema,
+    response_schema: DashboardApiResponseSchema,
+    handler: async ({ body, adminUser, response }) => {
+      if (!ctx.canEditDashboard(adminUser)) {
+        response.setStatus(403);
+        return { error: 'Dashboard edit is not allowed' };
+      }
+
+      const request = body as ConfigureWidgetRequest;
+      const { updatedDashboard, mutationError } = await replaceWidgetConfig(
+        ctx,
+        request.slug,
+        request.widgetId,
+        request.config,
+      );
+
+      if (!updatedDashboard) {
+        response.setStatus(404);
+        return { error: 'Dashboard not found' };
+      }
+
+      if (mutationError) {
+        response.setStatus(404);
+        return { error: mutationError };
+      }
+
+      return updatedDashboard;
+    },
+  });
+}
+
 export function registerWidgetEndpoints(
   server: IHttpServer,
   ctx: WidgetEndpointsContext,
@@ -50,35 +163,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 +214,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]));
+      if (mutationError) {
+        response.setStatus(404);
+        return { error: mutationError };
+      }
 
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: config.widgets.map((item) => ({
-          ...item,
-          order: reorderedWidgetIds.get(item.id) ?? item.order,
-        })),
-      });
+      return updatedDashboard;
     },
   });
 
@@ -152,28 +273,36 @@ 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;
     },
   });
 
+
   server.endpoint({
     method: 'POST',
     path: '/dashboard/set_widget_config',
@@ -186,37 +315,81 @@ export function registerWidgetEndpoints(
         return { error: 'Dashboard edit is not allowed' };
       }
 
-      const dashboard = await ctx.getDashboardRecord(body.slug);
+      const request = body as ConfigureWidgetRequest;
+      const { updatedDashboard, mutationError } = await replaceWidgetConfig(ctx, request.slug, request.widgetId, request.config);
 
-      if (!dashboard) {
+      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;
+      return updatedDashboard;
+    },
+  });
 
-      const nextWidget: DashboardWidgetConfig = {
-        ...typedWidgetConfig,
-        id: widget.id,
-        group_id: widget.group_id,
-        order: widget.order,
-      };
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_table_widget',
+    description: 'Configures an existing dashboard widget as a table. Superadmin only.',
+    requestSchema: ConfigureTableWidgetRequestSchema,
+  });
 
-      return ctx.persistDashboardConfig(dashboard, {
-        ...config,
-        widgets: config.widgets.map((item) => item.id === body.widgetId
-          ? nextWidget
-          : item),
-      });
-    },
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_kpi_card_widget',
+    description: 'Configures an existing dashboard widget as a KPI card. Superadmin only.',
+    requestSchema: ConfigureKpiCardWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_gauge_card_widget',
+    description: 'Configures an existing dashboard widget as a gauge card. Superadmin only.',
+    requestSchema: ConfigureGaugeCardWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_pivot_table_widget',
+    description: 'Configures an existing dashboard widget as a pivot table. Superadmin only.',
+    requestSchema: ConfigurePivotTableWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_line_chart_widget',
+    description: 'Configures an existing dashboard widget as a line chart. Superadmin only.',
+    requestSchema: ConfigureLineChartWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_bar_chart_widget',
+    description: 'Configures an existing dashboard widget as a bar chart. Superadmin only.',
+    requestSchema: ConfigureBarChartWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_stacked_bar_chart_widget',
+    description: 'Configures an existing dashboard widget as a stacked bar chart. Superadmin only.',
+    requestSchema: ConfigureStackedBarChartWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_pie_chart_widget',
+    description: 'Configures an existing dashboard widget as a pie chart. Superadmin only.',
+    requestSchema: ConfigurePieChartWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_histogram_chart_widget',
+    description: 'Configures an existing dashboard widget as a histogram chart. Superadmin only.',
+    requestSchema: ConfigureHistogramChartWidgetRequestSchema,
+  });
+
+  registerConfigureWidgetEndpoint(server, ctx, {
+    path: '/dashboard/configure_funnel_chart_widget',
+    description: 'Configures an existing dashboard widget as a funnel chart. Superadmin only.',
+    requestSchema: ConfigureFunnelChartWidgetRequestSchema,
   });
 
   server.endpoint({

package/package.json

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

package/schema/api.ts

@@ -1,9 +1,20 @@
 import { toJSONSchema, z } from 'zod'
-import { EditableDashboardWidgetConfigSchema, StoredWidgetConfigSchema } from './widget.js'
-
-function toAdminForthJsonSchema(schema: z.ZodType) {
-  return toJSONSchema(schema, { target: 'draft-7' })
-}
+import {
+  BarChartSchema,
+  FunnelChartSchema,
+  FunnelQueryConfigSchema,
+  GaugeCardViewConfigSchema,
+  HistogramChartSchema,
+  KpiCardViewConfigSchema,
+  LineChartSchema,
+  PieChartSchema,
+  PivotTableViewConfigSchema,
+  QueryConfigSchema,
+  StackedBarChartSchema,
+  TableViewConfigSchema,
+  WidgetEditableBaseSchema,
+  WidgetConfigSchema,
+} from './widget.js'
 
 export const DashboardErrorResponseZodSchema = z.object({
   error: z.string(),
@@ -22,7 +33,7 @@ export const DashboardGroupZodSchema = z.object({
 export const DashboardConfigZodSchema = z.object({
   version: z.number(),
   groups: z.array(DashboardGroupZodSchema),
-  widgets: z.array(StoredWidgetConfigSchema),
+  widgets: z.array(WidgetConfigSchema),
 }).strict()
 
 export const DashboardResponseZodSchema = z.object({
@@ -40,7 +51,7 @@ export const DashboardApiResponseZodSchema = z.union([
 
 export const DashboardWidgetDataResponseZodSchema = z.union([
   z.object({
-    widget: StoredWidgetConfigSchema,
+    widget: WidgetConfigSchema,
     data: z.unknown(),
   }),
   DashboardErrorResponseZodSchema,
@@ -50,11 +61,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(),
@@ -96,24 +102,138 @@ export const MoveWidgetRequestZodSchema = z.object({
   direction: z.enum(['up', 'down']),
 }).strict()
 
+const ConfigurableTableWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('table'),
+  table: TableViewConfigSchema.optional(),
+  query: QueryConfigSchema,
+})
+
+const ConfigurableKpiCardWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('kpi_card'),
+  card: KpiCardViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableGaugeCardWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('gauge_card'),
+  card: GaugeCardViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableLineChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: LineChartSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableBarChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: BarChartSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableStackedBarChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: StackedBarChartSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurablePieChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: PieChartSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableHistogramChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: HistogramChartSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableFunnelChartWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: FunnelChartSchema,
+  query: FunnelQueryConfigSchema,
+})
+
+const ConfigurablePivotTableWidgetConfigSchema = WidgetEditableBaseSchema.extend({
+  target: z.literal('pivot_table'),
+  pivot: PivotTableViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+const ConfigurableChartWidgetConfigSchema = z.union([
+  ConfigurableLineChartWidgetConfigSchema,
+  ConfigurableBarChartWidgetConfigSchema,
+  ConfigurableStackedBarChartWidgetConfigSchema,
+  ConfigurablePieChartWidgetConfigSchema,
+  ConfigurableHistogramChartWidgetConfigSchema,
+  ConfigurableFunnelChartWidgetConfigSchema,
+])
+
+export const ConfigurableWidgetConfigSchema = z.union([
+  ConfigurableTableWidgetConfigSchema,
+  ConfigurableKpiCardWidgetConfigSchema,
+  ConfigurableGaugeCardWidgetConfigSchema,
+  ConfigurableChartWidgetConfigSchema,
+  ConfigurablePivotTableWidgetConfigSchema,
+])
+
 export const SetWidgetConfigRequestZodSchema = z.object({
   slug: z.string(),
   widgetId: z.string(),
-  config: EditableDashboardWidgetConfigSchema,
+  config: ConfigurableWidgetConfigSchema,
 }).strict()
 
-export const DashboardErrorResponseSchema = toAdminForthJsonSchema(DashboardErrorResponseZodSchema)
-export const DashboardGroupSchema = toAdminForthJsonSchema(DashboardGroupZodSchema)
-export const DashboardConfigSchema = toAdminForthJsonSchema(DashboardConfigZodSchema)
-export const DashboardResponseSchema = toAdminForthJsonSchema(DashboardResponseZodSchema)
-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)
-export const WidgetIdRequestSchema = toAdminForthJsonSchema(WidgetIdRequestZodSchema)
-export const WidgetDataRequestSchema = toAdminForthJsonSchema(WidgetDataRequestZodSchema)
-export const MoveWidgetRequestSchema = toAdminForthJsonSchema(MoveWidgetRequestZodSchema)
-export const SetWidgetConfigRequestSchema = toAdminForthJsonSchema(SetWidgetConfigRequestZodSchema)
+function configureWidgetRequestSchema<T extends z.ZodTypeAny>(configSchema: T) {
+  return z.object({
+    slug: z.string(),
+    widgetId: z.string(),
+    config: configSchema,
+  }).strict()
+}
+
+export const ConfigureTableWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableTableWidgetConfigSchema)
+export const ConfigureKpiCardWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableKpiCardWidgetConfigSchema)
+export const ConfigureGaugeCardWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableGaugeCardWidgetConfigSchema)
+export const ConfigureLineChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableLineChartWidgetConfigSchema)
+export const ConfigureBarChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableBarChartWidgetConfigSchema)
+export const ConfigureStackedBarChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableStackedBarChartWidgetConfigSchema)
+export const ConfigurePieChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurablePieChartWidgetConfigSchema)
+export const ConfigureHistogramChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableHistogramChartWidgetConfigSchema)
+export const ConfigureFunnelChartWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurableFunnelChartWidgetConfigSchema)
+export const ConfigurePivotTableWidgetRequestZodSchema = configureWidgetRequestSchema(ConfigurablePivotTableWidgetConfigSchema)
+
+export const DashboardMutationResponseZodSchema = z.union([
+  z.object({
+    ok: z.literal(true),
+    slug: z.string(),
+    widgetId: z.string().optional(),
+    groupId: z.string().optional(),
+    target: z.string().optional(),
+    revision: z.number().optional(),
+  }).strict(),
+  DashboardErrorResponseZodSchema,
+])
+
+export const DashboardApiResponseSchema = toJSONSchema(DashboardApiResponseZodSchema, { target: 'draft-07' })
+export const DashboardWidgetDataResponseSchema = toJSONSchema(DashboardWidgetDataResponseZodSchema, { target: 'draft-07' })
+export const SlugRequestSchema = toJSONSchema(SlugRequestZodSchema, { target: 'draft-07' })
+export const GroupIdRequestSchema = toJSONSchema(GroupIdRequestZodSchema, { target: 'draft-07' })
+export const MoveGroupRequestSchema = toJSONSchema(MoveGroupRequestZodSchema, { target: 'draft-07' })
+export const SetGroupConfigRequestSchema = toJSONSchema(SetGroupConfigRequestZodSchema, { target: 'draft-07' })
+export const WidgetIdRequestSchema = toJSONSchema(WidgetIdRequestZodSchema, { target: 'draft-07' })
+export const WidgetDataRequestSchema = toJSONSchema(WidgetDataRequestZodSchema, { target: 'draft-07' })
+export const MoveWidgetRequestSchema = toJSONSchema(MoveWidgetRequestZodSchema, { target: 'draft-07' })
+export const DashboardMutationResponseSchema = toJSONSchema(DashboardMutationResponseZodSchema, { target: 'draft-07' })
+export const SetWidgetConfigRequestSchema = toJSONSchema(SetWidgetConfigRequestZodSchema, { target: 'draft-07' })
+export const ConfigureTableWidgetRequestSchema = toJSONSchema(ConfigureTableWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureKpiCardWidgetRequestSchema = toJSONSchema(ConfigureKpiCardWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureGaugeCardWidgetRequestSchema = toJSONSchema(ConfigureGaugeCardWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureLineChartWidgetRequestSchema = toJSONSchema(ConfigureLineChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureBarChartWidgetRequestSchema = toJSONSchema(ConfigureBarChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureStackedBarChartWidgetRequestSchema = toJSONSchema(ConfigureStackedBarChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigurePieChartWidgetRequestSchema = toJSONSchema(ConfigurePieChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureHistogramChartWidgetRequestSchema = toJSONSchema(ConfigureHistogramChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigureFunnelChartWidgetRequestSchema = toJSONSchema(ConfigureFunnelChartWidgetRequestZodSchema, { target: 'draft-07' })
+export const ConfigurePivotTableWidgetRequestSchema = toJSONSchema(ConfigurePivotTableWidgetRequestZodSchema, { target: 'draft-07' })