@solidxai/core 0.1.10 → 0.1.11-beta.1

package/src/seeders/seed-data/solid-core-metadata.json

@@ -5381,6 +5381,19 @@
       "moduleUserKey": "solid-core",
       "modelUserKey": "fieldMetadata"
     },
+    {
+      "displayName": "Datasource Management",
+      "name": "datasource-management-action",
+      "type": "custom",
+      "domain": "",
+      "context": "",
+      "customComponent": "/admin/core/solid-core/datasources",
+      "customIsModal": true,
+      "serverEndpoint": "",
+      "viewUserKey": "",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "moduleMetadata"
+    },
     {
       "displayName": "Field Metadata Tree Action",
       "name": "fieldMetadata-tree-action",
@@ -6105,6 +6118,14 @@
       "moduleUserKey": "solid-core",
       "parentMenuItemUserKey": "appBuilder-menu-item"
     },
+    {
+      "displayName": "Datasources",
+      "name": "datasource-management-menu-item",
+      "sequenceNumber": 4,
+      "actionUserKey": "datasource-management-action",
+      "moduleUserKey": "solid-core",
+      "parentMenuItemUserKey": "appBuilder-menu-item"
+    },
     {
       "displayName": "Menu Item",
       "name": "menuItemMetadata-menu-item",
@@ -14737,4 +14758,4 @@
     }
   ],
   "savedFilters": []
-}
+}

package/src/services/action-metadata.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { CRUDService } from 'src/services/crud.service';
@@ -10,6 +10,79 @@ import { ActionMetadata } from '../entities/action-metadata.entity';
 
 @Injectable()
 export class ActionMetadataService extends CRUDService<ActionMetadata> {
+  private readonly logger = new Logger(ActionMetadataService.name);
+  private readonly comparableFields = [
+    'name',
+    'displayName',
+    'type',
+    'domain',
+    'context',
+    'customComponent',
+    'customIsModal',
+    'serverEndpoint',
+    'module',
+    'model',
+    'view',
+  ] as const;
+  private readonly relationCompareFields = new Set(['module', 'model', 'view']);
+  private readonly jsonCompareFields = new Set(['domain', 'context']);
+
+  private normalizeJsonFieldValue(value: any): any {
+    if (typeof value === 'string') {
+      const trimmedValue = value.trim();
+      if (
+        (trimmedValue.startsWith('{') && trimmedValue.endsWith('}')) ||
+        (trimmedValue.startsWith('[') && trimmedValue.endsWith(']'))
+      ) {
+        try {
+          return this.normalizeJsonFieldValue(JSON.parse(trimmedValue));
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+
+    if (Array.isArray(value)) {
+      return value.map((item) => this.normalizeJsonFieldValue(item));
+    }
+
+    if (value && typeof value === 'object') {
+      return Object.keys(value)
+        .sort()
+        .reduce((result, key) => {
+          result[key] = this.normalizeJsonFieldValue(value[key]);
+          return result;
+        }, {} as Record<string, any>);
+    }
+
+    return value;
+  }
+
+  private getCanonicalJsonFieldString(value: any): string {
+    return JSON.stringify(this.normalizeJsonFieldValue(value) ?? null);
+  }
+
+  private hasChanges(existingSolidAction: ActionMetadata, updateSolidActionDto: any): boolean {
+    return this.comparableFields.some((key) => {
+      const value = updateSolidActionDto[key];
+      if (typeof value === 'undefined') {
+        return false;
+      }
+
+      if (this.relationCompareFields.has(key)) {
+        const relationValue = value as any;
+        return (existingSolidAction as any)[key]?.id !== relationValue?.id;
+      }
+
+      if (this.jsonCompareFields.has(key)) {
+        return this.getCanonicalJsonFieldString((existingSolidAction as any)[key]) !== this.getCanonicalJsonFieldString(value);
+      }
+
+      return (existingSolidAction as any)[key] !== value;
+    });
+  }
+
   constructor(
     @InjectEntityManager()
     readonly entityManager: EntityManager,
@@ -37,11 +110,23 @@ export class ActionMetadataService extends CRUDService<ActionMetadata> {
     const existingSolidAction = await this.repo.findOne({
       where: {
         name: updateSolidActionDto.name
-      }
+      },
+      relations: {
+        module: true,
+        model: true,
+        view: true,
+      },
     })
 
     // if found
     if (existingSolidAction) {
+      const hasChanges = this.hasChanges(existingSolidAction, updateSolidActionDto);
+
+      if (!hasChanges) {
+        this.logger.debug(`Skipping action upsert for ${updateSolidActionDto.name}; no changes detected.`);
+        return existingSolidAction;
+      }
+
       const updatedSolidActionDto = { ...existingSolidAction, ...updateSolidActionDto };
       return this.repo.save(updatedSolidActionDto);
     }

package/src/services/authentication.service.ts

@@ -309,7 +309,7 @@ export class AuthenticationService {
     if (signUpDto.roles && signUpDto.roles.length > 0) {
       for (let i = 0; i < signUpDto.roles.length; i++) {
         const roleName = signUpDto.roles[i];
-        await this.roleMetadataService.findRoleByName(roleName);
+        await this.roleMetadataService.assertRoleExistsByName(roleName);
       }
     }
     user.username = signUpDto.username;

package/src/services/dashboard-providers/mq-dashboard-latency-trend-provider.service.ts

@@ -2,7 +2,13 @@ import { Injectable } from "@nestjs/common";
 import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
 import { MqMessageRepository } from "src/repository/mq-message.repository";
 import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
-import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+import {
+    applyMqDashboardFilters,
+    buildMqDashboardBucketExpression,
+    normalizeBucket,
+    normalizeMqDashboardBucketValue,
+    toNumber,
+} from "src/services/dashboard-providers/mq-dashboard-provider-utils";
 
 @DashboardWidgetDataProvider()
 @Injectable()
@@ -29,7 +35,7 @@ export class MqDashboardLatencyTrendProvider implements IDashboardWidgetDataProv
         applyMqDashboardFilters(qb, ctxt.variables ?? {});
         qb.andWhere("mqMessage.elapsedMillis IS NOT NULL");
 
-        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const bucketExpr = buildMqDashboardBucketExpression(qb, bucket, "mqMessage.createdAt");
         const rows = await qb
             .select(bucketExpr, "bucket")
             .addSelect("AVG(mqMessage.elapsedMillis)", "value")
@@ -37,7 +43,7 @@ export class MqDashboardLatencyTrendProvider implements IDashboardWidgetDataProv
             .orderBy("bucket", "ASC")
             .getRawMany<{ bucket: string; value: string | number }>();
 
-        const categories = rows.map((r) => new Date(r.bucket).toISOString());
+        const categories = rows.map((r) => normalizeMqDashboardBucketValue(r.bucket));
         const values = rows.map((r) => Number(toNumber(r.value).toFixed(2)));
 
         return {
@@ -55,4 +61,3 @@ export class MqDashboardLatencyTrendProvider implements IDashboardWidgetDataProv
         };
     }
 }
-

package/src/services/dashboard-providers/mq-dashboard-messages-over-time-provider.service.ts

@@ -2,7 +2,13 @@ import { Injectable } from "@nestjs/common";
 import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
 import { MqMessageRepository } from "src/repository/mq-message.repository";
 import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
-import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+import {
+    applyMqDashboardFilters,
+    buildMqDashboardBucketExpression,
+    normalizeBucket,
+    normalizeMqDashboardBucketValue,
+    toNumber,
+} from "src/services/dashboard-providers/mq-dashboard-provider-utils";
 
 @DashboardWidgetDataProvider()
 @Injectable()
@@ -31,7 +37,7 @@ export class MqDashboardMessagesOverTimeProvider implements IDashboardWidgetData
         const qb = await this.mqMessageRepository.createSecurityRuleAwareQueryBuilder("mqMessage");
         applyMqDashboardFilters(qb, ctxt.variables ?? {});
 
-        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const bucketExpr = buildMqDashboardBucketExpression(qb, bucket, "mqMessage.createdAt");
         const rows = await qb
             .select(bucketExpr, "bucket")
             .addSelect("mqMessage.stage", "stage")
@@ -43,7 +49,7 @@ export class MqDashboardMessagesOverTimeProvider implements IDashboardWidgetData
 
         const bucketToStageMap = new Map<string, Record<string, number>>();
         for (const row of rows) {
-            const key = new Date(row.bucket).toISOString();
+            const key = normalizeMqDashboardBucketValue(row.bucket);
             const entry = bucketToStageMap.get(key) ?? {};
             entry[row.stage] = (entry[row.stage] ?? 0) + toNumber(row.count, 0);
             bucketToStageMap.set(key, entry);
@@ -76,4 +82,3 @@ export class MqDashboardMessagesOverTimeProvider implements IDashboardWidgetData
         };
     }
 }
-

package/src/services/dashboard-providers/mq-dashboard-provider-utils.ts

@@ -54,6 +54,59 @@ export function toNumber(value: any, fallback = 0): number {
     return Number.isFinite(n) ? n : fallback;
 }
 
+export function buildMqDashboardBucketExpression(
+    qb: SelectQueryBuilder<MqMessage>,
+    bucket: 'hour' | 'day' | 'week' | 'month',
+    columnExpr: string,
+): string {
+    const driver = `${qb.connection.options.type ?? ''}`.toLowerCase();
+
+    switch (driver) {
+        case 'postgres':
+        case 'cockroachdb':
+            return `DATE_TRUNC('${bucket}', ${columnExpr})`;
+        case 'mysql':
+        case 'mariadb':
+            switch (bucket) {
+                case 'hour':
+                    return `DATE_FORMAT(${columnExpr}, '%Y-%m-%d %H:00:00')`;
+                case 'day':
+                    return `DATE_FORMAT(${columnExpr}, '%Y-%m-%d 00:00:00')`;
+                case 'week':
+                    return `STR_TO_DATE(DATE_FORMAT(${columnExpr}, '%x-%v-1'), '%x-%v-%w')`;
+                case 'month':
+                    return `DATE_FORMAT(${columnExpr}, '%Y-%m-01 00:00:00')`;
+                default:
+                    throw new Error(`Unsupported bucket ${bucket} for driver ${driver}`);
+            }
+        case 'mssql':
+        case 'sqlserver':
+            switch (bucket) {
+                case 'hour':
+                    return `DATEADD(hour, DATEDIFF(hour, 0, ${columnExpr}), 0)`;
+                case 'day':
+                    return `DATEADD(day, DATEDIFF(day, 0, ${columnExpr}), 0)`;
+                case 'week':
+                    return `DATEADD(week, DATEDIFF(week, 0, ${columnExpr}), 0)`;
+                case 'month':
+                    return `DATEFROMPARTS(YEAR(${columnExpr}), MONTH(${columnExpr}), 1)`;
+                default:
+                    throw new Error(`Unsupported bucket ${bucket} for driver ${driver}`);
+            }
+        default:
+            throw new Error(`Unsupported driver ${driver} for mq dashboard bucket expressions.`);
+    }
+}
+
+export function normalizeMqDashboardBucketValue(value: any): string {
+    if (!value) return '';
+    const parsed = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(parsed.getTime())) {
+        return `${value}`;
+    }
+    return parsed.toISOString();
+}
+
 
 function applyDateFilter(qb: SelectQueryBuilder<MqMessage>, dateVariable: any): void {
     const range = resolveDateRange(dateVariable);
@@ -88,6 +141,35 @@ function applyStringOrArrayFilter(
     qb.andWhere(`${qualifiedColumn} IN (:...${paramKey})`, { [paramKey]: values });
 }
 
+export function applyCaseInsensitiveContainsFilter<T>(
+    qb: SelectQueryBuilder<T>,
+    qualifiedColumn: string,
+    query: string | undefined,
+    paramKey: string,
+) {
+    if (!query) {
+        return;
+    }
+
+    const driver = `${qb.connection.options.type ?? ''}`.toLowerCase();
+    const value = `%${query}%`;
+
+    switch (driver) {
+        case 'postgres':
+        case 'cockroachdb':
+            qb.andWhere(`${qualifiedColumn} ILIKE :${paramKey}`, { [paramKey]: value });
+            return;
+        case 'mysql':
+        case 'mariadb':
+        case 'mssql':
+        case 'sqlserver':
+            qb.andWhere(`LOWER(${qualifiedColumn}) LIKE LOWER(:${paramKey})`, { [paramKey]: value });
+            return;
+        default:
+            qb.andWhere(`${qualifiedColumn} LIKE :${paramKey}`, { [paramKey]: value });
+    }
+}
+
 function resolveDateRange(dateVariable: any): { from?: Date; to?: Date } {
     if (!dateVariable) return {};
 

package/src/services/dashboard-providers/mq-dashboard-queue-sla-heatmap-provider.service.ts

@@ -2,7 +2,13 @@ import { Injectable } from "@nestjs/common";
 import { DashboardWidgetDataProvider } from "src/decorators/dashboard-widget-data-provider.decorator";
 import { IDashboardWidgetDataProvider, IDashboardWidgetDataProviderContext, IDashboardWidgetDataResponseEnvelope } from "src/interfaces";
 import { MqMessageRepository } from "src/repository/mq-message.repository";
-import { applyMqDashboardFilters, normalizeBucket, toNumber } from "src/services/dashboard-providers/mq-dashboard-provider-utils";
+import {
+    applyMqDashboardFilters,
+    buildMqDashboardBucketExpression,
+    normalizeBucket,
+    normalizeMqDashboardBucketValue,
+    toNumber,
+} from "src/services/dashboard-providers/mq-dashboard-provider-utils";
 
 type HeatmapLegendThreshold = {
     label: string;
@@ -71,7 +77,7 @@ export class MqDashboardQueueSlaHeatmapProvider implements IDashboardWidgetDataP
         applyMqDashboardFilters(qb, ctxt.variables ?? {}, { ensureQueueJoin: true });
         qb.andWhere("mqMessage.elapsedMillis IS NOT NULL");
 
-        const bucketExpr = `DATE_TRUNC('${bucket}', mqMessage.createdAt)`;
+        const bucketExpr = buildMqDashboardBucketExpression(qb, bucket, "mqMessage.createdAt");
         const rows = await qb
             .select(bucketExpr, "bucket")
             .addSelect("mqMessageQueue.name", "queueName")
@@ -93,7 +99,7 @@ export class MqDashboardQueueSlaHeatmapProvider implements IDashboardWidgetDataP
         const xCategories = Array.from(
             new Set(
                 rows
-                    .map((row) => row?.bucket ? new Date(row.bucket).toISOString() : "")
+                    .map((row) => normalizeMqDashboardBucketValue(row?.bucket))
                     .filter((bucketValue) => !!bucketValue)
             )
         ).sort();
@@ -108,7 +114,7 @@ export class MqDashboardQueueSlaHeatmapProvider implements IDashboardWidgetDataP
         const pointDetails: HeatmapPointDetail[] = [];
 
         for (const row of rows) {
-            const bucketValue = row?.bucket ? new Date(row.bucket).toISOString() : "";
+            const bucketValue = normalizeMqDashboardBucketValue(row?.bucket);
             const queueName = `${row?.queueName ?? ""}`.trim();
             const xIndex = xIndexMap.get(bucketValue);
             const yIndex = yIndexMap.get(queueName);

package/src/services/datasource-introspection/mssql-datasource-introspection-provider.service.ts

@@ -0,0 +1,185 @@
+import { Injectable } from "@nestjs/common";
+import { DataSource } from "typeorm";
+import {
+    DatasourceIntrospectionColumn,
+    DatasourceIntrospectionProvider,
+    DatasourceIntrospectionTableRef,
+} from "src/interfaces/datasource-introspection-provider.interface";
+
+@Injectable()
+export class MssqlDatasourceIntrospectionProviderService implements DatasourceIntrospectionProvider {
+    readonly type = "mssql";
+
+    supports(type: string) {
+        return type?.toLowerCase() === this.type;
+    }
+
+    async listTables(dataSource: DataSource): Promise<DatasourceIntrospectionTableRef[]> {
+        const rows = await dataSource.query(`
+            SELECT
+                TABLE_SCHEMA AS tableSchema,
+                TABLE_NAME AS tableName
+            FROM INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_TYPE = 'BASE TABLE'
+              AND TABLE_SCHEMA NOT IN ('sys', 'INFORMATION_SCHEMA')
+            ORDER BY TABLE_SCHEMA, TABLE_NAME
+        `);
+
+        return rows.map((row: any) => ({
+            tableSchema: row.tableSchema ?? null,
+            tableName: row.tableName,
+        }));
+    }
+
+    async listColumns(dataSource: DataSource): Promise<DatasourceIntrospectionColumn[]> {
+        const rows = await dataSource.query(`
+            SELECT
+                schema_name(t.schema_id) AS tableSchema,
+                t.name AS tableName,
+                c.name AS columnName,
+                ty.name AS dataType,
+                c.is_identity AS isAutoGenerated,
+                CASE WHEN c.is_nullable = 1 THEN 'YES' ELSE 'NO' END AS isNullable,
+                dc.definition AS defaultValue,
+                CASE
+                    WHEN ty.name IN ('nchar', 'nvarchar') AND c.max_length > 0 THEN c.max_length / 2
+                    ELSE c.max_length
+                END AS characterMaximumLength,
+                c.precision AS numericPrecision,
+                c.scale AS numericScale,
+                c.column_id AS ordinalPosition
+            FROM sys.tables t
+            INNER JOIN sys.columns c ON c.object_id = t.object_id
+            INNER JOIN sys.types ty ON ty.user_type_id = c.user_type_id
+            LEFT JOIN sys.default_constraints dc ON dc.object_id = c.default_object_id
+            WHERE schema_name(t.schema_id) NOT IN ('sys', 'INFORMATION_SCHEMA')
+            ORDER BY schema_name(t.schema_id), t.name, c.column_id
+        `);
+
+        return rows.map((row: any) => ({
+            tableSchema: row.tableSchema ?? null,
+            tableName: row.tableName,
+            columnName: row.columnName,
+            dataType: row.dataType,
+            isAutoGenerated: Boolean(row.isAutoGenerated),
+            isNullable: String(row.isNullable).toUpperCase() === "YES",
+            defaultValue: row.defaultValue ?? null,
+            characterMaximumLength: this.toNumberOrNull(row.characterMaximumLength),
+            numericPrecision: this.toNumberOrNull(row.numericPrecision),
+            numericScale: this.toNumberOrNull(row.numericScale),
+            ordinalPosition: this.toNumberOrNull(row.ordinalPosition),
+        }));
+    }
+
+    async getTableDefinition(dataSource: DataSource, table: DatasourceIntrospectionTableRef): Promise<string | null> {
+        const rows = await dataSource.query(
+            `
+                DECLARE @schemaName NVARCHAR(128) = @0;
+                DECLARE @tableName NVARCHAR(128) = @1;
+
+                WITH target_table AS (
+                    SELECT t.object_id, s.name AS schema_name, t.name AS table_name
+                    FROM sys.tables t
+                    INNER JOIN sys.schemas s ON s.schema_id = t.schema_id
+                    WHERE t.name = @tableName
+                      AND (@schemaName IS NULL OR s.name = @schemaName)
+                ),
+                column_lines AS (
+                    SELECT
+                        c.column_id,
+                        '    [' + c.name + '] '
+                        + UPPER(ty.name)
+                        + CASE
+                            WHEN ty.name IN ('varchar', 'char', 'varbinary', 'binary') THEN
+                                '(' + CASE WHEN c.max_length = -1 THEN 'MAX' ELSE CAST(c.max_length AS VARCHAR(16)) END + ')'
+                            WHEN ty.name IN ('nvarchar', 'nchar') THEN
+                                '(' + CASE WHEN c.max_length = -1 THEN 'MAX' ELSE CAST(c.max_length / 2 AS VARCHAR(16)) END + ')'
+                            WHEN ty.name IN ('decimal', 'numeric') THEN
+                                '(' + CAST(c.precision AS VARCHAR(16)) + ',' + CAST(c.scale AS VARCHAR(16)) + ')'
+                            WHEN ty.name IN ('datetime2', 'datetimeoffset', 'time') THEN
+                                '(' + CAST(c.scale AS VARCHAR(16)) + ')'
+                            ELSE
+                                ''
+                          END
+                        + CASE
+                            WHEN ic.object_id IS NOT NULL THEN
+                                ' IDENTITY(' + CAST(CONVERT(BIGINT, ic.seed_value) AS VARCHAR(32)) + ',' + CAST(CONVERT(BIGINT, ic.increment_value) AS VARCHAR(32)) + ')'
+                            ELSE
+                                ''
+                          END
+                        + CASE
+                            WHEN dc.definition IS NOT NULL THEN ' DEFAULT ' + dc.definition
+                            ELSE ''
+                          END
+                        + CASE
+                            WHEN c.is_nullable = 1 THEN ' NULL'
+                            ELSE ' NOT NULL'
+                          END AS line
+                    FROM target_table tt
+                    INNER JOIN sys.columns c ON c.object_id = tt.object_id
+                    INNER JOIN sys.types ty ON ty.user_type_id = c.user_type_id
+                    LEFT JOIN sys.identity_columns ic
+                        ON ic.object_id = c.object_id
+                       AND ic.column_id = c.column_id
+                    LEFT JOIN sys.default_constraints dc ON dc.object_id = c.default_object_id
+                ),
+                constraint_lines AS (
+                    SELECT
+                        kc.name AS constraint_name,
+                        '    CONSTRAINT [' + kc.name + '] PRIMARY KEY ('
+                        + STUFF((
+                            SELECT ', [' + c.name + ']'
+                            FROM sys.index_columns ic
+                            INNER JOIN sys.columns c
+                                ON c.object_id = ic.object_id
+                               AND c.column_id = ic.column_id
+                            WHERE ic.object_id = kc.parent_object_id
+                              AND ic.index_id = kc.unique_index_id
+                            ORDER BY ic.key_ordinal
+                            FOR XML PATH(''), TYPE
+                        ).value('.', 'NVARCHAR(MAX)'), 1, 2, '')
+                        + ')' AS line
+                    FROM target_table tt
+                    INNER JOIN sys.key_constraints kc ON kc.parent_object_id = tt.object_id
+                    WHERE kc.type = 'PK'
+                )
+                SELECT
+                    'CREATE TABLE [' + tt.schema_name + '].[' + tt.table_name + '] (' + CHAR(10)
+                    + ISNULL((
+                        SELECT STUFF((
+                            SELECT ',' + CHAR(10) + cl.line
+                            FROM column_lines cl
+                            ORDER BY cl.column_id
+                            FOR XML PATH(''), TYPE
+                        ).value('.', 'NVARCHAR(MAX)'), 1, 2, '')
+                    ), '')
+                    + ISNULL((
+                        SELECT CASE
+                            WHEN EXISTS (SELECT 1 FROM constraint_lines)
+                                THEN ',' + CHAR(10) + STUFF((
+                                    SELECT ',' + CHAR(10) + cn.line
+                                    FROM constraint_lines cn
+                                    ORDER BY cn.constraint_name
+                                    FOR XML PATH(''), TYPE
+                                ).value('.', 'NVARCHAR(MAX)'), 1, 2, '')
+                            ELSE ''
+                        END
+                    ), '')
+                    + CHAR(10) + ');' AS ddl
+                FROM target_table tt
+            `,
+            [table.tableSchema, table.tableName],
+        );
+
+        return rows?.[0]?.ddl ?? null;
+    }
+
+    private toNumberOrNull(value: unknown) {
+        if (value === null || value === undefined || value === "") {
+            return null;
+        }
+
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+}

package/src/services/datasource-introspection/mysql-datasource-introspection-provider.service.ts

@@ -0,0 +1,95 @@
+import { Injectable } from "@nestjs/common";
+import { DataSource } from "typeorm";
+import {
+    DatasourceIntrospectionColumn,
+    DatasourceIntrospectionProvider,
+    DatasourceIntrospectionTableRef,
+} from "src/interfaces/datasource-introspection-provider.interface";
+
+@Injectable()
+export class MysqlDatasourceIntrospectionProviderService implements DatasourceIntrospectionProvider {
+    readonly type = "mysql";
+
+    supports(type: string) {
+        return type?.toLowerCase() === this.type;
+    }
+
+    async listTables(dataSource: DataSource): Promise<DatasourceIntrospectionTableRef[]> {
+        const rows = await dataSource.query(`
+            SELECT
+                TABLE_SCHEMA AS tableSchema,
+                TABLE_NAME AS tableName
+            FROM INFORMATION_SCHEMA.TABLES
+            WHERE TABLE_TYPE = 'BASE TABLE'
+              AND TABLE_SCHEMA = DATABASE()
+            ORDER BY TABLE_SCHEMA, TABLE_NAME
+        `);
+
+        return rows.map((row: any) => ({
+            tableSchema: row.tableSchema ?? null,
+            tableName: row.tableName,
+        }));
+    }
+
+    async listColumns(dataSource: DataSource): Promise<DatasourceIntrospectionColumn[]> {
+        const rows = await dataSource.query(`
+            SELECT
+                TABLE_SCHEMA AS tableSchema,
+                TABLE_NAME AS tableName,
+                COLUMN_NAME AS columnName,
+                DATA_TYPE AS dataType,
+                EXTRA AS extra,
+                IS_NULLABLE AS isNullable,
+                COLUMN_DEFAULT AS defaultValue,
+                CHARACTER_MAXIMUM_LENGTH AS characterMaximumLength,
+                NUMERIC_PRECISION AS numericPrecision,
+                NUMERIC_SCALE AS numericScale,
+                ORDINAL_POSITION AS ordinalPosition
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_SCHEMA = DATABASE()
+            ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+        `);
+
+        return rows.map((row: any) => ({
+            tableSchema: row.tableSchema ?? null,
+            tableName: row.tableName,
+            columnName: row.columnName,
+            dataType: row.dataType,
+            isAutoGenerated: String(row.extra ?? "").toLowerCase().includes("auto_increment"),
+            isNullable: String(row.isNullable).toUpperCase() === "YES",
+            defaultValue: row.defaultValue ?? null,
+            characterMaximumLength: this.toNumberOrNull(row.characterMaximumLength),
+            numericPrecision: this.toNumberOrNull(row.numericPrecision),
+            numericScale: this.toNumberOrNull(row.numericScale),
+            ordinalPosition: this.toNumberOrNull(row.ordinalPosition),
+        }));
+    }
+
+    async getTableDefinition(dataSource: DataSource, table: DatasourceIntrospectionTableRef): Promise<string | null> {
+        const schemaName = table.tableSchema ?? dataSource.options.database;
+        const rows = await dataSource.query(
+            `SHOW CREATE TABLE \`${schemaName}\`.\`${table.tableName}\``,
+        );
+
+        const firstRow = rows?.[0];
+        if (!firstRow || typeof firstRow !== "object") {
+            return null;
+        }
+
+        const ddlKey = Object.keys(firstRow).find((key) => key.toLowerCase().startsWith("create table"));
+        if (!ddlKey) {
+            return null;
+        }
+
+        return String(firstRow[ddlKey] ?? "").trim() || null;
+    }
+
+    private toNumberOrNull(value: unknown) {
+        if (value === null || value === undefined || value === "") {
+            return null;
+        }
+
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+}