@solidxai/core 0.1.10-beta.21 → 0.1.10-beta.23

package/src/services/dashboard-runtime.service.ts

@@ -0,0 +1,488 @@
+import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import qs from 'qs';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { DashboardVariableOptionsQueryDto } from 'src/dtos/dashboard-variable-options-query.dto';
+import { DashboardBatchDataRequestDto, DashboardSaveLayoutDto, DashboardWidgetDataRequestDto } from 'src/dtos/dashboard-widget-data-request.dto';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import { IDashboardWidgetDataProviderContext } from 'src/interfaces';
+import { DashboardUserLayoutService } from './dashboard-user-layout.service';
+
+@Injectable()
+export class DashboardRuntimeService {
+    private readonly logger = new Logger(DashboardRuntimeService.name);
+
+    constructor(
+        private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        private readonly solidRegistry: SolidRegistry,
+        private readonly dashboardUserLayoutService: DashboardUserLayoutService,
+    ) { }
+
+    async getDashboardDefinition(moduleName: string, dashboardName: string): Promise<any> {
+        const moduleMetadata = await this.getModuleMetadata(moduleName);
+        const dashboards = this.getDashboards(moduleMetadata);
+        const dashboard = dashboards.find((d) => d?.name === dashboardName || d?.routeName === dashboardName);
+
+        if (!dashboard) {
+            throw new NotFoundException(`Dashboard ${dashboardName} not found for module ${moduleName}.`);
+        }
+
+        return dashboard;
+    }
+
+    async getWidgetData(
+        moduleName: string,
+        dashboardName: string,
+        widgetName: string,
+        request: DashboardWidgetDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        return this.getWidgetDataFromDefinition(dashboardDefinition, moduleName, dashboardName, widgetName, request, activeUser);
+    }
+
+    async getDashboardData(
+        moduleName: string,
+        dashboardName: string,
+        request: DashboardBatchDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const allWidgets = Array.isArray(dashboardDefinition.widgets) ? dashboardDefinition.widgets : [];
+
+        const targetWidgets = request.widgetNames?.length
+            ? allWidgets.filter((widget) => request.widgetNames.includes(widget.id) || request.widgetNames.includes(widget.name))
+            : allWidgets;
+
+        const widgets = await Promise.all(
+            targetWidgets.map((widget) => this.getWidgetDataFromDefinition(
+                dashboardDefinition,
+                moduleName,
+                dashboardName,
+                widget.id ?? widget.name,
+                request,
+                activeUser
+            ))
+        );
+
+        return {
+            moduleName,
+            dashboardName: dashboardDefinition.name,
+            variables: request.variables ?? {},
+            widgets,
+        };
+    }
+
+    async getVariableOptions(
+        moduleName: string,
+        dashboardName: string,
+        variableName: string,
+        query: DashboardVariableOptionsQueryDto,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const variable = (dashboardDefinition.variables ?? []).find((v) => v.name === variableName);
+
+        if (!variable) {
+            throw new NotFoundException(`Variable ${variableName} not found in dashboard ${dashboardName}.`);
+        }
+
+        if (variable.type === 'selectionStatic') {
+            const values = Array.isArray(variable.selectionStaticValues) ? variable.selectionStaticValues : [];
+            return values.map((entry: string) => {
+                const [value, label] = `${entry}`.split(':');
+                return { label: label ?? value, value };
+            });
+        }
+
+        if (variable.type !== 'selectionDynamic') {
+            return [];
+        }
+
+        const providerName = variable?.selectionConfig?.providerName;
+        if (!providerName) {
+            throw new NotFoundException(`Variable ${variableName} does not define a dynamic selection provider.`);
+        }
+
+        const selectionProvider = this.solidRegistry.getSelectionProviderInstance(providerName);
+        if (!selectionProvider) {
+            throw new NotFoundException(ERROR_MESSAGES.PROVIDER_NOT_FOUND(providerName));
+        }
+
+        const providerContext = {
+            ...(variable?.selectionConfig?.providerContext ?? {}),
+            limit: query?.limit ?? 10,
+            offset: query?.offset ?? 0,
+            formValues: this.parseFormValues(query?.formValues),
+        };
+
+        if (query.optionValue) {
+            return selectionProvider.value(query.optionValue, providerContext as any);
+        }
+
+        return selectionProvider.values(query?.query ?? '', providerContext as any);
+    }
+
+    async getLayout(moduleName: string, dashboardName: string, activeUser?: ActiveUserData): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const defaultLayout = dashboardDefinition.defaultLayout ?? {};
+        const userId = activeUser?.sub ?? null;
+        let userLayoutRecord = null;
+        try {
+            userLayoutRecord = userId
+                ? await this.dashboardUserLayoutService.repo.findOne({
+                    where: {
+                        user: { id: userId },
+                        module: { name: moduleName },
+                        dashboardName: dashboardDefinition.name,
+                    } as any,
+                })
+                : null;
+        } catch (err: any) {
+            const isEntityMetadataMissing = `${err?.message ?? ''}`.includes('No metadata for "DashboardUserLayout" was found');
+            if (!isEntityMetadataMissing) throw err;
+            this.logger.warn('DashboardUserLayout entity metadata is not registered yet. Returning default layout fallback.');
+        }
+        const userLayout = this.parseLayoutJson(userLayoutRecord?.layoutJson);
+        const effectiveLayout = this.mergeLayouts(defaultLayout, userLayout);
+
+        return {
+            moduleName,
+            dashboardName: dashboardDefinition.name,
+            userId,
+            defaultLayout,
+            userLayout,
+            effectiveLayout,
+            persisted: !!userLayoutRecord,
+        };
+    }
+
+    async saveLayout(
+        moduleName: string,
+        dashboardName: string,
+        dto: DashboardSaveLayoutDto,
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const dashboardDefinition = await this.getDashboardDefinition(moduleName, dashboardName);
+        const resolvedDashboardName = dashboardDefinition?.name ?? dashboardName;
+        const resolvedLayoutJson = this.resolveLayoutPayload(dto);
+        const userId = activeUser?.sub;
+        if (!userId) {
+            return {
+                moduleName,
+                dashboardName: resolvedDashboardName,
+                userId: null,
+                persisted: false,
+                message: 'Unable to persist layout without active user context.',
+                layoutJson: resolvedLayoutJson,
+            };
+        }
+        const layoutJsonAsString = typeof resolvedLayoutJson === 'string'
+            ? resolvedLayoutJson
+            : JSON.stringify(resolvedLayoutJson ?? {});
+        let savedLayout: any = null;
+        try {
+            const layoutRepo = this.dashboardUserLayoutService.repo;
+            const existing = await layoutRepo.findOne({
+                where: {
+                    user: { id: userId },
+                    module: { name: moduleName },
+                    dashboardName: resolvedDashboardName,
+                } as any,
+            });
+
+            const moduleRepo = this.dashboardUserLayoutService.entityManager.getRepository(ModuleMetadata);
+            const moduleEntity = await moduleRepo.findOne({ where: { name: moduleName } as any });
+
+            if (!moduleEntity) {
+                throw new NotFoundException(`Module ${moduleName} not found.`);
+            }
+
+            const toSave = layoutRepo.create({
+                ...(existing ? { id: existing.id } : {}),
+                user: { id: userId } as any,
+                module: { id: moduleEntity.id } as any,
+                dashboardName: resolvedDashboardName,
+                layoutJson: layoutJsonAsString,
+                version: (existing?.version ?? 0) + 1,
+            } as any);
+
+            savedLayout = await layoutRepo.save(toSave);
+        } catch (err: any) {
+            const isEntityMetadataMissing = `${err?.message ?? ''}`.includes('No metadata for "DashboardUserLayout" was found');
+            if (!isEntityMetadataMissing) throw err;
+            this.logger.warn('DashboardUserLayout entity metadata is not registered yet. Returning non-persistent save fallback.');
+            return {
+                moduleName,
+                dashboardName: resolvedDashboardName,
+                userId,
+                persisted: false,
+                message: 'Layout model generated but entity is not registered in TypeORM yet. Please add DashboardUserLayout to module TypeOrm entities and restart.',
+                layoutJson: resolvedLayoutJson,
+            };
+        }
+
+        return {
+            moduleName,
+            dashboardName: resolvedDashboardName,
+            userId,
+            persisted: true,
+            message: 'Layout saved successfully.',
+            layoutJson: this.parseLayoutJson(savedLayout.layoutJson),
+        };
+    }
+
+    private async getModuleMetadata(moduleName: string): Promise<any> {
+        const configPath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        const moduleMetadata = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(configPath);
+
+        if (!moduleMetadata) {
+            throw new NotFoundException(ERROR_MESSAGES.MODULE_NOT_FOUND(moduleName));
+        }
+
+        return moduleMetadata;
+    }
+
+    private getDashboards(moduleMetadata: any): any[] {
+        return Array.isArray(moduleMetadata?.dashboards) ? moduleMetadata.dashboards : [];
+    }
+
+    private findWidgetDefinition(dashboardDefinition: any, widgetName: string): any {
+        const widgets = Array.isArray(dashboardDefinition.widgets) ? dashboardDefinition.widgets : [];
+        const widgetDefinition = widgets.find((widget) => widget?.id === widgetName || widget?.name === widgetName);
+
+        if (!widgetDefinition) {
+            throw new NotFoundException(`Widget ${widgetName} not found in dashboard ${dashboardDefinition?.name ?? ''}.`);
+        }
+
+        return widgetDefinition;
+    }
+
+    private async getWidgetDataFromDefinition(
+        dashboardDefinition: any,
+        moduleName: string,
+        dashboardName: string,
+        widgetName: string,
+        request: DashboardWidgetDataRequestDto = {},
+        activeUser?: ActiveUserData,
+    ): Promise<any> {
+        const widgetDefinition = this.findWidgetDefinition(dashboardDefinition, widgetName);
+        const resolvedWidgetName = widgetDefinition.id ?? widgetDefinition.name ?? widgetName;
+        const providerName = widgetDefinition.dataProvider;
+
+        if (!this.hasDashboardWidgetPermission(activeUser, dashboardDefinition?.name ?? dashboardName, resolvedWidgetName)) {
+            return this.buildUnauthorizedWidgetResponse(
+                dashboardDefinition?.name ?? dashboardName,
+                resolvedWidgetName,
+                providerName,
+            );
+        }
+
+        if (!providerName) {
+            throw new NotFoundException(`Widget ${widgetName} is missing dataProvider definition.`);
+        }
+
+        const provider = this.solidRegistry.getDashboardWidgetDataProviderInstance(providerName);
+        if (!provider) {
+            throw new NotFoundException(ERROR_MESSAGES.PROVIDER_NOT_FOUND(providerName));
+        }
+
+        const providerContext = {
+            ...(widgetDefinition.providerContext ?? {}),
+            ...(request.providerContext ?? {}),
+        };
+
+        const runtimeContext: IDashboardWidgetDataProviderContext = {
+            moduleName,
+            dashboardName,
+            widgetName: resolvedWidgetName,
+            variables: request.variables ?? {},
+            providerContext,
+            activeUser,
+        };
+
+        const startTime = Date.now();
+        const providerResponse = await provider.getData(widgetDefinition, runtimeContext);
+        const durationMs = Date.now() - startTime;
+
+        if (providerResponse && typeof providerResponse === 'object' && providerResponse.data !== undefined) {
+            const nextMeta = {
+                ...(providerResponse.meta ?? {}),
+                providerName,
+                widgetName: runtimeContext.widgetName,
+                durationMs: providerResponse?.meta?.durationMs ?? durationMs,
+                generatedAt: providerResponse?.meta?.generatedAt ?? new Date().toISOString(),
+            };
+
+            return {
+                ...providerResponse,
+                meta: nextMeta,
+            };
+        }
+
+        this.logger.debug(`Widget provider ${providerName} returned a non-envelope payload for ${runtimeContext.widgetName}. Normalizing response.`);
+        return {
+            meta: {
+                providerName,
+                widgetName: runtimeContext.widgetName,
+                durationMs,
+                generatedAt: new Date().toISOString(),
+            },
+            data: providerResponse,
+        };
+    }
+
+    private parseFormValues(formValues?: Record<string, any> | string): Record<string, any> {
+        if (!formValues) {
+            return {};
+        }
+        if (typeof formValues === 'object') {
+            return formValues;
+        }
+
+        try {
+            const parsedFromQueryString = qs.parse(formValues);
+            if (parsedFromQueryString && typeof parsedFromQueryString === 'object') {
+                if (parsedFromQueryString['formValues'] && typeof parsedFromQueryString['formValues'] === 'object') {
+                    return parsedFromQueryString['formValues'] as Record<string, any>;
+                }
+                return parsedFromQueryString as Record<string, any>;
+            }
+        } catch (err) {
+            // ignore parse errors and try JSON
+        }
+
+        try {
+            return JSON.parse(formValues);
+        } catch (err) {
+            return {};
+        }
+    }
+
+    private hasDashboardWidgetPermission(
+        activeUser: ActiveUserData | undefined,
+        dashboardName: string,
+        widgetName: string,
+    ): boolean {
+        const permissions = Array.isArray(activeUser?.permissions) ? activeUser.permissions : [];
+        if (!dashboardName || !widgetName || permissions.length === 0) {
+            return false;
+        }
+
+        return permissions.some((permission) => this.matchesDashboardWidgetPermission(permission, dashboardName, widgetName));
+    }
+
+    private matchesDashboardWidgetPermission(permission: string, dashboardName: string, widgetName: string): boolean {
+        const match = /^dashboard:([^:]+):(.+)$/.exec(`${permission ?? ''}`.trim());
+        if (!match) {
+            return false;
+        }
+
+        const [, permissionDashboardName, widgetPattern] = match;
+        if (permissionDashboardName !== dashboardName || !widgetPattern) {
+            return false;
+        }
+
+        if (widgetPattern === '*') {
+            return true;
+        }
+
+        if (widgetPattern === widgetName) {
+            return true;
+        }
+
+        try {
+            return new RegExp(widgetPattern).test(widgetName);
+        } catch {
+            return false;
+        }
+    }
+
+    private buildUnauthorizedWidgetResponse(
+        dashboardName: string,
+        widgetName: string,
+        providerName?: string,
+    ): any {
+        return {
+            meta: {
+                providerName: providerName ?? null,
+                widgetName,
+                durationMs: 0,
+                generatedAt: new Date().toISOString(),
+                unauthorized: true,
+                permissionExpression: `dashboard:${dashboardName}:${widgetName}`,
+            },
+            data: null,
+            uiHints: {
+                state: 'unauthorized',
+                message: 'Unauthorized',
+            },
+        };
+    }
+
+    private parseLayoutJson(layoutJson: any): any {
+        if (layoutJson === null || layoutJson === undefined) return null;
+        if (typeof layoutJson !== 'string') return layoutJson;
+        try {
+            return JSON.parse(layoutJson);
+        } catch {
+            return layoutJson;
+        }
+    }
+
+    private resolveLayoutPayload(dto: DashboardSaveLayoutDto | Record<string, any> | null | undefined): any {
+        if (!dto) return {};
+        if (dto.layoutJson !== undefined) return dto.layoutJson;
+        if ((dto as any).layout !== undefined) return (dto as any).layout;
+        return dto;
+    }
+
+    private mergeLayouts(defaultLayout: any, userLayout: any): any {
+        if (!defaultLayout && !userLayout) return {};
+        if (!defaultLayout) return userLayout ?? {};
+        if (!userLayout) return defaultLayout ?? {};
+
+        const defaultItems = Array.isArray(defaultLayout?.items) ? defaultLayout.items : [];
+        const userItems = Array.isArray(userLayout?.items) ? userLayout.items : [];
+
+        if (!defaultItems.length) {
+            return {
+                ...defaultLayout,
+                ...userLayout,
+                items: userItems,
+            };
+        }
+
+        const userByWidget = new Map<string, any>();
+        userItems.forEach((item: any) => {
+            const key = item?.widgetId ?? item?.id;
+            if (key) userByWidget.set(key, item);
+        });
+
+        const mergedDefaultItems = defaultItems.map((baseItem: any) => {
+            const key = baseItem?.widgetId ?? baseItem?.id;
+            if (!key) return baseItem;
+            const override = userByWidget.get(key);
+            return override ? { ...baseItem, ...override, widgetId: key } : baseItem;
+        });
+
+        const defaultKeys = new Set(
+            defaultItems
+                .map((item: any) => item?.widgetId ?? item?.id)
+                .filter((value: any) => !!value)
+        );
+
+        const userOnlyItems = userItems.filter((item: any) => {
+            const key = item?.widgetId ?? item?.id;
+            return !!key && !defaultKeys.has(key);
+        });
+
+        return {
+            ...defaultLayout,
+            ...userLayout,
+            columns: userLayout?.columns ?? defaultLayout?.columns ?? 12,
+            items: [...mergedDefaultItems, ...userOnlyItems],
+        };
+    }
+}

package/src/services/dashboard-user-layout.service.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef  } from "@nestjs/core";
+import { EntityManager } from 'typeorm';
+import { CRUDService } from 'src/services/crud.service';
+import { DashboardUserLayout } from '../entities/dashboard-user-layout.entity';
+import { DashboardUserLayoutRepository } from '../repositories/dashboard-user-layout.repository';
+
+@Injectable()
+export class DashboardUserLayoutService extends CRUDService<DashboardUserLayout>{
+  constructor(
+    @InjectEntityManager("default")
+    readonly entityManager: EntityManager,
+    readonly repo: DashboardUserLayoutRepository,
+    readonly moduleRef: ModuleRef,
+      
+ ) {
+   super(entityManager, repo, 'dashboardUserLayout', 'solid-core', moduleRef);
+ }
+}

package/src/services/module-metadata.service.ts

@@ -410,7 +410,7 @@ export class ModuleMetadataService {
     const module = await this.findOne(moduleId);
     return this.commandService.executeCommandWithArgs({
       command: 'npx',
-      args: ['@solixai/solidctl@latest', 'generate', 'module', `--name=${module.name}`],
+      args: ['@solidxai/solidctl@latest', 'generate', 'module', `--name=${module.name}`],
       cwd: path.join(process.cwd(), '..'),
     });
   }

package/src/services/selection-providers/mq-dashboard-message-broker-variable-options-provider.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { MqMessageRepository } from "src/repository/mq-message.repository";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "src/interfaces";
+
+@SelectionProvider()
+@Injectable()
+export class MqDashboardMessageBrokerVariableOptionsProvider implements ISelectionProvider<ISelectionProviderContext> {
+    constructor(
+        private readonly mqMessageRepository: MqMessageRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardMessageBrokerVariableOptionsProvider";
+    }
+
+    help(): string {
+        return "Dynamic options provider for dashboard messageBroker variable.";
+    }
+
+    async value(optionValue: string): Promise<ISelectionProviderValues | null> {
+        if (!optionValue) return null;
+        return { label: optionValue, value: optionValue };
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
+        const limit = Math.min(Math.max(ctxt?.limit ?? 25, 1), 200);
+        const offset = Math.max(ctxt?.offset ?? 0, 0);
+
+        qb.select("DISTINCT mqMessage.messageBroker", "value")
+            .where("mqMessage.messageBroker IS NOT NULL");
+
+        if (query) {
+            qb.andWhere("mqMessage.messageBroker ILIKE :query", { query: `%${query}%` });
+        }
+
+        const rows = await qb
+            .orderBy("value", "ASC")
+            .take(limit)
+            .skip(offset)
+            .getRawMany<{ value: string }>();
+
+        return rows
+            .filter((r) => !!r?.value)
+            .map((r) => ({
+                label: r.value,
+                value: r.value,
+            }));
+    }
+}
+

package/src/services/selection-providers/mq-dashboard-queue-name-variable-options-provider.service.ts

@@ -0,0 +1,51 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { MqMessageQueueRepository } from "src/repository/mq-message-queue.repository";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "src/interfaces";
+
+@SelectionProvider()
+@Injectable()
+export class MqDashboardQueueNameVariableOptionsProvider implements ISelectionProvider<ISelectionProviderContext> {
+    constructor(
+        private readonly mqMessageQueueRepository: MqMessageQueueRepository,
+    ) { }
+
+    name(): string {
+        return "MqDashboardQueueNameVariableOptionsProvider";
+    }
+
+    help(): string {
+        return "Dynamic options provider for dashboard queueName variable.";
+    }
+
+    async value(optionValue: string): Promise<ISelectionProviderValues | null> {
+        if (!optionValue) return null;
+        const queue = await this.mqMessageQueueRepository.findOne({
+            where: { name: optionValue },
+        });
+        if (!queue?.name) return null;
+        return { label: queue.name, value: queue.name };
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const qb = await this.mqMessageQueueRepository.createSecurityRuleAwareQueryBuilder("mqMessageQueue");
+        const limit = Math.min(Math.max(ctxt?.limit ?? 25, 1), 200);
+        const offset = Math.max(ctxt?.offset ?? 0, 0);
+
+        if (query) {
+            qb.andWhere("mqMessageQueue.name ILIKE :query", { query: `%${query}%` });
+        }
+
+        const records = await qb
+            .select(["mqMessageQueue.name"])
+            .orderBy("mqMessageQueue.name", "ASC")
+            .take(limit)
+            .skip(offset)
+            .getMany();
+
+        return records
+            .filter((r) => !!r?.name)
+            .map((r) => ({ label: r.name, value: r.name }));
+    }
+}
+