@solidxai/core 0.1.10-beta.9 → 0.1.10

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);
-  }
-
-
-}

package/src/services/dashboard.service.ts

@@ -1,148 +0,0 @@
-import { Injectable, Logger, NotFoundException } 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 * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
-import { SelectionDynamicSourceType } from 'src/dtos/create-dashboard-variable.dto';
-import { DashboardVariableSelectionDynamicQueryDto } from 'src/dtos/dashboard-variable-selection-dynamic-query.dto';
-import { DashboardVariable } from 'src/entities/dashboard-variable.entity';
-import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
-import { SolidRegistry } from 'src/helpers/solid-registry';
-import { DashboardMapper } from 'src/mappers/dashboard-mapper';
-import { DashboardRepository } from 'src/repository/dashboard.repository';
-import { Dashboard } from '../entities/dashboard.entity';
-import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
-
-
-export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
-@Injectable()
-export class DashboardService extends CRUDService<Dashboard> {
-  private readonly logger = new Logger(this.constructor.name);
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    readonly repo: DashboardRepository, // Assuming you have a DashboardRepository for custom queries
-    readonly moduleRef: ModuleRef,
-    readonly solidRegistry: SolidRegistry, // Assuming solidRegistry is injected for selection providers
-    readonly moduleMetadataHelperService: ModuleMetadataHelperService,
-    readonly dashboardMapper: DashboardMapper,
-  ) {
-    super(entityManager, repo, 'dashboard', 'solid-core', moduleRef);
-  }
-
-
-  async create(createDto: CreateDashboardDto, files: Express.Multer.File[]) {
-    createDto.name = createDto.name.trim().replace(/\s+/g, '-').toLowerCase();
-    return super.create(createDto, files);
-  }
-
-  async getSelectionDynamicValues(query: DashboardVariableSelectionDynamicQueryDto) {
-    // Get the dashboard variable repo
-    const dashboardVariable = await this.loadDashboardVariable(query.variableId);
-
-    // Get the providerName and context for the dashboard variable
-    const [providerName, context] = this.getProviderNameAndContext(dashboardVariable, query);
-
-    // Get hold of the provider instance from the SolidRegistry
-    const selectionProviderInstance = this.solidRegistry.getDashboardVariableSelectionProviderInstance(providerName);
-    if (!selectionProviderInstance) {
-      throw new NotFoundException(`Field incorrectly configured. No provider with name ${providerName} registered in backend.`);
-    }
-
-    // 4. Call the provider's getSelectionDynamicValues method
-    return selectionProviderInstance.values(query.query, context);
-  }
-
-
-  private getProviderNameAndContext(dashboardVariable: DashboardVariable, query: DashboardVariableSelectionDynamicQueryDto): [string, any] {
-    const sourceType = dashboardVariable.selectionDynamicSourceType;
-
-    // Get the appropriate provide name based on the source type
-    let providerName: string;
-    const context = { limit: query.limit, offset: query.offset };
-    switch (sourceType) {
-      case SelectionDynamicSourceType.SQL:
-        providerName = SQL_DYNAMIC_PROVIDER_NAME;
-        context['sql'] = dashboardVariable.selectionDynamicSQL;
-        break;
-      case SelectionDynamicSourceType.PROVIDER:
-        providerName = dashboardVariable.selectionDynamicProviderName;
-        break;
-      default:
-        throw new Error(`Unsupported selection dynamic source type: ${sourceType}`);
-    }
-    return [providerName, context];
-  }
-
-  private async loadDashboardVariable(variableId: number) {
-    const dashboardVariableRepo = this.entityManager.getRepository(DashboardVariable);
-
-    // Load the dashboard record using the field
-    const dashboardVariable = await dashboardVariableRepo.findOne({
-      where: {
-        id: variableId,
-      },
-    });
-    return dashboardVariable;
-  }
-
-  async saveDashboardToConfig(entity: Dashboard) {
-    if (!entity) {
-      this.logger.debug('No entity found in the DashboardSubscriber saveDashboardToConfig method');
-      return;
-    }
-
-    // Validate dashboard details
-    const dashboard = entity as Dashboard;
-    const moduleMetadata = entity.module;
-    if (!moduleMetadata) {
-      throw new Error(`Module metadata not found for dashboard id ${entity.id}`);
-    }
-
-    // Get config file details
-    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name);
-    if (!filePath || !metaData) {
-      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
-    }
-
-    // Write the dashboard to the config file
-    await this.writeToConfig(metaData, dashboard, filePath);
-  }
-
-  private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
-    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
-    try {
-      await fs.access(filePath);
-    } catch (error: any) {
-      throw new Error(`Configuration file not found for module: ${moduleName}`);
-    }
-    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
-    return { filePath, metaData };
-  }
-
-  private async writeToConfig(metaData: any, dashboard: Dashboard, filePath: string) {
-    if (metaData.dashboards && Array.isArray(metaData.dashboards)) {
-      const dashboardIndex = metaData.dashboards?.findIndex((dashboardFromFile: { name: string; }) => dashboardFromFile.name === dashboard.name);
-      const dto = await this.dashboardMapper.toDto(dashboard);
-      if (dashboardIndex !== -1) {
-        metaData.dashboards[dashboardIndex] = dto;
-      }
-      else {
-        metaData.dashboards.push(dto);
-      }
-    }
-    else {
-      const dashboards = [];
-      const dto = await this.dashboardMapper.toDto(dashboard);
-      dashboards.push(dto);
-      metaData.dashboards = dashboards;
-    }
-    // Write the updated object back to the file
-    const updatedContent = JSON.stringify(metaData, null, 2);
-    await fs.writeFile(filePath, updatedContent);
-  }
-}

package/src/services/database/database-bootstrap.service.ts

@@ -1,91 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { readdir, readFile } from 'fs/promises';
-import * as path from 'path';
-import { InjectDataSource } from '@nestjs/typeorm';
-
-@Injectable()
-export class DatabaseBootstrapService implements OnModuleInit {
-  private readonly logger = new Logger(DatabaseBootstrapService.name);
-
-  constructor(
-    @InjectDataSource()
-    private readonly dataSource: DataSource,
-  ) { }
-
-  async onModuleInit() {
-    if (!this.dataSource.isInitialized) {
-      this.logger.warn(`[${this.dataSource.name}] DataSource not initialized. Skipping SQL bootstrap.`);
-      return;
-    }
-
-    this.logger.debug(`[${this.dataSource.name}] Bootstrapping stored procedures...`);
-
-    await this.applyAllSqlFiles();
-
-    this.logger.debug(`[${this.dataSource.name}] SQL bootstrap completed`);
-  }
-
-  private resolveSqlDirectory(): string {
-    const datasourceName = this.dataSource.name || 'default';
-    const dbType = this.dataSource.options.type;
-
-    const sqlFilePath = path.resolve(__dirname, `../../../sql/${datasourceName}/${dbType}`);
-
-    return sqlFilePath
-  }
-
-  private async applyAllSqlFiles() {
-    const sqlDir = this.resolveSqlDirectory();
-
-    this.logger.debug(`[${this.dataSource.name}] SQL directory: ${sqlDir}`);
-
-    let files: string[];
-    try {
-      files = await readdir(sqlDir);
-    } catch {
-      this.logger.warn(
-        `[${this.dataSource.name}] No SQL directory found. Skipping.`,
-      );
-      return;
-    }
-
-    const sqlFiles = files
-      .filter(file => file.endsWith('.sql'))
-      .sort();
-
-    if (!sqlFiles.length) {
-      this.logger.warn(
-        `[${this.dataSource.name}] No SQL files found`,
-      );
-      return;
-    }
-
-    for (const file of sqlFiles) {
-      await this.applySqlFileSafely(
-        path.join(sqlDir, file),
-        file,
-      );
-    }
-  }
-
-  private async applySqlFileSafely(
-    filePath: string,
-    fileName: string,
-  ) {
-    this.logger.debug(`[${this.dataSource.name}] Applying ${fileName}`);
-
-    try {
-      const sql = await readFile(filePath, 'utf8');
-      await this.dataSource.query(sql);
-
-      this.logger.debug(`[${this.dataSource.name}] Applied ${fileName}`);
-    } catch (error: any) {
-      // DO NOT THROW — continue with next file
-      this.logger.error(
-        `[${this.dataSource.name}] Failed ${fileName}`,
-        error instanceof Error ? error.stack : String(error),
-      );
-    }
-  }
-}