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

package/src/services/sql-expression-resolver.service.ts

@@ -1,140 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { SqlExpression, SqlExpressionOperator } from "./question-data-providers/chartjs-sql-data-provider.service";
-import { RequestContextService } from "./request-context.service";
-import { ERROR_MESSAGES } from "src/constants/error-messages";
-
-export interface SqlReplacementResult {
-  rawSql: string;
-  parameters: any[]; // Positional parameters
-}
-
-@Injectable()
-export class SqlExpressionResolverService {
-  constructor(private readonly requestContextService: RequestContextService) { }
-  resolveSqlWithExpressions(sql: string, expressions: SqlExpression[]): SqlReplacementResult {
-    const variableToColumnMap: Record<string, string> = {};
-    const variablePattern = /{{\s*(\w+)\s*\[\s*([\w.]+)\s*\]\s*}}/g;
-
-    let paramIndex = 1;
-    const parameters: any[] = [];
-
-    // Handle sql expression tokens like {{$activeUserId}} in the SQL string
-    if (sql.includes('{{$activeUserId}}')) {
-      const activeUser = this.requestContextService.getActiveUser();
-      if (activeUser && activeUser.sub) {
-        // Replace custom placeholder with parameter placeholder ($1)
-        sql = sql.replace(/\{\{\$activeUserId\}\}/g, `$${paramIndex++}`);
-        // Add the active user ID to parameters
-        parameters.push(activeUser.sub);
-      }
-    }
-
-    // --- Pass 1: extract variable -> column mappings ---
-    let simplifiedSql = sql.replace(variablePattern, (_, variableName, columnName) => {
-      variableToColumnMap[variableName] = columnName;
-      return `{{${variableName}}}`;
-    });
-
-    // --- Pass 2: Replace each variable with positional fragment ---
-
-    for (const expr of expressions) {
-      const column = variableToColumnMap[expr.variableName];
-      if (!column) continue;
-
-      let sqlFragment = '';
-      const placeholder = `{{${expr.variableName}}}`;
-
-      switch (expr.operator) {
-        case SqlExpressionOperator.EQUALS:
-          sqlFragment = `${column} = $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        case SqlExpressionOperator.NOT_EQUALS:
-          sqlFragment = `${column} != $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        case SqlExpressionOperator.CONTAINS:
-          sqlFragment = `${column} LIKE $${paramIndex++}`;
-          parameters.push(`%${expr.value[0]}%`);
-          break;
-
-        case SqlExpressionOperator.NOT_CONTAINS:
-          sqlFragment = `${column} NOT LIKE $${paramIndex++}`;
-          parameters.push(`%${expr.value[0]}%`);
-          break;
-
-        case SqlExpressionOperator.STARTS_WITH:
-          sqlFragment = `${column} LIKE $${paramIndex++}`;
-          parameters.push(`${expr.value[0]}%`);
-          break;
-
-        case SqlExpressionOperator.ENDS_WITH:
-          sqlFragment = `${column} LIKE $${paramIndex++}`;
-          parameters.push(`%${expr.value[0]}`);
-          break;
-
-        case SqlExpressionOperator.IN:
-          const inParams = expr.value.map(val => {
-            parameters.push(val);
-            return `$${paramIndex++}`;
-          });
-          sqlFragment = `${column} IN (${inParams.join(", ")})`;
-          break;
-
-        case SqlExpressionOperator.NOT_IN:
-          const notInParams = expr.value.map(val => {
-            parameters.push(val);
-            return `$${paramIndex++}`;
-          });
-          sqlFragment = `${column} NOT IN (${notInParams.join(", ")})`;
-          break;
-
-        case SqlExpressionOperator.BETWEEN:
-          sqlFragment = `${column} BETWEEN $${paramIndex} AND $${paramIndex + 1}`;
-          parameters.push(expr.value[0], expr.value[1]);
-          paramIndex += 2;
-          break;
-
-        case SqlExpressionOperator.LT:
-          sqlFragment = `${column} < $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        case SqlExpressionOperator.LTE:
-          sqlFragment = `${column} <= $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        case SqlExpressionOperator.GT:
-          sqlFragment = `${column} > $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        case SqlExpressionOperator.GTE:
-          sqlFragment = `${column} >= $${paramIndex++}`;
-          parameters.push(expr.value[0]);
-          break;
-
-        default:
-          throw new Error(ERROR_MESSAGES.UNSUPPORTED_SQL_OPERATOR(expr.operator));
-      }
-      simplifiedSql = simplifiedSql.replace(placeholder, sqlFragment);
-    }
-
-    // --- Final cleanup: remove any remaining placeholders ---
-    simplifiedSql = simplifiedSql.replace(/{{\s*\w+\s*}}/g, '');
-
-    // Remove dangling where clause if no expressions were applied
-    simplifiedSql = simplifiedSql.replace(/\bwhere\b\s*$/i, '').trim();
-
-    // Need to handle scenarios of complex expression i.e with and / or clauses. probably need to have this logic in the sql expression object itself
-
-
-    return {
-      rawSql: simplifiedSql,
-      parameters
-    };
-  }
-}

package/src/subscribers/dashboard-question-sql-dataset-config.subscriber.ts

@@ -1,61 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { InjectDataSource } from "@nestjs/typeorm";
-import { DashboardQuestionSqlDatasetConfig } from "src/entities/dashboard-question-sql-dataset-config.entity";
-import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
-import { DashboardService } from "src/services/dashboard.service";
-import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
-
-@Injectable()
-export class DashboardQuestionSqlDatasetConfigSubscriber implements EntitySubscriberInterface<DashboardQuestionSqlDatasetConfig> {
-    private readonly logger = new Logger(this.constructor.name);
-    constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
-        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
-    ) {
-        this.dataSource.subscribers.push(this);
-    }
-
-    listenTo() {
-        return DashboardQuestionSqlDatasetConfig;
-    }
-
-    async afterInsert(event: InsertEvent<DashboardQuestionSqlDatasetConfig>) {
-        const question = event.entity.question;
-        if (!question) {
-            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterInsert method');
-            return;
-        }
-        await this.saveQuestionToConfig(question, event.queryRunner.manager);
-    }
-
-    async afterUpdate(event: UpdateEvent<DashboardQuestionSqlDatasetConfig>) {
-        const question = event.databaseEntity.question;
-        if (!question) {
-            this.logger.debug('No question found in the QuestionSqlDatasetConfigSubscriber afterUpdate method');
-            return;
-        }
-        await this.saveQuestionToConfig(question, event.queryRunner.manager);
-    }
-
-    private async saveQuestionToConfig(question: DashboardQuestion, entityManager: EntityManager): Promise<void> {
-        // Populate the dashboard for the question
-        const populatedQuestion = await entityManager.findOne(DashboardQuestion, {
-            where: {
-                id: question.id,
-            },
-            relations: ['dashboard', 'dashboard.module', 'dashboard.dashboardVariables', 'dashboard.questions', 'dashboard.questions.questionSqlDatasetConfigs'],
-        });
-        const dashboard = populatedQuestion?.dashboard;
-
-        if (!dashboard) {
-            throw new Error(`Dashboard not found for question id ${question.id}`);
-        }
-
-        // Call the saveDashboardToConfig method from the DashboardService
-        await this.dashboardService.saveDashboardToConfig(dashboard);
-    }
-
-}

package/src/subscribers/dashboard-question.subscriber.ts

@@ -1,62 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { InjectDataSource } from "@nestjs/typeorm";
-import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { Dashboard } from "src/entities/dashboard.entity";
-import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
-import { DashboardService } from "src/services/dashboard.service";
-import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
-
-@Injectable()
-export class DashboardQuestionSubscriber implements EntitySubscriberInterface<DashboardQuestion> {
-    private readonly logger = new Logger(this.constructor.name);
-    constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
-        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-        readonly dashboardService: DashboardService,
-    ) {
-        this.dataSource.subscribers.push(this);
-    }
-
-    listenTo() {
-        return DashboardQuestion;
-    }
-
-    async afterInsert(event: InsertEvent<DashboardQuestion>) {
-        if (!event.entity) {
-            this.logger.debug('No question entity found in the QuestionSubscriber afterInsert method');
-            return;
-        }
-        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
-    }
-
-    async afterUpdate(event: UpdateEvent<DashboardQuestion>) {
-        if (!event.databaseEntity) {
-            this.logger.debug('No question entity found in the QuestionSubscriber afterUpdate method');
-            return;
-        }
-        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
-    }
-
-    private async saveDashboardToConfig(question: DashboardQuestion, entityManager: EntityManager): Promise<void> {
-        const dashboard = question.dashboard;
-        // Get the dashboard from the question & call the saveDashboardToConfig method
-        if (!dashboard) {
-            this.logger.debug(`Dashboard is undefined for question id ${question.id}`);
-            return;
-        }
-
-        // populate the dashboard with its variables
-        const populatedDashboard = await entityManager.findOne(Dashboard, {
-            where: { id: dashboard.id },
-            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (!populatedDashboard) {
-            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
-        }
-
-        // Call the saveDashboardToConfig method from the DashboardService
-        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
-    }
-}

package/src/subscribers/dashboard-variable.subscriber.ts

@@ -1,63 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { InjectDataSource } from "@nestjs/typeorm";
-import { DashboardVariable } from "src/entities/dashboard-variable.entity";
-import { Dashboard } from "src/entities/dashboard.entity";
-import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
-import { DashboardVariableService } from "src/services/dashboard-variable.service";
-import { DashboardService } from "src/services/dashboard.service";
-import { EntitySubscriberInterface, DataSource, InsertEvent, UpdateEvent, EntityManager } from "typeorm";
-
-@Injectable()
-export class DashboardVariableSubscriber implements EntitySubscriberInterface<DashboardVariable> {
-    private readonly logger = new Logger(this.constructor.name);
-    constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
-        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
-    ) {
-        this.dataSource.subscribers.push(this);
-    }
-
-    listenTo() {
-        return DashboardVariable;
-    }
-
-    async afterInsert(event: InsertEvent<DashboardVariable>) {
-        if (!event.entity) {
-            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterInsert method');
-            return;
-        }
-        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
-    }
-
-    async afterUpdate(event: UpdateEvent<DashboardVariable>) {
-        if (!event.databaseEntity) {
-            this.logger.debug('No dashboard variable entity found in the DashboardVariableSubscriber afterUpdate method');
-            return;
-        }
-        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
-    }
-
-    private async saveDashboardToConfig(dashboardVariable: DashboardVariable, entityManager: EntityManager): Promise<void> {
-        const dashboard = dashboardVariable.dashboard;
-        // Get the dashboard from the question & call the saveDashboardToConfig method
-        if (!dashboard) {
-            this.logger.debug(`Dashboard is undefined for dashboard variable id ${dashboardVariable.id}`);
-            return;
-        }
-
-        // populate the dashboard with its variables
-        const populatedDashboard = await entityManager.findOne(Dashboard, {
-            where: { id: dashboard.id },
-            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (!populatedDashboard) {
-            throw new Error(`Dashboard not found for question id ${populatedDashboard.id}`);
-        }
-
-        // Call the saveDashboardToConfig method from the DashboardService
-        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
-    }
-}

package/src/subscribers/dashboard.subscriber.ts

@@ -1,62 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectDataSource } from "@nestjs/typeorm";
-import { Dashboard } from 'src/entities/dashboard.entity';
-import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
-import { DashboardService } from 'src/services/dashboard.service';
-import { DataSource, EntityManager, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
-
-@Injectable()
-export class DashboardSubscriber implements EntitySubscriberInterface<Dashboard> {
-    private readonly logger = new Logger(this.constructor.name);
-    constructor(
-        @InjectDataSource()
-        private readonly dataSource: DataSource,
-        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-        readonly dashboardService: DashboardService, // Assuming you have a DashboardService for custom queries
-    ) {
-        this.dataSource.subscribers.push(this);
-    }
-
-    listenTo() {
-        return Dashboard;
-    }
-
-    async afterInsert(event: InsertEvent<Dashboard>) {
-        if (!event.entity) {
-            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
-            return;
-        }
-        await this.saveDashboardToConfig(event.entity, event.queryRunner.manager);
-    }
-
-    async afterUpdate(event: UpdateEvent<Dashboard>) {
-        if (!event.entity) {
-            this.logger.debug('No dashboard entity found in the DashboardSubscriber afterInsert method');
-            return;
-        }
-
-        await this.saveDashboardToConfig(event.databaseEntity, event.queryRunner.manager);
-    }
-
-    private async saveDashboardToConfig(dashboard: Dashboard, entityManager: EntityManager): Promise<void> {
-        if (!dashboard || !dashboard.id) {
-            this.logger.debug('Dashboard or dashboard id is undefined');
-            return;
-        }
-
-        // Load the dashboard with module relation populated
-        const populatedDashboard = await entityManager.findOne(Dashboard, {
-            where: { id: dashboard.id },
-            relations: ['module','dashboardVariables', 'questions', 'questions.questionSqlDatasetConfigs'],
-        });
-
-        if (!populatedDashboard) {
-            this.logger.error(`Dashboard not found for id ${dashboard.id}`);
-            return;
-        }
-
-        // Call the saveDashboardToConfig method from the DashboardService
-        await this.dashboardService.saveDashboardToConfig(populatedDashboard);
-    }
-
-}