@adminforth/dashboard 1.3.0 → 1.4.1

package/schema/widget.ts

@@ -1,10 +1,5 @@
 import { z } from 'zod'
-
-export type DashboardWidgetConfigValidationError = {
-  field: string
-  message: string
-}
-
+export type { DashboardWidgetConfigValidationError } from '../custom/model/dashboard.types.js'
 const DashboardWidgetSizeSchema = z.enum([
   'small',
   'medium',
@@ -38,6 +33,15 @@ const FieldRefSchema = z.union([
   }).strict(),
 ])
 
+const JsonValueSchema: z.ZodType = z.lazy(() => z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null(),
+  z.array(JsonValueSchema),
+  z.record(z.string(), JsonValueSchema),
+]))
+
 const FilterExpressionSchema: z.ZodType = z.lazy(() => z.union([
   z.array(FilterExpressionSchema),
   z.object({
@@ -48,16 +52,16 @@ const FilterExpressionSchema: z.ZodType = z.lazy(() => z.union([
   }).strict(),
   z.object({
     field: z.string(),
-    eq: z.unknown().optional(),
-    neq: z.unknown().optional(),
-    gt: z.unknown().optional(),
-    gte: z.unknown().optional(),
-    lt: z.unknown().optional(),
-    lte: z.unknown().optional(),
-    in: z.array(z.unknown()).optional(),
-    not_in: z.array(z.unknown()).optional(),
-    like: z.unknown().optional(),
-    ilike: z.unknown().optional(),
+    eq: JsonValueSchema.optional(),
+    neq: JsonValueSchema.optional(),
+    gt: JsonValueSchema.optional(),
+    gte: JsonValueSchema.optional(),
+    lt: JsonValueSchema.optional(),
+    lte: JsonValueSchema.optional(),
+    in: z.array(JsonValueSchema).optional(),
+    not_in: z.array(JsonValueSchema).optional(),
+    like: JsonValueSchema.optional(),
+    ilike: JsonValueSchema.optional(),
   }).strict(),
 ]))
 
@@ -74,7 +78,7 @@ const QueryAggregateOperationSchema = z.enum([
 const QueryFieldSelectItemSchema = z.object({
   field: z.string(),
   as: z.string().optional(),
-  grain: z.enum(['hour', 'day', 'week', 'month', 'quarter', 'year']).optional(),
+  grain: z.enum(['day', 'week', 'month', 'year']).optional(),
 }).strict()
 
 const QueryAggregateSelectItemSchema = z.object({
@@ -85,7 +89,7 @@ const QueryAggregateSelectItemSchema = z.object({
 }).strict().superRefine((item, ctx) => {
   if (!['count'].includes(item.agg) && !item.field) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: 'custom',
       path: ['field'],
       message: `field is required for ${item.agg}`,
     })
@@ -108,7 +112,7 @@ const QueryGroupByItemSchema = z.union([
   z.object({
     field: z.string(),
     as: z.string().optional(),
-    grain: z.enum(['hour', 'day', 'week', 'month', 'quarter', 'year']).optional(),
+    grain: z.enum(['day', 'week', 'month', 'year']).optional(),
     timezone: z.string().optional(),
   }).strict(),
 ])
@@ -120,14 +124,14 @@ const QueryOrderByItemSchema = z.object({
 
 const TimeSeriesConfigSchema = z.object({
   field: z.string(),
-  grain: z.enum(['hour', 'day', 'week', 'month', 'quarter', 'year']),
+  grain: z.enum(['day', 'week', 'month', 'year']),
   timezone: z.string().optional(),
 }).strict()
 
 const PeriodConfigSchema = z.object({
   field: z.string(),
-  gte: z.unknown().optional(),
-  lt: z.unknown().optional(),
+  gte: JsonValueSchema.optional(),
+  lt: JsonValueSchema.optional(),
 }).strict()
 
 const BucketConfigSchema = z.object({
@@ -144,17 +148,18 @@ const QueryCalcItemSchema = z.object({
   as: z.string(),
 }).strict()
 
-const FormattingConfigSchema = z.record(z.string(), z.unknown())
+const FormattingConfigSchema = z.record(z.string(), JsonValueSchema)
+const VariablesConfigSchema = z.record(z.string(), JsonValueSchema)
 
 export const QueryConfigSchema = z.object({
   resource: z.string(),
   select: z.array(QuerySelectItemSchema).optional(),
   filters: FilterExpressionSchema.optional(),
-  groupBy: z.array(QueryGroupByItemSchema).optional(),
-  orderBy: z.array(QueryOrderByItemSchema).optional(),
+  group_by: z.array(QueryGroupByItemSchema).optional(),
+  order_by: z.array(QueryOrderByItemSchema).optional(),
   limit: z.number().int().positive().optional(),
   offset: z.number().int().nonnegative().optional(),
-  timeSeries: TimeSeriesConfigSchema.optional(),
+  time_series: TimeSeriesConfigSchema.optional(),
   period: PeriodConfigSchema.optional(),
   bucket: BucketConfigSchema.optional(),
   calcs: z.array(QueryCalcItemSchema).optional(),
@@ -170,29 +175,34 @@ const FunnelQueryStepSchema = z.object({
 
 export const FunnelQueryConfigSchema = z.object({
   steps: z.array(FunnelQueryStepSchema).min(1),
+  calcs: z.array(QueryCalcItemSchema).optional(),
 }).strict()
 
-const WidgetBaseSchema = z.object({
-  id: z.string().optional(),
-  group_id: z.string().optional(),
+const EditableWidgetBaseSchema = z.object({
   label: z.string().optional(),
+  variables: VariablesConfigSchema.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(),
+  min_width: z.number().nonnegative('Min width must be a non-negative number').optional(),
+  max_width: z.number().nonnegative('Max width must be a non-negative number').nullable().optional(),
+}).strict()
+
+const StoredWidgetBaseSchema = EditableWidgetBaseSchema.extend({
+  id: z.string(),
+  group_id: z.string(),
+  order: z.number(),
 })
 
 const TableViewConfigSchema = z.object({
   columns: z.array(FieldRefSchema).optional(),
   pagination: z.boolean().optional(),
-  pageSize: z.number().int().positive().optional(),
+  page_size: z.number().int().positive().optional(),
 }).strict()
 
 const ChartBaseSchema = z.object({
   title: z.string().optional(),
-})
+}).strict()
 
 const ChartBucketSchema = z.object({
   label: z.string().min(1, 'Bucket label is required'),
@@ -224,8 +234,8 @@ const BarChartSchema = ChartBaseSchema.extend({
 const StackedBarChartSchema = ChartBaseSchema.extend({
   type: z.literal('stacked_bar'),
   x: ChartFieldRefSchema,
-  y: ChartFieldRefSchema,
-  series: ChartSeriesRefSchema,
+  y: z.union([ChartFieldRefSchema, z.array(ChartFieldRefSchema).min(1)]),
+  series: ChartSeriesRefSchema.optional(),
   colors: z.array(z.string()).optional(),
 })
 
@@ -272,8 +282,8 @@ const KpiCardViewConfigSchema = z.object({
     text: z.string().optional(),
     field: z.string().optional(),
   }).strict().optional(),
-  comparison: z.unknown().optional(),
-  sparkline: z.unknown().optional(),
+  comparison: JsonValueSchema.optional(),
+  sparkline: JsonValueSchema.optional(),
 }).strict()
 
 const GaugeCardViewConfigSchema = z.object({
@@ -290,9 +300,9 @@ const GaugeCardViewConfigSchema = z.object({
     label: z.string().optional(),
   }).strict().optional(),
   progress: z.object({
-    valueField: z.string(),
-    targetValue: z.number().optional(),
-    targetField: z.string().optional(),
+    value_field: z.string(),
+    target_value: z.number().optional(),
+    target_field: z.string().optional(),
     format: ValueFormatSchema,
   }).strict().optional(),
   color: z.string().optional(),
@@ -309,17 +319,27 @@ const PivotTableViewConfigSchema = z.object({
   }).strict()).min(1),
 }).strict()
 
-export const EmptyWidgetConfigSchema = WidgetBaseSchema.extend({
+const EditableEmptyWidgetConfigSchema = EditableWidgetBaseSchema.extend({
+  target: z.literal('empty'),
+})
+
+export const EmptyWidgetConfigSchema = StoredWidgetBaseSchema.extend({
   target: z.literal('empty'),
 })
 
-const TableWidgetConfigSchema = WidgetBaseSchema.extend({
+const EditableTableWidgetConfigSchema = EditableWidgetBaseSchema.extend({
   target: z.literal('table'),
   table: TableViewConfigSchema.optional(),
   query: QueryConfigSchema,
 })
 
-const ChartWidgetTargetConfigSchema = WidgetBaseSchema.extend({
+const TableWidgetConfigSchema = StoredWidgetBaseSchema.extend({
+  target: z.literal('table'),
+  table: TableViewConfigSchema.optional(),
+  query: QueryConfigSchema,
+})
+
+const EditableChartWidgetTargetConfigSchema = EditableWidgetBaseSchema.extend({
   target: z.literal('chart'),
   chart: ChartConfigSchema,
   query: z.union([QueryConfigSchema, FunnelQueryConfigSchema]),
@@ -327,39 +347,83 @@ const ChartWidgetTargetConfigSchema = WidgetBaseSchema.extend({
   const isFunnelChart = widget.chart.type === 'funnel'
   const isFunnelQuery = 'steps' in widget.query
 
-  if (isFunnelChart !== isFunnelQuery) {
+  if (isFunnelChart && !isFunnelQuery) {
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: 'custom',
       path: ['query'],
-      message: 'Funnel charts must use steps query, other charts must use resource query',
+      message: 'Funnel charts must use steps query',
     })
   }
 })
 
-const KpiCardWidgetConfigSchema = WidgetBaseSchema.extend({
+const ChartWidgetTargetConfigSchema = StoredWidgetBaseSchema.extend({
+  target: z.literal('chart'),
+  chart: ChartConfigSchema,
+  query: z.union([QueryConfigSchema, FunnelQueryConfigSchema]),
+}).superRefine((widget, ctx) => {
+  const isFunnelChart = widget.chart.type === 'funnel'
+  const isFunnelQuery = 'steps' in widget.query
+
+  if (isFunnelChart && !isFunnelQuery) {
+    ctx.addIssue({
+      code: 'custom',
+      path: ['query'],
+      message: 'Funnel charts must use steps query',
+    })
+  }
+})
+
+const EditableKpiCardWidgetConfigSchema = EditableWidgetBaseSchema.extend({
+  target: z.literal('kpi_card'),
+  card: KpiCardViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+const KpiCardWidgetConfigSchema = StoredWidgetBaseSchema.extend({
   target: z.literal('kpi_card'),
   card: KpiCardViewConfigSchema,
   query: QueryConfigSchema,
 })
 
-const GaugeCardWidgetConfigSchema = WidgetBaseSchema.extend({
+const EditableGaugeCardWidgetConfigSchema = EditableWidgetBaseSchema.extend({
   target: z.literal('gauge_card'),
   card: GaugeCardViewConfigSchema,
   query: QueryConfigSchema,
 })
 
-const PivotTableWidgetConfigSchema = WidgetBaseSchema.extend({
+const GaugeCardWidgetConfigSchema = StoredWidgetBaseSchema.extend({
+  target: z.literal('gauge_card'),
+  card: GaugeCardViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+const EditablePivotTableWidgetConfigSchema = EditableWidgetBaseSchema.extend({
   target: z.literal('pivot_table'),
   pivot: PivotTableViewConfigSchema,
   query: QueryConfigSchema,
 })
 
+const PivotTableWidgetConfigSchema = StoredWidgetBaseSchema.extend({
+  target: z.literal('pivot_table'),
+  pivot: PivotTableViewConfigSchema,
+  query: QueryConfigSchema,
+})
+
+export const EditableDashboardWidgetConfigSchema = z.discriminatedUnion('target', [
+  EditableEmptyWidgetConfigSchema,
+  EditableTableWidgetConfigSchema,
+  EditableChartWidgetTargetConfigSchema,
+  EditableKpiCardWidgetConfigSchema,
+  EditableGaugeCardWidgetConfigSchema,
+  EditablePivotTableWidgetConfigSchema,
+])
+
 export const WidgetConfigSchema = z.discriminatedUnion('target', [
-  TableWidgetConfigSchema,
-  ChartWidgetTargetConfigSchema,
-  KpiCardWidgetConfigSchema,
-  GaugeCardWidgetConfigSchema,
-  PivotTableWidgetConfigSchema,
+  EditableTableWidgetConfigSchema,
+  EditableChartWidgetTargetConfigSchema,
+  EditableKpiCardWidgetConfigSchema,
+  EditableGaugeCardWidgetConfigSchema,
+  EditablePivotTableWidgetConfigSchema,
 ])
 
 export const StoredWidgetConfigSchema = z.discriminatedUnion('target', [

package/services/dashboardConfigService.ts

@@ -1,9 +1,8 @@
 import { Filters } from 'adminforth';
 import type { IAdminForth } from 'adminforth';
-import { normalizeDashboardConfig } from '../custom/model/dashboard.types.js';
 import type { DashboardConfig, DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
-
-const DASHBOARD_CONFIG_UPDATED_TOPIC_PREFIX = '/opentopic/dashboard-config-updated';
+import { getDashboardConfigUpdatedTopic } from '../custom/model/dashboardTopics.js';
+import { DashboardConfigZodSchema } from '../schema/api.js';
 
 export type DashboardRecord = {
   id: string;
@@ -14,21 +13,9 @@ export type DashboardRecord = {
 };
 
 export function parseStoredDashboardConfig(config: unknown): DashboardConfig {
-  if (typeof config === 'string') {
-    return normalizeDashboardConfig(JSON.parse(config));
-  }
+  const parsedConfig = typeof config === 'string' ? JSON.parse(config) : config;
 
-  return normalizeDashboardConfig(config);
-}
-
-export function buildDashboardResponse(dashboard: DashboardRecord) {
-  return {
-    id: dashboard.id,
-    slug: dashboard.slug,
-    label: dashboard.label,
-    revision: dashboard.revision,
-    config: parseStoredDashboardConfig(dashboard.config),
-  };
+  return DashboardConfigZodSchema.parse(parsedConfig) as DashboardConfig;
 }
 
 export type PersistedDashboardResponse = {
@@ -39,11 +26,7 @@ export type PersistedDashboardResponse = {
   config: DashboardConfig;
 };
 
-export function dashboardConfigUpdatedTopic(slug: string) {
-  return `${DASHBOARD_CONFIG_UPDATED_TOPIC_PREFIX}/${slug}`;
-}
-
-export function normalizeDashboardOrder(config: DashboardConfig): DashboardConfig {
+function normalizeDashboardOrder(config: DashboardConfig): DashboardConfig {
   const widgetsByGroupId = new Map<string, DashboardWidgetConfig[]>();
 
   for (const widget of config.widgets) {
@@ -93,7 +76,7 @@ export async function persistDashboardConfig(
     revision: dashboard.revision + 1,
   });
 
-  await adminforth.websocket.publish(dashboardConfigUpdatedTopic(dashboard.slug), {
+  await adminforth.websocket.publish(getDashboardConfigUpdatedTopic(dashboard.slug), {
     id: dashboard.id,
     slug: dashboard.slug,
     revision: dashboard.revision + 1,
@@ -115,7 +98,6 @@ export type DashboardConfigService = {
     dashboard: DashboardRecord,
     config: DashboardConfig,
   ) => Promise<PersistedDashboardResponse>;
-  buildDashboardResponse: typeof buildDashboardResponse;
 };
 
 export function createDashboardConfigService(
@@ -131,6 +113,5 @@ export function createDashboardConfigService(
       dashboard,
       config,
     ),
-    buildDashboardResponse,
   };
 }