@adminforth/dashboard 1.5.0 → 1.7.0

package/dist/schema/widgets/table.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const TableViewConfigSchema: z.ZodObject<{
+    columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        format: z.ZodOptional<z.ZodEnum<{
+            number: "number";
+            integer: "integer";
+            compact_number: "compact_number";
+            currency: "currency";
+            percent: "percent";
+            percent_delta: "percent_delta";
+            number_delta: "number_delta";
+            currency_delta: "currency_delta";
+        }>>;
+    }, z.core.$strict>>>;
+    pagination: z.ZodOptional<z.ZodBoolean>;
+    page_size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const TableWidgetConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    group_id: z.ZodString;
+    order: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    size: z.ZodOptional<z.ZodEnum<{
+        small: "small";
+        medium: "medium";
+        large: "large";
+        wide: "wide";
+        full: "full";
+    }>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    min_width: z.ZodOptional<z.ZodNumber>;
+    max_width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    target: z.ZodLiteral<"table">;
+    table: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodEnum<{
+                number: "number";
+                integer: "integer";
+                compact_number: "compact_number";
+                currency: "currency";
+                percent: "percent";
+                percent_delta: "percent_delta";
+                number_delta: "number_delta";
+                currency_delta: "currency_delta";
+            }>>;
+        }, z.core.$strict>>>;
+        pagination: z.ZodOptional<z.ZodBoolean>;
+        page_size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    query: z.ZodObject<{
+        resource: z.ZodString;
+        select: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            grain: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            agg: z.ZodEnum<{
+                sum: "sum";
+                count: "count";
+                count_distinct: "count_distinct";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                median: "median";
+            }>;
+            field: z.ZodOptional<z.ZodString>;
+            as: z.ZodString;
+            filters: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            calc: z.ZodString;
+            as: z.ZodString;
+        }, z.core.$strict>]>>>;
+        sparkline: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            grain: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            as: z.ZodString;
+            fill_missing: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+        filters: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        group_by: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            field: z.ZodString;
+            as: z.ZodOptional<z.ZodString>;
+            grain: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>>;
+            timezone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>>;
+        order_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            direction: z.ZodOptional<z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>>;
+        }, z.core.$strict>>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        bucket: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            buckets: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        calcs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            calc: z.ZodString;
+            as: z.ZodString;
+        }, z.core.$strict>>>;
+        formatting: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schema/widgets/table.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { ChartFieldRefSchema, QueryConfigSchema, WidgetBaseSchema, } from './common.js';
+export const TableViewConfigSchema = z.object({
+    columns: z.array(ChartFieldRefSchema).optional(),
+    pagination: z.boolean().optional(),
+    page_size: z.number().int().positive().optional(),
+}).strict();
+export const TableWidgetConfigSchema = WidgetBaseSchema.extend({
+    target: z.literal('table'),
+    table: TableViewConfigSchema.optional(),
+    query: QueryConfigSchema,
+});

package/dist/services/widgetDataService.js

@@ -11,7 +11,8 @@ import { Filters, Sorts } from 'adminforth';
 const CALC_IDENTIFIER_RE = /\b[a-zA-Z_][a-zA-Z0-9_]*\b/g;
 const LOOKUP_CALL_RE = /lookup\(\s*(\$variables(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*,\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)/g;
 const VARIABLE_PATH_PREFIX_RE = /^\$variables\.?/;
-const SAFE_CALC_EXPRESSION_RE = /^[\d+\-*/().\s]+$/;
+const SAFE_CALC_EXPRESSION_RE = /^[\d+\-*/().\s?:<>=!]+$/;
+const RELATIVE_DURATION_RE = /^(\d+)(h|d|w|mo|y)$/;
 const FILTER_OPERATORS = {
     eq: Filters.EQ,
     neq: Filters.NEQ,
@@ -78,6 +79,10 @@ function getFunnelWidgetData(adminforth, query, variables) {
 function getQueryWidgetData(adminforth, query, variables) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c;
+        const metricSelect = getSingleAggregateMetricSelect(query);
+        if (metricSelect) {
+            return getMetricWidgetData(adminforth, query, metricSelect);
+        }
         const selectedRows = isAggregateQuery(query)
             ? yield buildAggregateQueryRows(adminforth, query, variables)
             : buildPlainQueryRows(yield getResourceRows(adminforth, query.resource, query.filters, getBackendSort(query.order_by)), query, variables);
@@ -97,6 +102,43 @@ function getQueryWidgetData(adminforth, query, variables) {
         };
     });
 }
+function getMetricWidgetData(adminforth, query, metric) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const [currentValues = {}] = yield getAggregateRows(adminforth, query.resource, query.filters, [metric], []);
+        const values = {
+            [metric.as]: (_a = currentValues[metric.as]) !== null && _a !== void 0 ? _a : 0,
+        };
+        const rows = query.sparkline
+            ? yield getMetricSparklineRows(adminforth, query, metric, getAdminForthFilters(query.filters))
+            : [values];
+        const columns = Array.from(new Set([
+            metric.as,
+            ...(query.sparkline ? [query.sparkline.as] : []),
+        ]));
+        return {
+            kind: 'aggregate',
+            columns,
+            rows,
+            values,
+        };
+    });
+}
+function getMetricSparklineRows(adminforth, query, metric, filters) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sparkline = query.sparkline;
+        const groupBy = [{
+                field: sparkline.field,
+                as: sparkline.as,
+                grain: sparkline.grain,
+            }];
+        const rows = yield getAggregateRows(adminforth, query.resource, filters, [metric], groupBy);
+        return rows.map((row) => {
+            var _a;
+            return (Object.assign(Object.assign({}, (_a = query.sparkline) === null || _a === void 0 ? void 0 : _a.fill_missing), row));
+        });
+    });
+}
 function getResourceRows(adminforth, resourceId, filters, sort) {
     return __awaiter(this, void 0, void 0, function* () {
         return adminforth.resource(resourceId).list(getAdminForthFilters(filters), undefined, 0, sort);
@@ -238,6 +280,18 @@ function isAggregateQuery(query) {
     return Boolean(((_a = query.group_by) === null || _a === void 0 ? void 0 : _a.length)
         || ((_b = query.select) === null || _b === void 0 ? void 0 : _b.some((item) => isAggregateSelectItem(item))));
 }
+function getSingleAggregateMetricSelect(query) {
+    var _a, _b;
+    if ((_a = query.group_by) === null || _a === void 0 ? void 0 : _a.length) {
+        return undefined;
+    }
+    const select = (_b = query.select) !== null && _b !== void 0 ? _b : [];
+    const aggregateItems = select.filter(isAggregateSelectItem);
+    if (aggregateItems.length !== 1 || aggregateItems.length !== select.length) {
+        return undefined;
+    }
+    return aggregateItems[0];
+}
 function isFieldSelectItem(item) {
     return 'field' in item && !('agg' in item);
 }
@@ -454,11 +508,51 @@ function toAdminForthFilter(filter) {
     }
     for (const [operator, createFilter] of Object.entries(FILTER_OPERATORS)) {
         if (Object.prototype.hasOwnProperty.call(filter, operator)) {
-            return createFilter(filter.field, filter[operator]);
+            return createFilter(filter.field, resolveFilterValue(filter[operator]));
         }
     }
     return Filters.AND([]);
 }
+function resolveFilterValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => resolveFilterValue(item));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    if (value.now === true) {
+        return new Date().toISOString();
+    }
+    if (typeof value.now_minus === 'string') {
+        return subtractDuration(new Date(), value.now_minus).toISOString();
+    }
+    return value;
+}
+function subtractDuration(now, duration) {
+    const match = duration.match(RELATIVE_DURATION_RE);
+    if (!match) {
+        throw new Error(`Unsupported relative date duration: ${duration}`);
+    }
+    const amount = Number(match[1]);
+    const unit = match[2];
+    const date = new Date(now);
+    if (unit === 'h') {
+        date.setUTCHours(date.getUTCHours() - amount);
+    }
+    else if (unit === 'd') {
+        date.setUTCDate(date.getUTCDate() - amount);
+    }
+    else if (unit === 'w') {
+        date.setUTCDate(date.getUTCDate() - amount * 7);
+    }
+    else if (unit === 'mo') {
+        date.setUTCMonth(date.getUTCMonth() - amount);
+    }
+    else if (unit === 'y') {
+        date.setUTCFullYear(date.getUTCFullYear() - amount);
+    }
+    return date;
+}
 function toFiniteNumber(value) {
     const numberValue = typeof value === 'number' ? value : Number(value);
     return Number.isFinite(numberValue) ? numberValue : 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>;
@@ -38,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,
@@ -193,6 +302,7 @@ export function registerWidgetEndpoints(
     },
   });
 
+
   server.endpoint({
     method: 'POST',
     path: '/dashboard/set_widget_config',
@@ -205,31 +315,8 @@ export function registerWidgetEndpoints(
         return { error: 'Dashboard edit is not allowed' };
       }
 
-      let mutationError: string | null = null;
-      const updatedDashboard = await 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 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),
-        };
-      });
+      const request = body as ConfigureWidgetRequest;
+      const { updatedDashboard, mutationError } = await replaceWidgetConfig(ctx, request.slug, request.widgetId, request.config);
 
       if (!updatedDashboard) {
         response.setStatus(404);
@@ -245,6 +332,66 @@ export function registerWidgetEndpoints(
     },
   });
 
+  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',

package/package.json

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