@adminforth/dashboard 1.8.0 → 1.10.0

package/endpoint/widgets.ts

@@ -21,7 +21,7 @@ import {
   ConfigurePivotTableWidgetRequestSchema,
   ConfigureStackedBarChartWidgetRequestSchema,
   ConfigureTableWidgetRequestSchema,
-  DashboardApiResponseSchema,
+  DashboardMutationResponseSchema,
   DashboardWidgetDataResponseSchema,
   GroupIdRequestSchema,
   MoveWidgetRequestSchema,
@@ -117,11 +117,11 @@ function registerConfigureWidgetEndpoint(
     path: options.path,
     description: options.description,
     request_schema: options.requestSchema,
-    response_schema: DashboardApiResponseSchema,
+    response_schema: DashboardMutationResponseSchema,
     handler: async ({ body, adminUser, response }) => {
       if (!ctx.canEditDashboard(adminUser)) {
         response.setStatus(403);
-        return { error: 'Dashboard edit is not allowed' };
+        return { ok: false, error: 'Dashboard edit is not allowed' };
       }
 
       const request = body as ConfigureWidgetRequest;
@@ -134,15 +134,15 @@ function registerConfigureWidgetEndpoint(
 
       if (!updatedDashboard) {
         response.setStatus(404);
-        return { error: 'Dashboard not found' };
+        return { ok: false, error: 'Dashboard not found' };
       }
 
       if (mutationError) {
         response.setStatus(404);
-        return { error: mutationError };
+        return { ok: false, error: mutationError };
       }
 
-      return updatedDashboard;
+      return { ok: true };
     },
   });
 }
@@ -156,14 +156,15 @@ export function registerWidgetEndpoints(
     path: '/dashboard/add_dashboard_widget',
     description: 'Adds a new empty widget to a dashboard group. Superadmin only.',
     request_schema: GroupIdRequestSchema,
-    response_schema: DashboardApiResponseSchema,
+    response_schema: DashboardMutationResponseSchema,
     handler: async ({ body, adminUser, response }) => {
       if (!ctx.canEditDashboard(adminUser)) {
         response.setStatus(403);
-        return { error: 'Dashboard edit is not allowed' };
+        return { ok: false, error: 'Dashboard edit is not allowed' };
       }
 
       let mutationError: string | null = null;
+      let widgetId: string | null = null;
       const updatedDashboard = await ctx.updateDashboardConfig(body.slug, (config) => {
         const group = config.groups.find((item) => item.id === body.groupId);
 
@@ -181,6 +182,7 @@ export function registerWidgetEndpoints(
           order: nextOrder,
           target: 'empty',
         };
+        widgetId = widget.id;
 
         return {
           ...config,
@@ -190,15 +192,15 @@ export function registerWidgetEndpoints(
 
       if (!updatedDashboard) {
         response.setStatus(404);
-        return { error: 'Dashboard not found' };
+        return { ok: false, error: 'Dashboard not found' };
       }
 
       if (mutationError) {
         response.setStatus(404);
-        return { error: mutationError };
+        return { ok: false, error: mutationError };
       }
 
-      return updatedDashboard;
+      return { ok: true, widgetId };
     },
   });
 
@@ -207,11 +209,11 @@ export function registerWidgetEndpoints(
     path: '/dashboard/move_dashboard_widget',
     description: 'Moves a dashboard widget up or down inside its group. Superadmin only.',
     request_schema: MoveWidgetRequestSchema,
-    response_schema: DashboardApiResponseSchema,
+    response_schema: DashboardMutationResponseSchema,
     handler: async ({ body, adminUser, response }) => {
       if (!ctx.canEditDashboard(adminUser)) {
         response.setStatus(403);
-        return { error: 'Dashboard edit is not allowed' };
+        return { ok: false, error: 'Dashboard edit is not allowed' };
       }
 
       let mutationError: string | null = null;
@@ -249,15 +251,15 @@ export function registerWidgetEndpoints(
 
       if (!updatedDashboard) {
         response.setStatus(404);
-        return { error: 'Dashboard not found' };
+        return { ok: false, error: 'Dashboard not found' };
       }
 
       if (mutationError) {
         response.setStatus(404);
-        return { error: mutationError };
+        return { ok: false, error: mutationError };
       }
 
-      return updatedDashboard;
+      return { ok: true };
     },
   });
 
@@ -266,11 +268,11 @@ export function registerWidgetEndpoints(
     path: '/dashboard/remove_dashboard_widget',
     description: 'Removes one dashboard widget by id. Superadmin only.',
     request_schema: WidgetIdRequestSchema,
-    response_schema: DashboardApiResponseSchema,
+    response_schema: DashboardMutationResponseSchema,
     handler: async ({ body, adminUser, response }) => {
       if (!ctx.canEditDashboard(adminUser)) {
         response.setStatus(403);
-        return { error: 'Dashboard edit is not allowed' };
+        return { ok: false, error: 'Dashboard edit is not allowed' };
       }
 
       let mutationError: string | null = null;
@@ -290,15 +292,15 @@ export function registerWidgetEndpoints(
 
       if (!updatedDashboard) {
         response.setStatus(404);
-        return { error: 'Dashboard not found' };
+        return { ok: false, error: 'Dashboard not found' };
       }
 
       if (mutationError) {
         response.setStatus(404);
-        return { error: mutationError };
+        return { ok: false, error: mutationError };
       }
 
-      return updatedDashboard;
+      return { ok: true };
     },
   });
 
@@ -308,11 +310,11 @@ export function registerWidgetEndpoints(
     path: '/dashboard/set_widget_config',
     description: 'Replaces editable JSON configuration for a dashboard widget while preserving widget id, group id, and order. Superadmin only.',
     request_schema: SetWidgetConfigRequestSchema,
-    response_schema: DashboardApiResponseSchema,
+    response_schema: DashboardMutationResponseSchema,
     handler: async ({ body, adminUser, response }) => {
       if (!ctx.canEditDashboard(adminUser)) {
         response.setStatus(403);
-        return { error: 'Dashboard edit is not allowed' };
+        return { ok: false, error: 'Dashboard edit is not allowed' };
       }
 
       const request = body as ConfigureWidgetRequest;
@@ -320,15 +322,15 @@ export function registerWidgetEndpoints(
 
       if (!updatedDashboard) {
         response.setStatus(404);
-        return { error: 'Dashboard not found' };
+        return { ok: false, error: 'Dashboard not found' };
       }
 
       if (mutationError) {
         response.setStatus(404);
-        return { error: mutationError };
+        return { ok: false, error: mutationError };
       }
 
-      return updatedDashboard;
+      return { ok: true };
     },
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/dashboard",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -56,6 +56,7 @@
     }
   ],
   "dependencies": {
+    "expr-eval-fork": "^3.0.3",
     "vue": "^3.5.34",
     "vue-router": "^5.0.7",
     "yaml": "^2.9.0",

package/schema/api.ts

@@ -203,19 +203,14 @@ export const ConfigureHistogramChartWidgetRequestZodSchema = configureWidgetRequ
 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 DashboardMutationResponseZodSchema = z.object({
+  ok: z.boolean(),
+  error: z.string().optional(),
+  groupId: z.string().optional(),
+  widgetId: z.string().optional(),
+}).strict()
 
-export const DashboardApiResponseSchema = toJSONSchema(DashboardApiResponseZodSchema, { target: 'draft-07' })
+export const DashboardApiResponseSchema = toJSONSchema(z.unknown(), { 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' })

package/schema/widgets/common.ts

@@ -160,13 +160,6 @@ const ResourceQueryConfigSchema = z.object({
   formatting: z.record(z.string(), z.unknown()).optional(),
 }).strict()
 
-const StepsQueryMetricStepSchema = z.object({
-  name: z.string(),
-  resource: z.string(),
-  metric: QueryAggregateSelectItemSchema,
-  filters: FilterExpressionSchema.optional(),
-}).strict()
-
 const StepsQuerySelectStepSchema = z.object({
   name: z.string(),
   resource: z.string(),
@@ -178,10 +171,7 @@ export const QueryConfigSchema = z.union([
   ResourceQueryConfigSchema,
   z.object({
     source: z.literal('steps'),
-    steps: z.array(z.union([
-      StepsQueryMetricStepSchema,
-      StepsQuerySelectStepSchema,
-    ])).min(1),
+    steps: z.array(StepsQuerySelectStepSchema).min(1),
     calcs: z.array(QueryCalcItemSchema).optional(),
     order_by: z.array(QueryOrderByItemSchema).optional(),
     limit: z.number().int().positive().optional(),

package/services/calc-evaluator.ts

@@ -0,0 +1,71 @@
+import { Parser } from 'expr-eval-fork';
+import type { DashboardVariables } from '../custom/model/dashboard.types.js';
+
+const LOOKUP_VARIABLE_PATH_RE = /lookup\(\s*\$variables((?:\.[a-zA-Z_][a-zA-Z0-9_]*)+)\s*,/g;
+const CALC_PARSER_OPTIONS = {
+  allowMemberAccess: false,
+  operators: {
+    assignment: false,
+    concatenate: false,
+    conditional: true,
+    comparison: true,
+    fndef: false,
+    in: false,
+    logical: true,
+    random: false,
+  },
+} as const;
+
+export function evaluateCalc(
+  calc: string,
+  values: Record<string, unknown>,
+  variables: DashboardVariables = {},
+) {
+  const parser = createCalcParser(variables);
+
+  return parser.parse(normalizeLookupPaths(calc)).evaluate(normalizeCalcValues(values));
+}
+
+function createCalcParser(variables: DashboardVariables) {
+  const parser = new Parser(CALC_PARSER_OPTIONS);
+
+  parser.functions.lookup = (path: string | number, key: string | number, defaultValue = 0) => {
+    const map = resolveVariablePath(variables, String(path));
+    const value = isRecord(map) && Object.prototype.hasOwnProperty.call(map, String(key))
+      ? map[String(key)]
+      : defaultValue;
+
+    return toFiniteNumber(value);
+  };
+
+  return parser;
+}
+
+function normalizeLookupPaths(calc: string) {
+  return calc.replace(LOOKUP_VARIABLE_PATH_RE, (_match, path: string) => {
+    return `lookup("${path.replace(/^\./, '')}",`;
+  });
+}
+
+function normalizeCalcValues(values: Record<string, unknown>) {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    typeof value === 'string' ? value : toFiniteNumber(value),
+  ]));
+}
+
+function toFiniteNumber(value: unknown) {
+  const numberValue = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+
+function resolveVariablePath(variables: DashboardVariables, path: string) {
+  return path
+    .split('.')
+    .filter(Boolean)
+    .reduce<unknown>((current, segment) => isRecord(current) ? current[segment] : undefined, variables);
+}
+
+function isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null;
+}

package/services/dashboardFilterService.ts

@@ -0,0 +1,162 @@
+import { Filters } from 'adminforth';
+import type {
+  IAdminForthAndOrFilter,
+  IAdminForthSingleFilter,
+} from 'adminforth';
+import type { FilterExpression } from '../custom/model/dashboard.types.js';
+
+export type DashboardQueryFilters =
+  | IAdminForthSingleFilter
+  | IAdminForthAndOrFilter
+  | Array<IAdminForthSingleFilter | IAdminForthAndOrFilter>;
+
+const RELATIVE_DURATION_RE = /^(\d+)(h|d|w|mo|y)$/;
+
+const FILTER_OPERATORS = {
+  eq: Filters.EQ,
+  neq: Filters.NEQ,
+  gt: Filters.GT,
+  gte: Filters.GTE,
+  lt: Filters.LT,
+  lte: Filters.LTE,
+  in: Filters.IN,
+  not_in: Filters.NOT_IN,
+  like: Filters.LIKE,
+  ilike: Filters.ILIKE,
+} as const;
+
+export function getAdminForthFilters(filters: FilterExpression | DashboardQueryFilters | undefined): DashboardQueryFilters {
+  if (Array.isArray(filters)) {
+    return filters.map((filter) => isDashboardFilterExpression(filter)
+      ? toAdminForthFilter(filter)
+      : filter);
+  }
+
+  if (isDashboardFilterExpression(filters)) {
+    return toAdminForthFilter(filters);
+  }
+
+  if (filters) {
+    return filters;
+  }
+
+  return [];
+}
+
+export function mergeFilters(...filters: Array<FilterExpression | DashboardQueryFilters | undefined>) {
+  const merged: Array<IAdminForthSingleFilter | IAdminForthAndOrFilter> = [];
+
+  for (const filter of filters) {
+    const normalized = getAdminForthFilters(filter);
+
+    if (Array.isArray(normalized)) {
+      merged.push(...normalized);
+      continue;
+    }
+
+    if (normalized) {
+      merged.push(normalized);
+    }
+  }
+
+  if (!merged.length) {
+    return [] as DashboardQueryFilters;
+  }
+
+  return merged.length === 1 ? merged[0] : merged;
+}
+
+function isDashboardFilterExpression(value: unknown): value is FilterExpression {
+  if (Array.isArray(value)) {
+    return true;
+  }
+
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return 'and' in value
+    || 'or' in value
+    || 'eq' in value
+    || 'neq' in value
+    || 'gt' in value
+    || 'gte' in value
+    || 'lt' in value
+    || 'lte' in value
+    || 'in' in value
+    || 'not_in' in value
+    || 'like' in value
+    || 'ilike' in value;
+}
+
+function toAdminForthFilter(filter: FilterExpression): IAdminForthSingleFilter | IAdminForthAndOrFilter {
+  if (Array.isArray(filter)) {
+    return Filters.AND(filter.map((item) => toAdminForthFilter(item)));
+  }
+
+  if ('and' in filter) {
+    return Filters.AND(filter.and.map((item) => toAdminForthFilter(item)));
+  }
+
+  if ('or' in filter) {
+    return Filters.OR(filter.or.map((item) => toAdminForthFilter(item)));
+  }
+
+  for (const [operator, createFilter] of Object.entries(FILTER_OPERATORS)) {
+    if (Object.prototype.hasOwnProperty.call(filter, operator)) {
+      return createFilter(filter.field, resolveFilterValue(filter[operator as keyof typeof FILTER_OPERATORS]));
+    }
+  }
+
+  return Filters.AND([]);
+}
+
+function resolveFilterValue(value: unknown): unknown {
+  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: Date, duration: string) {
+  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 isRecord(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null;
+}