@solidxai/core 0.0.2

package/src/services/csv.service.ts

@@ -0,0 +1,151 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { format, parse } from 'fast-csv';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { PassThrough, Readable } from 'stream';
+
+export interface CsvReadOptions {
+  pageSize?: number; // Number of records per page
+  hasHeaderRow?: boolean;
+  providedHeaders?: string[]
+};
+const DEFAULT_PAGE_SIZE = 100; // Default page size if not provided
+export interface CsvReadResult {
+  headers: string[]; // Headers of the CSV file
+  data: Record<string, any>[]; // Data records in the current page
+}
+
+@Injectable()
+export class CsvService {
+  private logger = new Logger(CsvService.name);
+  public async createCsvStream(
+    getDataRecords: (chunkIndex: number, chunkSize: number) => Promise<any[]> = null,
+    chunkSize: number = 100,
+    headers: string[] = []
+  ): Promise<Readable> {
+    // Validations
+    // If neither headers nor data records function is provided, throw an error
+    if (headers.length === 0 && typeof getDataRecords !== 'function') {
+      throw new Error(ERROR_MESSAGES.MISSING_HEADERS_OR_FUNCTION);
+    }
+
+    // If data records function is provided, chunkSize must be greater than 0
+    if (getDataRecords && chunkSize <= 0) {
+      throw new Error(ERROR_MESSAGES.INVALID_CHUNK_SIZE);
+    }
+
+    const passThrough = new PassThrough(); // ✅ Create a streaming pipe
+    const csvStream = headers.length
+      ? format({ headers })
+      : format({ headers: true });
+
+    csvStream.pipe(passThrough); // ✅ Pipe CSV output to PassThrough stream
+
+    try {
+      // 🧠 If no data retrieval logic is provided, just write headers and close
+      if (typeof getDataRecords !== 'function') {
+
+        const dummyRow = headers.reduce((acc, header) => {
+          acc[header] = '';
+          return acc;
+        }, {} as Record<string, string>);
+        csvStream.write(dummyRow);
+        csvStream.end();
+        return passThrough;
+      }
+
+      // Write the data records in chunks
+      let chunkIndex = 0;
+      while (true) {
+        const records = await getDataRecords(chunkIndex, chunkSize); // ✅ Fetch chunked data
+        if (records.length === 0) break; // ✅ Stop if no more records
+
+        for (const record of records) {
+          csvStream.write(record); // ✅ Write each record to the CSV stream
+        }
+
+        chunkIndex++; // ✅ Fetch next chunk
+        this.logger.debug(`✅ Chunk ${chunkIndex} written to CSV`);
+      }
+
+      csvStream.end(); // ✅ Ensure CSV stream is finalized
+    } catch (error) {
+      this.logger.error(`❌ Error writing CSV: ${error.message}`);
+      passThrough.destroy(error); // ✅ Properly destroy stream on error
+      throw error;
+    }
+
+    return passThrough; // ✅ Return the streaming response
+  }
+
+  public async  *readCsvInPagesFromStream(
+    stream: Readable,
+    options?: CsvReadOptions
+  ): AsyncGenerator<CsvReadResult> {
+    const { pageSize = DEFAULT_PAGE_SIZE, hasHeaderRow = true, providedHeaders = [] } = options || {};
+    let headers: string[] = [];
+    let page: Record<string, any>[] = [];
+    let isFirstRow = true;
+    let hasYieldedData = false;
+
+    // Create parser
+    const parser = parse({ headers: hasHeaderRow, renameHeaders: false, trim: true });
+
+    // Pipe the input stream into the parser
+    const parsingStream = stream.pipe(parser);
+
+    for await (const row of parsingStream) {
+      if (isFirstRow && !hasHeaderRow) {
+        isFirstRow = false;
+
+        if (providedHeaders.length) {
+          headers = providedHeaders;
+        } else {
+          // If no header row and no provided headers, generate index-based headers
+          headers = Object.keys(row).length > 0 ? Object.keys(row).map((_, i) => i.toString()) : [];
+        }
+      }
+
+      // If hasHeaderRow = true, fast-csv already assigns keys as headers, so capture once
+      if (hasHeaderRow && isFirstRow) {
+        headers = Object.keys(row);
+        isFirstRow = false;
+      }
+
+      // When headers are not set yet (edge case), set them now
+      if (!headers.length) {
+        headers = providedHeaders.length ? providedHeaders : Object.keys(row);
+      }
+
+      // Map row fields to headers - if keys mismatch, fallback to index-based mapping
+      const record: Record<string, any> = {};
+      for (let i = 0; i < headers.length; i++) {
+        // For safety, access by header name or fallback by index
+        const key = headers[i];
+        const value = row[key] ?? Object.values(row)[i] ?? null;
+        record[key] = value;
+      }
+
+      // Skip empty rows
+      if (Object.values(record).every(v => v === null || v === '')) continue;
+
+      page.push(record);
+
+      if (page.length === pageSize) {
+        yield { headers, data: page };
+        hasYieldedData = true;
+        page = [];
+      }
+    }
+
+    if (page.length > 0) {
+      yield { headers, data: page };
+      hasYieldedData = true;
+    }
+
+    // If only headers present but no data, yield headers with empty data array
+    if (!hasYieldedData && headers.length > 0) {
+      yield { headers, data: [] };
+    }
+  }
+
+}

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,131 @@
+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';
+
+enum SOURCE_TYPE {
+  SQL = 'sql',
+  PROVIDER = 'provider',
+}
+
+const CHARTJS_SQL_DATA_PROVIDER_NAME = 'ChartJsSqlDataProvider';
+const PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME = 'PrimeReactMeterGroupSqlDataProvider';
+const PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME = 'PrimeReactDatatableSqlDataProvider';
+
+@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;
+
+    if (question.sourceType === SOURCE_TYPE.SQL && ['bar', 'pie', 'line', 'donut'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(CHARTJS_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-meter-group'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_METER_GROUP_SQL_DATA_PROVIDER_NAME);
+    }
+    if (question.sourceType === SOURCE_TYPE.SQL && ['prime-datatable'].includes(question.visualisedAs)) {
+      dataProvider = this.solidRegistry.getDashboardQuestionDataProviderInstance(PRIME_REACT_DATATABLE_SQL_DATA_PROVIDER_NAME);
+    }
+
+    if (!dataProvider) {
+      throw new NotImplementedException(`Invalid data source type ${question.sourceType}`);
+    }
+
+    return await dataProvider.getData(question, expressions);
+
+  }
+
+  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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,141 @@
+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';
+
+
+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 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) {
+      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

@@ -0,0 +1,91 @@
+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) {
+      // DO NOT THROW — continue with next file
+      this.logger.error(
+        `[${this.dataSource.name}] Failed ${fileName}`,
+        error instanceof Error ? error.stack : String(error),
+      );
+    }
+  }
+}