@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/commands/fixtures/fixtures-setup.command.ts

@@ -0,0 +1,44 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { FixturesService } from 'src/services/fixtures.service';
+
+interface CommandOptions {
+  scenario: string;
+  module: string;
+}
+
+@Command({
+  name: 'fixtures setup',
+  description: 'Handles setup and tear down of fixtures for the SolidX application',
+})
+export class FixturesSetupCommand extends CommandRunner {
+  constructor(
+    private readonly fixturesService: FixturesService,
+  ) {
+    super();
+  }
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+    await this.fixturesService.setupFixtures(options.module, options.scenario);
+  }
+
+  // Accept the task name i.e setup/tear-down for the fixtures command
+  @Option({
+    flags: '-s, --scenario [scenario name]',
+    description: 'Setup scenario name for the fixtures command',
+    required: true,
+  })
+  parseScenario(val: string): string {
+    return val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-m, --module-name [module name]',
+    description: 'Module Name from the ss_model_metadata table',
+    required: true,
+  })
+  parseModule(val: string): string {
+    return val;
+  }
+
+}

package/src/commands/fixtures/fixtures-tear-down.command.ts

@@ -0,0 +1,45 @@
+import { Logger } from '@nestjs/common';
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { SolidIntrospectService } from 'src/services/solid-introspect.service';
+
+interface CommandOptions {
+  scenario: string;
+  module: string;
+}
+
+@Command({
+  name: 'fixtures tear-down',
+  description: 'Handles setup and tear down of fixtures for the SolidX application',
+})
+export class FixturesTearDownCommand extends CommandRunner {
+  constructor(
+    private readonly introspectService: SolidIntrospectService,
+  ) {
+    super();
+  }
+  private readonly logger = new Logger(this.constructor.name);
+
+  async run(_passedParam: string[], options?: CommandOptions): Promise<void> {
+  }
+
+  // Accept the task name i.e setup/tear-down for the fixtures command
+  @Option({
+    flags: '-s, --scenario [scenario name]',
+    description: 'Setup scenario name for the fixtures command',
+    required: true,
+  })
+  parseScenario(val: string): string {
+    return val;
+  }
+
+  // Accept the module name as an argument
+  @Option({
+    flags: '-m, --module [module name]',
+    description: 'Module Name from the ss_model_metadata table',
+    required: true,
+  })
+  parseModule(val: string): string {
+    return val;
+  }
+
+}

package/src/commands/mcp.command.ts

@@ -0,0 +1,215 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { Logger } from '@nestjs/common';
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ISolidDatabaseModule } from 'src/interfaces';
+import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+
+interface McpCommandOptions {
+    repoPath?: string;
+    detached?: boolean;
+}
+
+@Command({
+    name: 'mcp',
+    description: 'Manage the SolidX MCP server and Celery worker docker containers (start/stop)',
+})
+export class McpCommand extends CommandRunner {
+    private readonly logger = new Logger(McpCommand.name);
+
+    constructor(
+        private readonly solidRegistry: SolidRegistry
+    ) {
+        super();
+    }
+
+    async run(passedParams: string[], options?: McpCommandOptions): Promise<void> {
+        const mode = (passedParams[0] || 'start').toLowerCase();
+
+        if (mode === 'stop') {
+            await this.stopContainers(options);
+        } else if (mode === 'start') {
+            await this.startContainers(options);
+        } else {
+            this.logger.error(
+                `Unknown mode "${mode}". Supported modes are: start, stop.\n` +
+                'Examples:\n' +
+                '  solid mcp start -p ~/mcp/servers/solidx_mcp_server\n' +
+                '  solid mcp stop  -p ~/mcp/servers/solidx_mcp_server\n'
+            );
+        }
+    }
+
+    // ---------------------------------------------------------------
+    // START
+    // ---------------------------------------------------------------
+    private async startContainers(options?: McpCommandOptions): Promise<void> {
+        // 1. Validate license key
+        const apiKey = process.env.MCP_API_KEY;
+
+        // Form the Database url to be used by the MCP server based on the consuming projects details. 
+        const defaultDatabaseUser = process.env.DEFAULT_DATABASE_USER;
+        const defaultDatabasePwd = process.env.DEFAULT_DATABASE_PASSWORD
+            ? encodeURIComponent(process.env.DEFAULT_DATABASE_PASSWORD)
+            : '';
+        const defaultDatabaseHost = process.env.DEFAULT_DATABASE_HOST === 'localhost' ? 'host.docker.internal' : process.env.DEFAULT_DATABASE_HOST;
+        const defaultDatabaseName = process.env.DEFAULT_DATABASE_NAME;
+        const databaseDialect = process.env.DEFAULT_DATABASE_TYPE?.toLowerCase() === 'mssql' ? 'mssql+pyodbc' : 'postgresql';
+        // const databaseUrl = `${databaseDialect}://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+
+        const defaultDatasource: ISolidDatabaseModule = this.solidRegistry.getDefaultSolidDatabaseModule()
+
+        let databaseUrl: string;
+        if (defaultDatasource.type() === DatasourceType.mssql) {
+            const base = `mssql+pyodbc://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+            const driver = encodeURIComponent('ODBC Driver 18 for SQL Server');
+            databaseUrl = `${base}?driver=${driver}&TrustServerCertificate=yes`;
+        }
+        if (defaultDatasource.type() === DatasourceType.postgres) {
+            databaseUrl = `postgresql://${defaultDatabaseUser}:${defaultDatabasePwd}@${defaultDatabaseHost}/${defaultDatabaseName}`;
+        }
+
+        if (!apiKey || apiKey.trim() === '') {
+            this.logger.error(
+                '❌ MCP_API_KEY environment variable is missing.\n' +
+                'Set it before running:\n' +
+                '   export MCP_API_KEY="your_license_key"\n'
+            );
+            return;
+        }
+
+        this.logger.log('✔ MCP_API_KEY found.');
+
+        // 2. Resolve paths
+        const repoPath = options?.repoPath ? this.resolvePath(options.repoPath) : process.cwd();
+        const consumingProjectPath = path.resolve(process.cwd(), '..');
+        const composeFile = path.join(repoPath, 'docker-compose.yml');
+
+        if (!fs.existsSync(composeFile)) {
+            this.logger.error(`docker-compose.yml not found at ${composeFile}`);
+            return;
+        }
+
+        const detached = options?.detached ?? false;
+
+        this.logger.log(`Mode: start`);
+        this.logger.log(`Using repo path: ${repoPath}`);
+        this.logger.log(`Detached mode: ${detached}`);
+        this.logger.log(`Consuming project root: ${consumingProjectPath}`);
+
+        // 3. Build docker compose args
+        const cmd = 'docker';
+        const args = ['compose', '-f', composeFile, 'up'];
+
+        if (detached) {
+            args.push('-d');
+        }
+
+        // Service names as defined in docker-compose.yml
+        args.push('mcp_redis', 'mcp_server', 'mcp_celery_worker');
+
+        const env: NodeJS.ProcessEnv = {
+            ...process.env,
+            MCP_API_KEY: apiKey,
+            HOST_SOLIDX_CONSUMING_PROJECT_ROOT: consumingProjectPath,
+            DATABASE_URL: databaseUrl,
+        };
+
+        this.logger.log(`Running: ${cmd} ${args.join(' ')}`);
+        // const envLog = Object.entries(env)
+        //     .map(([key, value]) => `${key}=${value ?? ''}`)
+        //     .join('\n');
+        // this.logger.log(`Using env overrides:\n${envLog}`);
+
+        await this.runDockerCommand(cmd, args, repoPath, env);
+
+        this.logger.log(
+            detached
+                ? 'MCP containers started in detached mode.'
+                : 'MCP containers started in foreground.'
+        );
+    }
+
+    // ---------------------------------------------------------------
+    // STOP
+    // ---------------------------------------------------------------
+    private async stopContainers(options?: McpCommandOptions): Promise<void> {
+        const repoPath = options?.repoPath ? this.resolvePath(options.repoPath) : process.cwd();
+        const composeFile = path.join(repoPath, 'docker-compose.yml');
+
+        if (!fs.existsSync(composeFile)) {
+            this.logger.error(`docker-compose.yml not found at ${composeFile}`);
+            return;
+        }
+
+        this.logger.log(`Mode: stop`);
+        this.logger.log(`Using repo path: ${repoPath}`);
+
+        const cmd = 'docker';
+        const args = ['compose', '-f', composeFile, 'down'];
+
+        this.logger.log(`Running: ${cmd} ${args.join(' ')}`);
+
+        await this.runDockerCommand(cmd, args, repoPath, process.env);
+
+        this.logger.log('MCP containers stopped (docker compose down).');
+    }
+
+    // ---------------------------------------------------------------
+    // Helpers
+    // ---------------------------------------------------------------
+    private resolvePath(inputPath: string): string {
+        if (inputPath.startsWith('~')) {
+            return path.join(process.env.HOME!, inputPath.slice(1));
+        }
+        return path.resolve(inputPath);
+    }
+
+    private runDockerCommand(
+        cmd: string,
+        args: string[],
+        cwd: string,
+        env: NodeJS.ProcessEnv,
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const child = spawn(cmd, args, {
+                cwd,
+                env,
+                stdio: 'inherit',
+            });
+
+            child.on('error', (err) => {
+                this.logger.error(`Docker error: ${err.message}`);
+                reject(err);
+            });
+
+            child.on('close', (code) => {
+                if (code === 0) resolve();
+                else reject(new Error(`Docker exited with code ${code}`));
+            });
+        });
+    }
+
+    // Flags
+
+    @Option({
+        flags: '-d, --detached [boolean]',
+        description: 'Run containers in detached mode (only for start, default: false)',
+        required: false,
+    })
+    parseDetached(val: string): boolean {
+        if (val === undefined) return false;
+        return val === 'true' || val === '1';
+    }
+
+    @Option({
+        flags: '-p, --repo-path [path]',
+        description: 'Path to the SolidX MCP Server repo containing docker-compose.yml',
+        required: false,
+    })
+    parseRepoPath(val: string): string {
+        return val;
+    }
+}

package/src/commands/refresh-model.command.ts

@@ -1,12 +1,15 @@
-import { Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, Inject, Logger } from '@nestjs/common';
 import { Command, CommandRunner, Option } from 'nest-commander';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { CommandError } from './helper';
+import { In } from 'typeorm';
 
 interface CommandOptions {
-  name: string;
-  id: number;
-  dryRun: boolean;
+  name?: string;
+  id?: number;
+  fieldIds?: number[];
+  fieldNames?: string[];
+  dryRun?: boolean;
 }
 
 @Command({
@@ -15,6 +18,7 @@ interface CommandOptions {
 })
 export class RefreshModelCommand extends CommandRunner {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     private readonly modelMetadataService: ModelMetadataService,
   ) {
     super();
@@ -32,10 +36,13 @@ export class RefreshModelCommand extends CommandRunner {
       modelId: options.id,
       modelUserKey: options.name,
       dryRun: options.dryRun,
+      fieldIdsForRefresh: options.fieldIds,
+      fieldNamesForRefresh: options.fieldNames,
     };
     await this.modelMetadataService.handleGenerateCode(codeGenerationOptions);
   }
 
+  // Accept the model ID as an argument
   @Option({
     flags: '-i, --id [model ID]',
     description: 'Model ID from the ss_model_metadata table',
@@ -53,6 +60,7 @@ export class RefreshModelCommand extends CommandRunner {
     return val;
   }
 
+  // Accept dry run as an argument
   @Option({
     flags: '-d, --dryRun [dry run]',
     description: 'Dry run the command',
@@ -62,8 +70,34 @@ export class RefreshModelCommand extends CommandRunner {
     return (val === 'false') ? false : true;
   }
 
+  // Accept field IDs as an argument
+  @Option({
+    flags: '-fids, --fieldIds [Array of field IDs]',
+    description: 'Json array of Field IDs from the ss_field_metadata table',
+  })
+  parseFieldIds(val: string): number[] {
+    //Check if the value is a json array
+    if (!val.startsWith('[') || !val.endsWith(']')) {
+      throw new BadRequestException('Field IDs should be a json array');
+    }
+    return JSON.parse(val).map((id: string) => parseInt(id));
+  }
+
+  // Accept field Names as an argument
+  @Option({
+    flags: '-fnames, --fieldNames [Array of field Names]',
+    description: 'Json array of Field Names from the ss_field_metadata table',
+  })
+  parseFieldNames(val: string): string[] {
+    //Check if the value is a json array
+    if (!val.startsWith('[') || !val.endsWith(']')) {
+      throw new BadRequestException('Field Names should be a json array');
+    }
+    return JSON.parse(val).map((name: string) => name.toString());
+  }
+
   // Validate the options passed
-  validate(options: CommandOptions): CommandError[] {
+  private validate(options: CommandOptions): CommandError[] {
     if (!options.id && !options.name) {
       return [new CommandError('Model ID or Model Name is required')];
     }

package/src/commands/remove-fields.command.ts

@@ -11,7 +11,7 @@ interface CommandOptions {
 
 @Command({
   name: 'remove-fields',
-  description: 'Adds fields to a model',
+  description: 'Removes fields from a model',
 })
 export class RemoveFieldsCommand extends CommandRunner {
   constructor(

package/src/commands/seed.command.ts

@@ -3,7 +3,7 @@ import { Command, CommandRunner, Option } from 'nest-commander';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 
 interface SeedCommandOptions {
-  // module?: string;
+  conf?: string;
   seeder?: string;
 }
 
@@ -16,6 +16,25 @@ export class SeedCommand extends CommandRunner {
   }
 
   async run(passedParam: string[], options?: SeedCommandOptions): Promise<void> {
+    // TODO: check if options.conf is non empty and a valid json string only is -c flag is passed.
+    // TODO: convert to json object JSON.parse
+    let parsedConf: any = null;
+
+    // Parse conf only if provided
+    if (options?.conf !== undefined) {
+      try {
+        parsedConf = JSON.parse(options.conf);
+        this.logger.log(`Parsed conf: ${JSON.stringify(parsedConf, null, 2)}`);
+      } catch (err) {
+        this.logger.error('Failed to parse --conf. Please provide valid JSON.');
+        return;
+      }
+    } else {
+      this.logger.log('No --conf flag provided. Running with default seeder behavior.');
+    }
+
+
+
     const seeder = this.solidRegistry
       .getSeeders()
       .filter((seeder) => seeder.name === options.seeder)
@@ -26,22 +45,22 @@ export class SeedCommand extends CommandRunner {
       return;
     }
     this.logger.log(`Running the seed() method for seeder :${seeder.constructor.name}`);
-    await seeder.seed();
+    await seeder.seed(parsedConf);
   }
 
-  // @Option({
-  //   flags: '-m, --module [module name]',
-  //   description: 'Name of the module, all seeders inside this module will be run automatically.',
-  //   required: true
-  // })
-  // /**
-  //  * TODO
-  //  * This parameter will be useful, to support seeders with the same name in different modules
-  //  * Currently the seeder service won't support seeder with same classname within a module
-  //  **/
-  // parseModule(val: string): string {
-  //   return val;
-  // }
+  @Option({
+    flags: '-c, --conf [configuration json]',
+    description: 'A configuration json, pass a valid json string.',
+    required: false
+  })
+  /**
+   * TODO
+   * This parameter will be useful, to support seeders with the same name in different modules
+   * Currently the seeder service won't support seeder with same classname within a module
+   **/
+  parseConf(val: string): string {
+    return val;
+  }
 
   @Option({
     flags: '-s, --seeder [seeder name]',

package/src/constants/error-messages.ts

@@ -84,7 +84,7 @@ export const ERROR_MESSAGES = {
     FIELD_NOT_FOUND: (id: number | string) => `No field with id #${id} exists`,
     PROVIDER_NOT_FOUND: (provider: string) => `Field incorrectly configured. No provider with name ${provider} registered in backend.`,
     FILE_WRITE_FAILED: 'File creation failed, rolling back transaction',
-
+    FILE_DELETE_FAILED: 'File deletion failed, rolling back transaction',
     // file service errors
     FILE_NOT_FOUND: 'File not found',
     FILE_COPY_ERROR: 'Error copying file',
@@ -123,4 +123,10 @@ export const ERROR_MESSAGES = {
     UNABLE_TO_RESOLVE_MCP_HANDLER: 'Unable to resolve a mcp tool handler.',
 
     DEFAULT_REGEX_PATTERN_NOT_MATCHING_ERROR_MSG: 'Invalid regex pattern.',
+
+    PERMISSION_MESSAGES: {
+    insertMany: (model?: string) =>
+      `You do not have permission to import ${model ?? 'these'} records.`,
+    } as Record<string, (model?: string) => string>,
+
 };

package/src/controllers/authentication.controller.ts

@@ -15,7 +15,7 @@ import { AuthenticationService } from '../services/authentication.service';
 
 // @Auth(AuthType.None)
 @Controller('iam')
-@ApiTags("Iam")
+@ApiTags("Solid Core")
 // @UseGuards(ThrottlerGuard)
 // @SkipThrottle({login: true, short: true, burst: true, sustained: true}) // disable all sets by default for this controller
 export class AuthenticationController {

package/src/controllers/email-template.controller.ts

@@ -10,7 +10,7 @@ import Mailgen = require('mailgen');
 
 
 @Controller('email-template')
-@ApiTags("Common")
+@ApiTags("Solid Core")
 export class EmailTemplateController {
   constructor(private readonly service: EmailTemplateService) { }
 

package/src/controllers/field-metadata.controller.ts

@@ -6,9 +6,10 @@ import { FieldMetadataService } from '../services/field-metadata.service';
 import { Public } from 'src/decorators/public.decorator';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
 import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
+import { ResolveS3UrlDto } from 'src/dtos/resolve-s3-url.dto';
 
 @Controller('field-metadata')
-@ApiTags("App Builder")
+@ApiTags("Solid Core")
 export class FieldMetadataController {
 
     constructor(
@@ -67,6 +68,11 @@ export class FieldMetadataController {
         return this.fieldMetadataService.delete(id);
     }
 
+    @ApiBearerAuth("jwt")
+    @Post('/resolve-s3-url')
+    resolveS3Url(@Body() resolveS3UrlDto: ResolveS3UrlDto) {
+        return this.fieldMetadataService.resolveS3Url(resolveS3UrlDto);
 
+    }
 
 }

package/src/controllers/media-storage-provider-metadata.controller.ts

@@ -8,7 +8,7 @@ import { UpdateMediaStorageProviderMetadataDto } from '../dtos/update-media-stor
 import { AnyFilesInterceptor } from '@nestjs/platform-express';
 
 @Controller('media-storage-provider-metadata')
-@ApiTags("App Builder")
+@ApiTags("Solid Core")
 export class MediaStorageProviderMetadataController {
     private logger = new Logger(MediaStorageProviderMetadataController.name);
 

package/src/controllers/model-metadata.controller.ts

@@ -7,7 +7,7 @@ import { UpdateModelMetaDataDto } from '../dtos/update-model-metadata.dto';
 import { ModelMetadataService } from '../services/model-metadata.service';
 
 @Controller('model-metadata')
-@ApiTags("App Builder")
+@ApiTags("Solid Core")
 // @UseGuards(ThrottlerGuard)
 // @SkipThrottle({ short: true, login: true, burst: true, sustained: true }) //Skip all
 export class ModelMetadataController {

package/src/controllers/model-sequence.controller.ts

@@ -0,0 +1,93 @@
+import { Controller, Post, Body, Param, UploadedFiles, UseInterceptors, Put, Get, Query, Delete, Patch } from '@nestjs/common';
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
+import { ModelSequenceService } from '../services/model-sequence.service';
+import { CreateModelSequenceDto } from '../dtos/create-model-sequence.dto';
+import { UpdateModelSequenceDto } from '../dtos/update-model-sequence.dto';
+
+enum ShowSoftDeleted {
+  INCLUSIVE = "inclusive",
+  EXCLUSIVE = "exclusive",
+}
+
+@ApiTags('Solid Core')
+@Controller('model-sequence')
+export class ModelSequenceController {
+  constructor(private readonly service: ModelSequenceService) {}
+
+  @ApiBearerAuth("jwt")
+  @Post()
+  @UseInterceptors(AnyFilesInterceptor())
+  create(@Body() createDto: CreateModelSequenceDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.create(createDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk')
+  @UseInterceptors(AnyFilesInterceptor())
+  insertMany(@Body() createDtos: CreateModelSequenceDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
+    return this.service.insertMany(createDtos, filesArray);
+  }
+
+
+  @ApiBearerAuth("jwt")
+  @Put(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  update(@Param('id') id: number, @Body() updateDto: UpdateModelSequenceDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Patch(':id')
+  @UseInterceptors(AnyFilesInterceptor())
+  partialUpdate(@Param('id') id: number, @Body() updateDto: UpdateModelSequenceDto, @UploadedFiles() files: Array<Express.Multer.File>) {
+    return this.service.update(id, updateDto, files, true);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Post('/bulk-recover')
+  async recoverMany(@Body() ids: number[]) {
+    return this.service.recoverMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get('/recover/:id')
+  async recover(@Param('id') id: number) {
+    return this.service.recover(id);
+  }
+    
+  @ApiBearerAuth("jwt")
+  @ApiQuery({ name: 'showSoftDeleted', required: false, enum: ShowSoftDeleted })
+  @ApiQuery({ name: 'limit', required: false, type: Number })
+  @ApiQuery({ name: 'offset', required: false, type: Number })
+  @ApiQuery({ name: 'fields', required: false, type: Array })
+  @ApiQuery({ name: 'sort', required: false, type: Array }) 
+  @ApiQuery({ name: 'groupBy', required: false, type: Array })
+  @ApiQuery({ name: 'populate', required: false, type: Array })
+  @ApiQuery({ name: 'populateMedia', required: false, type: Array })
+  @ApiQuery({ name: 'filters', required: false, type: Array })
+  @Get()
+  async findMany(@Query() query: any) { 
+    return this.service.find(query);  
+  }
+
+  @ApiBearerAuth("jwt")
+  @Get(':id')
+  async findOne(@Param('id') id: string, @Query() query: any) {
+    return this.service.findOne(+id, query);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete('/bulk')
+  async deleteMany(@Body() ids: number[]) {
+    return this.service.deleteMany(ids);
+  }
+
+  @ApiBearerAuth("jwt")
+  @Delete(':id')
+  async delete(@Param('id') id: number) {
+    return this.service.delete(id);
+  }
+
+
+}

package/src/controllers/module-metadata.controller.ts

@@ -19,7 +19,7 @@ import { ModuleMetadataService } from '../services/module-metadata.service';
 import { AnyFilesInterceptor } from '@nestjs/platform-express';
 
 @Controller('module-metadata')
-@ApiTags("App Builder")
+@ApiTags("Solid Core")
 export class ModuleMetadataController {
   constructor(private readonly moduleMetadataService: ModuleMetadataService) { }
 

package/src/controllers/otp-authentication.controller.ts

@@ -13,7 +13,7 @@ import { AuthenticationService } from '../services/authentication.service';
 
 @Auth(AuthType.None)
 @Controller('iam/otp')
-@ApiTags("Iam")
+@ApiTags("Solid Core")
 // @UseGuards(ThrottlerGuard)
 // @SkipThrottle({ login: false, short: true, burst: true, sustained: true }) //Enable the login throttle only
 export class OTPAuthenticationController {