@solidxai/core 0.1.10-beta.9 → 0.1.11-beta.0

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

@@ -0,0 +1,1278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasourceIntrospectionService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const typeorm_1 = require("@nestjs/typeorm");
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const lodash_1 = require("lodash");
+const legacy_table_type_enum_1 = require("../enums/legacy-table-type.enum");
+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 field_metadata_service_1 = require("./field-metadata.service");
+const model_metadata_service_1 = require("./model-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");
+let DatasourceIntrospectionService = class DatasourceIntrospectionService {
+    constructor(moduleRef, datasourceManagementService, moduleMetadataRepository, modelMetadataRepository, moduleMetadataHelperService, modelMetadataHelperService, fieldMetadataService, modelMetadataService, mssqlProvider, mysqlProvider, postgresProvider) {
+        this.moduleRef = moduleRef;
+        this.datasourceManagementService = datasourceManagementService;
+        this.moduleMetadataRepository = moduleMetadataRepository;
+        this.modelMetadataRepository = modelMetadataRepository;
+        this.moduleMetadataHelperService = moduleMetadataHelperService;
+        this.modelMetadataHelperService = modelMetadataHelperService;
+        this.fieldMetadataService = fieldMetadataService;
+        this.modelMetadataService = modelMetadataService;
+        this.mssqlProvider = mssqlProvider;
+        this.mysqlProvider = mysqlProvider;
+        this.postgresProvider = postgresProvider;
+        this.supportedDatasourceTypes = new Set(["mssql", "mysql", "postgres"]);
+    }
+    async getBootstrap(moduleId) {
+        const module = await this.loadModule(moduleId);
+        const datasources = this.datasourceManagementService
+            .listRecords()
+            .filter((record) => this.supportedDatasourceTypes.has(record.type?.toLowerCase?.() ?? ""));
+        return {
+            data: {
+                module: this.toModuleSummary(module),
+                datasources: datasources.map((record) => this.toDatasourceSummary(record)),
+                recommendedDatasourceName: datasources.find((record) => record.name === module.defaultDataSource)?.name
+                    ?? datasources[0]?.name
+                    ?? null,
+            },
+        };
+    }
+    async getTables(moduleId, datasourceName) {
+        const module = await this.loadModule(moduleId);
+        const datasource = this.requireDatasource(datasourceName);
+        if (datasource.synchronize === true) {
+            return {
+                data: {
+                    module: this.toModuleSummary(module),
+                    datasource: this.toDatasourceSummary(datasource),
+                    synchronizeBlocked: true,
+                    synchronizeMessage: this.buildSynchronizeBlockedMessage(datasource),
+                    records: [],
+                    meta: {
+                        totalRecords: 0,
+                    },
+                },
+            };
+        }
+        const inventory = await this.buildTableInventory(datasource);
+        return {
+            data: {
+                module: this.toModuleSummary(module),
+                datasource: this.toDatasourceSummary(datasource),
+                synchronizeBlocked: false,
+                synchronizeMessage: null,
+                records: inventory.records,
+                meta: {
+                    totalRecords: inventory.records.length,
+                },
+            },
+        };
+    }
+    async getTableDetail(moduleId, datasourceName, tableName, schema) {
+        const module = await this.loadModule(moduleId);
+        const datasource = this.requireDatasource(datasourceName);
+        if (datasource.synchronize === true) {
+            throw new common_1.BadRequestException(this.buildSynchronizeBlockedMessage(datasource));
+        }
+        const inventory = await this.buildTableInventory(datasource);
+        const tableKey = this.toTableKey(schema ?? null, tableName);
+        const selectedTable = inventory.recordsByKey.get(tableKey);
+        if (!selectedTable) {
+            throw new common_1.NotFoundException(`Table "${tableName}" was not found on datasource "${datasource.name}".`);
+        }
+        const provider = this.getProvider(datasource.type);
+        const runtimeDataSource = this.resolveDataSourceByName(datasource.name);
+        const rawColumns = inventory.columnsByKey.get(tableKey) ?? [];
+        const detailColumns = rawColumns.map((column) => this.toDetailColumnRecord(column, selectedTable.suggestedLegacyTableType, datasource.type));
+        const userKeyCandidates = this.buildUserKeyCandidates(rawColumns);
+        const suggestedSingularName = this.toSingularNameCandidate(tableName);
+        const suggestedPluralName = this.toPluralNameCandidate(tableName, suggestedSingularName);
+        const rawDdl = await this.buildRawDdl(provider, runtimeDataSource, {
+            tableName: selectedTable.tableName,
+            tableSchema: selectedTable.schema,
+        });
+        return {
+            data: {
+                module: this.toModuleSummary(module),
+                datasource: this.toDatasourceSummary(datasource),
+                table: selectedTable,
+                columns: detailColumns,
+                rawDdl,
+                userKeyCandidates,
+                suggestedMetadata: {
+                    singularName: suggestedSingularName,
+                    pluralName: suggestedPluralName,
+                    displayName: (0, lodash_1.startCase)(suggestedSingularName),
+                    tableName: selectedTable.tableName,
+                    schema: selectedTable.schema,
+                    dataSource: datasource.name,
+                    dataSourceType: datasource.type,
+                    legacyTableType: selectedTable.suggestedLegacyTableType,
+                    baseClassName: selectedTable.suggestedBaseClassName,
+                    userKeyField: selectedTable.suggestedUserKeyField,
+                    synchronize: false,
+                },
+            },
+        };
+    }
+    async previewMapping(moduleId, mappingDto) {
+        const plan = await this.buildMappingPreview(moduleId, mappingDto);
+        return {
+            data: {
+                operation: plan.operation,
+                mappedModelId: plan.mappedModelId,
+                metadataJson: plan.metadataJson,
+                migration: plan.migration,
+                summary: plan.summary,
+            },
+        };
+    }
+    async applyMapping(moduleId, mappingDto) {
+        const plan = await this.buildMappingPreview(moduleId, mappingDto);
+        if (plan.operation === "update" && !mappingDto.modelId) {
+            throw new common_1.BadRequestException("Mapped tables require a model id before changes can be applied.");
+        }
+        const persistedModel = plan.operation === "update" && mappingDto.modelId
+            ? await this.modelMetadataService.update(mappingDto.modelId, plan.modelPayload)
+            : await this.modelMetadataService.create(plan.modelPayload);
+        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;
+        return {
+            data: {
+                modelId: persistedModelId,
+                operation: plan.operation,
+                metadataJson: plan.metadataJson,
+                migration: {
+                    ...plan.migration,
+                    written: Boolean(plan.migration.willGenerate && plan.migration.filePath),
+                },
+                summary: plan.summary,
+            },
+        };
+    }
+    async buildMappingPreview(moduleId, mappingDto) {
+        const module = await this.loadModule(moduleId);
+        const datasource = this.requireDatasource(mappingDto.dataSource);
+        if (datasource.synchronize === true) {
+            throw new common_1.BadRequestException(this.buildSynchronizeBlockedMessage(datasource));
+        }
+        const inventory = await this.buildTableInventory(datasource);
+        const tableKey = this.toTableKey(mappingDto.schema ?? null, mappingDto.tableName);
+        const tableRecord = inventory.recordsByKey.get(tableKey);
+        if (!tableRecord) {
+            throw new common_1.NotFoundException(`Table "${mappingDto.tableName}" was not found on datasource "${datasource.name}".`);
+        }
+        const existingModel = mappingDto.mapped && mappingDto.modelId
+            ? await this.modelMetadataRepository.findOne({
+                where: { id: mappingDto.modelId },
+                relations: ["fields", "module", "parentModel"],
+                order: {
+                    fields: {
+                        id: "ASC",
+                    },
+                },
+            })
+            : null;
+        if (mappingDto.mapped && !existingModel) {
+            throw new common_1.NotFoundException(`Mapped model "${mappingDto.modelId}" was not found.`);
+        }
+        const reviewedModel = this.normalizeReviewedMetadataModel(mappingDto.reviewedModel, mappingDto);
+        const modelPayload = reviewedModel
+            ? this.buildModelPayloadFromReviewedModel(moduleId, mappingDto, existingModel, reviewedModel)
+            : this.buildModelPayload(moduleId, mappingDto, existingModel);
+        const metadataJson = reviewedModel
+            ? await this.buildMetadataJsonPreviewFromReviewedModel(module.name, reviewedModel)
+            : await this.buildMetadataJsonPreview(module.name, mappingDto, existingModel);
+        const migration = await this.buildMigrationPreview(module.name, datasource, mappingDto, inventory.columnsByKey.get(tableKey) ?? []);
+        const includedColumnNames = mappingDto.columns
+            .filter((column) => !column.handledBySuperclass && column.include)
+            .map((column) => column.columnName);
+        const removedColumnNames = mappingDto.columns
+            .filter((column) => column.matched && !column.handledBySuperclass && !column.include)
+            .map((column) => column.columnName);
+        return {
+            operation: mappingDto.mapped ? "update" : "create",
+            mappedModelId: mappingDto.modelId ?? null,
+            metadataJson,
+            migration,
+            summary: {
+                includedColumnNames,
+                removedColumnNames,
+                missingSystemColumns: migration.missingSystemColumns,
+                generatedSystemColumnCount: migration.missingSystemColumns.length,
+            },
+            modelPayload,
+        };
+    }
+    buildModelPayload(moduleId, mappingDto, existingModel) {
+        const includedColumns = mappingDto.columns.filter((column) => !column.handledBySuperclass && column.include);
+        const matchedFieldIds = new Set(mappingDto.columns
+            .filter((column) => typeof column.fieldId === "number")
+            .map((column) => column.fieldId));
+        const preservedFieldPayloads = existingModel
+            ? existingModel.fields
+                .filter((field) => field.isSystem || !matchedFieldIds.has(field.id))
+                .map((field) => this.sanitizeExistingFieldPayload(field))
+            : [];
+        const updatedFieldPayloads = includedColumns.map((column) => {
+            const existingField = existingModel?.fields?.find((field) => field.id === column.fieldId) ?? null;
+            return this.buildFieldPayload(column, mappingDto, existingField);
+        });
+        return {
+            singularName: mappingDto.singularName.trim(),
+            pluralName: mappingDto.pluralName.trim(),
+            displayName: mappingDto.displayName.trim(),
+            description: mappingDto.description.trim() || mappingDto.displayName.trim(),
+            dataSource: mappingDto.dataSource,
+            dataSourceType: mappingDto.dataSourceType,
+            tableName: mappingDto.tableName,
+            enableSoftDelete: mappingDto.enableSoftDelete,
+            enableAuditTracking: mappingDto.enableAuditTracking,
+            internationalisation: mappingDto.internationalisation,
+            draftPublishWorkflow: mappingDto.draftPublishWorkflow,
+            moduleId,
+            fields: [...preservedFieldPayloads, ...updatedFieldPayloads],
+            isSystem: false,
+            isChild: false,
+            parentModelId: null,
+            parentModelUserKey: "",
+            legacyTableType: mappingDto.legacyTableType,
+        };
+    }
+    buildModelPayloadFromReviewedModel(moduleId, mappingDto, existingModel, reviewedModel) {
+        const systemFieldPayloads = existingModel
+            ? existingModel.fields
+                .filter((field) => field.isSystem)
+                .map((field) => this.sanitizeExistingFieldPayload(field))
+            : [];
+        const reviewedFieldPayloads = reviewedModel.fields.map((field) => {
+            const matchedExistingField = this.matchExistingFieldForReviewedModel(field, mappingDto, existingModel);
+            return {
+                ...field,
+                ...(matchedExistingField?.id ? { id: matchedExistingField.id } : {}),
+                isUserKey: field.name === reviewedModel.userKeyFieldUserKey,
+                isSystem: field.isSystem ?? false,
+            };
+        });
+        return {
+            singularName: reviewedModel.singularName.trim(),
+            pluralName: reviewedModel.pluralName.trim(),
+            displayName: reviewedModel.displayName.trim(),
+            description: reviewedModel.description.trim() || reviewedModel.displayName.trim(),
+            dataSource: reviewedModel.dataSource,
+            dataSourceType: reviewedModel.dataSourceType,
+            tableName: reviewedModel.tableName,
+            enableSoftDelete: reviewedModel.enableSoftDelete,
+            enableAuditTracking: reviewedModel.enableAuditTracking,
+            internationalisation: reviewedModel.internationalisation,
+            draftPublishWorkflow: reviewedModel.draftPublishWorkflow,
+            moduleId,
+            fields: [...systemFieldPayloads, ...reviewedFieldPayloads],
+            isSystem: false,
+            isChild: false,
+            parentModelId: null,
+            parentModelUserKey: reviewedModel.parentModelUserKey ?? "",
+            legacyTableType: reviewedModel.legacyTableType,
+        };
+    }
+    async buildMetadataJsonPreview(moduleName, mappingDto, existingModel) {
+        const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        const previewFields = await this.buildMetadataPreviewFields(mappingDto, existingModel);
+        return {
+            filePath,
+            model: {
+                singularName: mappingDto.singularName.trim(),
+                pluralName: mappingDto.pluralName.trim(),
+                displayName: mappingDto.displayName.trim(),
+                description: mappingDto.description.trim() || mappingDto.displayName.trim(),
+                dataSource: mappingDto.dataSource,
+                dataSourceType: mappingDto.dataSourceType,
+                tableName: mappingDto.tableName,
+                userKeyFieldUserKey: mappingDto.userKeyField,
+                isChild: false,
+                legacyTableType: mappingDto.legacyTableType,
+                parentModelUserKey: "",
+                enableAuditTracking: mappingDto.enableAuditTracking,
+                enableSoftDelete: mappingDto.enableSoftDelete,
+                draftPublishWorkflow: mappingDto.draftPublishWorkflow,
+                internationalisation: mappingDto.internationalisation,
+                fields: previewFields,
+            },
+        };
+    }
+    async buildMetadataJsonPreviewFromReviewedModel(moduleName, reviewedModel) {
+        const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        return {
+            filePath,
+            model: reviewedModel,
+        };
+    }
+    async buildMetadataPreviewFields(mappingDto, existingModel) {
+        const finalFields = new Map();
+        const existingFields = existingModel?.fields ?? [];
+        const matchedFieldIds = new Set(mappingDto.columns
+            .filter((column) => typeof column.fieldId === "number")
+            .map((column) => column.fieldId));
+        const includedColumns = mappingDto.columns.filter((column) => !column.handledBySuperclass && column.include);
+        for (const field of existingFields) {
+            if (field.isSystem || !matchedFieldIds.has(field.id)) {
+                finalFields.set(this.toFieldPreviewKey(field.id, field.name), this.sanitizeExistingFieldPayload(field));
+            }
+        }
+        for (const column of includedColumns) {
+            const existingField = existingFields.find((field) => field.id === column.fieldId) ?? null;
+            const fieldPayload = this.buildFieldPayload(column, mappingDto, existingField);
+            finalFields.set(this.toFieldPreviewKey(fieldPayload.id ?? null, fieldPayload.name), fieldPayload);
+        }
+        for (const column of mappingDto.columns.filter((entry) => entry.matched && !entry.include && entry.fieldId)) {
+            const existingField = existingFields.find((field) => field.id === column.fieldId);
+            if (!existingField || existingField.isSystem) {
+                continue;
+            }
+            finalFields.set(this.toFieldPreviewKey(existingField.id, existingField.name), {
+                ...this.sanitizeExistingFieldPayload(existingField),
+                isMarkedForRemoval: true,
+                isUserKey: false,
+            });
+        }
+        const serialized = Array.from(finalFields.values())
+            .filter((field) => !field.isSystem)
+            .map((field) => ({
+            ...field,
+            isUserKey: field.name === mappingDto.userKeyField,
+        }))
+            .sort((left, right) => {
+            const leftOrder = typeof left.id === "number" ? left.id : Number.MAX_SAFE_INTEGER;
+            const rightOrder = typeof right.id === "number" ? right.id : Number.MAX_SAFE_INTEGER;
+            if (leftOrder !== rightOrder) {
+                return leftOrder - rightOrder;
+            }
+            return `${left.name}`.localeCompare(`${right.name}`);
+        });
+        const previewFields = [];
+        for (const field of serialized) {
+            previewFields.push(await this.fieldMetadataService.createFieldConfig(field));
+        }
+        return previewFields;
+    }
+    async buildMigrationPreview(moduleName, datasource, mappingDto, tableColumns) {
+        const systemColumnDefinitions = this.getLegacySystemColumnDefinitions(mappingDto.legacyTableType, datasource.type);
+        const existingColumns = new Set(tableColumns.map((column) => column.columnName.toLowerCase()));
+        const missingSystemColumns = systemColumnDefinitions.filter((definition) => !existingColumns.has(definition.columnName.toLowerCase()));
+        const removedLegacyMappings = mappingDto.columns.filter((column) => column.matched && !column.include && !column.handledBySuperclass);
+        if (!missingSystemColumns.length) {
+            return {
+                willGenerate: false,
+                filePath: null,
+                fileName: null,
+                className: null,
+                timestamp: mappingDto.plannedMigrationTimestamp ?? null,
+                content: null,
+                note: removedLegacyMappings.length
+                    ? "No migration will be generated for this change because it only updates metadata mapping for existing legacy columns."
+                    : "All required SolidX system columns already exist on this table, so no migration will be generated.",
+                missingSystemColumns: [],
+            };
+        }
+        const modulePath = await this.moduleMetadataHelperService.getModulePath(moduleName);
+        const migrationTimestamp = mappingDto.plannedMigrationTimestamp ?? Date.now();
+        const migrationBaseName = `Sync${(0, lodash_1.startCase)(this.toSingularNameCandidate(mappingDto.tableName)).replace(/\s+/g, "")}SolidxSystemFields`;
+        const className = `${migrationBaseName}${migrationTimestamp}`;
+        const fileName = `${migrationTimestamp}-${migrationBaseName}.ts`;
+        const filePath = path.join(modulePath, "migrations", datasource.name, fileName);
+        return {
+            willGenerate: true,
+            filePath,
+            fileName,
+            className,
+            timestamp: migrationTimestamp,
+            content: this.renderMigrationTemplate(className, mappingDto, missingSystemColumns),
+            note: `Saving this mapping will also write a template migration for the missing SolidX system columns: ${missingSystemColumns.map((column) => column.columnName).join(", ")}.`,
+            missingSystemColumns: missingSystemColumns.map((column) => column.columnName),
+        };
+    }
+    sanitizeExistingFieldPayload(field) {
+        const { createdAt, updatedAt, deletedAt, model, mediaStorageProvider, identifier, ...rest } = field ?? {};
+        if (mediaStorageProvider?.id && !rest.mediaStorageProviderId) {
+            rest.mediaStorageProviderId = mediaStorageProvider.id;
+        }
+        return rest;
+    }
+    normalizeReviewedMetadataModel(reviewedModel, mappingDto) {
+        if (!reviewedModel) {
+            return null;
+        }
+        if (typeof reviewedModel !== "object" || Array.isArray(reviewedModel)) {
+            throw new common_1.BadRequestException("Reviewed metadata JSON must be a valid object.");
+        }
+        const readString = (key, allowEmpty = false) => {
+            const value = reviewedModel[key];
+            if (typeof value !== "string") {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON is missing a valid "${key}" string value.`);
+            }
+            const trimmed = value.trim();
+            if (!allowEmpty && !trimmed) {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON cannot leave "${key}" blank.`);
+            }
+            return trimmed;
+        };
+        const readBoolean = (key) => {
+            const value = reviewedModel[key];
+            if (typeof value !== "boolean") {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON is missing a valid "${key}" boolean value.`);
+            }
+            return value;
+        };
+        const rawFields = reviewedModel.fields;
+        if (!Array.isArray(rawFields)) {
+            throw new common_1.BadRequestException("Reviewed metadata JSON must contain a fields array.");
+        }
+        const immutableKeyChecks = [
+            { key: "dataSource", label: "dataSource" },
+            { key: "dataSourceType", label: "dataSourceType" },
+            { key: "tableName", label: "tableName" },
+            { key: "legacyTableType", label: "legacyTableType" },
+        ];
+        for (const check of immutableKeyChecks) {
+            if (`${reviewedModel[check.label] ?? ""}` !== `${mappingDto[check.key] ?? ""}`) {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON cannot change immutable binding key "${check.label}".`);
+            }
+        }
+        const normalizedFields = rawFields.map((field, index) => this.normalizeReviewedField(field, index));
+        const fieldNames = new Set();
+        for (const field of normalizedFields) {
+            const loweredName = field.name.toLowerCase();
+            if (fieldNames.has(loweredName)) {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON contains duplicate field name "${field.name}".`);
+            }
+            fieldNames.add(loweredName);
+        }
+        const userKeyFieldUserKey = readString("userKeyFieldUserKey");
+        if (!normalizedFields.some((field) => field.name === userKeyFieldUserKey && !field.isMarkedForRemoval)) {
+            throw new common_1.BadRequestException("Reviewed metadata JSON must keep the selected userKeyFieldUserKey in the fields array.");
+        }
+        return {
+            singularName: readString("singularName"),
+            pluralName: readString("pluralName"),
+            displayName: readString("displayName"),
+            description: readString("description", true),
+            dataSource: readString("dataSource"),
+            dataSourceType: readString("dataSourceType"),
+            tableName: readString("tableName"),
+            userKeyFieldUserKey,
+            isChild: false,
+            legacyTableType: mappingDto.legacyTableType,
+            parentModelUserKey: typeof reviewedModel.parentModelUserKey === "string" ? reviewedModel.parentModelUserKey : "",
+            enableAuditTracking: readBoolean("enableAuditTracking"),
+            enableSoftDelete: readBoolean("enableSoftDelete"),
+            draftPublishWorkflow: readBoolean("draftPublishWorkflow"),
+            internationalisation: readBoolean("internationalisation"),
+            fields: normalizedFields.map((field) => ({
+                ...field,
+                isUserKey: field.name === userKeyFieldUserKey,
+            })),
+        };
+    }
+    normalizeReviewedField(field, index) {
+        if (!field || typeof field !== "object" || Array.isArray(field)) {
+            throw new common_1.BadRequestException(`Reviewed metadata JSON field at index ${index} is not a valid object.`);
+        }
+        if (typeof field.name !== "string" || !field.name.trim()) {
+            throw new common_1.BadRequestException(`Reviewed metadata JSON field at index ${index} must include a non-empty "name".`);
+        }
+        if (typeof field.type !== "string" || !field.type.trim()) {
+            throw new common_1.BadRequestException(`Reviewed metadata JSON field "${field.name}" must include a non-empty "type".`);
+        }
+        if (typeof field.ormType !== "string" || !field.ormType.trim()) {
+            throw new common_1.BadRequestException(`Reviewed metadata JSON field "${field.name}" must include a non-empty "ormType".`);
+        }
+        if (typeof field.columnName !== "string" || !field.columnName.trim()) {
+            throw new common_1.BadRequestException(`Reviewed metadata JSON field "${field.name}" must include a non-empty "columnName".`);
+        }
+        return {
+            ...field,
+            name: field.name.trim(),
+            type: field.type.trim(),
+            ormType: field.ormType.trim(),
+            columnName: field.columnName.trim(),
+            displayName: typeof field.displayName === "string" && field.displayName.trim()
+                ? field.displayName.trim()
+                : (0, lodash_1.startCase)(field.name),
+            description: typeof field.description === "string" ? field.description : "",
+        };
+    }
+    matchExistingFieldForReviewedModel(reviewedField, mappingDto, existingModel) {
+        const nonSystemFields = existingModel?.fields?.filter((field) => !field.isSystem) ?? [];
+        const byColumnName = typeof reviewedField.columnName === "string"
+            ? mappingDto.columns.find((column) => column.columnName.toLowerCase() === reviewedField.columnName.toLowerCase())
+            : null;
+        if (byColumnName?.fieldId) {
+            return nonSystemFields.find((field) => field.id === byColumnName.fieldId) ?? null;
+        }
+        const byColumnOnExisting = typeof reviewedField.columnName === "string"
+            ? nonSystemFields.find((field) => `${field.columnName ?? ""}`.toLowerCase() === reviewedField.columnName.toLowerCase())
+            : null;
+        if (byColumnOnExisting) {
+            return byColumnOnExisting;
+        }
+        const byName = nonSystemFields.find((field) => field.name?.toLowerCase?.() === reviewedField.name.toLowerCase());
+        return byName ?? null;
+    }
+    buildFieldPayload(column, mappingDto, existingField) {
+        const preserved = existingField ? this.sanitizeExistingFieldPayload(existingField) : {};
+        const maxLength = column.characterMaximumLength && ["shortText", "longText"].includes(column.solidFieldType)
+            ? column.characterMaximumLength
+            : preserved.max;
+        return {
+            ...preserved,
+            ...(column.fieldId ? { id: column.fieldId } : {}),
+            name: column.fieldName,
+            displayName: preserved.displayName ?? (0, lodash_1.startCase)(column.fieldName),
+            description: preserved.description ?? "",
+            type: column.solidFieldType,
+            ormType: column.ormType,
+            length: preserved.length ?? column.characterMaximumLength ?? undefined,
+            defaultValue: preserved.defaultValue ?? column.defaultValue ?? undefined,
+            required: preserved.required ?? (!column.nullable || column.isPrimaryKey),
+            unique: preserved.unique ?? false,
+            encrypt: preserved.encrypt ?? false,
+            index: preserved.index ?? false,
+            max: maxLength ?? undefined,
+            min: preserved.min ?? undefined,
+            private: preserved.private ?? false,
+            isSystem: preserved.isSystem ?? false,
+            isMarkedForRemoval: false,
+            columnName: column.columnName,
+            isUserKey: mappingDto.userKeyField === column.fieldName,
+            enableAuditTracking: preserved.enableAuditTracking ?? mappingDto.enableAuditTracking,
+            isMultiSelect: preserved.isMultiSelect ?? false,
+            isPrimaryKey: column.isPrimaryKey,
+        };
+    }
+    toFieldPreviewKey(id, name) {
+        return typeof id === "number" ? `id:${id}` : `name:${name.toLowerCase()}`;
+    }
+    getLegacySystemColumnDefinitions(legacyTableType, datasourceType) {
+        const normalizedDatasourceType = datasourceType.toLowerCase();
+        const timestampType = normalizedDatasourceType === "postgres"
+            ? "timestamp"
+            : normalizedDatasourceType === "mysql"
+                ? "datetime"
+                : "datetime2";
+        const publishedAtType = normalizedDatasourceType === "postgres"
+            ? "timestamp"
+            : "datetime";
+        const integerType = normalizedDatasourceType === "postgres" ? "integer" : "int";
+        const varcharType = normalizedDatasourceType === "mssql" ? "nvarchar" : "varchar";
+        const currentTimestampDefault = normalizedDatasourceType === "postgres"
+            ? "now()"
+            : normalizedDatasourceType === "mysql"
+                ? "CURRENT_TIMESTAMP"
+                : "getdate()";
+        return this.modelMetadataHelperService
+            .getSystemFieldsMetadata(legacyTableType)
+            .map((field) => {
+            switch (field.name) {
+                case "id":
+                    return {
+                        columnName: field.columnName,
+                        type: integerType,
+                        isNullable: false,
+                        isGenerated: true,
+                        isUnique: true,
+                    };
+                case "createdAt":
+                case "updatedAt":
+                    return {
+                        columnName: field.columnName,
+                        type: timestampType,
+                        isNullable: false,
+                        defaultExpression: currentTimestampDefault,
+                    };
+                case "deletedAt":
+                    return {
+                        columnName: field.columnName,
+                        type: timestampType,
+                        isNullable: true,
+                    };
+                case "deletedTracker":
+                    return {
+                        columnName: field.columnName,
+                        type: varcharType,
+                        length: "255",
+                        isNullable: false,
+                        defaultExpression: "'not-deleted'",
+                    };
+                case "publishedAt":
+                    return {
+                        columnName: field.columnName,
+                        type: publishedAtType,
+                        isNullable: true,
+                    };
+                case "localeName":
+                    return {
+                        columnName: field.columnName,
+                        type: "varchar",
+                        length: "255",
+                        isNullable: true,
+                    };
+                case "defaultEntityLocaleId":
+                case "createdBy":
+                case "updatedBy":
+                    return {
+                        columnName: field.columnName,
+                        type: integerType,
+                        isNullable: true,
+                    };
+                default:
+                    return {
+                        columnName: field.columnName,
+                        type: "varchar",
+                        isNullable: true,
+                    };
+            }
+        });
+    }
+    renderMigrationTemplate(className, mappingDto, missingSystemColumns) {
+        const tableNameLiteral = this.toMigrationTableName(mappingDto.schema, mappingDto.tableName);
+        const deletedAtIndexName = this.buildMigrationObjectName("IDX", tableNameLiteral, "ss_deleted_at");
+        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");
+        }).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\"],",
+                "                }));",
+                "            }",
+                "        }",
+            ].join("\n"));
+        }
+        if (missingSystemColumns.some((definition) => definition.columnName === "ss_id")) {
+            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,",
+                "                }));",
+                "            }",
+                "        }",
+            ].join("\n"));
+        }
+        const downStatements = [];
+        if (missingSystemColumns.some((definition) => definition.columnName === "ss_id")) {
+            downStatements.push([
+                "        {",
+                "            const table = await queryRunner.getTable(tableName);",
+                `            const index = table?.indices.find((entry) => entry.name === ${JSON.stringify(generatedIdUniqueName)});`,
+                "            if (index) {",
+                "                await queryRunner.dropIndex(tableName, index);",
+                "            }",
+                "        }",
+            ].join("\n"));
+        }
+        if (missingSystemColumns.some((definition) => definition.columnName === "ss_deleted_at")) {
+            downStatements.push([
+                "        {",
+                "            const table = await queryRunner.getTable(tableName);",
+                `            const index = table?.indices.find((entry) => entry.name === ${JSON.stringify(deletedAtIndexName)});`,
+                "            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")));
+        return [
+            "import { MigrationInterface, QueryRunner, TableColumn, TableIndex } from \"typeorm\";",
+            "",
+            `export class ${className} implements MigrationInterface {`,
+            `    name = '${className}'`,
+            "",
+            "    public async up(queryRunner: QueryRunner): Promise<void> {",
+            `        const tableName = ${JSON.stringify(tableNameLiteral)};`,
+            upColumnStatements,
+            postUpStatements.length ? `\n${postUpStatements.join("\n\n")}` : "",
+            "    }",
+            "",
+            "    public async down(queryRunner: QueryRunner): Promise<void> {",
+            `        const tableName = ${JSON.stringify(tableNameLiteral)};`,
+            downStatements.join("\n\n"),
+            "    }",
+            "}",
+            "",
+        ].filter(Boolean).join("\n");
+    }
+    renderTableColumnLiteral(definition) {
+        const properties = [
+            `{\n                name: ${JSON.stringify(definition.columnName)},`,
+            `                type: ${JSON.stringify(definition.type)},`,
+        ];
+        if (definition.length) {
+            properties.push(`                length: ${JSON.stringify(definition.length)},`);
+        }
+        if (typeof definition.isNullable === "boolean") {
+            properties.push(`                isNullable: ${definition.isNullable},`);
+        }
+        if (definition.defaultExpression) {
+            properties.push(`                default: ${JSON.stringify(definition.defaultExpression)},`);
+        }
+        if (definition.isGenerated) {
+            properties.push("                isGenerated: true,");
+            properties.push("                generationStrategy: \"increment\",");
+        }
+        if (definition.isUnique) {
+            properties.push("                isUnique: true,");
+        }
+        properties.push("            }");
+        return properties.join("\n");
+    }
+    buildMigrationObjectName(prefix, tableName, columnName) {
+        const hash = (0, crypto_1.createHash)("md5").update(`${tableName}:${columnName}:${prefix}`).digest("hex").slice(0, 24);
+        return `${prefix}_${hash}`;
+    }
+    toMigrationTableName(schema, tableName) {
+        return schema ? `${schema}.${tableName}` : tableName;
+    }
+    async buildRawDdl(provider, dataSource, table) {
+        try {
+            const statement = await provider.getTableDefinition(dataSource, table);
+            return {
+                statement,
+                available: Boolean(statement),
+                note: statement ? null : "The datasource provider did not return a CREATE TABLE statement for this table.",
+            };
+        }
+        catch (error) {
+            return {
+                statement: null,
+                available: false,
+                note: `DDL preview is unavailable right now: ${error?.message ?? "Unknown error."}`,
+            };
+        }
+    }
+    async buildTableInventory(datasource) {
+        const provider = this.getProvider(datasource.type);
+        const runtimeDataSource = this.resolveDataSourceByName(datasource.name);
+        const [tables, columns, models] = await Promise.all([
+            provider.listTables(runtimeDataSource),
+            provider.listColumns(runtimeDataSource),
+            this.modelMetadataRepository.find({ relations: { module: true } }),
+        ]);
+        const modelMap = this.buildModelMap(models);
+        const columnsByKey = this.groupColumnsByTable(columns);
+        const tableKeys = new Set();
+        for (const table of tables) {
+            tableKeys.add(this.toTableKey(table.tableSchema, table.tableName));
+        }
+        for (const column of columns) {
+            tableKeys.add(this.toTableKey(column.tableSchema, column.tableName));
+        }
+        const records = Array.from(tableKeys)
+            .map((tableKey) => {
+            const matchingTable = tables.find((table) => this.toTableKey(table.tableSchema, table.tableName) === tableKey);
+            const tableColumns = columnsByKey.get(tableKey) ?? [];
+            const schema = matchingTable?.tableSchema ?? tableColumns[0]?.tableSchema ?? null;
+            const tableName = matchingTable?.tableName ?? tableColumns[0]?.tableName;
+            if (!tableName) {
+                return null;
+            }
+            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 physicalColumns = tableColumns.filter((column) => !this.isHandledBySuperclass(column.columnName, suggestedLegacyTableType));
+            return {
+                schema,
+                tableName,
+                mapped: Boolean(mappedModel),
+                mappedModelId: mappedModel?.id ?? null,
+                mappedModelSingularName: mappedModel?.singularName ?? null,
+                mappedModelDisplayName: mappedModel?.displayName ?? null,
+                mappedModuleId: mappedModel?.module?.id ?? null,
+                mappedModuleName: mappedModel?.module?.name ?? null,
+                mappedModuleDisplayName: mappedModel?.module?.displayName ?? null,
+                suggestedLegacyTableType,
+                suggestedBaseClassName: this.getBaseClassName(suggestedLegacyTableType),
+                suggestedIdColumnName: suggestedIdColumn?.columnName ?? null,
+                suggestedUserKeyField: this.buildUserKeyCandidates(tableColumns)[0]?.name ?? "id",
+                columnCount: tableColumns.length,
+                physicalColumnCount: physicalColumns.length,
+            };
+        })
+            .filter((record) => Boolean(record))
+            .sort((left, right) => {
+            if (left.mapped !== right.mapped) {
+                return left.mapped ? 1 : -1;
+            }
+            const leftLabel = `${left.schema ?? ""}.${left.tableName}`.toLowerCase();
+            const rightLabel = `${right.schema ?? ""}.${right.tableName}`.toLowerCase();
+            return leftLabel.localeCompare(rightLabel);
+        });
+        return {
+            records,
+            recordsByKey: new Map(records.map((record) => [this.toTableKey(record.schema, record.tableName), record])),
+            columnsByKey,
+        };
+    }
+    buildModelMap(models) {
+        const map = 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);
+        }
+        return map;
+    }
+    groupColumnsByTable(columns) {
+        const grouped = new Map();
+        for (const column of columns) {
+            const key = this.toTableKey(column.tableSchema, column.tableName);
+            const bucket = grouped.get(key);
+            if (bucket) {
+                bucket.push(column);
+                continue;
+            }
+            grouped.set(key, [column]);
+        }
+        return grouped;
+    }
+    detectLegacyTableType(datasourceType, columns) {
+        const normalizedDatasourceType = datasourceType.toLowerCase();
+        const hasExistingGeneratedId = columns.some((column) => column.isAutoGenerated);
+        if ((normalizedDatasourceType === "mssql" || normalizedDatasourceType === "mysql") && hasExistingGeneratedId) {
+            return legacy_table_type_enum_1.LegacyTableType.EXISTING_ID;
+        }
+        return legacy_table_type_enum_1.LegacyTableType.GENERATED_ID;
+    }
+    getSuggestedIdColumn(datasourceType, columns, legacyTableType) {
+        if (legacyTableType !== legacy_table_type_enum_1.LegacyTableType.EXISTING_ID) {
+            return null;
+        }
+        const normalizedDatasourceType = datasourceType.toLowerCase();
+        if (normalizedDatasourceType !== "mssql" && normalizedDatasourceType !== "mysql") {
+            return null;
+        }
+        return columns.find((column) => column.isAutoGenerated) ?? null;
+    }
+    buildUserKeyCandidates(columns) {
+        const eligibleColumns = columns.filter((column) => !column.columnName.toLowerCase().startsWith("ss_"));
+        const scoreMap = new Map();
+        const priorityMatchers = [
+            { score: 100, reason: "Exact legacy external identifier", test: (name) => name === "external_id" || name === "externalid" },
+            { score: 95, reason: "Exact user key style column", test: (name) => name === "user_key" || name === "userkey" },
+            { score: 90, reason: "Code-style business identifier", test: (name) => name === "code" || name.endsWith("_code") },
+            { score: 85, reason: "Reference-style business identifier", test: (name) => name.includes("reference") || name.endsWith("_number") || name.endsWith("_no") },
+            { score: 80, reason: "Human readable display field", test: (name) => name === "name" || name === "display_name" || name.endsWith("_name") },
+            { score: 70, reason: "Contact field that could identify a record", test: (name) => name === "email" || name === "mobile" || name === "phone" },
+            { score: 60, reason: "Fallback primary identifier", test: (name) => name === "id" },
+        ];
+        for (const column of eligibleColumns) {
+            const normalizedName = column.columnName.toLowerCase();
+            for (const matcher of priorityMatchers) {
+                if (!matcher.test(normalizedName)) {
+                    continue;
+                }
+                const existing = scoreMap.get(column.columnName);
+                if (!existing || matcher.score > existing.score) {
+                    scoreMap.set(column.columnName, {
+                        name: this.toFieldName(column.columnName),
+                        label: column.columnName,
+                        score: matcher.score,
+                        reason: matcher.reason,
+                    });
+                }
+            }
+        }
+        const candidates = Array.from(scoreMap.values())
+            .sort((left, right) => right.score - left.score || left.label.localeCompare(right.label))
+            .map((candidate, index) => ({
+            ...candidate,
+            isDefault: index === 0,
+        }));
+        if (candidates.length) {
+            return candidates;
+        }
+        const hasIdColumn = eligibleColumns.some((column) => column.columnName.toLowerCase() === "id");
+        return [{
+                name: "id",
+                label: hasIdColumn ? "id" : "id (fallback)",
+                score: 0,
+                reason: "Default to the SolidX id field when no stronger user key candidate is available.",
+                isDefault: true,
+            }];
+    }
+    toDetailColumnRecord(column, legacyTableType, datasourceType) {
+        const superclassFieldName = this.getSuperclassFieldName(column.columnName, legacyTableType);
+        const fieldName = legacyTableType === legacy_table_type_enum_1.LegacyTableType.EXISTING_ID && column.isAutoGenerated
+            ? "id"
+            : this.toFieldName(column.columnName);
+        return {
+            columnName: column.columnName,
+            fieldName,
+            dataType: column.dataType,
+            solidFieldType: this.toSolidFieldType(column),
+            ormType: this.toOrmFieldType(column, datasourceType),
+            nullable: column.isNullable,
+            defaultValue: column.defaultValue,
+            characterMaximumLength: column.characterMaximumLength,
+            numericPrecision: column.numericPrecision,
+            numericScale: column.numericScale,
+            ordinalPosition: column.ordinalPosition,
+            isAutoGenerated: column.isAutoGenerated,
+            handledBySuperclass: Boolean(superclassFieldName),
+            superclassFieldName,
+        };
+    }
+    getSuperclassFieldName(columnName, legacyTableType) {
+        return this.getLegacySuperclassFieldName(columnName, legacyTableType);
+    }
+    getLegacySuperclassFieldName(columnName, legacyTableType) {
+        const normalized = columnName.toLowerCase();
+        const legacyFieldMap = {
+            ss_created_at: "createdAt",
+            ss_updated_at: "updatedAt",
+            ss_deleted_at: "deletedAt",
+            ss_deleted_tracker: "deletedTracker",
+            ss_published_at: "publishedAt",
+            ss_locale_name: "localeName",
+            ss_default_entity_locale_id: "defaultEntityLocaleId",
+            ss_created_by_id: "createdBy",
+            ss_updated_by_id: "updatedBy",
+        };
+        if (normalized === "ss_id" && legacyTableType === legacy_table_type_enum_1.LegacyTableType.GENERATED_ID) {
+            return "id";
+        }
+        return legacyFieldMap[normalized] ?? null;
+    }
+    isHandledBySuperclass(columnName, legacyTableType) {
+        return Boolean(this.getSuperclassFieldName(columnName, legacyTableType));
+    }
+    getBaseClassName(legacyTableType) {
+        if (legacyTableType === legacy_table_type_enum_1.LegacyTableType.GENERATED_ID) {
+            return "LegacyCommonEntityWithGeneratedId";
+        }
+        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";
+        }
+        if (["json", "jsonb", "simple-json", "simplejson"].includes(normalized) || 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";
+        }
+        return "shortText";
+    }
+    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))
+                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))
+                return "int";
+            if (["decimal", "numeric"].includes(normalized))
+                return "decimal";
+            if (["float", "double", "real", "money", "smallmoney"].includes(normalized))
+                return "double";
+            if (["bit", "bool", "boolean"].includes(normalized))
+                return "boolean";
+            if (["date"].includes(normalized))
+                return "date";
+            if (["time"].includes(normalized))
+                return "time";
+            if (["datetime", "timestamp", "smalldatetime"].includes(normalized) || normalized.includes("date"))
+                return "datetime";
+            if (["json", "jsonb", "simple-json", "simplejson"].includes(normalized) || normalized.includes("json"))
+                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";
+    }
+    toFieldName(columnName) {
+        return (0, lodash_1.camelCase)(columnName.replace(/^ss_/, ""));
+    }
+    toSingularNameCandidate(tableName) {
+        const normalized = (0, lodash_1.camelCase)(tableName);
+        if (normalized.endsWith("ies")) {
+            return `${normalized.slice(0, -3)}y`;
+        }
+        if (normalized.endsWith("ses")) {
+            return normalized.slice(0, -2);
+        }
+        if (normalized.endsWith("s") && !normalized.endsWith("ss")) {
+            return normalized.slice(0, -1);
+        }
+        return normalized;
+    }
+    toPluralNameCandidate(tableName, singularName) {
+        const normalized = (0, lodash_1.camelCase)(tableName);
+        if (normalized && normalized !== singularName) {
+            return normalized;
+        }
+        if (singularName.endsWith("y")) {
+            return `${singularName.slice(0, -1)}ies`;
+        }
+        if (singularName.endsWith("s")) {
+            return `${singularName}es`;
+        }
+        return `${singularName}s`;
+    }
+    toTableKey(schema, tableName) {
+        return `${(schema ?? "").toLowerCase()}::${tableName.toLowerCase()}`;
+    }
+    toModelMapKey(datasourceName, tableName) {
+        return `${datasourceName.toLowerCase()}::${tableName.toLowerCase()}`;
+    }
+    buildSynchronizeBlockedMessage(datasource) {
+        return `Datasource "${datasource.displayName}" has synchronize enabled. Set ${datasource.envPrefix}_DATABASE_SYNCHRONIZE=false before starting legacy table introspection.`;
+    }
+    resolveDataSourceByName(datasourceName) {
+        const token = datasourceName === "default" ? (0, typeorm_1.getDataSourceToken)() : (0, typeorm_1.getDataSourceToken)(datasourceName);
+        try {
+            const dataSource = this.moduleRef.get(token, { strict: false });
+            if (!dataSource) {
+                throw new common_1.NotFoundException(`Datasource "${datasourceName}" is not registered in the current runtime.`);
+            }
+            return dataSource;
+        }
+        catch (error) {
+            throw new common_1.NotFoundException(`Failed to resolve datasource "${datasourceName}": ${error?.message ?? error}`);
+        }
+    }
+    getProvider(type) {
+        const providers = [
+            this.mssqlProvider,
+            this.mysqlProvider,
+            this.postgresProvider,
+        ];
+        const provider = providers.find((candidate) => candidate.supports(type));
+        if (!provider) {
+            throw new common_1.BadRequestException(`Datasource type "${type}" is not supported for introspection yet.`);
+        }
+        return provider;
+    }
+    requireDatasource(datasourceName) {
+        const datasource = this.datasourceManagementService.findOneByName(datasourceName);
+        if (!datasource) {
+            throw new common_1.NotFoundException(`Datasource "${datasourceName}" is not configured.`);
+        }
+        if (!this.supportedDatasourceTypes.has(datasource.type?.toLowerCase?.() ?? "")) {
+            throw new common_1.BadRequestException(`Datasource "${datasource.type}" is not supported for introspection yet.`);
+        }
+        return datasource;
+    }
+    async loadModule(moduleId) {
+        const module = await this.moduleMetadataRepository.findOne({
+            where: { id: moduleId },
+        });
+        if (!module) {
+            throw new common_1.NotFoundException(`Module with id "${moduleId}" was not found.`);
+        }
+        return module;
+    }
+    toModuleSummary(module) {
+        return {
+            id: module.id,
+            name: module.name,
+            displayName: module.displayName,
+            description: module.description ?? "",
+            defaultDataSource: module.defaultDataSource ?? "",
+        };
+    }
+    toDatasourceSummary(record) {
+        return {
+            name: record.name,
+            displayName: record.displayName,
+            type: record.type,
+            envPrefix: record.envPrefix,
+            isDefault: record.isDefault,
+            synchronize: record.synchronize,
+            host: record.host,
+            port: record.port,
+            database: record.database,
+        };
+    }
+};
+exports.DatasourceIntrospectionService = DatasourceIntrospectionService;
+exports.DatasourceIntrospectionService = DatasourceIntrospectionService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ModuleRef,
+        datasource_management_service_1.DatasourceManagementService,
+        module_metadata_repository_1.ModuleMetadataRepository,
+        model_metadata_repository_1.ModelMetadataRepository,
+        module_metadata_helper_service_1.ModuleMetadataHelperService,
+        model_metadata_helper_service_1.ModelMetadataHelperService,
+        field_metadata_service_1.FieldMetadataService,
+        model_metadata_service_1.ModelMetadataService,
+        mssql_datasource_introspection_provider_service_1.MssqlDatasourceIntrospectionProviderService,
+        mysql_datasource_introspection_provider_service_1.MysqlDatasourceIntrospectionProviderService,
+        postgres_datasource_introspection_provider_service_1.PostgresDatasourceIntrospectionProviderService])
+], DatasourceIntrospectionService);
+//# sourceMappingURL=datasource-introspection.service.js.map