@solidxai/core 0.1.11-beta.1 → 0.1.11-beta.4

package/dist/services/datasource-introspection.service.js

@@ -50,19 +50,101 @@ const crypto_1 = require("crypto");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const lodash_1 = require("lodash");
+const ts_morph_1 = require("ts-morph");
 const legacy_table_type_enum_1 = require("../enums/legacy-table-type.enum");
+const string_helper_1 = require("../helpers/string.helper");
 const module_metadata_helper_service_1 = require("../helpers/module-metadata-helper.service");
 const model_metadata_helper_service_1 = require("../helpers/model-metadata-helper.service");
 const model_metadata_repository_1 = require("../repository/model-metadata.repository");
 const module_metadata_repository_1 = require("../repository/module-metadata.repository");
 const datasource_management_service_1 = require("./datasource-management.service");
+const command_service_1 = require("../helpers/command.service");
 const field_metadata_service_1 = require("./field-metadata.service");
 const model_metadata_service_1 = require("./model-metadata.service");
+const module_metadata_service_1 = require("./module-metadata.service");
 const mssql_datasource_introspection_provider_service_1 = require("./datasource-introspection/mssql-datasource-introspection-provider.service");
 const mysql_datasource_introspection_provider_service_1 = require("./datasource-introspection/mysql-datasource-introspection-provider.service");
 const postgres_datasource_introspection_provider_service_1 = require("./datasource-introspection/postgres-datasource-introspection-provider.service");
+const DATASOURCE_TYPE_FAMILY_ALIASES = {
+    boolean: ["bit", "bool", "boolean"],
+    bigint: ["bigint"],
+    int: ["int", "integer", "smallint", "tinyint"],
+    numeric: ["numeric"],
+    decimal: ["decimal", "money", "smallmoney"],
+    float: ["float", "double", "real"],
+    date: ["date"],
+    time: ["time", "time without time zone", "time with time zone"],
+    datetime: ["datetime", "datetime2", "smalldatetime", "timestamp", "timestamp without time zone"],
+    datetimeWithTimezone: ["timestamptz", "timestamp with time zone"],
+    json: ["json", "simple-json", "simplejson"],
+    jsonb: ["jsonb"],
+    uuid: ["uniqueidentifier", "uuid"],
+    longText: ["text", "ntext", "longtext", "clob"],
+    mediumText: ["mediumtext"],
+    shortText: ["varchar", "char", "citext"],
+    unicodeShortText: ["nvarchar", "nchar"],
+};
+const ORM_TYPE_BY_DATASOURCE_FAMILY = {
+    mssql: {
+        boolean: "bit",
+        bigint: "bigint",
+        int: "int",
+        numeric: "numeric",
+        decimal: "decimal",
+        float: "decimal",
+        date: "date",
+        time: "time",
+        datetime: "datetime",
+        datetimeWithTimezone: "datetime",
+        json: "simple-json",
+        jsonb: "simple-json",
+        uuid: "uniqueidentifier",
+        longText: "text",
+        mediumText: "text",
+        shortText: "varchar",
+        unicodeShortText: "nvarchar",
+    },
+    mysql: {
+        boolean: "boolean",
+        bigint: "int",
+        int: "int",
+        numeric: "decimal",
+        decimal: "decimal",
+        float: "double",
+        date: "date",
+        time: "time",
+        datetime: "datetime",
+        datetimeWithTimezone: "datetime",
+        json: "json",
+        jsonb: "json",
+        uuid: "varchar",
+        longText: "longtext",
+        mediumText: "mediumtext",
+        shortText: "varchar",
+        unicodeShortText: "varchar",
+    },
+    postgres: {
+        boolean: "boolean",
+        bigint: "bigint",
+        int: "integer",
+        numeric: "decimal",
+        decimal: "decimal",
+        float: "decimal",
+        date: "date",
+        time: "time",
+        datetime: "timestamp",
+        datetimeWithTimezone: "timestamptz",
+        json: "json",
+        jsonb: "jsonb",
+        uuid: "uuid",
+        longText: "text",
+        mediumText: "text",
+        shortText: "varchar",
+        unicodeShortText: "varchar",
+    },
+};
 let DatasourceIntrospectionService = class DatasourceIntrospectionService {
-    constructor(moduleRef, datasourceManagementService, moduleMetadataRepository, modelMetadataRepository, moduleMetadataHelperService, modelMetadataHelperService, fieldMetadataService, modelMetadataService, mssqlProvider, mysqlProvider, postgresProvider) {
+    constructor(moduleRef, datasourceManagementService, moduleMetadataRepository, modelMetadataRepository, moduleMetadataHelperService, modelMetadataHelperService, fieldMetadataService, modelMetadataService, moduleMetadataService, commandService, mssqlProvider, mysqlProvider, postgresProvider) {
         this.moduleRef = moduleRef;
         this.datasourceManagementService = datasourceManagementService;
         this.moduleMetadataRepository = moduleMetadataRepository;
@@ -71,6 +153,8 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         this.modelMetadataHelperService = modelMetadataHelperService;
         this.fieldMetadataService = fieldMetadataService;
         this.modelMetadataService = modelMetadataService;
+        this.moduleMetadataService = moduleMetadataService;
+        this.commandService = commandService;
         this.mssqlProvider = mssqlProvider;
         this.mysqlProvider = mysqlProvider;
         this.postgresProvider = postgresProvider;
@@ -189,24 +273,98 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         const persistedModel = plan.operation === "update" && mappingDto.modelId
             ? await this.modelMetadataService.update(mappingDto.modelId, plan.modelPayload)
             : await this.modelMetadataService.create(plan.modelPayload);
+        const persistedModelId = mappingDto.modelId ?? persistedModel?.id ?? null;
+        return {
+            data: {
+                modelId: persistedModelId,
+                operation: plan.operation,
+                metadataJson: plan.metadataJson,
+                summary: plan.summary,
+            },
+        };
+    }
+    async createMigrationArtifacts(moduleId, mappingDto) {
+        const plan = await this.buildMappingPreview(moduleId, mappingDto);
+        const module = await this.loadModule(moduleId);
+        const datasource = this.requireDatasource(mappingDto.dataSource);
+        if (!mappingDto.modelId) {
+            throw new common_1.BadRequestException("Persist the model mapping first so the generated entity can be registered before creating migration artifacts.");
+        }
         if (plan.migration.willGenerate && plan.migration.content && plan.migration.filePath) {
             await fs.mkdir(path.dirname(plan.migration.filePath), { recursive: true });
             await fs.writeFile(plan.migration.filePath, plan.migration.content, "utf8");
         }
-        const persistedModelId = mappingDto.modelId ?? persistedModel?.id ?? null;
+        const datasourceFile = await this.syncTypeormDatasourceFile(module.name, datasource, plan.modelPayload.singularName);
         return {
             data: {
-                modelId: persistedModelId,
+                modelId: mappingDto.modelId,
                 operation: plan.operation,
-                metadataJson: plan.metadataJson,
                 migration: {
                     ...plan.migration,
                     written: Boolean(plan.migration.willGenerate && plan.migration.filePath),
                 },
+                datasourceFile,
                 summary: plan.summary,
             },
         };
     }
+    async generateCode(moduleId) {
+        await this.loadModule(moduleId);
+        const output = await this.moduleMetadataService.generateCodeViaCtl(moduleId);
+        return {
+            data: {
+                moduleId,
+                output,
+                message: "Module code generation completed.",
+            },
+        };
+    }
+    async runMigration(moduleId, datasourceName) {
+        const module = await this.loadModule(moduleId);
+        const datasource = this.requireDatasource(datasourceName);
+        const cwd = path.join(process.cwd(), "..");
+        const outputs = [];
+        const migrationOutput = await this.commandService.executeCommandWithArgs({
+            command: "npx",
+            args: ["-y", "@solidxai/solidctl@latest", "migration", "-d", datasource.name, "run"],
+            cwd,
+        });
+        outputs.push([
+            `npx @solidxai/solidctl@latest migration -d ${datasource.name} run`,
+            migrationOutput,
+        ].filter(Boolean).join("\n"));
+        const buildOutput = await this.commandService.executeCommandWithArgs({
+            command: "npx",
+            args: ["-y", "@solidxai/solidctl@latest", "build"],
+            cwd,
+        });
+        outputs.push([
+            "npx @solidxai/solidctl@latest build",
+            buildOutput,
+        ].filter(Boolean).join("\n"));
+        const seedOutput = await this.commandService.executeCommandWithArgs({
+            command: "npx",
+            args: ["-y", "@solidxai/solidctl@latest", "seed", "--modules-to-seed", module.name],
+            cwd,
+        });
+        outputs.push([
+            `npx @solidxai/solidctl@latest seed --modules-to-seed ${module.name}`,
+            seedOutput,
+        ].filter(Boolean).join("\n"));
+        return {
+            data: {
+                moduleId,
+                datasource: datasource.name,
+                output: outputs.join("\n\n"),
+                command: [
+                    `npx @solidxai/solidctl@latest migration -d ${datasource.name} run`,
+                    "npx @solidxai/solidctl@latest build",
+                    `npx @solidxai/solidctl@latest seed --modules-to-seed ${module.name}`,
+                ].join("\n"),
+                message: `Migration, build, and seed completed successfully for datasource "${datasource.name}".`,
+            },
+        };
+    }
     async buildMappingPreview(moduleId, mappingDto) {
         const module = await this.loadModule(moduleId);
         const datasource = this.requireDatasource(mappingDto.dataSource);
@@ -252,6 +410,13 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             mappedModelId: mappingDto.modelId ?? null,
             metadataJson,
             migration,
+            datasourceFile: {
+                filePath: path.resolve(process.cwd(), "src", `typeorm-${datasource.name}-datasource.ts`),
+                created: false,
+                updated: false,
+                entityRegistered: false,
+                migrationGlobRegistered: false,
+            },
             summary: {
                 includedColumnNames,
                 removedColumnNames,
@@ -584,7 +749,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             ...preserved,
             ...(column.fieldId ? { id: column.fieldId } : {}),
             name: column.fieldName,
-            displayName: preserved.displayName ?? (0, lodash_1.startCase)(column.fieldName),
+            displayName: column.displayName?.trim() || preserved.displayName || (0, lodash_1.startCase)(column.fieldName),
             description: preserved.description ?? "",
             type: column.solidFieldType,
             ormType: column.ormType,
@@ -696,23 +861,19 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         const generatedIdUniqueName = this.buildMigrationObjectName("UQ", tableNameLiteral, "ss_id");
         const upColumnStatements = missingSystemColumns.map((definition) => {
             const columnLiteral = this.renderTableColumnLiteral(definition);
-            return [
-                `        if (!(await queryRunner.hasColumn(tableName, ${JSON.stringify(definition.columnName)}))) {`,
-                `            await queryRunner.addColumn(tableName, new TableColumn(${columnLiteral}));`,
-                "        }",
-            ].join("\n");
+            return `        if (!(await queryRunner.hasColumn(tableName, ${JSON.stringify(definition.columnName)})))\n`
+                + `            await queryRunner.addColumn(tableName, new TableColumn(${columnLiteral}));`;
         }).join("\n\n");
         const postUpStatements = [];
         if (missingSystemColumns.some((definition) => definition.columnName === "ss_deleted_at")) {
             postUpStatements.push([
                 "        {",
                 "            const table = await queryRunner.getTable(tableName);",
-                `            if (table && !table.indices.some((index) => index.name === ${JSON.stringify(deletedAtIndexName)})) {`,
-                "                await queryRunner.createIndex(tableName, new TableIndex({",
-                `                    name: ${JSON.stringify(deletedAtIndexName)},`,
-                "                    columnNames: [\"ss_deleted_at\"],",
-                "                }));",
-                "            }",
+                `            if (table && !table.indices.some((index) => index.name === ${JSON.stringify(deletedAtIndexName)}))`,
+                `                await queryRunner.createIndex(tableName, new TableIndex(${this.renderTableIndexLiteral({
+                    name: deletedAtIndexName,
+                    columnNames: ["ss_deleted_at"],
+                })}));`,
                 "        }",
             ].join("\n"));
         }
@@ -720,13 +881,12 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             postUpStatements.push([
                 "        {",
                 "            const table = await queryRunner.getTable(tableName);",
-                `            if (table && !table.indices.some((index) => index.name === ${JSON.stringify(generatedIdUniqueName)})) {`,
-                "                await queryRunner.createIndex(tableName, new TableIndex({",
-                `                    name: ${JSON.stringify(generatedIdUniqueName)},`,
-                "                    columnNames: [\"ss_id\"],",
-                "                    isUnique: true,",
-                "                }));",
-                "            }",
+                `            if (table && !table.indices.some((index) => index.name === ${JSON.stringify(generatedIdUniqueName)}))`,
+                `                await queryRunner.createIndex(tableName, new TableIndex(${this.renderTableIndexLiteral({
+                    name: generatedIdUniqueName,
+                    columnNames: ["ss_id"],
+                    isUnique: true,
+                })}));`,
                 "        }",
             ].join("\n"));
         }
@@ -736,9 +896,8 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
                 "        {",
                 "            const table = await queryRunner.getTable(tableName);",
                 `            const index = table?.indices.find((entry) => entry.name === ${JSON.stringify(generatedIdUniqueName)});`,
-                "            if (index) {",
+                "            if (index)",
                 "                await queryRunner.dropIndex(tableName, index);",
-                "            }",
                 "        }",
             ].join("\n"));
         }
@@ -747,20 +906,16 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
                 "        {",
                 "            const table = await queryRunner.getTable(tableName);",
                 `            const index = table?.indices.find((entry) => entry.name === ${JSON.stringify(deletedAtIndexName)});`,
-                "            if (index) {",
+                "            if (index)",
                 "                await queryRunner.dropIndex(tableName, index);",
-                "            }",
                 "        }",
             ].join("\n"));
         }
         downStatements.push(...missingSystemColumns
             .slice()
             .reverse()
-            .map((definition) => [
-            `        if (await queryRunner.hasColumn(tableName, ${JSON.stringify(definition.columnName)})) {`,
-            `            await queryRunner.dropColumn(tableName, ${JSON.stringify(definition.columnName)});`,
-            "        }",
-        ].join("\n")));
+            .map((definition) => `        if (await queryRunner.hasColumn(tableName, ${JSON.stringify(definition.columnName)}))\n`
+            + `            await queryRunner.dropColumn(tableName, ${JSON.stringify(definition.columnName)});`));
         return [
             "import { MigrationInterface, QueryRunner, TableColumn, TableIndex } from \"typeorm\";",
             "",
@@ -783,27 +938,36 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
     }
     renderTableColumnLiteral(definition) {
         const properties = [
-            `{\n                name: ${JSON.stringify(definition.columnName)},`,
-            `                type: ${JSON.stringify(definition.type)},`,
+            `name: ${JSON.stringify(definition.columnName)}`,
+            `type: ${JSON.stringify(definition.type)}`,
         ];
         if (definition.length) {
-            properties.push(`                length: ${JSON.stringify(definition.length)},`);
+            properties.push(`length: ${JSON.stringify(definition.length)}`);
         }
         if (typeof definition.isNullable === "boolean") {
-            properties.push(`                isNullable: ${definition.isNullable},`);
+            properties.push(`isNullable: ${definition.isNullable}`);
         }
         if (definition.defaultExpression) {
-            properties.push(`                default: ${JSON.stringify(definition.defaultExpression)},`);
+            properties.push(`default: ${JSON.stringify(definition.defaultExpression)}`);
         }
         if (definition.isGenerated) {
-            properties.push("                isGenerated: true,");
-            properties.push("                generationStrategy: \"increment\",");
+            properties.push("isGenerated: true");
+            properties.push("generationStrategy: \"increment\"");
+        }
+        if (definition.isUnique) {
+            properties.push("isUnique: true");
         }
+        return `{ ${properties.join(", ")}, }`;
+    }
+    renderTableIndexLiteral(definition) {
+        const properties = [
+            `name: ${JSON.stringify(definition.name)}`,
+            `columnNames: ${JSON.stringify(definition.columnNames)}`,
+        ];
         if (definition.isUnique) {
-            properties.push("                isUnique: true,");
+            properties.push("isUnique: true");
         }
-        properties.push("            }");
-        return properties.join("\n");
+        return `{ ${properties.join(", ")}, }`;
     }
     buildMigrationObjectName(prefix, tableName, columnName) {
         const hash = (0, crypto_1.createHash)("md5").update(`${tableName}:${columnName}:${prefix}`).digest("hex").slice(0, 24);
@@ -832,12 +996,14 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
     async buildTableInventory(datasource) {
         const provider = this.getProvider(datasource.type);
         const runtimeDataSource = this.resolveDataSourceByName(datasource.name);
-        const [tables, columns, models] = await Promise.all([
+        const [rawTables, rawColumns, models] = await Promise.all([
             provider.listTables(runtimeDataSource),
             provider.listColumns(runtimeDataSource),
             this.modelMetadataRepository.find({ relations: { module: true } }),
         ]);
-        const modelMap = this.buildModelMap(models);
+        const tables = rawTables.filter((table) => !this.isSolidxInternalTableName(table.tableName));
+        const columns = rawColumns.filter((column) => !this.isSolidxInternalTableName(column.tableName));
+        const modelLookup = this.buildModelLookup(models);
         const columnsByKey = this.groupColumnsByTable(columns);
         const tableKeys = new Set();
         for (const table of tables) {
@@ -857,7 +1023,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             }
             const suggestedLegacyTableType = this.detectLegacyTableType(datasource.type, tableColumns);
             const suggestedIdColumn = this.getSuggestedIdColumn(datasource.type, tableColumns, suggestedLegacyTableType);
-            const mappedModel = modelMap.get(this.toModelMapKey(datasource.name, tableName)) ?? null;
+            const mappedModel = this.resolveMappedModel(modelLookup, datasource.name, tableName);
             const physicalColumns = tableColumns.filter((column) => !this.isHandledBySuperclass(column.columnName, suggestedLegacyTableType));
             return {
                 schema,
@@ -892,16 +1058,37 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             columnsByKey,
         };
     }
-    buildModelMap(models) {
-        const map = new Map();
+    buildModelLookup(models) {
+        const byDatasourceAndTable = new Map();
+        const byTableName = new Map();
         for (const model of models) {
             if (!model.tableName) {
                 continue;
             }
-            map.set(this.toModelMapKey(model.dataSource, model.tableName), model);
-            map.set(this.toModelMapKey("*", model.tableName), model);
+            byDatasourceAndTable.set(this.toModelMapKey(model.dataSource, model.tableName), model);
+            const normalizedTableName = model.tableName.trim().toLowerCase();
+            const bucket = byTableName.get(normalizedTableName);
+            if (bucket) {
+                bucket.push(model);
+                continue;
+            }
+            byTableName.set(normalizedTableName, [model]);
+        }
+        return {
+            byDatasourceAndTable,
+            byTableName,
+        };
+    }
+    resolveMappedModel(lookup, datasourceName, tableName) {
+        const exactMatch = lookup.byDatasourceAndTable.get(this.toModelMapKey(datasourceName, tableName));
+        if (exactMatch) {
+            return exactMatch;
+        }
+        const fallbackMatches = lookup.byTableName.get(tableName.trim().toLowerCase()) ?? [];
+        if (fallbackMatches.length === 1) {
+            return fallbackMatches[0];
         }
-        return map;
+        return fallbackMatches[0] ?? null;
     }
     groupColumnsByTable(columns) {
         const grouped = new Map();
@@ -916,6 +1103,9 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         }
         return grouped;
     }
+    isSolidxInternalTableName(tableName) {
+        return typeof tableName === "string" && tableName.toLowerCase().startsWith("ss_");
+    }
     detectLegacyTableType(datasourceType, columns) {
         const normalizedDatasourceType = datasourceType.toLowerCase();
         const hasExistingGeneratedId = columns.some((column) => column.isAutoGenerated);
@@ -983,12 +1173,16 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
     }
     toDetailColumnRecord(column, legacyTableType, datasourceType) {
         const superclassFieldName = this.getSuperclassFieldName(column.columnName, legacyTableType);
+        const normalizedColumnName = column.columnName.toLowerCase();
         const fieldName = legacyTableType === legacy_table_type_enum_1.LegacyTableType.EXISTING_ID && column.isAutoGenerated
             ? "id"
-            : this.toFieldName(column.columnName);
+            : legacyTableType === legacy_table_type_enum_1.LegacyTableType.GENERATED_ID && normalizedColumnName === "id"
+                ? "legacyId"
+                : this.toFieldName(column.columnName);
         return {
             columnName: column.columnName,
             fieldName,
+            displayName: (0, lodash_1.startCase)(fieldName),
             dataType: column.dataType,
             solidFieldType: this.toSolidFieldType(column),
             ormType: this.toOrmFieldType(column, datasourceType),
@@ -999,6 +1193,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             numericScale: column.numericScale,
             ordinalPosition: column.ordinalPosition,
             isAutoGenerated: column.isAutoGenerated,
+            isPrimaryKey: column.isPrimaryKey,
             handledBySuperclass: Boolean(superclassFieldName),
             superclassFieldName,
         };
@@ -1033,127 +1228,70 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         }
         return "LegacyCommonEntityWithExistingId";
     }
-    toSolidFieldType(column) {
-        const normalized = column.dataType.toLowerCase();
-        const charLength = column.characterMaximumLength ?? null;
-        if (["bit", "bool", "boolean"].includes(normalized)) {
-            return "boolean";
-        }
-        if (["bigint"].includes(normalized)) {
-            return "bigint";
-        }
-        if (["int", "integer", "smallint", "tinyint"].includes(normalized)) {
-            return "int";
-        }
-        if (["numeric", "decimal", "float", "double", "real", "money", "smallmoney"].includes(normalized)) {
-            return "decimal";
-        }
-        if (["date"].includes(normalized)) {
-            return "date";
-        }
-        if (["time"].includes(normalized)) {
-            return "time";
-        }
-        if (["datetime", "datetime2", "timestamp", "timestamptz", "smalldatetime"].includes(normalized) || normalized.includes("date")) {
-            return "datetime";
+    getDatasourceTypeFamily(dataType) {
+        const normalized = dataType.toLowerCase();
+        for (const [family, aliases] of Object.entries(DATASOURCE_TYPE_FAMILY_ALIASES)) {
+            if (aliases.includes(normalized)) {
+                return family;
+            }
         }
-        if (["json", "jsonb", "simple-json", "simplejson"].includes(normalized) || normalized.includes("json")) {
+        if (normalized.includes("json")) {
             return "json";
         }
-        if (["uniqueidentifier", "uuid"].includes(normalized)) {
-            return "uuid";
-        }
-        if (["text", "ntext", "mediumtext", "longtext", "clob"].includes(normalized)) {
-            return "longText";
-        }
-        if (["varchar", "nvarchar", "char", "nchar", "citext"].includes(normalized)) {
-            if (charLength !== null && charLength > 255) {
-                return "longText";
-            }
-            return "shortText";
+        if (normalized.includes("date")) {
+            return "datetime";
         }
-        return "shortText";
+        return null;
     }
-    toOrmFieldType(column, datasourceType) {
-        const normalized = column.dataType.toLowerCase();
-        const normalizedDatasourceType = datasourceType.toLowerCase();
-        if (normalizedDatasourceType === "mssql") {
-            if (["bit", "bool", "boolean"].includes(normalized))
-                return "bit";
-            if (["bigint"].includes(normalized))
+    toSolidFieldType(column) {
+        const family = this.getDatasourceTypeFamily(column.dataType);
+        const charLength = column.characterMaximumLength ?? null;
+        switch (family) {
+            case "boolean":
+                return "boolean";
+            case "bigint":
                 return "bigint";
-            if (["int", "integer", "smallint", "tinyint"].includes(normalized))
-                return "int";
-            if (["numeric"].includes(normalized))
-                return "numeric";
-            if (["decimal", "float", "double", "real", "money", "smallmoney"].includes(normalized))
-                return "decimal";
-            if (["date"].includes(normalized))
-                return "date";
-            if (["time"].includes(normalized))
-                return "time";
-            if (["datetime2"].includes(normalized))
-                return "datetime2";
-            if (["datetime", "smalldatetime", "timestamp"].includes(normalized) || normalized.includes("date"))
-                return "datetime";
-            if (["json", "jsonb", "simple-json", "simplejson"].includes(normalized) || normalized.includes("json"))
-                return "simple-json";
-            if (["uniqueidentifier", "uuid"].includes(normalized))
-                return "uniqueidentifier";
-            if (["text", "ntext", "mediumtext", "longtext", "clob"].includes(normalized))
-                return "text";
-            if (["nvarchar", "nchar"].includes(normalized))
-                return "nvarchar";
-            return "varchar";
-        }
-        if (normalizedDatasourceType === "mysql") {
-            if (["bigint"].includes(normalized))
-                return "int";
-            if (["int", "integer", "smallint", "tinyint"].includes(normalized))
+            case "int":
                 return "int";
-            if (["decimal", "numeric"].includes(normalized))
+            case "numeric":
+            case "decimal":
+            case "float":
                 return "decimal";
-            if (["float", "double", "real", "money", "smallmoney"].includes(normalized))
-                return "double";
-            if (["bit", "bool", "boolean"].includes(normalized))
-                return "boolean";
-            if (["date"].includes(normalized))
+            case "date":
                 return "date";
-            if (["time"].includes(normalized))
+            case "time":
                 return "time";
-            if (["datetime", "timestamp", "smalldatetime"].includes(normalized) || normalized.includes("date"))
+            case "datetime":
+            case "datetimeWithTimezone":
                 return "datetime";
-            if (["json", "jsonb", "simple-json", "simplejson"].includes(normalized) || normalized.includes("json"))
+            case "json":
+            case "jsonb":
                 return "json";
-            if (["mediumtext"].includes(normalized))
-                return "mediumtext";
-            if (["longtext", "text", "ntext", "clob"].includes(normalized))
-                return "longtext";
-            return "varchar";
-        }
-        if (["bigint"].includes(normalized))
-            return "bigint";
-        if (["int", "integer", "smallint", "tinyint"].includes(normalized))
-            return "integer";
-        if (["decimal", "numeric", "float", "double", "real", "money", "smallmoney"].includes(normalized))
-            return "decimal";
-        if (["bit", "bool", "boolean"].includes(normalized))
-            return "boolean";
-        if (["date"].includes(normalized))
-            return "date";
-        if (["time"].includes(normalized))
-            return "time";
-        if (["timestamptz"].includes(normalized))
-            return "timestamptz";
-        if (["datetime", "datetime2", "timestamp", "smalldatetime"].includes(normalized) || normalized.includes("date"))
-            return "timestamp";
-        if (["jsonb"].includes(normalized))
-            return "jsonb";
-        if (["json", "simple-json", "simplejson"].includes(normalized) || normalized.includes("json"))
-            return "json";
-        if (["text", "ntext", "mediumtext", "longtext", "clob"].includes(normalized))
-            return "text";
-        return "varchar";
+            case "uuid":
+                return "uuid";
+            case "mediumText":
+            case "longText":
+                return "longText";
+            case "shortText":
+            case "unicodeShortText":
+                if (charLength !== null && charLength > 255) {
+                    return "longText";
+                }
+                return "shortText";
+            default:
+                return "shortText";
+        }
+    }
+    toOrmFieldType(column, datasourceType) {
+        const family = this.getDatasourceTypeFamily(column.dataType);
+        const normalizedDatasourceType = datasourceType.toLowerCase();
+        const ormType = family
+            ? ORM_TYPE_BY_DATASOURCE_FAMILY[normalizedDatasourceType]?.[family]
+            : undefined;
+        if (ormType) {
+            return ormType;
+        }
+        return normalizedDatasourceType === "postgres" ? "varchar" : "varchar";
     }
     toFieldName(columnName) {
         return (0, lodash_1.camelCase)(columnName.replace(/^ss_/, ""));
@@ -1190,6 +1328,240 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
     toModelMapKey(datasourceName, tableName) {
         return `${datasourceName.toLowerCase()}::${tableName.toLowerCase()}`;
     }
+    async syncTypeormDatasourceFile(moduleName, datasource, singularName) {
+        const datasourceFilePath = path.resolve(process.cwd(), "src", `typeorm-${datasource.name}-datasource.ts`);
+        const entityClassName = (0, string_helper_1.classify)(singularName);
+        const entityImportPath = `./${moduleName}/entities/${(0, lodash_1.kebabCase)(singularName)}.entity`;
+        const migrationGlob = `join(__dirname, './${moduleName}/migrations/${datasource.name}/*.{ts,js}')`;
+        const existingContent = await fs.readFile(datasourceFilePath, "utf8").catch(() => null);
+        if (!existingContent) {
+            const rendered = this.renderTypeormDatasourceTemplate({
+                datasource,
+                entityClassName,
+                entityImportPath,
+                migrationGlob,
+            });
+            await fs.writeFile(datasourceFilePath, rendered, "utf8");
+            return {
+                filePath: datasourceFilePath,
+                created: true,
+                updated: false,
+                entityRegistered: true,
+                migrationGlobRegistered: true,
+            };
+        }
+        const project = new ts_morph_1.Project({
+            skipAddingFilesFromTsConfig: true,
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+                indentationText: ts_morph_1.IndentationText.FourSpaces,
+                insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+            },
+        });
+        const sourceFile = project.createSourceFile(datasourceFilePath, existingContent, { overwrite: true });
+        const entityImportDeclaration = sourceFile.getImportDeclarations().find((declaration) => declaration.getModuleSpecifierValue() === entityImportPath);
+        if (entityImportDeclaration) {
+            const alreadyImported = entityImportDeclaration.getNamedImports().some((namedImport) => namedImport.getName() === entityClassName);
+            if (!alreadyImported) {
+                entityImportDeclaration.addNamedImport(entityClassName);
+            }
+        }
+        else {
+            sourceFile.addImportDeclaration({
+                moduleSpecifier: entityImportPath,
+                namedImports: [entityClassName],
+            });
+        }
+        const entitiesArray = sourceFile
+            .getVariableDeclarationOrThrow("entities")
+            .getInitializerIfKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+        const entityAlreadyRegistered = this.arrayLiteralContainsValue(entitiesArray, entityClassName);
+        if (!entityAlreadyRegistered) {
+            entitiesArray.addElement(entityClassName);
+        }
+        const dataSourceOptions = this.getTypeormDatasourceOptions(sourceFile);
+        const migrationsArray = this.getObjectPropertyArrayLiteral(dataSourceOptions, "migrations");
+        const migrationAlreadyRegistered = this.arrayLiteralContainsValue(migrationsArray, migrationGlob);
+        if (!migrationAlreadyRegistered) {
+            migrationsArray.addElement(migrationGlob);
+        }
+        sourceFile.organizeImports();
+        sourceFile.formatText();
+        const nextContent = sourceFile.getFullText();
+        const updated = nextContent !== existingContent;
+        if (updated) {
+            await fs.writeFile(datasourceFilePath, nextContent, "utf8");
+        }
+        return {
+            filePath: datasourceFilePath,
+            created: false,
+            updated,
+            entityRegistered: true,
+            migrationGlobRegistered: true,
+        };
+    }
+    renderTypeormDatasourceTemplate(input) {
+        const { datasource, entityClassName, entityImportPath, migrationGlob } = input;
+        const envPrefix = datasource.envPrefix?.toUpperCase?.() || "DEFAULT";
+        const portFallback = datasource.type === "postgres" ? 5432 : datasource.type === "mysql" ? 3306 : 1433;
+        const project = new ts_morph_1.Project({
+            skipAddingFilesFromTsConfig: true,
+            manipulationSettings: {
+                quoteKind: ts_morph_1.QuoteKind.Single,
+                indentationText: ts_morph_1.IndentationText.FourSpaces,
+                insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
+            },
+        });
+        const sourceFile = project.createSourceFile("typeorm-template.ts", "", { overwrite: true });
+        sourceFile.addImportDeclaration({ moduleSpecifier: "reflect-metadata" });
+        sourceFile.addImportDeclaration({ moduleSpecifier: "path", namedImports: ["join"] });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "dotenv",
+            namedImports: [{ name: "config", alias: "dotenvConfig" }],
+        });
+        sourceFile.addStatements("dotenvConfig({ path: join(__dirname, '../.env') });");
+        sourceFile.addStatements("");
+        sourceFile.addImportDeclaration({ moduleSpecifier: "typeorm", namedImports: ["DataSource"] });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "@solidxai/core",
+            namespaceImport: "SolidCoreModuleExports",
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "@solidxai/core",
+            namedImports: ["getDynamicModuleNames", "parseBooleanEnv"],
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "typeorm",
+            namedImports: ["getMetadataArgsStorage"],
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: "typeorm-naming-strategies",
+            namedImports: ["SnakeNamingStrategy"],
+        });
+        sourceFile.addImportDeclaration({
+            moduleSpecifier: entityImportPath,
+            namedImports: [entityClassName],
+        });
+        sourceFile.addFunction({
+            name: "getEntitiesFromExports",
+            parameters: [{ name: "exports", type: "Record<string, any>" }],
+            statements: (writer) => {
+                writer.writeLine("const metadataStorage = getMetadataArgsStorage();");
+                writer.writeLine("return Object.values(exports).filter((item) =>");
+                writer.indent(() => {
+                    writer.writeLine("metadataStorage.tables.some((table) => table.target === item),");
+                });
+                writer.write(");");
+            },
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "coreEntities",
+                    initializer: "getEntitiesFromExports(SolidCoreModuleExports)",
+                },
+            ],
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "dynamicModules",
+                    initializer: "getDynamicModuleNames()",
+                },
+            ],
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "entities",
+                    initializer: `[\n    ...coreEntities,\n    ${entityClassName},\n]`,
+                },
+            ],
+        });
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: "logging",
+                    initializer: `parseBooleanEnv('${envPrefix}_DATABASE_LOGGING')`,
+                },
+            ],
+        });
+        sourceFile.addStatements("// IMPORTANT: synchronize must be false when using migrations");
+        sourceFile.addVariableStatement({
+            declarationKind: ts_morph_1.VariableDeclarationKind.Const,
+            isExported: true,
+            declarations: [
+                {
+                    name: "DefaultDataSource",
+                    initializer: (writer) => {
+                        writer.write("new DataSource(");
+                        writer.inlineBlock(() => {
+                            writer.writeLine(`type: '${datasource.type}',`);
+                            writer.blankLine();
+                            writer.writeLine(`host: process.env.${envPrefix}_DATABASE_HOST,`);
+                            writer.writeLine(`port: +(process.env.${envPrefix}_DATABASE_PORT || ${portFallback}),`);
+                            writer.writeLine(`username: process.env.${envPrefix}_DATABASE_USER,`);
+                            writer.writeLine(`password: process.env.${envPrefix}_DATABASE_PASSWORD,`);
+                            writer.writeLine(`database: process.env.${envPrefix}_DATABASE_NAME,`);
+                            writer.blankLine();
+                            writer.writeLine("entities,");
+                            writer.writeLine("migrations: [");
+                            writer.indent(() => {
+                                writer.writeLine(`${migrationGlob},`);
+                            });
+                            writer.writeLine("],");
+                            writer.writeLine("synchronize: false,");
+                            writer.writeLine("logging,");
+                            writer.writeLine("namingStrategy: new SnakeNamingStrategy(),");
+                            if (datasource.type === "mssql") {
+                                writer.writeLine("options: {");
+                                writer.indent(() => {
+                                    writer.writeLine("encrypt: false,");
+                                    writer.writeLine("trustServerCertificate: true,");
+                                });
+                                writer.writeLine("},");
+                            }
+                        });
+                        writer.write(")");
+                    },
+                },
+            ],
+        });
+        sourceFile.organizeImports();
+        sourceFile.formatText();
+        return sourceFile.getFullText();
+    }
+    arrayLiteralContainsValue(arrayLiteral, rawValue) {
+        const normalizedTarget = rawValue.replace(/\s+/g, "");
+        return arrayLiteral.getElements().some((element) => element.getText().replace(/\s+/g, "") === normalizedTarget);
+    }
+    getTypeormDatasourceOptions(sourceFile) {
+        const defaultDataSourceDeclaration = sourceFile.getVariableDeclarationOrThrow("DefaultDataSource");
+        const initializer = defaultDataSourceDeclaration.getInitializer();
+        if (!initializer || !ts_morph_1.Node.isNewExpression(initializer)) {
+            throw new common_1.BadRequestException("Unable to locate DefaultDataSource initializer in datasource file.");
+        }
+        const options = initializer.getArguments()[0];
+        if (!options || !ts_morph_1.Node.isObjectLiteralExpression(options)) {
+            throw new common_1.BadRequestException("Unable to locate DefaultDataSource options object in datasource file.");
+        }
+        return options;
+    }
+    getObjectPropertyArrayLiteral(objectLiteral, propertyName) {
+        const property = objectLiteral.getProperty(propertyName);
+        if (!property || !ts_morph_1.Node.isPropertyAssignment(property)) {
+            throw new common_1.BadRequestException(`Unable to locate "${propertyName}" property in datasource file.`);
+        }
+        const initializer = property.getInitializer();
+        if (!initializer || !ts_morph_1.Node.isArrayLiteralExpression(initializer)) {
+            throw new common_1.BadRequestException(`Unable to locate "${propertyName}" array in datasource file.`);
+        }
+        return initializer;
+    }
     buildSynchronizeBlockedMessage(datasource) {
         return `Datasource "${datasource.displayName}" has synchronize enabled. Set ${datasource.envPrefix}_DATABASE_SYNCHRONIZE=false before starting legacy table introspection.`;
     }
@@ -1271,6 +1643,8 @@ exports.DatasourceIntrospectionService = DatasourceIntrospectionService = __deco
         model_metadata_helper_service_1.ModelMetadataHelperService,
         field_metadata_service_1.FieldMetadataService,
         model_metadata_service_1.ModelMetadataService,
+        module_metadata_service_1.ModuleMetadataService,
+        command_service_1.CommandService,
         mssql_datasource_introspection_provider_service_1.MssqlDatasourceIntrospectionProviderService,
         mysql_datasource_introspection_provider_service_1.MysqlDatasourceIntrospectionProviderService,
         postgres_datasource_introspection_provider_service_1.PostgresDatasourceIntrospectionProviderService])