@solidxai/core 0.1.11-beta.9 → 0.1.11

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

@@ -43,6 +43,10 @@ type TableInventoryRecord = {
     suggestedUserKeyField: string;
     columnCount: number;
     physicalColumnCount: number;
+    hasPrimaryKey: boolean;
+    primaryKeyColumnCount: number;
+    primaryKeyColumnNames: string[];
+    mappingBlockedReason: string | null;
 };
 
 type TableDetailColumnRecord = {
@@ -401,10 +405,7 @@ export class DatasourceIntrospectionService {
             throw new 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,
@@ -418,7 +419,7 @@ export class DatasourceIntrospectionService {
                 operation: plan.operation,
                 migration: {
                     ...plan.migration,
-                    written: Boolean(plan.migration.willGenerate && plan.migration.filePath),
+                    written: migrationWritten,
                 },
                 datasourceFile,
                 summary: plan.summary,
@@ -504,6 +505,8 @@ export class DatasourceIntrospectionService {
         if (!tableRecord) {
             throw new 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({
@@ -521,14 +524,14 @@ export class DatasourceIntrospectionService {
             throw new 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);
@@ -609,6 +612,11 @@ export class DatasourceIntrospectionService {
         existingModel: ModelMetadata | null,
         reviewedModel: ReviewedMetadataModel,
     ): CreateModelMetadataDto | UpdateModelMetaDataDto {
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(
+            reviewedModel.fields,
+            reviewedModel.userKeyFieldUserKey,
+            mappingDto.userKeyField,
+        );
         const systemFieldPayloads = existingModel
             ? existingModel.fields
                 .filter((field) => field.isSystem)
@@ -620,7 +628,7 @@ export class DatasourceIntrospectionService {
             return {
                 ...field,
                 ...(matchedExistingField?.id ? { id: matchedExistingField.id } : {}),
-                isUserKey: field.name === reviewedModel.userKeyFieldUserKey,
+                isUserKey: field.name === resolvedUserKeyFieldName,
                 isSystem: field.isSystem ?? false,
             };
         });
@@ -654,6 +662,11 @@ export class DatasourceIntrospectionService {
     ) {
         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,
@@ -665,7 +678,7 @@ export class DatasourceIntrospectionService {
                 dataSource: mappingDto.dataSource,
                 dataSourceType: mappingDto.dataSourceType,
                 tableName: mappingDto.tableName,
-                userKeyFieldUserKey: mappingDto.userKeyField,
+                userKeyFieldUserKey: resolvedUserKeyFieldName,
                 isChild: false,
                 legacyTableType: mappingDto.legacyTableType,
                 parentModelUserKey: "",
@@ -733,10 +746,6 @@ export 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;
@@ -752,6 +761,16 @@ export class DatasourceIntrospectionService {
             previewFields.push(await this.fieldMetadataService.createFieldConfig(field as any));
         }
 
+        const resolvedUserKeyFieldName = this.resolveReviewedUserKeyFieldName(
+            previewFields,
+            mappingDto.userKeyField,
+            mappingDto.userKeyField,
+        );
+
+        for (const field of previewFields) {
+            field.isUserKey = field.name === resolvedUserKeyFieldName;
+        }
+
         return previewFields;
     }
 
@@ -829,6 +848,7 @@ export class DatasourceIntrospectionService {
     private normalizeReviewedMetadataModel(
         reviewedModel: Record<string, any> | undefined,
         mappingDto: DatasourceIntrospectionMappingDto,
+        tableColumns: DatasourceIntrospectionColumn[],
     ): ReviewedMetadataModel | null {
         if (!reviewedModel) {
             return null;
@@ -888,11 +908,24 @@ export 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 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"),
@@ -911,11 +944,54 @@ export class DatasourceIntrospectionService {
             internationalisation: readBoolean("internationalisation"),
             fields: normalizedFields.map((field) => ({
                 ...field,
-                isUserKey: field.name === userKeyFieldUserKey,
+                isUserKey: field.name === resolvedUserKeyFieldName,
             })),
         };
     }
 
+    private resolveReviewedUserKeyFieldName(
+        reviewedFields: Array<Record<string, any>>,
+        requestedUserKeyFieldName: string,
+        fallbackUserKeyFieldName?: string,
+    ) {
+        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;
+    }
+
+    private isGeneratedIdInheritedUserKey(
+        legacyTableType: LegacyTableType,
+        requestedUserKeyFieldName: string | null | undefined,
+    ) {
+        return legacyTableType === LegacyTableType.GENERATED_ID
+            && `${requestedUserKeyFieldName ?? ""}`.trim().toLowerCase() === "id";
+    }
+
     private normalizeReviewedField(field: any, index: number) {
         if (!field || typeof field !== "object" || Array.isArray(field)) {
             throw new BadRequestException(`Reviewed metadata JSON field at index ${index} is not a valid object.`);
@@ -1309,6 +1385,8 @@ export 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,
@@ -1326,6 +1404,12 @@ export 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),
                 } satisfies TableInventoryRecord;
             })
             .filter((record): record is TableInventoryRecord => Boolean(record))
@@ -1530,6 +1614,66 @@ export class DatasourceIntrospectionService {
         };
     }
 
+    private validateTablePrimaryKeyForMapping(
+        tableRecord: TableInventoryRecord,
+        tableColumns: DatasourceIntrospectionColumn[],
+        mappingDto: DatasourceIntrospectionMappingDto,
+    ) {
+        const detectedPrimaryKeyColumns = tableColumns.filter((column) => column.isPrimaryKey);
+        if (!detectedPrimaryKeyColumns.length) {
+            throw new 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 BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" must remain present in the mapping request for table "${tableRecord.tableName}".`);
+            }
+
+            if (!matchingRequestColumn.include) {
+                throw new BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" cannot be excluded from the mapping for table "${tableRecord.tableName}".`);
+            }
+
+            if (!matchingRequestColumn.isPrimaryKey) {
+                throw new BadRequestException(`Primary key column "${primaryKeyColumn.columnName}" must stay marked as isPrimaryKey for table "${tableRecord.tableName}".`);
+            }
+        }
+    }
+
+    private validateReviewedPrimaryKeyFields(
+        reviewedFields: Array<Record<string, any>>,
+        tableColumns: DatasourceIntrospectionColumn[],
+    ) {
+        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 BadRequestException(`Reviewed metadata JSON must keep datasource primary key column "${primaryKeyColumn.columnName}" in the fields array.`);
+            }
+
+            if (!matchingReviewedField.isPrimaryKey) {
+                throw new BadRequestException(`Reviewed metadata JSON must keep datasource primary key column "${primaryKeyColumn.columnName}" marked with isPrimaryKey: true.`);
+            }
+        }
+    }
+
+    private buildMissingPrimaryKeyMessage(tableName: string) {
+        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.`;
+    }
+
     private getSuperclassFieldName(columnName: string, legacyTableType: LegacyTableType) {
         return this.getLegacySuperclassFieldName(columnName, legacyTableType);
     }
@@ -1771,6 +1915,22 @@ export class DatasourceIntrospectionService {
         };
     }
 
+    private async writeMigrationFile(migration: MappingPreviewRecord["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 BadRequestException(`Migration file could not be verified after writing: ${migration.filePath}`);
+        }
+
+        return true;
+    }
+
     private renderTypeormDatasourceTemplate(input: {
         datasource: DatasourceRecord;
         entityClassName: string;

package/src/services/menu-item-metadata.service.ts

@@ -154,7 +154,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           if (!i.parentMenuItem) {
             return true
           } else {
-            if(i.action.type === 'custom'){
+            if (i.action.type === 'custom') {
               return true;
             }
             return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
@@ -203,6 +203,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           key: rootItem.name.toLowerCase().replace(/\s+/g, '-'),
           icon: rootItem.iconName,
           // iconVariant : rootItem.iconVariant
+          isSystem: (rootItem.action?.model?.isSystem ?? false) || rootItem.module?.name === "solid-core",
         }
         if (children.length > 0) {
           data["children"] = await this.buildMenuTree(children, allMenuItems, activeUser);

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

@@ -1,6 +1,7 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { existsSync } from 'fs';
 import * as path from 'path';
 import { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
@@ -27,8 +28,6 @@ import { PermissionMetadata } from '../entities/permission-metadata.entity';
 import { RoleMetadata } from '../entities/role-metadata.entity';
 import { ViewMetadata } from '../entities/view-metadata.entity';
 import { CommandService } from '../helpers/command.service';
-import { isEmbeddedDb } from '../helpers/environment.helper';
-import { startNodemonHeartbeat } from '../helpers/nodemon-heartbeat';
 import {
   REFRESH_MODEL_COMMAND,
   REMOVE_FIELDS_COMMAND,
@@ -745,10 +744,72 @@ export class ModelMetadataService {
       }
     }
 
+    await this.cleanupAssociatedTypeormDatasourceFiles(modelEntity, modulePath);
+
     // - | Drop database table | Removes the database table from the DB, this is a very risky step. Best to review all relations to other models etc and then do this manually | Manual (X)
 
   }
 
+  private resolveSolidApiRoot(): string | null {
+    const cwd = process.cwd();
+    const candidates = [
+      cwd,
+      path.join(cwd, 'solid-api'),
+    ];
+
+    for (const candidate of candidates) {
+      const srcRoot = path.join(candidate, 'src');
+      if (existsSync(srcRoot)) {
+        return candidate;
+      }
+    }
+
+    return null;
+  }
+
+  private async cleanupAssociatedTypeormDatasourceFiles(modelEntity: ModelMetadata, modulePath?: string | null) {
+    if (!modulePath) {
+      return;
+    }
+
+    const solidApiRoot = this.resolveSolidApiRoot();
+    if (!solidApiRoot) {
+      this.logger.warn(`Unable to locate consuming solid-api workspace while cleaning datasource files for model '${modelEntity.singularName}'`);
+      return;
+    }
+
+    const srcRoot = path.join(solidApiRoot, 'src');
+    const srcEntries = await fs.readdir(srcRoot).catch(() => []);
+    const datasourceFiles = srcEntries
+      .filter((entry) => /^typeorm-.*-datasource\.ts$/.test(entry))
+      .map((entry) => path.join(srcRoot, entry));
+
+    if (datasourceFiles.length === 0) {
+      return;
+    }
+
+    const moduleDirName = path.basename(modulePath);
+    const entityClassName = classify(modelEntity.singularName);
+    const entityImportPath = `./${moduleDirName}/entities/${kebabCase(modelEntity.singularName)}.entity`;
+
+    this.logger.log(`Scanning ${datasourceFiles.length} TypeORM datasource file(s) for model '${modelEntity.singularName}' cleanup`);
+
+    try {
+      this.solidTsMorphService.begin();
+      for (const datasourceFile of datasourceFiles) {
+        this.solidTsMorphService.cleanupTypeormDatasourceEntity(
+          datasourceFile,
+          entityImportPath,
+          entityClassName,
+        );
+      }
+      await this.solidTsMorphService.commit();
+    } catch (error: any) {
+      this.solidTsMorphService.rollback();
+      this.logger.error(`Failed to clean datasource files for model '${modelEntity.singularName}':`, error);
+    }
+  }
+
   private async cleanupAssociatedViewsActionsAndMenus(modelId: number) {
     const viewRepo = this.dataSource.getRepository(ViewMetadata);
     const actionRepo = this.dataSource.getRepository(ActionMetadata);
@@ -969,26 +1030,6 @@ export class ModelMetadataService {
   @DisallowInProduction()
   async generateCodeViaCtl(modelId: number): Promise<string> {
     const model = await this.findOne(modelId);
-    const isEmbedded = isEmbeddedDb();
-
-    // When using an embedded PGlite database, the single-connection limit means
-    // a spawned `solid refresh-model` subprocess cannot get its own DB connection
-    // while the API server is already holding it. Fall back to in-process code
-    // generation (which reuses the existing connection).
-    if (isEmbedded) {
-      this.logger.log('Embedded database detected — generating API code in-process');
-      // Prevent nodemon from restarting the server while schematics write files.
-      const heartbeat = startNodemonHeartbeat(path.join(process.cwd(), 'src'));
-      try {
-        return await this.handleGenerateCode({
-          modelUserKey: model.singularName,
-          dryRun: false,
-        });
-      } finally {
-        heartbeat.stop();
-      }
-    }
-
     return this.commandService.executeCommandWithArgs({
       command: 'npx',
       args: ['@solidxai/solidctl@latest', 'generate', 'model', `--name=${model.singularName}`],

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

@@ -26,8 +26,6 @@ import {
 } from '../helpers/schematic.service';
 import { CommandService } from '../helpers/command.service';
 import { SolidRegistry } from '../helpers/solid-registry';
-import { isEmbeddedDb } from '../helpers/environment.helper';
-import { startNodemonHeartbeat } from '../helpers/nodemon-heartbeat';
 import { CodeGenerationOptions, ModuleMetadataConfiguration } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
 import { ModelMetadataService } from './model-metadata.service';
@@ -536,40 +534,6 @@ export class ModuleMetadataService {
   @DisallowInProduction()
   async generateCodeViaCtl(moduleId: number): Promise<string> {
     const module = await this.findOne(moduleId);
-    const isEmbedded = isEmbeddedDb();
-
-    // When using an embedded PGlite database, the single-connection limit means
-    // a spawned `solid refresh-module` subprocess cannot get its own DB connection
-    // while the API server is already holding it. Fall back to in-process code
-    // generation (which reuses the existing connection) and only spawn solidctl
-    // for the UI module scaffold (which does not need a database connection).
-    if (isEmbedded) {
-      this.logger.log('Embedded database detected — generating API code in-process');
-      // Prevent nodemon from restarting the server while schematics write files.
-      // The heartbeat touches a watched file every 1.5 s (nodemon delay is 2 s),
-      // keeping the delay from expiring during DB queries between schematic runs.
-      const heartbeat = startNodemonHeartbeat(path.join(process.cwd(), 'src'));
-      try {
-        const apiOutput = await this.generateCode({
-          moduleUserKey: module.name,
-          dryRun: false,
-        });
-        let uiOutput = '';
-        try {
-          uiOutput = await this.commandService.executeCommandWithArgs({
-            command: 'npx',
-            args: ['@solidxai/solidctl@latest', 'generate', 'ui-module', `--name=${module.name}`],
-            cwd: path.join(process.cwd(), '..'),
-          });
-        } catch (error) {
-          this.logger.warn('UI module scaffold failed (solidctl may be outdated); API code was generated successfully.');
-        }
-        return `${apiOutput}\n${uiOutput}`;
-      } finally {
-        heartbeat.stop();
-      }
-    }
-
     return this.commandService.executeCommandWithArgs({
       command: 'npx',
       args: ['@solidxai/solidctl@latest', 'generate', 'module', `--name=${module.name}`],