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

package/src/mappers/dashboard-mapper.ts

@@ -1,53 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { SelectionDynamicSourceType } from "src/dtos/create-dashboard-variable.dto";
-import { Dashboard } from "src/entities/dashboard.entity";
-
-@Injectable()
-export class DashboardMapper {
-    toDto(dashboard: Dashboard): any {
-        return {
-            name: dashboard.name,
-            layoutJson: this.safeParseJSON(dashboard.layoutJson, {}),
-            moduleUserKey: dashboard.module?.name ?? null, // safer fallback
-
-            dashboardVariables: (dashboard.dashboardVariables || []).map(variable => ({
-                variableName: variable.variableName,
-                variableType: variable.variableType,
-                selectionStaticValues: this.safeParseJSON(variable.selectionStaticValues, []),
-                selectionDynamicSourceType: variable.selectionDynamicSourceType as SelectionDynamicSourceType,
-                selectionDynamicSQL: variable.selectionDynamicSQL ?? null,
-                selectionDynamicProviderName: variable.selectionDynamicProviderName ?? null,
-                defaultValue: this.safeParseJSON(variable.defaultValue, []),
-                defaultOperator: variable.defaultOperator ?? null,
-            })),
-            questions: (dashboard.questions || []).map(question => ({
-                name: question.name,
-                sourceType: question.sourceType,
-                visualisedAs: question.visualisedAs,
-                providerName: question.providerName ?? null,
-                chartOptions: question.chartOptions ?? null,
-                labelSql: question.labelSql ?? null,
-                kpiSql: question.kpiSql ?? null,
-                externalId: question.externalId,
-                questionSqlDatasetConfigs: (question.questionSqlDatasetConfigs || []).map(config => ({
-                    sql: config.sql,
-                    datasetName: config.datasetName,
-                    datasetDisplayName: config.datasetDisplayName, // 🔧 fixed typo: `daataSetDisplayName`
-                    description: config.description,
-                    labelColumnName: config.labelColumnName,
-                    valueColumnName: config.valueColumnName,
-                    options: this.safeParseJSON(config.options, {}),
-                    externalId: config.externalId
-                }))
-            }))
-        };
-    }
-
-    private safeParseJSON(json: string | null | undefined, fallback: any): any {
-        try {
-            return json ? JSON.parse(json) : fallback;
-        } catch {
-            return fallback;
-        }
-    }
-}

package/src/repository/dashboard-layout.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
-
-@Injectable()
-export class DashboardLayoutRepository extends SolidBaseRepository<DashboardLayout> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardLayout, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard-question-sql-dataset-config.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardQuestionSqlDatasetConfigRepository extends SolidBaseRepository<DashboardQuestionSqlDatasetConfig> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardQuestionSqlDatasetConfig, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard-question.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardQuestion } from '../entities/dashboard-question.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardQuestionRepository extends SolidBaseRepository<DashboardQuestion> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardQuestion, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard-variable.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DashboardVariable } from '../entities/dashboard-variable.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class DashboardVariableRepository extends SolidBaseRepository<DashboardVariable> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(DashboardVariable, dataSource, requestContextService, securityRuleRepository);
-    }
-}

package/src/repository/dashboard.repository.ts

@@ -1,101 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { Dashboard } from "src/entities/dashboard.entity";
-import { ModuleMetadata } from "src/entities/module-metadata.entity";
-import { RequestContextService } from "src/services/request-context.service";
-import { DataSource } from "typeorm";
-import { SecurityRuleRepository } from "./security-rule.repository";
-import { SolidBaseRepository } from "./solid-base.repository";
-
-@Injectable()
-export class DashboardRepository extends SolidBaseRepository<Dashboard> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(Dashboard, dataSource, requestContextService, securityRuleRepository);
-    }
-
-
-    async upsertWithDto(createDto: any) {
-        const moduleMetadataRepository = this.dataSource.getRepository(ModuleMetadata);
-        const module = await moduleMetadataRepository.findOneBy({ name: createDto.moduleUserKey });
-
-        if (!module) throw new Error(`Module with key ${createDto.moduleUserKey} not found`);
-
-        const existingDashboard = await this.findOne({
-            where: { name: createDto.name },
-            relations: ['dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (existingDashboard) {
-            // Update basic fields
-            existingDashboard.layoutJson = JSON.stringify(createDto.layoutJson ?? {});
-            existingDashboard.module = module;
-
-            // Upsert dashboard variables
-            existingDashboard.dashboardVariables = createDto.dashboardVariables?.map(variable => {
-                const existingVar = existingDashboard.dashboardVariables.find(v => v.variableName === variable.variableName);
-                if (existingVar) {
-                    return Object.assign(existingVar, {
-                        ...variable,
-                        selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                        defaultValue: JSON.stringify(variable.defaultValue ?? []),
-                    });
-                }
-                return {
-                    ...variable,
-                    selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                    defaultValue: JSON.stringify(variable.defaultValue ?? []),
-                };
-            }) ?? [];
-
-            // Upsert questions and their configs
-            existingDashboard.questions = createDto.questions?.map(question => {
-                const existingQuestion = existingDashboard.questions.find(q => q.name === question.name);
-                const questionData: any = {
-                    ...question,
-                    questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => {
-                        const existingCfg = existingQuestion?.questionSqlDatasetConfigs.find(c => c.datasetName === cfg.datasetName);
-                        if (existingCfg) {
-                            return Object.assign(existingCfg, {
-                                ...cfg,
-                                options: JSON.stringify(cfg.options ?? {}),
-                            });
-                        }
-                        return {
-                            ...cfg,
-                            options: JSON.stringify(cfg.options ?? {}),
-                        };
-                    }) ?? [],
-                };
-
-                return existingQuestion ? Object.assign(existingQuestion, questionData) : questionData;
-            }) ?? [];
-
-            return this.save(existingDashboard);
-        }
-
-        // Else: new dashboard
-        const dashboardData = {
-            ...createDto,
-            module,
-            layoutJson: JSON.stringify(createDto.layoutJson ?? {}),
-            dashboardVariables: createDto.dashboardVariables?.map(variable => ({
-                ...variable,
-                selectionStaticValues: JSON.stringify(variable.selectionStaticValues ?? []),
-                defaultValue: JSON.stringify(variable.defaultValue ?? []),
-            })),
-            questions: createDto.questions?.map(question => ({
-                ...question,
-                questionSqlDatasetConfigs: question.questionSqlDatasetConfigs?.map(cfg => ({
-                    ...cfg,
-                    options: JSON.stringify(cfg.options ?? {}),
-                })),
-            })),
-        };
-
-        const newDashboard = this.create(dashboardData);
-        return this.save(newDashboard);
-    }
-}

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

@@ -1,111 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
-import { DashboardLayoutRepository } from 'src/repository/dashboard-layout.repository';
-import { CreateDashboardLayoutDto } from 'src/dtos/create-dashboard-layout.dto';
-import { RequestContextService } from './request-context.service';
-
-
-@Injectable()
-export class DashboardLayoutService extends CRUDService<DashboardLayout> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    readonly repo: DashboardLayoutRepository,
-    readonly requestContextService: RequestContextService,
-    readonly moduleRef: ModuleRef,
-  ) {
-    super(entityManager, repo, 'dashboardLayout', 'solid-core', moduleRef);
-  }
-
-  async upsertUserDashboardLayout(createDtos: CreateDashboardLayoutDto) {
-    const activeUser = this.requestContextService.getActiveUser();
-
-    if (!activeUser) {
-      throw new Error('User not found');
-    }
-
-    let userId = null;
-    if (activeUser.roles.includes('Admin')) {
-      userId = null;
-    } else {
-      userId = activeUser?.sub;
-    }
-    const existingLayout = await this.repo.findOne({
-      where: {
-        user: { id: userId },
-        dashboard: {
-          id: createDtos.dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-
-    if (existingLayout) {
-      return super.update(existingLayout.id, { layout: createDtos.layout }, [], true);
-    } else {
-      const createDto = {
-        layout: createDtos.layout,
-        dashboardId: createDtos.dashboardId,
-        uesrId: userId
-      }
-      return super.create(createDto, []);
-    }
-  }
-
-  async getUserDashboardLayoutByDashboardId(dashboardId: any) {
-    const activeUser = this.requestContextService.getActiveUser();
-
-    if (!activeUser) {
-      throw new Error('User not found');
-    }
-    const userId = activeUser?.sub;
-    const existingUserLayout = await this.repo.findOne({
-      where: {
-        user: { id: userId },
-        dashboard: {
-          id: dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-    if (existingUserLayout) {
-      // if dahsboard for userid exists 
-      return existingUserLayout;
-    }
-
-    // if not then check for default dashboard
-    const defaultLayout = await this.repo.findOne({
-      where: {
-        user: { id: null },
-        dashboard: {
-          id: dashboardId
-        }
-      },
-      relations: {
-        user: true,
-        dashboard: true,
-      }
-    });
-    if (defaultLayout) {
-      // if default layout exists return it
-      return defaultLayout;
-    } else {
-      // if default layout does not exist return empty layout 
-      return {
-        layout: null
-      }
-    }
-  }
-}

package/src/services/dashboard-question-sql-dataset-config.service.ts

@@ -1,25 +0,0 @@
-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 { DashboardQuestionSqlDatasetConfig } from '../entities/dashboard-question-sql-dataset-config.entity';
-import { DashboardQuestionSqlDatasetConfigRepository } from 'src/repository/dashboard-question-sql-dataset-config.repository';
-
-@Injectable()
-export class DashboardQuestionSqlDatasetConfigService extends CRUDService<DashboardQuestionSqlDatasetConfig>{
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardQuestionSqlDatasetConfig, 'default')
-    // readonly repo: Repository<DashboardQuestionSqlDatasetConfig>,
-    readonly repo: DashboardQuestionSqlDatasetConfigRepository,
-    readonly moduleRef: ModuleRef
-
- ) {
-   super(entityManager, repo, 'dashboardQuestionSqlDatasetConfig', 'solid-core', moduleRef);
- }
-}

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

@@ -1,150 +0,0 @@
-import { BadRequestException, Injectable, Logger, NotImplementedException } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-
-
-import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
-import { SolidRegistry } from 'src/helpers/solid-registry';
-import { DashboardQuestion } from '../entities/dashboard-question.entity';
-import { SqlExpression, SqlExpressionOperator } from './question-data-providers/chartjs-sql-data-provider.service';
-import { DashboardQuestionRepository } from 'src/repository/dashboard-question.repository';
-import { QuestionSqlDataProviderContext } from '../interfaces';
-
-enum SOURCE_TYPE {
-  SQL = 'sql',
-  PROVIDER = 'provider',
-}
-
-export const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
-export const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
-export const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
-
-export const INBUILT_SQL_DATA_PROVIDERS = [CHARTJS_SQL_DATA_PROVIDER_NAME, PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME, PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME];
-
-@Injectable()
-export class DashboardQuestionService extends CRUDService<DashboardQuestion> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardQuestion, 'default')
-    // readonly repo: Repository<DashboardQuestion>,
-    readonly repo: DashboardQuestionRepository,
-    readonly moduleRef: ModuleRef,
-    readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for data providers
-  ) {
-    super(entityManager, repo, 'dashboardQuestion', 'solid-core', moduleRef);
-  }
-
-  // Get the data for a specific question 
-  async getData(id: number, inputExpressions: SqlExpression[] = [], isPreview = false): Promise<any> {
-    // Load the question
-    const question = await this.loadQuestion(id);
-    if (!question) {
-      throw new BadRequestException(`Question with id ${id} not found`);
-    }
-
-    // Get the dashbbard variables from the question
-    const dashboardVariables = question.dashboard?.dashboardVariables || [];
-    const expressions: SqlExpression[] = this.getExpressions(isPreview, dashboardVariables, inputExpressions);
-
-    // Try to resolve the dataProvider based on a combination of sourceType and visualisedAs
-    let dataProvider = null;
-    let context = {};
-
-    // Decide which data provider to use based on the question visualisation type if sourceType is SQL. 
-    if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
-      context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
-            context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
-      context = {
-        expressions,
-      } as QuestionSqlDataProviderContext;
-    }
-
-    // If a custom provider is specified, use that one instead
-    if (question.sourceType === SOURCE_TYPE.PROVIDER) {
-      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(question.providerName);
-    }
-
-    if (!dataProvider) {
-      throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
-    }
-
-    return await dataProvider.getData(question, context);
-
-  }
-
-  private getExpressions(isPreview: boolean, dashboardVariables: DashboardVariable[], inputExpressions: SqlExpression[]) {
-    const expressions: SqlExpression[] = [];
-
-    if (isPreview) {
-      // Convert the dashboard variables into objects of interface type SqlExpression using the default value, default operator and the variable name
-      const expr: SqlExpression[] = dashboardVariables.map(variable => {
-        return {
-          variableName: variable.variableName,
-          operator: variable.defaultOperator as SqlExpressionOperator, // Assuming defaultOperator is a valid SqlExpressionOperator
-          value: JSON.parse(variable.defaultValue || '[]'), // Assuming defaultValue is a string or can be converted to a string array
-        };
-      });
-      expressions.push(...expr);
-    }
-    else {
-      // Loop through the dashboard variables and see if there is a matching input expression
-      // If there is, use that expression instead of the default value
-      for (const variable of dashboardVariables) {
-        const matchingInputExpression = inputExpressions.find(expr => expr.variableName === variable.variableName);
-        if (matchingInputExpression) {
-          expressions.push(matchingInputExpression);
-        }
-        else {
-          expressions.push({
-            variableName: variable.variableName,
-            operator: variable.defaultOperator as SqlExpressionOperator,
-            value: JSON.parse(variable.defaultValue || '[]'),
-          });
-        }
-      }
-      expressions.push(...expressions);
-    }
-
-    // Remove duplicate expressions based on variableName in the expressions array
-    const deduplicatedExpressions: SqlExpression[] = [];
-    const variableNames = new Set<string>();
-    for (const expr of expressions) {
-      if (!variableNames.has(expr.variableName)) {
-        deduplicatedExpressions.push(expr);
-        variableNames.add(expr.variableName);
-      }
-    }
-
-    return deduplicatedExpressions;
-  }
-
-  private async loadQuestion(id: number) {
-    const repo = this.entityManager.getRepository(DashboardQuestion);
-
-    // Load the dashboard record using the field
-    const question = await repo.findOne({
-      where: {
-        id,
-      },
-      relations: ['questionSqlDatasetConfigs', 'dashboard', 'dashboard.dashboardVariables'],
-    });
-    return question;
-  }
-
-}

package/src/services/dashboard-selection-providers/dashboard-variable-sql-dynamic-provider.service.ts

@@ -1,56 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { IDashboardVariableSelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-// import localeCodes from 'locale-codes';
-import { EntityManager } from "typeorm";
-import { DashboardVariableSelectionProvider } from "src/decorators/dashboard-selection-provider.decorator";
-
-@DashboardVariableSelectionProvider()
-@Injectable()
-export class DashboardVariableSQLDynamicProvider implements IDashboardVariableSelectionProvider<ISelectionProviderContext> {
-
-    constructor(private readonly entityManager: EntityManager) {
-    }
-
-    help(): string {
-        return "# Get the dashboard variable after executing the SQL query configured for the dashboard variable.\n";
-    }
-
-    name(): string {
-        return 'DashboardVariableSQLDynamicProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        throw new Error("DashboardVariableSQLDynamicProvider does not support value method. Use values method instead.");
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        const { sql, limit, offset } = ctxt as unknown as { sql: string, limit?: number, offset?: number };
-        if (!sql) {
-            throw new Error("DashboardVariableSQLDynamicProvider requires a SQL query to be provided in the context.");
-        }
-
-        // Here you would execute the SQL query against your database
-        // For demonstration, let's assume we have a mock database function that executes the SQL query
-        const results = await this.entityManager.query(this.appendLimitOffset(sql), [limit, offset]);
-
-        // Transform the results into the expected format
-        return results.map((result: any) => {
-            const transformedResult: ISelectionProviderValues = {
-                value: result.value, // Assuming the result has a 'value' field
-                label: result.label, // Assuming the result has a 'label' field
-                // Add any other fields you need to transform here
-            };
-            return transformedResult;
-        });
-    }
-
-    appendLimitOffset(sql: string): string {
-        // Strip trailing semicolon if present
-        const trimmedSql = sql.trim().replace(/;$/, '');
-
-        // Append the LIMIT/OFFSET
-        const finalSql = `${trimmedSql} LIMIT $1 OFFSET $2`; // FIXME This works with PostgreSQL. for mysql use ?. For this we will need to identify the datasource using the model for the particular dashboard variable
-
-        return finalSql;
-    }
-}

package/src/services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service.ts

@@ -1,37 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { IDashboardVariableSelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
-// import localeCodes from 'locale-codes';
-import { EntityManager } from "typeorm";
-import { DashboardVariableSelectionProvider } from "src/decorators/dashboard-selection-provider.decorator";
-
-@DashboardVariableSelectionProvider()
-@Injectable()
-export class DasbhoardVariableTestDynamicProvider implements IDashboardVariableSelectionProvider<ISelectionProviderContext> {
-
-    constructor(private readonly entityManager: EntityManager) {
-    }
-
-    help(): string {
-        return "# Get the dashboard variable values.\n";
-    }
-
-    name(): string {
-        return 'DasbhoardVariableTestDynamicProvider';
-    }
-
-    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
-        throw new Error("DasbhoardVariableTestDynamicProvider does not support value method. Use values method instead.");
-    }
-
-    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
-        // Return some dummy data for testing
-        const { sql, limit, offset } = ctxt as unknown as { sql: string, limit?: number, offset?: number };
-        return [
-            { value: '1', label: 'Option 1' },
-            { value: '2', label: 'Option 2' },
-            { value: '3', label: 'Option 3' },
-            { value: '4', label: 'Option 4' },
-        ]; 
-    }
-
-}

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

@@ -1,27 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-
-import { CRUDService } from 'src/services/crud.service';
-
-
-import { DashboardVariable } from '../entities/dashboard-variable.entity';
-import { DashboardVariableRepository } from 'src/repository/dashboard-variable.repository';
-
-@Injectable()
-export class DashboardVariableService extends CRUDService<DashboardVariable> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(DashboardVariable, 'default')
-    // readonly repo: Repository<DashboardVariable>,
-    readonly repo: DashboardVariableRepository,
-    readonly moduleRef: ModuleRef,
-  ) {
-    super(entityManager, repo, 'dashboardVariable', 'solid-core', moduleRef);
-  }
-
-
-}