@adminforth/dashboard 1.0.0

package/dist/custom/widgets/table/TableWidget.vue

@@ -0,0 +1,110 @@
+<template>
+  <div class="flex h-full min-h-0 flex-col overflow-hidden rounded-lg border border-lightListBorder bg-lightTableBackground dark:border-darkListBorder dark:bg-darkTableBackground">
+    <div
+      v-if="isLoading"
+      class="p-4 text-sm text-lightListTableText dark:text-darkListTableText"
+    >
+      Loading...
+    </div>
+
+    <div
+      v-else-if="error"
+      class="p-4 text-sm text-lightInputErrorColor"
+    >
+      Failed to load table data
+    </div>
+
+    <div
+      v-else-if="!tableData?.rows.length"
+      class="p-4 text-sm text-lightListTableText dark:text-darkListTableText"
+    >
+      No data available
+    </div>
+
+    <div
+      v-else
+      class="min-h-0 flex-1 overflow-auto"
+    >
+      <table class="min-w-max w-full border-collapse text-left text-sm">
+        <thead class="bg-lightTableHeadingBackground text-xs uppercase text-lightTableHeadingText dark:bg-darkTableHeadingBackground dark:text-darkTableHeadingText">
+          <tr>
+            <th
+              v-for="column in columns"
+              :key="column"
+              class="px-3 py-2 font-semibold"
+            >
+              {{ column }}
+            </th>
+          </tr>
+        </thead>
+
+        <tbody>
+          <tr
+            v-for="(row, index) in tableData.rows"
+            :key="index"
+            class="border-t border-lightListBorder odd:bg-lightTableOddBackground even:bg-lightTableEvenBackground dark:border-darkListBorder odd:dark:bg-darkTableOddBackground even:dark:bg-darkTableEvenBackground"
+          >
+            <td
+              v-for="column in columns"
+              :key="column"
+              class="px-3 py-2 text-lightListTableText dark:text-darkListTableText"
+            >
+              {{ formatCell(row[column]) }}
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+</template>
+
+
+
+<script setup lang="ts">
+import { computed, watch } from 'vue'
+import { useWidgetData } from '../../queries/useWidgetData.js'
+import type { DashboardWidgetConfig, DashboardWidgetTableData } from '../../model/dashboard.types.js'
+
+const props = defineProps<{
+  dashboardSlug: string
+  widget: DashboardWidgetConfig
+}>()
+
+const dashboardSlugRef = computed(() => props.dashboardSlug)
+const widgetIdRef = computed(() => props.widget.id)
+const {
+  data,
+  isLoading,
+  error,
+  refetch,
+} = useWidgetData(dashboardSlugRef, widgetIdRef)
+
+watch(
+  () => props.widget,
+  () => {
+    void refetch()
+  },
+  { deep: true },
+)
+
+const tableData = computed(() => {
+  return data.value?.data as DashboardWidgetTableData | null
+})
+
+const columns = computed(() => {
+  const configuredColumns = (props.widget.table as { columns?: string[] } | undefined)?.columns
+  return configuredColumns ?? tableData.value?.columns ?? []
+})
+
+function formatCell(value: unknown) {
+  if (value === null || value === undefined) {
+    return ''
+  }
+
+  if (typeof value === 'object') {
+    return JSON.stringify(value)
+  }
+
+  return String(value)
+}
+</script>

package/dist/endpoint/dashboard.d.ts

@@ -0,0 +1,7 @@
+import type { IHttpServer } from 'adminforth';
+import type { DashboardRecord } from '../services/dashboardConfigService.js';
+type DashboardEndpointsContext = {
+    getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+};
+export declare function registerDashboardEndpoints(server: IHttpServer, ctx: DashboardEndpointsContext): void;
+export {};

package/dist/endpoint/dashboard.js

@@ -0,0 +1,29 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DashboardApiResponseSchema, SlugRequestSchema } from '../schema/api.js';
+import { buildDashboardResponse } from '../services/dashboardConfigService.js';
+export function registerDashboardEndpoints(server, ctx) {
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/get-config',
+        description: 'Loads one dashboard configuration by slug for rendering or editing.',
+        request_schema: SlugRequestSchema,
+        response_schema: DashboardApiResponseSchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response }) {
+            const slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                response.setStatus(404);
+                return { error: 'Dashboard not found' };
+            }
+            return buildDashboardResponse(dashboard);
+        }),
+    });
+}

package/dist/endpoint/groups.d.ts

@@ -0,0 +1,30 @@
+import type { AdminUser, IHttpServer } from 'adminforth';
+import type { DashboardConfig } from '../custom/model/dashboard.types.js';
+type DashboardRecord = {
+    id: string;
+    slug: string;
+    label: string;
+    revision: number;
+    config: unknown;
+};
+type GroupEndpointsContext = {
+    canEditDashboard: (adminUser: AdminUser) => boolean;
+    getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+    parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
+    persistDashboardConfig: (dashboard: DashboardRecord, config: DashboardConfig) => Promise<{
+        id: string;
+        slug: string;
+        label: string;
+        revision: number;
+        config: DashboardConfig;
+    }>;
+    buildDashboardResponse: (dashboard: DashboardRecord) => {
+        id: string;
+        slug: string;
+        label: string;
+        revision: number;
+        config: DashboardConfig;
+    };
+};
+export declare function registerGroupEndpoints(server: IHttpServer, ctx: GroupEndpointsContext): void;
+export {};

package/dist/endpoint/groups.js

@@ -0,0 +1,131 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { randomUUID } from 'crypto';
+import { DashboardApiResponseSchema, GroupIdRequestSchema, MoveGroupRequestSchema, SetGroupConfigRequestSchema, SlugRequestSchema, } from '../schema/api.js';
+export function registerGroupEndpoints(server, ctx) {
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/add_dashboard_group',
+        description: 'Adds a new group to a dashboard configuration. Superadmin only.',
+        request_schema: SlugRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                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] }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/set_dashboard_group_config',
+        description: 'Replaces editable JSON configuration for a dashboard group while preserving group id and order. Superadmin only.',
+        request_schema: SetGroupConfigRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const groupId = String((body === null || body === void 0 ? void 0 : body.groupId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                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) {
+                response.setStatus(404);
+                return { error: 'Dashboard group not found' };
+            }
+            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { groups: config.groups.map((item) => item.id === groupId
+                    ? Object.assign(Object.assign({}, body.config), { id: group.id, order: group.order }) : item) }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/move_dashboard_group',
+        description: 'Moves a dashboard group up or down in its dashboard. Superadmin only.',
+        request_schema: MoveGroupRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const groupId = String((body === null || body === void 0 ? void 0 : body.groupId) || '');
+            const direction = (body === null || body === void 0 ? void 0 : body.direction) === 'down' ? 'down' : 'up';
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                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 === groupId);
+            if (currentIndex === -1) {
+                response.setStatus(404);
+                return { error: 'Dashboard group not found' };
+            }
+            const targetIndex = direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+            if (targetIndex < 0 || targetIndex >= sortedGroups.length) {
+                return ctx.buildDashboardResponse(dashboard);
+            }
+            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 }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/remove_dashboard_group',
+        description: 'Removes a dashboard group and all widgets inside it. Superadmin only.',
+        request_schema: GroupIdRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const groupId = String((body === null || body === void 0 ? void 0 : body.groupId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                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) {
+                response.setStatus(404);
+                return { error: 'Dashboard group not found' };
+            }
+            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { groups: nextGroups, widgets: config.widgets.filter((widget) => widget.group_id !== groupId) }));
+        }),
+    });
+}

package/dist/endpoint/widgets.d.ts

@@ -0,0 +1,15 @@
+import type { AdminUser, IHttpServer } from 'adminforth';
+import type { DashboardConfig, DashboardWidgetConfig } from '../custom/model/dashboard.types.js';
+import type { DashboardWidgetConfigValidationError } from '../schema/widget.js';
+import type { DashboardRecord, PersistedDashboardResponse } from '../services/dashboardConfigService.js';
+type WidgetEndpointsContext = {
+    canEditDashboard: (adminUser: AdminUser) => boolean;
+    getDashboardRecord: (slug: string) => Promise<DashboardRecord | null>;
+    parseStoredDashboardConfig: (config: unknown) => DashboardConfig;
+    persistDashboardConfig: (dashboard: DashboardRecord, config: DashboardConfig) => Promise<PersistedDashboardResponse>;
+    buildDashboardResponse: (dashboard: DashboardRecord) => PersistedDashboardResponse;
+    validateDashboardWidgetApiConfig: (widget: DashboardWidgetConfig) => DashboardWidgetConfigValidationError[];
+    getWidgetData: (widget: DashboardWidgetConfig) => Promise<unknown>;
+};
+export declare function registerWidgetEndpoints(server: IHttpServer, ctx: WidgetEndpointsContext): void;
+export {};

package/dist/endpoint/widgets.js

@@ -0,0 +1,182 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { randomUUID } from 'crypto';
+import { DashboardApiResponseSchema, DashboardWidgetDataResponseSchema, GroupIdRequestSchema, MoveWidgetRequestSchema, SetWidgetConfigRequestSchema, WidgetIdRequestSchema, } from '../schema/api.js';
+export function registerWidgetEndpoints(server, ctx) {
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/add_dashboard_widget',
+        description: 'Adds a new empty widget to a dashboard group. Superadmin only.',
+        request_schema: GroupIdRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const groupId = String((body === null || body === void 0 ? void 0 : body.groupId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                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) {
+                response.setStatus(404);
+                return { error: 'Dashboard group not found' };
+            }
+            const nextOrder = config.widgets.filter((item) => item.group_id === groupId).length + 1;
+            const widget = {
+                id: `widget_${randomUUID()}`,
+                group_id: groupId,
+                label: 'New widget',
+                size: 'small',
+                order: nextOrder,
+                target: 'empty',
+            };
+            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { widgets: [...config.widgets, widget] }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/move_dashboard_widget',
+        description: 'Moves a dashboard widget up or down inside its group. Superadmin only.',
+        request_schema: MoveWidgetRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const widgetId = String((body === null || body === void 0 ? void 0 : body.widgetId) || '');
+            const direction = (body === null || body === void 0 ? void 0 : body.direction) === 'down' ? 'down' : 'up';
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                response.setStatus(404);
+                return { error: 'Dashboard not found' };
+            }
+            const config = ctx.parseStoredDashboardConfig(dashboard.config);
+            const widget = config.widgets.find((item) => item.id === widgetId);
+            if (!widget) {
+                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 === widgetId);
+            const targetIndex = direction === 'up' ? currentIndex - 1 : currentIndex + 1;
+            if (targetIndex < 0 || targetIndex >= sortedWidgets.length) {
+                return ctx.buildDashboardResponse(dashboard);
+            }
+            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 }));
+                }) }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/remove_dashboard_widget',
+        description: 'Removes one dashboard widget by id. Superadmin only.',
+        request_schema: WidgetIdRequestSchema,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const widgetId = String((body === null || body === void 0 ? void 0 : body.widgetId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                response.setStatus(404);
+                return { error: 'Dashboard not found' };
+            }
+            const config = ctx.parseStoredDashboardConfig(dashboard.config);
+            const nextWidgets = config.widgets.filter((item) => item.id !== widgetId);
+            if (nextWidgets.length === config.widgets.length) {
+                response.setStatus(404);
+                return { error: 'Dashboard widget not found' };
+            }
+            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { widgets: nextWidgets }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        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,
+        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 slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const widgetId = String((body === null || body === void 0 ? void 0 : body.widgetId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                response.setStatus(404);
+                return { error: 'Dashboard not found' };
+            }
+            const config = ctx.parseStoredDashboardConfig(dashboard.config);
+            const widget = config.widgets.find((item) => item.id === widgetId);
+            if (!widget) {
+                response.setStatus(404);
+                return { error: 'Dashboard widget not found' };
+            }
+            const typedWidgetConfig = body.config;
+            const apiValidationErrors = ctx.validateDashboardWidgetApiConfig(typedWidgetConfig);
+            if (apiValidationErrors.length) {
+                response.setStatus(422);
+                return {
+                    error: 'Invalid widget config',
+                    validationErrors: apiValidationErrors,
+                };
+            }
+            return ctx.persistDashboardConfig(dashboard, Object.assign(Object.assign({}, config), { widgets: config.widgets.map((item) => item.id === widgetId
+                    ? Object.assign(Object.assign({}, typedWidgetConfig), { id: widget.id, group_id: widget.group_id, order: widget.order }) : item) }));
+        }),
+    });
+    server.endpoint({
+        method: 'POST',
+        path: '/dashboard/get_dashboard_widget_data',
+        description: 'Loads query result data for one dashboard widget by dashboard slug and widget id.',
+        request_schema: WidgetIdRequestSchema,
+        response_schema: DashboardWidgetDataResponseSchema,
+        handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response }) {
+            const slug = String((body === null || body === void 0 ? void 0 : body.slug) || 'default');
+            const widgetId = String((body === null || body === void 0 ? void 0 : body.widgetId) || '');
+            const dashboard = yield ctx.getDashboardRecord(slug);
+            if (!dashboard) {
+                response.setStatus(404);
+                return { error: 'Dashboard not found' };
+            }
+            const config = ctx.parseStoredDashboardConfig(dashboard.config);
+            const widget = config.widgets.find((item) => item.id === widgetId);
+            if (!widget) {
+                response.setStatus(404);
+                return { error: 'Dashboard widget not found' };
+            }
+            return {
+                widget,
+                data: yield ctx.getWidgetData(widget),
+            };
+        }),
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { AdminForthPlugin } from "adminforth";
+import type { AdminForthResource, IAdminForth, IHttpServer } from "adminforth";
+import type { PluginOptions } from "./types.js";
+export default class DashboardPlugin extends AdminForthPlugin {
+    options: PluginOptions;
+    private didRegisterMenuProvider;
+    private didInstallSeedHook;
+    constructor(options: PluginOptions);
+    modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource): Promise<void>;
+    private ensureDefaultDashboardConfig;
+    setupEndpoints(server: IHttpServer): void;
+    instanceUniqueRepresentation(): string;
+}

package/dist/index.js

@@ -0,0 +1,124 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { AdminForthPlugin } from "adminforth";
+import { randomUUID } from 'crypto';
+import path from 'path';
+import { registerDashboardEndpoints } from './endpoint/dashboard.js';
+import { registerGroupEndpoints } from "./endpoint/groups.js";
+import { registerWidgetEndpoints } from './endpoint/widgets.js';
+import { createDashboardConfigService } from "./services/dashboardConfigService.js";
+import { createWidgetDataService } from "./services/widgetDataService.js";
+import { createWidgetConfigValidatorService } from "./services/widgetConfigValidator.js";
+const DEFAULT_DASHBOARD_CONFIG = {
+    version: 1,
+    groups: [{
+            id: 'default',
+            label: 'Default Group',
+            order: 1,
+        }],
+    widgets: [],
+};
+function canEditDashboard(adminUser) {
+    return adminUser.dbUser.role === 'superadmin';
+}
+export default class DashboardPlugin extends AdminForthPlugin {
+    constructor(options) {
+        super(options, import.meta.url);
+        this.didRegisterMenuProvider = false;
+        this.didInstallSeedHook = false;
+        this.options = options;
+        this.customFolderName = 'custom';
+        this.customFolderPath = path.join(this.pluginDir, this.customFolderName);
+    }
+    modifyResourceConfig(adminforth, resourceConfig) {
+        const _super = Object.create(null, {
+            modifyResourceConfig: { get: () => super.modifyResourceConfig }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.modifyResourceConfig.call(this, adminforth, resourceConfig);
+            if (!this.didRegisterMenuProvider) {
+                this.didRegisterMenuProvider = true;
+                const adminforthWithDynamicMenu = adminforth;
+                adminforthWithDynamicMenu.registerMenuContributionProvider(() => __awaiter(this, void 0, void 0, function* () {
+                    if (this.adminforth.statuses.dbDiscover !== 'done') {
+                        return [];
+                    }
+                    const dashboards = yield this.adminforth.resource(this.options.dashboardConfigsResourceId).list([]);
+                    return [
+                        {
+                            item: {
+                                itemId: 'dashboardMenu',
+                                type: 'group',
+                                label: 'Dashboards',
+                                icon: 'flowbite:chart-pie-solid',
+                                open: true,
+                                children: dashboards.map((dashboard) => ({
+                                    itemId: `dashboard-${dashboard.id}`,
+                                    type: 'page',
+                                    label: dashboard.label,
+                                    url: `/dashboard/${dashboard.slug}`,
+                                })),
+                            },
+                            placement: { position: 'first' },
+                        },
+                    ];
+                }));
+            }
+            if (!this.didInstallSeedHook) {
+                this.didInstallSeedHook = true;
+                const discoverDatabases = adminforth.discoverDatabases.bind(adminforth);
+                adminforth.discoverDatabases = () => __awaiter(this, void 0, void 0, function* () {
+                    yield discoverDatabases();
+                    yield this.ensureDefaultDashboardConfig();
+                });
+            }
+            adminforth.config.customization.customPages.push({
+                path: '/dashboard/:slug',
+                component: {
+                    file: this.componentPath('runtime/DashboardPage.vue'),
+                    meta: {
+                        title: 'Dashboard',
+                    },
+                },
+            });
+        });
+    }
+    ensureDefaultDashboardConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dashboardConfigs = this.adminforth.resource(this.options.dashboardConfigsResourceId);
+            const dashboardsCount = yield dashboardConfigs.count();
+            if (dashboardsCount > 0) {
+                return;
+            }
+            const createResult = yield dashboardConfigs.create({
+                id: randomUUID(),
+                slug: 'default',
+                label: 'Default Dashboard',
+                revision: 1,
+                config: DEFAULT_DASHBOARD_CONFIG,
+            });
+            if (!createResult.ok) {
+                throw new Error(createResult.error || 'Failed to create default dashboard config');
+            }
+        });
+    }
+    setupEndpoints(server) {
+        const dashboardConfigService = createDashboardConfigService(this.adminforth, this.options.dashboardConfigsResourceId);
+        const widgetDataService = createWidgetDataService(this.adminforth);
+        const widgetConfigValidatorService = createWidgetConfigValidatorService(this.adminforth);
+        const ctx = Object.assign(Object.assign(Object.assign({ adminforth: this.adminforth, dashboardConfigsResourceId: this.options.dashboardConfigsResourceId, canEditDashboard }, dashboardConfigService), widgetDataService), widgetConfigValidatorService);
+        registerDashboardEndpoints(server, ctx);
+        registerGroupEndpoints(server, ctx);
+        registerWidgetEndpoints(server, ctx);
+    }
+    instanceUniqueRepresentation() {
+        return "dashboard";
+    }
+}