@adminforth/dashboard 1.4.2 → 1.6.0

package/dist/endpoint/dashboard.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { DashboardApiResponseSchema, SetDashboardConfigRequestSchema, SlugRequestSchema, } from '../schema/api.js';
+import { DashboardApiResponseSchema, SlugRequestSchema, } from '../schema/api.js';
 export function registerDashboardEndpoints(server, ctx) {
     server.endpoint({
         method: 'POST',
@@ -30,24 +30,4 @@ export function registerDashboardEndpoints(server, ctx) {
             };
         }),
     });
-    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: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
-            if (!ctx.canEditDashboard(adminUser)) {
-                response.setStatus(403);
-                return { error: 'Dashboard edit is not allowed' };
-            }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
-                response.setStatus(404);
-                return { error: 'Dashboard not found' };
-            }
-            const config = body.config;
-            return ctx.persistDashboardConfig(dashboard, config);
-        }),
-    });
 }

package/dist/endpoint/groups.d.ts

@@ -6,6 +6,7 @@ type GroupEndpointsContext = {
     getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
     parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
     persistDashboardConfig: (dashboard: DashboardRecord, config: DashboardConfig) => Promise<PersistedDashboardResponse>;
+    updateDashboardConfig: (slug: string, mutateConfig: (config: DashboardConfig, dashboard: DashboardRecord) => DashboardConfig | null | Promise<DashboardConfig | null>) => Promise<PersistedDashboardResponse | null>;
 };
 export declare function registerGroupEndpoints(server: IHttpServer, ctx: GroupEndpointsContext): void;
 export {};

package/dist/endpoint/groups.js

@@ -21,19 +21,20 @@ export function registerGroupEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            const updatedDashboard = yield ctx.updateDashboardConfig(body.slug, (config) => {
+                const nextOrder = config.groups.length + 1;
+                const group = {
+                    id: `group_${randomUUID()}`,
+                    label: 'New group',
+                    order: nextOrder,
+                };
+                return Object.assign(Object.assign({}, config), { groups: [...config.groups, group] });
+            });
+            if (!updatedDashboard) {
                 response.setStatus(404);
                 return { error: 'Dashboard not found' };
             }
-            const config = ctx.parseStoredDashboardConfig(dashboard.config);
-            const nextOrder = config.groups.length + 1;
-            const group = {
-                id: `group_${randomUUID()}`,
-                label: 'New group',
-                order: nextOrder,
-            };
-            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { groups: [...config.groups, group] }));
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -48,21 +49,27 @@ export function registerGroupEndpoints(server, ctx) {
                 return { error: 'Dashboard edit is not allowed' };
             }
             const groupId = body.groupId;
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield 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 = Object.assign(Object.assign({}, body.config), { id: group.id, order: group.order });
+                return Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, body.config), { id: group.id, order: group.order });
-            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { groups: config.groups.map((item) => item.id === groupId
-                    ? nextGroup
-                    : item) }));
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -76,32 +83,32 @@ export function registerGroupEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield 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 (currentIndex === -1) {
+                    mutationError = 'Dashboard group not found';
+                    return null;
+                }
+                const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+                if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
+                    return null;
+                }
+                const reorderedGroups = [...sortedGroups];
+                const [group] = reorderedGroups.splice(currentIndex, 1);
+                reorderedGroups.splice(targetIndex, 0, group);
+                return Object.assign(Object.assign({}, config), { groups: reorderedGroups });
+            });
+            if (!updatedDashboard) {
                 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 === body.groupId);
-            if (currentIndex === -1) {
+            if (mutationError) {
                 response.setStatus(404);
-                return { error: 'Dashboard group not found' };
-            }
-            const targetIndex = body.direction === 'up' ? currentIndex - 1 : currentIndex + 1;
-            if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
-                return {
-                    id: dashboard.id,
-                    slug: dashboard.slug,
-                    label: dashboard.label,
-                    revision: dashboard.revision,
-                    config: ctx.parseStoredDashboardConfig(dashboard.config),
-                };
+                return { error: mutationError };
             }
-            const reorderedGroups = [...sortedGroups];
-            const [group] = reorderedGroups.splice(currentIndex, 1);
-            reorderedGroups.splice(targetIndex, 0, group);
-            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { groups: reorderedGroups }));
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -116,18 +123,24 @@ export function registerGroupEndpoints(server, ctx) {
                 return { error: 'Dashboard edit is not allowed' };
             }
             const groupId = body.groupId;
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield 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 Object.assign(Object.assign({}, config), { groups: nextGroups, widgets: config.widgets.filter((widget) => widget.group_id !== groupId) });
+            });
+            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, Object.assign(Object.assign({}, config), { groups: nextGroups, widgets: config.widgets.filter((widget) => widget.group_id !== groupId) }));
+            return updatedDashboard;
         }),
     });
 }

package/dist/endpoint/widgets.d.ts

@@ -6,6 +6,7 @@ type WidgetEndpointsContext = {
     getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
     parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
     persistDashboardConfig: (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?: {
         pagination?: {
             page: number;

package/dist/endpoint/widgets.js

@@ -8,7 +8,53 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { randomUUID } from 'crypto';
-import { DashboardApiResponseSchema, DashboardWidgetDataResponseSchema, GroupIdRequestSchema, MoveWidgetRequestSchema, SetWidgetConfigRequestSchema, WidgetDataRequestSchema, WidgetIdRequestSchema, } from '../schema/api.js';
+import { ConfigureBarChartWidgetRequestSchema, ConfigureFunnelChartWidgetRequestSchema, ConfigureGaugeCardWidgetRequestSchema, ConfigureHistogramChartWidgetRequestSchema, ConfigureKpiCardWidgetRequestSchema, ConfigureLineChartWidgetRequestSchema, ConfigurePieChartWidgetRequestSchema, ConfigurePivotTableWidgetRequestSchema, ConfigureStackedBarChartWidgetRequestSchema, ConfigureTableWidgetRequestSchema, DashboardApiResponseSchema, DashboardWidgetDataResponseSchema, GroupIdRequestSchema, MoveWidgetRequestSchema, SetWidgetConfigRequestSchema, WidgetDataRequestSchema, WidgetIdRequestSchema, } from '../schema/api.js';
+function replaceWidgetConfig(ctx, slug, widgetId, widgetConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let mutationError = null;
+        const updatedDashboard = yield ctx.updateDashboardConfig(slug, (config) => {
+            const widget = config.widgets.find((item) => item.id === widgetId);
+            if (!widget) {
+                mutationError = 'Dashboard widget not found';
+                return null;
+            }
+            const nextWidget = Object.assign(Object.assign({}, widgetConfig), { id: widget.id, group_id: widget.group_id, order: widget.order });
+            return Object.assign(Object.assign({}, config), { widgets: config.widgets.map((item) => item.id === widgetId
+                    ? nextWidget
+                    : item) });
+        });
+        return {
+            updatedDashboard,
+            mutationError,
+        };
+    });
+}
+function registerConfigureWidgetEndpoint(server, ctx, options) {
+    server.endpoint({
+        method: 'POST',
+        path: options.path,
+        description: options.description,
+        request_schema: options.requestSchema,
+        response_schema: DashboardApiResponseSchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, adminUser, response }) {
+            if (!ctx.canEditDashboard(adminUser)) {
+                response.setStatus(403);
+                return { error: 'Dashboard edit is not allowed' };
+            }
+            const request = body;
+            const { updatedDashboard, mutationError } = yield 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, ctx) {
     server.endpoint({
         method: 'POST',
@@ -21,27 +67,33 @@ export function registerWidgetEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield 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 = {
+                    id: `widget_${randomUUID()}`,
+                    group_id: body.groupId,
+                    label: 'New widget',
+                    size: 'small',
+                    order: nextOrder,
+                    target: 'empty',
+                };
+                return Object.assign(Object.assign({}, 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' };
-            }
-            const nextOrder = config.widgets.filter((item) => item.group_id === body.groupId).length + 1;
-            const widget = {
-                id: `widget_${randomUUID()}`,
-                group_id: body.groupId,
-                label: 'New widget',
-                size: 'small',
-                order: nextOrder,
-                target: 'empty',
-            };
-            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { widgets: [...config.widgets, widget] }));
+                return { error: mutationError };
+            }
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -55,39 +107,39 @@ export function registerWidgetEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield ctx.updateDashboardConfig(body.slug, (config) => {
+                const widget = config.widgets.find((item) => item.id === body.widgetId);
+                if (!widget) {
+                    mutationError = 'Dashboard widget not found';
+                    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;
+                if (targetIndex < 0 || targetIndex >= sortedWidgets.length) {
+                    return null;
+                }
+                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 Object.assign(Object.assign({}, config), { widgets: config.widgets.map((item) => {
+                        var _a;
+                        return (Object.assign(Object.assign({}, item), { order: (_a = reorderedWidgetIds.get(item.id)) !== null && _a !== void 0 ? _a : item.order }));
+                    }) });
+            });
+            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' };
-            }
-            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 (targetIndex < 0 || targetIndex >= sortedWidgets.length) {
-                return {
-                    id: dashboard.id,
-                    slug: dashboard.slug,
-                    label: dashboard.label,
-                    revision: dashboard.revision,
-                    config: ctx.parseStoredDashboardConfig(dashboard.config),
-                };
+                return { error: mutationError };
             }
-            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, Object.assign(Object.assign({}, config), { widgets: config.widgets.map((item) => {
-                    var _a;
-                    return (Object.assign(Object.assign({}, item), { order: (_a = reorderedWidgetIds.get(item.id)) !== null && _a !== void 0 ? _a : item.order }));
-                }) }));
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -101,18 +153,24 @@ export function registerWidgetEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            let mutationError = null;
+            const updatedDashboard = yield ctx.updateDashboardConfig(body.slug, (config) => {
+                const nextWidgets = config.widgets.filter((item) => item.id !== body.widgetId);
+                if (nextWidgets.length === config.widgets.length) {
+                    mutationError = 'Dashboard widget not found';
+                    return null;
+                }
+                return Object.assign(Object.assign({}, 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, Object.assign(Object.assign({}, config), { widgets: nextWidgets }));
+            return updatedDashboard;
         }),
     });
     server.endpoint({
@@ -126,24 +184,69 @@ export function registerWidgetEndpoints(server, ctx) {
                 response.setStatus(403);
                 return { error: 'Dashboard edit is not allowed' };
             }
-            const dashboard = yield ctx.getDashboardRecord(body.slug);
-            if (!dashboard) {
+            const request = body;
+            const { updatedDashboard, mutationError } = yield replaceWidgetConfig(ctx, request.slug, request.widgetId, request.config);
+            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;
-            const nextWidget = Object.assign(Object.assign({}, typedWidgetConfig), { id: widget.id, group_id: widget.group_id, order: widget.order });
-            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { widgets: config.widgets.map((item) => item.id === body.widgetId
-                    ? nextWidget
-                    : item) }));
+            return updatedDashboard;
         }),
     });
+    registerConfigureWidgetEndpoint(server, ctx, {
+        path: '/dashboard/configure_table_widget',
+        description: 'Configures an existing dashboard widget as a table. Superadmin only.',
+        requestSchema: ConfigureTableWidgetRequestSchema,
+    });
+    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({
         method: 'POST',
         path: '/dashboard/get_dashboard_widget_data',