@solidstarters/solid-core 1.2.134 → 1.2.136

package/src/services/import-transaction.service.ts

@@ -496,7 +496,7 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     };
   }
 
-  private async createErrorLogEntry(importTransaction: ImportTransaction, record: Record<string, any>, error: any) {
+  async createErrorLogEntry(importTransaction: ImportTransaction, record: Record<string, any>, error: any) {
     const importTransactionRepo = this.entityManager.getRepository(ImportTransactionErrorLog);
     // Create a new ImportTransactionErrorLog entry
     const rowNumber = uuidv4(); // Generate a unique row number or use page.rowNumber if available 
@@ -574,11 +574,39 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         return this.populateDtoForNumber(dtoRecord, fieldMetadata, record, key);
       case SolidFieldType.boolean:
         return this.populateDtoForBoolean(dtoRecord, fieldMetadata, record, key);
+      case SolidFieldType.selectionStatic:
+      case SolidFieldType.selectionDynamic:
+        return this.populateDtoForSelectionValues(dtoRecord, fieldMetadata, record, key);
       default:
         dtoRecord[fieldMetadata.name] = record[key];
         return dtoRecord;
     }
   }
+  
+  private populateDtoForSelectionValues(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
+    const rawValue = record[key];
+
+    if (rawValue == null) {
+      dtoRecord[fieldMetadata.name] = null;
+      return dtoRecord;
+    }
+
+    const isMultipleSelection = fieldMetadata.isMultiSelect;
+
+    if (isMultipleSelection) {
+      const selectionValues = String(rawValue)
+        .split(',')
+        .map(value => value.trim())
+        .filter(value => value !== '');
+
+      dtoRecord[fieldMetadata.name] = JSON.stringify(selectionValues);
+    } else {
+      dtoRecord[fieldMetadata.name] = rawValue; // Single select: assign directly
+    }
+
+    return dtoRecord;
+  }
+
 
   private populateDtoForBoolean(dtoRecord: Record<string, any>, fieldMetadata: FieldMetadata, record: Record<string, any>, key: string) {
     const booleanValue = Boolean(record[key]);

package/src/services/list-of-values.service.ts

@@ -39,6 +39,11 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
       },
     });
   }
+
+  async findAll(): Promise<ListOfValues[]> {
+    return await this.repo.find();
+  }
+  
   async upsert(updateListOfValuesDto: any) {
     // First check if module already exists using name
     const existingListOfValue = await this.repo.findOne({

package/src/services/menu-item-metadata.service.ts

@@ -169,7 +169,8 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           // TODO: Here we are assuming that we will always take the user to collection view of a model. 
           // We can make provision to take them other views also in the future. 
           // path = `/admin/core/${rootItem.module.name}/${rootItem.action.model.singularName}/${rootItem.action.view.name}`;
-          path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action.model.singularName)}/${rootItem.action.view.type}`;
+          path = `/admin/core/${rootItem.module.name}/${dasherize(rootItem.action?.model?.singularName ?? 'unknown')}/${rootItem.action?.view?.type ?? 'list'}`;
+
         }
       }
 

package/src/services/question-data-providers/chartjs-sql-data-provider.service.ts

@@ -0,0 +1,125 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { EntityManager } from "typeorm";
+import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
+import { getKpi, getLabels } from "./helpers";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+export enum SqlExpressionOperator {
+    EQUALS = '$equals',
+    NOT_EQUALS = '$notEquals',
+    CONTAINS = '$contains',
+    NOT_CONTAINS = '$notContains',
+    STARTS_WITH = '$startsWith',
+    ENDS_WITH = '$endsWith',
+    IN = '$in',
+    NOT_IN = '$notIn',
+    BETWEEN = '$between',
+    LT = '$lt',
+    LTE = '$lte',
+    GT = '$gt',
+    GTE = '$gte'
+}
+
+export interface SqlExpression {
+    variableName: string; // The name of the variable in the SQL query
+    operator: SqlExpressionOperator; // The operator to use for the replacement (e.g., '=', '>', '<', etc.)
+    value: string[]; // The value to replace the variable with
+}
+
+@DashboardQuestionDataProvider()
+@Injectable()
+export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
+    private readonly logger = new Logger(ChartJsSqlDataProvider.name);
+
+    constructor(private readonly entityManager: EntityManager, private readonly sqlExpressionResolver: SqlExpressionResolverService) { }
+
+    help(): string {
+        return "Provides data for dashboard questions using a SQL dataset configuration. Configure your SQL dataset in the admin panel, then reference it in your dashboard question to fetch data.";
+    }
+
+    name(): string {
+        return "ChartJsSqlDataProvider";
+    }
+
+    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+        // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
+
+        // This is what we have to return.
+        // const data = {
+        //     labels: ['January', 'February', 'March', 'April', 'May', 'June', 'July'],
+        //     datasets: [
+        //         {
+        //             label: 'Dataset 1',
+        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
+        //             backgroundColor: 'rgba(255, 99, 132, 0.5)',
+        //         },
+        //         {
+        //             label: 'Dataset 2',
+        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
+        //             backgroundColor: 'rgba(53, 162, 235, 0.5)',
+        //         },
+        //         {
+        //             label: 'Dataset 3',
+        //             data: labels.map(() => faker.number.int({ min: 0, max: 1000 })),
+        //             backgroundColor: 'rgba(53, 235, 162, 0.5)',
+        //         },
+        //     ],
+        // };
+
+        // TODO: Load the set of labels by using a separate field on the question entity.
+
+        let datasetIdx = 0;
+        const datasets = [];
+
+        const labels: string[] = await getLabels(question, expressions, this.entityManager, this.sqlExpressionResolver);
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
+
+        // const question = context.question;
+        for (const questionSqlDatasetConfig of question.questionSqlDatasetConfigs) {
+
+            const sql = questionSqlDatasetConfig.sql;
+            if (!sql) {
+                throw new Error(`SQL dataset ${questionSqlDatasetConfig.datasetName} configuration does not contain a valid SQL query.`);
+            }
+
+            const sqlReplacementResult = this.sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+            this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
+            this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is parameters=[${JSON.stringify(sqlReplacementResult.parameters)}]`);
+            const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+
+            // Also for each data set we create the dataset object as is expected by ChartJs.
+            const data = [];
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                data.push(result[questionSqlDatasetConfig.valueColumnName]);
+            }
+            datasets.push({
+                label: questionSqlDatasetConfig.datasetDisplayName,
+                data: data,
+                ...JSON.parse(questionSqlDatasetConfig.options || '{}'),
+            });
+
+            datasetIdx++;
+        }
+
+        return {
+            kpi,
+            visualizedAs: question.visualisedAs,
+            visualizationData: {
+                labels,
+                datasets
+            }
+        };
+
+    }
+
+
+}

package/src/services/question-data-providers/helpers.ts

@@ -0,0 +1,30 @@
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { EntityManager } from "typeorm";
+import { SqlExpression } from "./chartjs-sql-data-provider.service";
+import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
+
+export async function getLabels(question: DashboardQuestion, expressions: SqlExpression[], entityManager: EntityManager, sqlExpressionResolver: SqlExpressionResolverService): Promise<string[]> {
+    const sql = question.labelSql;
+    if (!sql) {
+        return [];
+    } 
+    const sqlReplacementResult = sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+   
+    const labelResults = await entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+    
+    // Assuming labelResults has a single row with a 'label' field
+    // Map the label results to the labels array
+    const labels: string[] = labelResults.map((result: { [x: string]: string; }) => result['label']);
+    return labels;
+}
+
+export async function getKpi(question: DashboardQuestion, expressions: SqlExpression[], entityManager: EntityManager, sqlExpressionResolver: SqlExpressionResolverService): Promise<string> {
+    const sql = question.kpiSql;
+    if (!sql) {
+        return "";
+    }
+    const sqlReplacementResult = sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+    const result = await entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+    const kpiResult = result.pop();
+    return kpiResult?.kpi || "";
+}

package/src/services/question-data-providers/prime-react-datatable-sql-data-provider.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { EntityManager } from "typeorm";
+import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
+import { Logger } from '@nestjs/common';
+import { SqlExpression } from "./chartjs-sql-data-provider.service";
+import { getKpi } from "./helpers";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+@DashboardQuestionDataProvider()
+@Injectable()
+export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
+    private readonly logger = new Logger(PrimeReactDatatableSqlDataProvider.name);
+
+    constructor(private readonly entityManager: EntityManager, private readonly sqlExpressionResolver: SqlExpressionResolverService) { }
+
+    help(): string {
+        return "Provides data for dashboard questions using a SQL dataset configuration. Configure your SQL dataset in the admin panel, then reference it in your dashboard question to fetch data.";
+    }
+
+    name(): string {
+        return "PrimeReactDatatableSqlDataProvider";
+    }
+
+    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+        // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
+
+        // Check the expected response for prime react data tables to understand what is going on here...
+
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
+        // TODO: Load the set of labels by using a separate field on the question entity.
+        const labelSql = question.labelSql;
+        const labelResults = await this.entityManager.query(labelSql);
+        const columns = [];
+        for (let i = 0; i < labelResults.length; i++) {
+            const labelResult = labelResults[i];
+            columns.push({
+                field: labelResult['field'],
+                header: labelResult['header'],
+            });
+        }
+
+        // Load the chart options as a JSON 
+        // const chartOptions = JSON.parse(question.barChartLabelOptions || '{}');
+
+        const values = []
+
+        // For meter group we can assume that we only have one sql dataset config.
+        const questionSqlDatasetConfig = question.questionSqlDatasetConfigs[0];
+
+        const sql = questionSqlDatasetConfig.sql;
+        if (!sql) {
+            throw new Error(`SQL dataset ${questionSqlDatasetConfig.datasetName} configuration does not contain a valid SQL query.`);
+        }
+
+        const sqlReplacementResult = this.sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is parameters=[${JSON.stringify(sqlReplacementResult.parameters)}]`);
+        const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+
+        return {
+            kpi,
+            visualisedAs: question.visualisedAs,
+            visualizationData: {
+                columns,
+                rows: results,
+            }
+        };
+
+    }
+}

package/src/services/question-data-providers/prime-react-meter-group-sql-data-provider.service.ts

@@ -0,0 +1,119 @@
+import { Injectable } from "@nestjs/common";
+import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
+import { DashboardQuestion } from "src/entities/dashboard-question.entity";
+import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { EntityManager } from "typeorm";
+import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
+import { Logger } from '@nestjs/common';
+import { SqlExpression } from "./chartjs-sql-data-provider.service";
+import { getKpi } from "./helpers";
+
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+}
+
+@DashboardQuestionDataProvider()
+@Injectable()
+export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
+    private readonly logger = new Logger(PrimeReactMeterGroupSqlDataProvider.name);
+
+    constructor(private readonly entityManager: EntityManager, private readonly sqlExpressionResolver: SqlExpressionResolverService) { }
+
+    help(): string {
+        return "Provides data for dashboard questions using a SQL dataset configuration. Configure your SQL dataset in the admin panel, then reference it in your dashboard question to fetch data.";
+    }
+
+    name(): string {
+        return "PrimeReactMeterGroupSqlDataProvider";
+    }
+
+    hslToHex(h: number, s: number, l: number): string {
+        l /= 100;
+        s /= 100;
+
+        const k = (n: number) => (n + h / 30) % 12;
+        const a = s * Math.min(l, 1 - l);
+        const f = (n: number) =>
+            Math.round(255 * (l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)))));
+
+        return `#${f(0).toString(16).padStart(2, '0')}${f(8).toString(16).padStart(2, '0')}${f(4)
+            .toString(16)
+            .padStart(2, '0')}`;
+    }
+
+    generateDistinctColors(count: number): string[] {
+        const colors: string[] = [];
+
+        const hueStep = 360 / count;
+        const saturation = 65; // keep it vibrant
+        const lightness = 55;  // balanced for both light/dark themes
+
+        for (let i = 0; i < count; i++) {
+            const hue = Math.round(i * hueStep);
+            colors.push(this.hslToHex(hue, saturation, lightness));
+        }
+
+        return colors;
+    }
+
+    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+        // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
+
+        // This is what we have to return.
+        // const values = [
+        //     { label: 'Apps', color: '#34d399', value: 16 },
+        //     { label: 'Messages', color: '#fbbf24', value: 8 },
+        //     { label: 'Media', color: '#60a5fa', value: 24 },
+        //     { label: 'System', color: '#c084fc', value: 10 }
+        // ];
+
+        // TODO: Load the set of labels by using a separate field on the question entity.
+
+        const kpi: string = await getKpi(question, expressions, this.entityManager, this.sqlExpressionResolver);
+        
+        // Load the chart options as a JSON 
+        const chartOptions = JSON.parse(question.chartOptions || '{}');
+
+        const values = []
+
+        // For meter group we can assume that we only have one sql dataset config.
+        const questionSqlDatasetConfig = question.questionSqlDatasetConfigs[0];
+
+        const sql = questionSqlDatasetConfig.sql;
+        if (!sql) {
+            throw new Error(`SQL dataset ${questionSqlDatasetConfig.datasetName} configuration does not contain a valid SQL query.`);
+        }
+
+        const sqlReplacementResult = this.sqlExpressionResolver.resolveSqlWithExpressions(sql, expressions || []);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is query=[${sqlReplacementResult.rawSql}]`);
+        this.logger.debug(`Final Sql query for dataset [${questionSqlDatasetConfig.datasetName}] is parameters=[${JSON.stringify(sqlReplacementResult.parameters)}]`);
+        const results = await this.entityManager.query(sqlReplacementResult.rawSql, sqlReplacementResult.parameters);
+
+        const colors = this.generateDistinctColors(results.length);
+
+        // Also for each data set we create the dataset object as is expected by ChartJs.
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+
+            const colorFromChartOptions = chartOptions?.colors?.[result[questionSqlDatasetConfig.labelColumnName]];
+            const color = typeof colorFromChartOptions === 'string' ? colorFromChartOptions : colors[i];
+
+            values.push({
+                label: result[questionSqlDatasetConfig.labelColumnName],
+                color: color,
+                value: result[questionSqlDatasetConfig.valueColumnName]
+            })
+        }
+
+        return {
+            kpi,
+            visualizedAs: question.visualisedAs,
+            visualizationData: {
+                dataset: values
+            },
+        };
+
+    }
+}

package/src/services/question-data-providers/test.sql

@@ -0,0 +1 @@
+SELECT  TO_CHAR(DATE_TRUNC('month', created_at), 'Mon-YYYY') AS label,FROM  public.sapphire_clientwhere   created_at >= $1  GROUP BY   DATE_TRUNC('month', created_at) ORDER BY   DATE_TRUNC('month', created_at)

package/src/services/queues/publisher-factory.service.ts

@@ -16,7 +16,7 @@ export class PublisherFactory<T> {
     }
 
     async publish(message: QueueMessage<T>, publisherName: string, brokerToUse?: string): Promise<string> {
-        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER;
+        let defaultBrokerToUse = brokerToUse || process.env.QUEUES_DEFAULT_BROKER || "database";
         let resolvedPublisherName = `${publisherName}${classify(defaultBrokerToUse)}`;
 
         // Register all ISolidDatabaseModules implementations

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -18,88 +18,54 @@ export class SchedulerServiceImpl implements ISchedulerService {
         private readonly solidRegistry: SolidRegistry,
     ) { }
 
-    // @Cron(CronExpression.EVERY_MINUTE)
-    // async runScheduledJobs(): Promise<void> {
-    //     const now = new Date();
-
-    //     const dueScheduledJobs = await this.scheduledJobRepo.find({
-    //         where: {
-    //             isActive: true,
-    //             nextRunAt: LessThanOrEqual(now),
-    //         },
-    //     });
-
-    //     for (const dueScheduledJob of dueScheduledJobs) {
-    //         try {
-    //             const jobName = dueScheduledJob.job;
-    //             // @ts-ignore                
-    //             // const jobHandler = this.jobMap[jobName];
-    //             // const jobHandler = ''; 
-    //             const jobHandler: IScheduledJob | undefined = this.solidRegistry.getScheduledJobProviderInstance(jobName)
-
-    //             if (!jobHandler) {
-    //                 this.logger.warn(`No job service found for: ${jobName}`);
-    //                 continue;
-    //             }
-
-    //             await jobHandler.executeReminder(dueScheduledJob);
-
-    //             // Update nextRunAt and lastRunAt based on frequency
-    //             dueScheduledJob.lastRunAt = now;
-    //             dueScheduledJob.nextRunAt = this.computeNextRunAt(dueScheduledJob);
-    //             await this.scheduledJobRepo.save(dueScheduledJob);
-
-    //             this.logger.log(`Successfully ran job: ${jobName}`);
-    //         } catch (err) {
-    //             this.logger.error(`Failed to run job for reminder ${dueScheduledJob.id}`, err.stack);
-    //         }
-    //     }
-    // }
-
-    // private computeNextRunAt(reminder: ScheduledJob): Date {
-    //     const now = new Date();
-    //     switch (reminder.frequency) {
-    //         case 'daily':
-    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000);
-    //         case 'weekly':
-    //             return new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
-    //         case 'monthly':
-    //             return new Date(now.setMonth(now.getMonth() + 1));
-    //         default:
-    //             return new Date(now.getTime() + 24 * 60 * 60 * 1000); // default fallback
-    //     }
-    // }
-
     @Cron(CronExpression.EVERY_MINUTE)
     async runScheduledJobs(): Promise<void> {
         const now = new Date();
+
+        this.logger.log(`[${now.getTime()}]: scheduler service started run...`);
         const dueJobs = await this.scheduledJobRepo.find({
-            where: {
-                isActive: true,
-                nextRunAt: LessThanOrEqual(now),
-            },
+            where: [
+                {
+                    isActive: true,
+                    nextRunAt: LessThanOrEqual(now),
+                },
+                // Newly created jobs are also picked for examination 
+                {
+                    isActive: true,
+                    nextRunAt: null,
+                },
+            ],
         });
 
+        this.logger.log(`[${now.getTime()}]: scheduler service identified ${dueJobs.length} jobs to run...`);
+
         for (const job of dueJobs) {
+            this.logger.log(`[${now.getTime()}]: scheduler service attempting to run job ${job.job}`);
             try {
                 if (!this.shouldRunNow(job, now)) {
+                    this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${job.job}`);
                     continue;
                 }
 
                 const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
                 if (!handler) {
-                    this.logger.warn(`No job handler found for job: ${job.job}`);
+                    this.logger.warn(`[${now.getTime()}]: scheduler service skipping because job handler not found: ${job.job}`);
                     continue;
                 }
 
+                this.logger.log(`[${now.getTime()}]: scheduler service about to run job ${job.job}`);
                 await handler.executeReminder(job);
+                this.logger.log(`[${now.getTime()}]: scheduler service finished running job ${job.job}`);
+
                 job.isActive = true;
                 job.lastRunAt = now;
                 job.nextRunAt = this.computeNextRunAt(job, now);
+                this.logger.log(`[${now.getTime()}]: scheduler service coomputed next run for ${job.job} as ${job.nextRunAt}`);
+
                 await this.scheduledJobRepo.save(job);
-                this.logger.log(`Successfully ran job: ${job.job}`);
+                this.logger.log(`[${now.getTime()}]: scheduler service finished running job: ${job.job}`);
             } catch (err) {
-                this.logger.error(`Failed to run job ${job.job}`, err.stack);
+                this.logger.error(`[${now.getTime()}]: scheduler service failed to run job ${job.job}`, err.stack);
             }
         }
     }
@@ -143,8 +109,10 @@ export class SchedulerServiceImpl implements ISchedulerService {
         const base = new Date(from);
 
         switch (job.frequency.toLowerCase()) {
-            case 'once':
-                return null; // don't reschedule
+            // case 'once':
+            //     return null; // don't reschedule
+            case 'every minute':
+                return new Date(base.getTime() + 1 * 60 * 1000);
             case 'hourly':
                 return new Date(base.getTime() + 60 * 60 * 1000);
             case 'daily':
@@ -155,9 +123,9 @@ export class SchedulerServiceImpl implements ISchedulerService {
                 const next = new Date(base);
                 next.setMonth(base.getMonth() + 1);
                 return next;
-            case 'custom':
-                // Optional: let job handler decide via metadata or registry
-                return new Date(base.getTime() + 24 * 60 * 60 * 1000);
+            // case 'custom':
+            //     // Optional: let job handler decide via metadata or registry
+            //     return new Date(base.getTime() + 24 * 60 * 60 * 1000);
             default:
                 return new Date(base.getTime() + 24 * 60 * 60 * 1000);
         }

package/src/services/selection-providers/list-of-dashboard-question-providers-selection-provider.service.ts

@@ -0,0 +1,41 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+import { SQL_DYNAMIC_PROVIDER_NAME } from "../dashboard.service";
+
+
+@SelectionProvider()
+@Injectable()
+export class ListOfDashboardQuestionProvidersSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry,
+    ) {
+    }
+
+    help(): string {
+        return "# Allows one to dynamically fetch all the dashboard providers that are registered in the system. ";
+    }
+
+    name(): string {
+        return 'ListOfDashboardQuestionProvidersSelectionProvider';
+    }
+
+    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const dashboardSelectionProvider: IDashboardQuestionDataProvider<any, any> | undefined = this.solidRegistry.getDashboardQuestionDataProviderInstance(optionValue);
+        if (!dashboardSelectionProvider) {
+            return null;
+        }
+
+        return { label: dashboardSelectionProvider.name(), value: dashboardSelectionProvider.name() };
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const dashboardSelectionProviders = this.solidRegistry.getDashboardQuestionDataProviders()
+        //Exclude the SQL dynamic provider from the list, (since although it is a dashboard selection provider, it is not a valid option for the user to select)
+        return dashboardSelectionProviders.map(i => {
+            return { label: i.name, value: i.name };
+        });
+    }
+}

package/src/services/selection-providers/list-of-dashboard-variable-providers-selection-provider.service.ts

@@ -0,0 +1,41 @@
+import { Injectable } from "@nestjs/common";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IDashboardVariableSelectionProvider, ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+import { SQL_DYNAMIC_PROVIDER_NAME } from "../dashboard.service";
+
+
+@SelectionProvider()
+@Injectable()
+export class ListOfDashboardVariableProvidersSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry,
+    ) {
+    }
+
+    help(): string {
+        return "# Allows one to dynamically fetch all the dashboard providers that are registered in the system. ";
+    }
+
+    name(): string {
+        return 'ListOfDashboardVariableProvidersSelectionProvider';
+    }
+
+    async value(optionValue: string, ctxt: ISelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const dashboardSelectionProvider: IDashboardVariableSelectionProvider<ISelectionProviderContext> | undefined = this.solidRegistry.getDashboardVariableSelectionProviderInstance(optionValue);
+        if (!dashboardSelectionProvider) {
+            return null;
+        }
+
+        return { label: dashboardSelectionProvider.name(), value: dashboardSelectionProvider.name() };
+    }
+
+    async values(query: string, ctxt: ISelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const dashboardSelectionProviders = this.solidRegistry.getDashboardVariableSelectionProviders()
+        //Exclude the SQL dynamic provider from the list, (since although it is a dashboard selection provider, it is not a valid option for the user to select)
+        return dashboardSelectionProviders.filter(i => (i.name !== SQL_DYNAMIC_PROVIDER_NAME)).map(i => {
+            return { label: i.name, value: i.name };
+        });
+    }
+}