@adminforth/dashboard 1.3.0 → 1.4.1

package/dist/schema/widget.js

@@ -28,6 +28,14 @@ const FieldRefSchema = z.union([
         format: ValueFormatSchema,
     }).strict(),
 ]);
+const JsonValueSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema),
+]));
 const FilterExpressionSchema = z.lazy(() => z.union([
     z.array(FilterExpressionSchema),
     z.object({
@@ -38,16 +46,16 @@ const FilterExpressionSchema = 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(),
 ]));
 const QueryAggregateOperationSchema = z.enum([
@@ -62,7 +70,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({
     agg: QueryAggregateOperationSchema,
@@ -72,7 +80,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}`,
         });
@@ -92,7 +100,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(),
 ]);
@@ -102,13 +110,13 @@ const QueryOrderByItemSchema = z.object({
 }).strict();
 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({
     field: z.string(),
@@ -122,16 +130,17 @@ const QueryCalcItemSchema = z.object({
     calc: z.string(),
     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(),
@@ -145,26 +154,30 @@ const FunnelQueryStepSchema = z.object({
 }).strict();
 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'),
     min: z.number().optional(),
@@ -191,8 +204,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(),
 });
 const PieChartSchema = ChartBaseSchema.extend({
@@ -234,8 +247,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({
     title: z.string().optional(),
@@ -251,9 +264,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(),
@@ -268,50 +281,96 @@ const PivotTableViewConfigSchema = z.object({
         aggregation: z.enum(['sum', 'count', 'avg', 'min', 'max']).optional(),
     }).strict()).min(1),
 }).strict();
-export const EmptyWidgetConfigSchema = WidgetBaseSchema.extend({
+const EditableEmptyWidgetConfigSchema = EditableWidgetBaseSchema.extend({
     target: z.literal('empty'),
 });
-const TableWidgetConfigSchema = WidgetBaseSchema.extend({
+export const EmptyWidgetConfigSchema = StoredWidgetBaseSchema.extend({
+    target: z.literal('empty'),
+});
+const EditableTableWidgetConfigSchema = EditableWidgetBaseSchema.extend({
+    target: z.literal('table'),
+    table: TableViewConfigSchema.optional(),
+    query: QueryConfigSchema,
+});
+const TableWidgetConfigSchema = StoredWidgetBaseSchema.extend({
     target: z.literal('table'),
     table: TableViewConfigSchema.optional(),
     query: QueryConfigSchema,
 });
-const ChartWidgetTargetConfigSchema = WidgetBaseSchema.extend({
+const EditableChartWidgetTargetConfigSchema = EditableWidgetBaseSchema.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) {
+    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 GaugeCardWidgetConfigSchema = WidgetBaseSchema.extend({
+const KpiCardWidgetConfigSchema = StoredWidgetBaseSchema.extend({
+    target: z.literal('kpi_card'),
+    card: KpiCardViewConfigSchema,
+    query: QueryConfigSchema,
+});
+const EditableGaugeCardWidgetConfigSchema = EditableWidgetBaseSchema.extend({
+    target: z.literal('gauge_card'),
+    card: GaugeCardViewConfigSchema,
+    query: QueryConfigSchema,
+});
+const GaugeCardWidgetConfigSchema = StoredWidgetBaseSchema.extend({
     target: z.literal('gauge_card'),
     card: GaugeCardViewConfigSchema,
     query: QueryConfigSchema,
 });
-const PivotTableWidgetConfigSchema = WidgetBaseSchema.extend({
+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', [
     EmptyWidgetConfigSchema,

package/dist/services/dashboardConfigService.d.ts

@@ -8,13 +8,6 @@ export type DashboardRecord = {
     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;
@@ -22,14 +15,11 @@ export type PersistedDashboardResponse = {
     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

@@ -8,27 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Filters } from 'adminforth';
-import { normalizeDashboardConfig } 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 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}`;
+    const parsedConfig = typeof config === 'string' ? JSON.parse(config) : config;
+    return DashboardConfigZodSchema.parse(parsedConfig);
 }
-export function normalizeDashboardOrder(config) {
+function normalizeDashboardOrder(config) {
     var _a;
     const widgetsByGroupId = new Map();
     for (const widget of config.widgets) {
@@ -55,7 +41,7 @@ export function persistDashboardConfig(adminforth, dashboardConfigsResourceId, d
             config: normalizedConfig,
             revision: dashboard.revision + 1,
         });
-        yield adminforth.websocket.publish(dashboardConfigUpdatedTopic(dashboard.slug), {
+        yield adminforth.websocket.publish(getDashboardConfigUpdatedTopic(dashboard.slug), {
             id: dashboard.id,
             slug: dashboard.slug,
             revision: dashboard.revision + 1,
@@ -74,6 +60,5 @@ export function createDashboardConfigService(adminforth, dashboardConfigsResourc
         getDashboardRecord: (slug) => getDashboardRecord(adminforth, dashboardConfigsResourceId, slug),
         parseStoredDashboardConfig,
         persistDashboardConfig: (dashboard, config) => persistDashboardConfig(adminforth, dashboardConfigsResourceId, dashboard, config),
-        buildDashboardResponse,
     };
 }

package/dist/services/widgetDataService.d.ts

@@ -1,10 +1,11 @@
 import type { IAdminForth } from 'adminforth';
-import type { DashboardWidgetConfig, DashboardWidgetData } from '../custom/model/dashboard.types.js';
+import type { DashboardWidgetConfig, DashboardWidgetData, DashboardVariables } from '../custom/model/dashboard.types.js';
 export type DashboardWidgetDataOptions = {
     pagination?: {
         page: number;
         pageSize: number;
     };
+    variables?: DashboardVariables;
 };
 export type WidgetDataService = {
     getWidgetData: (widget: DashboardWidgetConfig, options?: DashboardWidgetDataOptions) => Promise<DashboardWidgetData | null>;