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

package/src/services/import-transaction.service.ts

@@ -204,6 +204,11 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
 
     // Iterate through the fields and populate the standard instructions
     for (const field of allFields) {
+
+      // Skip Computed fields
+      if (field.type === SolidFieldType.computed) {
+        continue;
+      }
       // Skip system fields
       if (systemFieldNames.includes(field.name)) {
         continue;

package/src/services/locale.service.ts

@@ -1,7 +1,7 @@
-import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
+import { EntityManager, In, IsNull, Not } from 'typeorm';
 
 import { Locale } from 'src/entities/locale.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
@@ -31,7 +31,115 @@ export class LocaleService extends CRUDService<Locale> implements OnApplicationB
     // Load the security rules from the database
     this.loadLocales();
   }
-   async loadLocales() {
+
+  private async assertCanSetAsDefault(currentLocaleId?: number) {
+    const defaultLocales = await this.repo.find({
+      where: {
+        isDefault: true,
+      } as any,
+    });
+
+    const conflictingDefaultLocale = defaultLocales.find(
+      (locale) => locale.id !== currentLocaleId
+    );
+
+    if (conflictingDefaultLocale) {
+      throw new BadRequestException(
+        `Locale "${conflictingDefaultLocale.displayName}" is already marked as default. Mark it as non-default first.`
+      );
+    }
+  }
+
+  override async create(createDto: any, files: Express.Multer.File[] = [], solidRequestContext: any = {}): Promise<Locale> {
+    if (createDto?.isDefault === true) {
+      await this.assertCanSetAsDefault();
+    }
+
+    const savedLocale = await super.create(createDto, files, solidRequestContext);
+    await this.loadLocales();
+    return savedLocale;
+  }
+
+  override async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [], solidRequestContext: any = {}): Promise<Locale[]> {
+    const defaultLocalesInPayload = (createDtos || []).filter((dto) => dto?.isDefault === true);
+
+    if (defaultLocalesInPayload.length > 1) {
+      throw new BadRequestException(`Only one locale can be marked as default.`);
+    }
+
+    if (defaultLocalesInPayload.length === 1) {
+      await this.assertCanSetAsDefault();
+    }
+
+    const savedLocales = await super.insertMany(createDtos, filesArray, solidRequestContext);
+    await this.loadLocales();
+    return savedLocales;
+  }
+
+  override async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}, isUpdate: boolean = false): Promise<Locale> {
+    if (updateDto?.isDefault === true) {
+      await this.assertCanSetAsDefault(id);
+    }
+
+    const savedLocale = await super.update(id, updateDto, files, isPartialUpdate, solidRequestContext, isUpdate);
+    await this.loadLocales();
+    return savedLocale;
+  }
+
+  override async recover(id: number, solidRequestContext: any = {}) {
+    const localeToRecover = await this.repo.findOne({
+      where: {
+        id,
+        deletedAt: Not(IsNull()),
+      } as any,
+      withDeleted: true,
+    });
+
+    if (localeToRecover?.isDefault) {
+      await this.assertCanSetAsDefault(id);
+    }
+
+    const recoveredLocale = await super.recover(id, solidRequestContext);
+    await this.loadLocales();
+    return recoveredLocale;
+  }
+
+  override async recoverMany(ids: number[], solidRequestContext: any = {}) {
+    const localesToRecover = await this.repo.find({
+      where: {
+        id: In(ids),
+        deletedAt: Not(IsNull()),
+      } as any,
+      withDeleted: true,
+    });
+
+    const defaultLocalesToRecover = localesToRecover.filter((locale) => locale.isDefault);
+    if (defaultLocalesToRecover.length > 1) {
+      throw new BadRequestException(`Only one locale can be marked as default.`);
+    }
+
+    if (defaultLocalesToRecover.length === 1) {
+      await this.assertCanSetAsDefault(defaultLocalesToRecover[0].id);
+    }
+
+    const recoveredLocales = await super.recoverMany(ids, solidRequestContext);
+    await this.loadLocales();
+    return recoveredLocales;
+  }
+
+  override async delete(id: number, solidRequestContext: any = {}) {
+    const deletedLocale = await super.delete(id, solidRequestContext);
+    await this.loadLocales();
+    return deletedLocale;
+  }
+
+  override async deleteMany(ids: number[], solidRequestContext: any = {}) {
+    const deletedLocales = await super.deleteMany(ids, solidRequestContext);
+    await this.loadLocales();
+    return deletedLocales;
+  }
+
+  async loadLocales() {
     const locales = await this.repo.find();
     this.logger.debug(`Loaded ${locales.length} locales into registry`);
     this.solidRegistry.registerlocales(locales);

package/src/services/mediaStorageProviders/file-s3-storage-provider.ts

@@ -2,8 +2,8 @@ import { Injectable, Logger } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { CommonEntity } from "src/entities/common.entity";
 import { FieldMetadata } from "src/entities/field-metadata.entity";
-import { LegacyCommonEntityWithExistingId } from "src/entities/legacy-common.entity";
-import { LegacyCommonEntityWithGeneratedId } from "src/entities/legacy-common-with-id.entity";
+import { LegacyCommonEntityWithExistingId } from "src/entities/legacy-common.entity-with-existing-id.entity";
+import { LegacyCommonEntityWithGeneratedId } from "src/entities/legacy-common-with-generated-id.entity";
 import { Media } from "src/entities/media.entity";
 import { MediaStorageProvider } from "src/interfaces";
 import { DiskFileService, S3FileService } from "src/services/file";

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,6 +28,8 @@ 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,
@@ -743,10 +746,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);
@@ -967,6 +1032,26 @@ 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}`],
@@ -1478,7 +1563,7 @@ export class ModelMetadataService {
     //Filter out the fields by id
     const fieldsForRemoval = model.fields.filter((field) => options.fieldIdsForRemoval.includes(+field.id));
     const removeOutput = await this.executeRemoveFieldsCommand(model, fieldsForRemoval, options.dryRun);
-
+    const migrationOutput = await this.executeMigrationRemoveFieldsCommand(model, fieldsForRemoval, options.dryRun);
     // Remove the fields from the database as well. This also checks, if the field is marked for removal
     for (const field of fieldsForRemoval) {
       if (field.isMarkedForRemoval) {
@@ -1515,6 +1600,13 @@ export class ModelMetadataService {
 
     return removeOutput;
   }
+  // model-metadata.service.ts mein naya method add karo
+  // async executeRemoveFieldsWithModel(model: ModelMetadata, fieldNames: string[], dryRun = false,) {
+  //   const fieldsForRemoval = model.fields.filter(
+  //     field => fieldNames.includes(field.name)
+  //   );
+  //   return this.executeRemoveFieldsCommand(model, fieldsForRemoval, dryRun);
+  // }
 
   async generateModelCode(options: CodeGenerationOptions): Promise<string> {
     if (!options.modelId && !options.modelUserKey) {
@@ -1563,6 +1655,22 @@ export class ModelMetadataService {
     return output;
   }
 
+  private async executeMigrationRemoveFieldsCommand(model: ModelMetadata, fieldsForRemoval: FieldMetadata[], dryRun: boolean = false,): Promise<string> {
+    if (!fieldsForRemoval || fieldsForRemoval.length === 0) {
+      return "";
+    }
+
+    const output = await this.commandService.executeCommandWithArgs({
+      command: 'npx',
+      args: ['@solidxai/solidctl@latest', 'migration', '-n', model.singularName, 'remove-field', ...(dryRun ? [] : ['--apply'])],
+      cwd: path.join(process.cwd(), '..'),
+    });
+
+    this.logger.debug(`Schematic output : ${output}`);
+    return output;
+  }
+
+
   async updateUserKey(data: any) {
     const { modelName, fieldName } = data;
 

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

@@ -26,6 +26,8 @@ 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';
@@ -534,6 +536,40 @@ 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}`],