@solidxai/core 0.1.11-beta.9 → 0.1.11

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

@@ -290,10 +290,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         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 migrationWritten = await this.writeMigrationFile(plan.migration);
         const datasourceFile = await this.syncTypeormDatasourceFile(module.name, datasource, plan.modelPayload.singularName);
         return {
             data: {
@@ -301,7 +298,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
                 operation: plan.operation,
                 migration: {
                     ...plan.migration,
-                    written: Boolean(plan.migration.willGenerate && plan.migration.filePath),
+                    written: migrationWritten,
                 },
                 datasourceFile,
                 summary: plan.summary,
@@ -377,6 +374,8 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         if (!tableRecord) {
             throw new common_1.NotFoundException(`Table "${mappingDto.tableName}" was not found on datasource "${datasource.name}".`);
         }
+        const tableColumns = inventory.columnsByKey.get(tableKey) ?? [];
+        this.validateTablePrimaryKeyForMapping(tableRecord, tableColumns, mappingDto);
         const existingModel = mappingDto.mapped && mappingDto.modelId
             ? await this.modelMetadataRepository.findOne({
                 where: { id: mappingDto.modelId },
@@ -391,14 +390,14 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         if (mappingDto.mapped && !existingModel) {
             throw new common_1.NotFoundException(`Mapped model "${mappingDto.modelId}" was not found.`);
         }
-        const reviewedModel = this.normalizeReviewedMetadataModel(mappingDto.reviewedModel, mappingDto);
+        const reviewedModel = this.normalizeReviewedMetadataModel(mappingDto.reviewedModel, mappingDto, tableColumns);
         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 migration = await this.buildMigrationPreview(module.name, datasource, mappingDto, tableColumns);
         const includedColumnNames = mappingDto.columns
             .filter((column) => !column.handledBySuperclass && column.include)
             .map((column) => column.columnName);
@@ -462,6 +461,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         };
     }
     buildModelPayloadFromReviewedModel(moduleId, mappingDto, existingModel, reviewedModel) {
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(reviewedModel.fields, reviewedModel.userKeyFieldUserKey, mappingDto.userKeyField);
         const systemFieldPayloads = existingModel
             ? existingModel.fields
                 .filter((field) => field.isSystem)
@@ -472,7 +472,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             return {
                 ...field,
                 ...(matchedExistingField?.id ? { id: matchedExistingField.id } : {}),
-                isUserKey: field.name === reviewedModel.userKeyFieldUserKey,
+                isUserKey: field.name === resolvedUserKeyFieldName,
                 isSystem: field.isSystem ?? false,
             };
         });
@@ -500,6 +500,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
     async buildMetadataJsonPreview(moduleName, mappingDto, existingModel) {
         const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
         const previewFields = await this.buildMetadataPreviewFields(mappingDto, existingModel);
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(previewFields, mappingDto.userKeyField, mappingDto.userKeyField) ?? mappingDto.userKeyField;
         return {
             filePath,
             model: {
@@ -510,7 +511,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
                 dataSource: mappingDto.dataSource,
                 dataSourceType: mappingDto.dataSourceType,
                 tableName: mappingDto.tableName,
-                userKeyFieldUserKey: mappingDto.userKeyField,
+                userKeyFieldUserKey: resolvedUserKeyFieldName,
                 isChild: false,
                 legacyTableType: mappingDto.legacyTableType,
                 parentModelUserKey: "",
@@ -559,10 +560,6 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         }
         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;
@@ -575,6 +572,10 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         for (const field of serialized) {
             previewFields.push(await this.fieldMetadataService.createFieldConfig(field));
         }
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(previewFields, mappingDto.userKeyField, mappingDto.userKeyField);
+        for (const field of previewFields) {
+            field.isUserKey = field.name === resolvedUserKeyFieldName;
+        }
         return previewFields;
     }
     async buildMigrationPreview(moduleName, datasource, mappingDto, tableColumns) {
@@ -626,7 +627,7 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
         }
         return this.sanitizeExistingFieldPayload(fieldConfig);
     }
-    normalizeReviewedMetadataModel(reviewedModel, mappingDto) {
+    normalizeReviewedMetadataModel(reviewedModel, mappingDto, tableColumns) {
         if (!reviewedModel) {
             return null;
         }
@@ -675,10 +676,14 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             }
             fieldNames.add(loweredName);
         }
-        const userKeyFieldUserKey = readString("userKeyFieldUserKey");
-        if (!normalizedFields.some((field) => field.name === userKeyFieldUserKey && !field.isMarkedForRemoval)) {
+        const requestedUserKeyFieldUserKey = readString("userKeyFieldUserKey");
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(normalizedFields, requestedUserKeyFieldUserKey, mappingDto.userKeyField);
+        const inheritedGeneratedIdUserKey = this.isGeneratedIdInheritedUserKey(mappingDto.legacyTableType, requestedUserKeyFieldUserKey);
+        if (!resolvedUserKeyFieldName && !inheritedGeneratedIdUserKey) {
             throw new common_1.BadRequestException("Reviewed metadata JSON must keep the selected userKeyFieldUserKey in the fields array.");
         }
+        this.validateReviewedPrimaryKeyFields(normalizedFields, tableColumns);
+        const userKeyFieldUserKey = resolvedUserKeyFieldName ?? requestedUserKeyFieldUserKey;
         return {
             singularName: readString("singularName"),
             pluralName: readString("pluralName"),
@@ -697,10 +702,39 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             internationalisation: readBoolean("internationalisation"),
             fields: normalizedFields.map((field) => ({
                 ...field,
-                isUserKey: field.name === userKeyFieldUserKey,
+                isUserKey: field.name === resolvedUserKeyFieldName,
             })),
         };
     }
+    resolveReviewedUserKeyFieldName(reviewedFields, requestedUserKeyFieldName, fallbackUserKeyFieldName) {
+        const activeFields = reviewedFields.filter((field) => !field.isMarkedForRemoval);
+        const normalizedRequested = `${requestedUserKeyFieldName ?? ""}`.trim().toLowerCase();
+        const normalizedFallback = `${fallbackUserKeyFieldName ?? ""}`.trim().toLowerCase();
+        const byExactRequested = activeFields.find((field) => field.name?.toLowerCase?.() === normalizedRequested);
+        if (byExactRequested) {
+            return byExactRequested.name;
+        }
+        const byExistingUserKeyFlag = activeFields.find((field) => field.isUserKey);
+        if (byExistingUserKeyFlag) {
+            return byExistingUserKeyFlag.name;
+        }
+        const byPrimaryKeyFallback = activeFields.find((field) => {
+            if (!field.isPrimaryKey) {
+                return false;
+            }
+            const normalizedName = `${field.name ?? ""}`.trim().toLowerCase();
+            return normalizedName === normalizedFallback || normalizedName === "id" || normalizedName === "legacyid";
+        });
+        if (byPrimaryKeyFallback) {
+            return byPrimaryKeyFallback.name;
+        }
+        const byFallbackFieldName = activeFields.find((field) => field.name?.toLowerCase?.() === normalizedFallback);
+        return byFallbackFieldName?.name ?? null;
+    }
+    isGeneratedIdInheritedUserKey(legacyTableType, requestedUserKeyFieldName) {
+        return legacyTableType === legacy_table_type_enum_1.LegacyTableType.GENERATED_ID
+            && `${requestedUserKeyFieldName ?? ""}`.trim().toLowerCase() === "id";
+    }
     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.`);
@@ -1036,6 +1070,8 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             const suggestedIdColumn = this.getSuggestedIdColumn(datasource.type, tableColumns, suggestedLegacyTableType);
             const mappedModel = this.resolveMappedModel(modelLookup, datasource.name, tableName);
             const physicalColumns = tableColumns.filter((column) => !this.isHandledBySuperclass(column.columnName, suggestedLegacyTableType));
+            const primaryKeyColumns = tableColumns.filter((column) => column.isPrimaryKey);
+            const hasPrimaryKey = primaryKeyColumns.length > 0;
             return {
                 schema,
                 tableName,
@@ -1052,6 +1088,12 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
                 suggestedUserKeyField: this.buildUserKeyCandidates(tableColumns)[0]?.name ?? "id",
                 columnCount: tableColumns.length,
                 physicalColumnCount: physicalColumns.length,
+                hasPrimaryKey,
+                primaryKeyColumnCount: primaryKeyColumns.length,
+                primaryKeyColumnNames: primaryKeyColumns.map((column) => column.columnName),
+                mappingBlockedReason: hasPrimaryKey
+                    ? null
+                    : this.buildMissingPrimaryKeyMessage(tableName),
             };
         })
             .filter((record) => Boolean(record))
@@ -1209,6 +1251,44 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             superclassFieldName,
         };
     }
+    validateTablePrimaryKeyForMapping(tableRecord, tableColumns, mappingDto) {
+        const detectedPrimaryKeyColumns = tableColumns.filter((column) => column.isPrimaryKey);
+        if (!detectedPrimaryKeyColumns.length) {
+            throw new common_1.BadRequestException(tableRecord.mappingBlockedReason ?? this.buildMissingPrimaryKeyMessage(tableRecord.tableName));
+        }
+        const requestColumnsByName = new Map(mappingDto.columns.map((column) => [column.columnName.trim().toLowerCase(), column]));
+        for (const primaryKeyColumn of detectedPrimaryKeyColumns) {
+            const matchingRequestColumn = requestColumnsByName.get(primaryKeyColumn.columnName.trim().toLowerCase());
+            if (!matchingRequestColumn) {
+                throw new common_1.BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" must remain present in the mapping request for table "${tableRecord.tableName}".`);
+            }
+            if (!matchingRequestColumn.include) {
+                throw new common_1.BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" cannot be excluded from the mapping for table "${tableRecord.tableName}".`);
+            }
+            if (!matchingRequestColumn.isPrimaryKey) {
+                throw new common_1.BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" must stay marked as isPrimaryKey for table "${tableRecord.tableName}".`);
+            }
+        }
+    }
+    validateReviewedPrimaryKeyFields(reviewedFields, tableColumns) {
+        const detectedPrimaryKeyColumns = tableColumns.filter((column) => column.isPrimaryKey);
+        if (!detectedPrimaryKeyColumns.length) {
+            return;
+        }
+        const activeReviewedFields = reviewedFields.filter((field) => !field.isMarkedForRemoval);
+        for (const primaryKeyColumn of detectedPrimaryKeyColumns) {
+            const matchingReviewedField = activeReviewedFields.find((field) => `${field.columnName ?? ""}`.trim().toLowerCase() === primaryKeyColumn.columnName.trim().toLowerCase());
+            if (!matchingReviewedField) {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON must keep datasource primary key column "${primaryKeyColumn.columnName}" in the fields array.`);
+            }
+            if (!matchingReviewedField.isPrimaryKey) {
+                throw new common_1.BadRequestException(`Reviewed metadata JSON must keep datasource primary key column "${primaryKeyColumn.columnName}" marked with isPrimaryKey: true.`);
+            }
+        }
+    }
+    buildMissingPrimaryKeyMessage(tableName) {
+        return `Table "${tableName}" cannot be mapped because the datasource table does not define any primary key. Add a real primary key to the table before continuing with SolidX mapping.`;
+    }
     getSuperclassFieldName(columnName, legacyTableType) {
         return this.getLegacySuperclassFieldName(columnName, legacyTableType);
     }
@@ -1411,6 +1491,18 @@ let DatasourceIntrospectionService = class DatasourceIntrospectionService {
             migrationGlobRegistered: true,
         };
     }
+    async writeMigrationFile(migration) {
+        if (!migration.willGenerate || !migration.content || !migration.filePath) {
+            return false;
+        }
+        await fs.mkdir(path.dirname(migration.filePath), { recursive: true });
+        await fs.writeFile(migration.filePath, migration.content, "utf8");
+        const writtenContent = await fs.readFile(migration.filePath, "utf8").catch(() => null);
+        if (writtenContent !== migration.content) {
+            throw new common_1.BadRequestException(`Migration file could not be verified after writing: ${migration.filePath}`);
+        }
+        return true;
+    }
     renderTypeormDatasourceTemplate(input) {
         const { datasource, entityClassName, entityImportPath, migrationGlob } = input;
         const envPrefix = datasource.envPrefix?.toUpperCase?.() || "DEFAULT";