@solidstarters/solid-core 1.2.184 → 1.2.186

package/src/services/genai/mcp-handlers/solid-add-controller-handler-method-mcp-handler.service.ts

@@ -0,0 +1,67 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
+
+@Injectable()
+export class SolidAddControllerHandlerMcpHandler implements IMcpToolResponseHandler {
+  private readonly logger = new Logger(SolidAddControllerHandlerMcpHandler.name);
+
+  constructor(private readonly tsMorph: SolidTsMorphService) { }
+
+  async apply(aiInteraction: AiInteraction) {
+    const raw = this.safeParse(aiInteraction.message);
+    const payload: McpComputedProviderResponse | undefined = (raw?.data?.plan ? raw.data : raw) as McpComputedProviderResponse;
+
+    if (!payload || !Array.isArray(payload.plan)) {
+      throw new Error("SolidAddControllerHandlerMethodMcpHandler: invalid MCP response; missing plan[]");
+    }
+
+    // Batch all plan steps in a single txn so nodemon restarts only once.
+    this.tsMorph.begin();
+    try {
+      for (const step of payload.plan as PlanStep[]) {
+        switch (step.type) {
+          case "createNewFile": {
+            const overwrite = step.overwrite ?? false;
+            this.tsMorph.createNewFile(step.path, step.content, overwrite);
+            break;
+          }
+          case "addMethodToExistingClass": {
+            this.tsMorph.addMethodToExistingClass(
+              step.path,
+              step.className,
+              step.methodName,
+              step.content,
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+        }
+      }
+
+      const result = await this.tsMorph.commit();
+
+      return {
+        seedingRequired: true,
+        serverRebooting: true,
+        appliedSteps: payload.plan.length,
+        wroteFiles: result.wrote,
+      };
+    } catch (err) {
+      this.logger.error(`Apply failed; rolling back. ${String(err)}`);
+      this.tsMorph.rollback();
+      throw err;
+    }
+  }
+
+  private safeParse(str: string): any {
+    try {
+      return JSON.parse(str);
+    } catch {
+      const unescaped = str.replace(/\\'/g, "'");
+      return JSON.parse(unescaped);
+    }
+  }
+}

package/src/services/genai/mcp-handlers/solid-add-custom-service-method-mcp-handler.service.ts

@@ -0,0 +1,69 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
+
+const RESTART_TOUCH_FILE = process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch";
+
+@Injectable()
+export class SolidAddCustomServiceMethodMcpHandler implements IMcpToolResponseHandler {
+  private readonly logger = new Logger(SolidAddCustomServiceMethodMcpHandler.name);
+
+  constructor(private readonly tsMorph: SolidTsMorphService) { }
+
+  async apply(aiInteraction: AiInteraction) {
+    const raw = this.safeParse(aiInteraction.message);
+    const payload: McpComputedProviderResponse | undefined = (raw?.data?.plan ? raw.data : raw) as McpComputedProviderResponse;
+
+    if (!payload || !Array.isArray(payload.plan)) {
+      throw new Error("SolidAddCustomServiceMethodMcpHandler: invalid MCP response; missing plan[]");
+    }
+
+    // Batch all plan steps in a single txn so nodemon restarts only once.
+    this.tsMorph.begin();
+    try {
+      for (const step of payload.plan as PlanStep[]) {
+        switch (step.type) {
+          case "createNewFile": {
+            const overwrite = step.overwrite ?? false;
+            this.tsMorph.createNewFile(step.path, step.content, overwrite);
+            break;
+          }
+          case "addMethodToExistingClass": {
+            this.tsMorph.addMethodToExistingClass(
+              step.path,
+              step.className,
+              step.methodName,
+              step.content,
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+        }
+      }
+
+      const result = await this.tsMorph.commit();
+
+      return {
+        seedingRequired: false,
+        serverRebooting: true,
+        appliedSteps: payload.plan.length,
+        wroteFiles: result.wrote,
+      };
+    } catch (err) {
+      this.logger.error(`Apply failed; rolling back. ${String(err)}`);
+      this.tsMorph.rollback();
+      throw err;
+    }
+  }
+
+  private safeParse(str: string): any {
+    try {
+      return JSON.parse(str);
+    } catch {
+      const unescaped = str.replace(/\\'/g, "'");
+      return JSON.parse(unescaped);
+    }
+  }
+}

package/src/services/genai/mcp-handlers/solid-add-header-button-or-row-button-to-list-view-mcp-handler.service.ts

@@ -0,0 +1,141 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import * as fs from "fs/promises";
+
+const RESTART_TOUCH_FILE = process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch";
+
+@Injectable()
+export class SolidAddHeaderButtonOrRowButtonToListViewMcpHandler implements IMcpToolResponseHandler {
+    private readonly logger = new Logger(SolidAddHeaderButtonOrRowButtonToListViewMcpHandler.name);
+
+    constructor(
+        private readonly tsMorph: SolidTsMorphService,
+        private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+
+    ) { }
+
+    async apply(aiInteraction: AiInteraction) {
+        const raw = this.safeParse(aiInteraction.message);
+        const payload: McpComputedProviderResponse | undefined = (raw?.data?.plan ? raw.data : raw) as McpComputedProviderResponse;
+
+        if (!payload || !Array.isArray(payload.plan)) {
+            throw new Error("SolidAddHeaderButtonOrRowButtonToListViewMcpHandler: invalid MCP response; missing plan[]");
+        }
+
+        // Batch all plan steps in a single txn so nodemon restarts only once.
+        this.tsMorph.begin();
+        try {
+            for (const step of payload.plan as PlanStep[]) {
+                switch (step.type) {
+                    case "createNewFile": {
+                        const overwrite = step.overwrite ?? false;
+                        this.tsMorph.createNewFile(step.path, step.content, overwrite);
+                        break;
+                    }
+                    case "registerSolidXExtensionComponent": {
+                        this.tsMorph.registerSolidUiExtension(
+                            step.path,
+                            step.content,
+                        );
+                        this.tsMorph.addImport(
+                            step.path,
+                            step.importExtensionComponent,
+                        );
+                        break;
+                    }
+                    case "addListViewButton": {
+
+                        const filePath =
+                            await this.moduleMetadataHelperService.getModuleMetadataFilePath(
+                                step.moduleName
+                            );
+                        try {
+                            await fs.access(filePath);
+                        } catch {
+                            this.logger.error(`Metadata file not found: ${filePath}`);
+                            return;
+                        }
+                        const metaData =
+                            await this.moduleMetadataHelperService.getModuleMetadataConfiguration(
+                                filePath
+                            );
+                        // Remove, update or insert logic
+
+
+                        // Find the existing view of type "list" for the given module & model
+                        const existingViewIndex = metaData.views.findIndex(
+                            (view: any) =>
+                                view.type === "list" &&
+                                view.moduleUserKey === step.moduleName &&
+                                view.modelUserKey === step.modelName
+                        );
+
+                        if (existingViewIndex !== -1) {
+                            const view = metaData.views[existingViewIndex];
+
+                            // Ensure layout & attrs exist
+                            view.layout = view.layout || {};
+                            view.layout.attrs = view.layout.attrs || {};
+
+                            // Initialize rowButtons or headerButtons if not present
+                            if (!Array.isArray(view.layout.attrs[step.buttonType])) {
+                                view.layout.attrs[step.buttonType] = [];
+                            }
+
+                            let buttonContent = step.content;
+
+                            // Parse only if it’s a string
+                            if (typeof buttonContent === "string") {
+                                try {
+                                    buttonContent = JSON.parse(buttonContent);
+                                } catch (err) {
+                                    this.logger.error("❌ Failed to parse step.content JSON:", err);
+                                    return;
+                                }
+                            }
+
+
+                            // Push the new button content
+                            view.layout.attrs[step.buttonType].push(buttonContent);
+
+                            console.log(`✅ Added ${step.buttonType} to view: ${view.name}`);
+                        } else {
+                            console.warn(`⚠️ No matching list view found for module=${step.moduleName} and model=${step.modelName}`);
+                        }
+
+                        const updatedContent = JSON.stringify(metaData, null, 2);
+                        await fs.writeFile(filePath, updatedContent);
+                        this.logger.log(`Updated list view in ${filePath}`);
+
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+                }
+            }
+
+            const result = await this.tsMorph.commit();
+
+            return {
+                seedingRequired: true,
+                serverRebooting: false,
+            };
+        } catch (err) {
+            this.logger.error(`Apply failed; rolling back. ${String(err)}`);
+            this.tsMorph.rollback();
+            throw err;
+        }
+    }
+
+    private safeParse(str: string): any {
+        try {
+            return JSON.parse(str);
+        } catch {
+            const unescaped = str.replace(/\\'/g, "'");
+            return JSON.parse(unescaped);
+        }
+    }
+}

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

@@ -657,28 +657,30 @@ export class ModelMetadataService {
     // <moduleName>-metadata.json | Remove references to this model in the model metadata, menu, action & view sections. | Automatic
     const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(modelEntity.module.name);
     const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
-    const existingModelIndex = metaData.moduleMetadata.models.findIndex(
-      (existingModel: any) => existingModel.singularName === modelEntity.singularName
-    );
+    if (metaData) {
+      const existingModelIndex = metaData.moduleMetadata.models.findIndex(
+        (existingModel: any) => existingModel.singularName === modelEntity.singularName
+      );
 
-    // Remove the model to be deleted from the metadata
-    if (existingModelIndex !== -1) {
-      metaData.moduleMetadata.models.splice(existingModelIndex, 1);
-    }
+      // Remove the model to be deleted from the metadata
+      if (existingModelIndex !== -1) {
+        metaData.moduleMetadata.models.splice(existingModelIndex, 1);
+      }
 
-    // Remove references to this model in the menu, action & view sections.
-    metaData.moduleMetadata.menus = metaData.moduleMetadata.menus.filter(
-      (menu: any) => menu.modelUserKey !== modelEntity.singularName
-    );
-    metaData.moduleMetadata.actions = metaData.moduleMetadata.actions.filter(
-      (action: any) => action.modelUserKey !== modelEntity.singularName
-    );
-    metaData.moduleMetadata.views = metaData.moduleMetadata.views.filter(
-      (view: any) => view.modelUserKey !== modelEntity.singularName
-    );
+      // Remove references to this model in the menu, action & view sections.
+      metaData.moduleMetadata.menus = metaData.moduleMetadata.menus.filter(
+        (menu: any) => menu.modelUserKey !== modelEntity.singularName
+      );
+      metaData.moduleMetadata.actions = metaData.moduleMetadata.actions.filter(
+        (action: any) => action.modelUserKey !== modelEntity.singularName
+      );
+      metaData.moduleMetadata.views = metaData.moduleMetadata.views.filter(
+        (view: any) => view.modelUserKey !== modelEntity.singularName
+      );
 
-    const updatedContent = JSON.stringify(metaData, null, 2);
-    await fs.writeFile(filePath, updatedContent);
+      const updatedContent = JSON.stringify(metaData, null, 2);
+      await fs.writeFile(filePath, updatedContent);
+    }
 
     // <moduleName>.module.ts | Remove all references and imports of the above files. | Manual (X)
     // const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module.name)}.module.ts`);
@@ -901,12 +903,12 @@ export class ModelMetadataService {
                 children: [
                   {
                     type: "column",
-                    attrs: { name: "group-1", label: "", className: "col-6" },
+                    attrs: { name: "group-1", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                     children: column1Fields
                   },
                   {
                     type: "column",
-                    attrs: { name: "group-2", label: "", className: "col-6" },
+                    attrs: { name: "group-2", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                     children: column2Fields
                   }
                 ]
@@ -1014,12 +1016,12 @@ export class ModelMetadataService {
                   children: [
                     {
                       type: "column",
-                      attrs: { name: "group-1", label: "", className: "col-6" },
+                      attrs: { name: "group-1", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                       children: firstHalf
                     },
                     {
                       type: "column",
-                      attrs: { name: "group-2", label: "", className: "col-6" },
+                      attrs: { name: "group-2", label: "", className: "col-12 sm:col-12 md:col-6 lg:col-6" },
                       children: secondHalf
                     }
                   ]

package/src/services/setting.service.ts

@@ -76,7 +76,8 @@ export class SettingService extends CRUDService<Setting> {
       solidXGenAiCodeBuilderConfig: JSON.stringify({
             defaultProvider: "",
             availableProviders: []
-        })
+        }),
+      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
     };
 
     const existingSettings = await this.repo.find();
@@ -187,7 +188,8 @@ export class SettingService extends CRUDService<Setting> {
             defaultProvider: "",
             availableProviders: []
         }),
-      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword
+      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword,
+      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
     };
   }
 

package/src/services/solid-ts-morph.service.ts

@@ -3,6 +3,7 @@ import { Injectable, Logger } from "@nestjs/common";
 import { join, dirname, normalize, isAbsolute, basename } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { Project, Node, ObjectLiteralExpression, ArrayLiteralExpression, QuoteKind, IndentationText } from "ts-morph";
+import { MethodDeclarationStructure, StructureKind } from "ts-morph";
 
 type Bucket = "providers" | "exports";
 
@@ -260,4 +261,115 @@ export class SolidTsMorphService {
         this.logger.log(`Staged provider registration in: ${this.rel(abs)} (${registerIn.join(", ")})`);
         return { staged: true };
     }
+
+
+    addMethodToExistingClass(
+        filePath: string,
+        className: string,
+        methodName: string,
+        methodCode: string,
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`addMethodToExistingClass: File not found at ${filePath}`);
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const targetClass = sourceFile.getClass(className);
+        if (!targetClass)
+            throw new Error(`addMethodToExistingClass: Class ${className} not found in ${filePath}`);
+
+        const existingMethod = targetClass.getMethod(methodName);
+        if (existingMethod) {
+
+            this.logger.log(`Skipped adding method '${methodName}' (already exists)`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+        // Add the LLM-generated method directly
+        targetClass.addMember(methodCode);
+
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged method '${methodName}' in class ${className} at ${this.rel(abs)}`);
+        return { staged: true, overwritten: !!existingMethod, skipped: false };
+    }
+
+    registerSolidUiExtension(
+        filePath: string,
+        lineToAdd: string
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`registerSolidUiExtension: File not found at ${filePath}`);
+
+        const fileContent = readFileSync(abs, "utf8");
+
+        // Check if the line already exists (avoid duplicates)
+        if (fileContent.includes(lineToAdd.trim())) {
+            this.logger.log(`Skipped adding line (already exists): ${lineToAdd}`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+
+        // Append the new line at the end, ensuring newline
+        const newContent = fileContent.trimEnd() + "\n" + lineToAdd.trim() + "\n";
+
+        // Write updated content back
+        writeFileSync(abs, newContent, "utf8");
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged new line in ${this.rel(abs)}: ${lineToAdd}`);
+        return { staged: true, overwritten: false, skipped: false };
+    }
+
+    addImport(
+        filePath: string,
+        importLine: string
+    ): { staged: boolean; overwritten: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs))
+            throw new Error(`addImport: File not found at ${filePath}`);
+
+        let fileContent = readFileSync(abs, "utf8");
+
+        // If import already exists — skip
+        if (fileContent.includes(importLine.trim())) {
+            this.logger.log(`Skipped adding import (already exists): ${importLine}`);
+            return { staged: false, overwritten: false, skipped: true };
+        }
+
+        // Find last import statement (so we can insert after all imports)
+        const importRegex = /^import .+ from .+;$/gm;
+        let lastImportMatch: RegExpExecArray | null;
+        let lastImportIndex = -1;
+
+        while ((lastImportMatch = importRegex.exec(fileContent)) !== null) {
+            lastImportIndex = lastImportMatch.index + lastImportMatch[0].length;
+        }
+
+        // Insert after last import (or at top if none exist)
+        let newContent: string;
+        if (lastImportIndex !== -1) {
+            newContent =
+                fileContent.slice(0, lastImportIndex) +
+                "\n" +
+                importLine.trim() +
+                "\n" +
+                fileContent.slice(lastImportIndex);
+        } else {
+            // No imports found — insert at top
+            newContent = importLine.trim() + "\n\n" + fileContent;
+        }
+
+        writeFileSync(abs, newContent, "utf8");
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged import in ${this.rel(abs)}: ${importLine}`);
+        return { staged: true, overwritten: false, skipped: false };
+    }
+
+
+
 }

package/src/solid-core.module.ts

@@ -102,6 +102,7 @@ import { UserSeederService } from './seeders/user-seeder.service';
 import { AuthenticationService } from './services/authentication.service';
 import { BcryptService } from './services/bcrypt.service';
 import { UuidExternalIdComputedFieldProvider } from './services/computed-fields/uuid-external-id-computed-field-provider.service';
+import { UuidExternalIdEntityComputedFieldProvider } from './services/computed-fields/entity/uuid-externalid-entity-computed-field-provider.service';
 import { EmailTemplateService } from './services/email-template.service';
 import { FileService } from './services/file.service';
 import { HashingService } from './services/hashing.service';
@@ -296,6 +297,9 @@ import { SolidCreateComputedProviderMcpHandler } from './services/genai/mcp-hand
 import { SolidTsMorphService } from './services/solid-ts-morph.service';
 import { SolidAddVariableToDashboardMcpHandler } from './services/genai/mcp-handlers/solid-add-variable-to-dashboard-mcp-handler.service';
 import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-handlers/solid-add-question-to-dashboard-mcp-handler.service';
+import { SolidAddCustomServiceMethodMcpHandler } from './services/genai/mcp-handlers/solid-add-custom-service-method-mcp-handler.service';
+import { SolidAddHeaderButtonOrRowButtonToListViewMcpHandler } from './services/genai/mcp-handlers/solid-add-header-button-or-row-button-to-list-view-mcp-handler.service';
+import { SolidAddControllerHandlerMcpHandler } from './services/genai/mcp-handlers/solid-add-controller-handler-method-mcp-handler.service';
 
 
 @Global()
@@ -538,6 +542,7 @@ import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-hand
     TinyUrlService,
     PdfService,
     UuidExternalIdComputedFieldProvider,
+    UuidExternalIdEntityComputedFieldProvider,
     ListOfModelsSelectionProvider,
     ListOfScheduledJobsSelectionProvider,
     LocaleListSelectionProvider,
@@ -632,7 +637,7 @@ import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-hand
     SolidCreateModelWithFieldsMcpHandler,
     SolidAddFieldsToModelMcpHandler,
     SolidUpdateLayoutMcpHandler,
-
+    
     SolidCreateDashboardWithWidgetsMcpHandler,
     SolidCreateDashboardQuestionMcpHandler,
     SolidCreateDashboardQuestionSqlDatasetConfigMcpHandler,
@@ -640,6 +645,10 @@ import { SolidAddQuestionToDashboardMcpHandler } from './services/genai/mcp-hand
     SolidCreateComputedProviderMcpHandler,
     SolidAddVariableToDashboardMcpHandler,
     SolidAddQuestionToDashboardMcpHandler,
+
+    SolidAddCustomServiceMethodMcpHandler,
+    SolidAddHeaderButtonOrRowButtonToListViewMcpHandler,
+    SolidAddControllerHandlerMcpHandler,
     SolidTsMorphService,
 
     ViewMetadataRepository,

package/src/controllers/user.controller.ts.bkp

@@ -1,78 +0,0 @@
-import { Body, Controller, Delete, Get, Param, ParseIntPipe, Post, Query } from '@nestjs/common';
-import { ApiBearerAuth, ApiForbiddenResponse, ApiQuery, ApiTags } from '@nestjs/swagger';
-import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
-import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
-import { ActiveUser } from '../decorators/active-user.decorator';
-import { UserService } from '../services/user.service';
-import { MutateUserRolesDto } from '../dtos/mutate-user-roles.dto';
-import { MutateUserRolesBulkDto } from '../dtos/mutate-user-roles-list.dto';
-import { BasicFilterDto } from 'src/dtos/basic-filters.dto';
-
-@Controller('users')
-@ApiTags("Iam")
-export class UserController {
-    constructor(
-        private readonly userService: UserService
-    ) { }
-
-    // /api/users
-    @ApiBearerAuth("jwt")
-    @Get()
-    @ApiBearerAuth("jwt")
-    @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 })
-    async findMany(
-        @Query() basicFilterDto: BasicFilterDto,
-        @ActiveUser() activeUser: ActiveUserData,
-    ) {
-        return this.userService.findMany(basicFilterDto);
-    }
-
-    // /api/users/:id
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Get(':id')
-    findOne(@Param('id', ParseIntPipe) id: number) {
-        return this.userService.findOne(id);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Post('roles')
-    addRoleToUser(@Body() mutateUserRoles: MutateUserRolesDto) {
-        return this.userService.addRoleToUser(mutateUserRoles.username, mutateUserRoles.roleName);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Post('roles/bulk')
-    addRolesToUser(@Body() mutateUserRolesBulk: MutateUserRolesBulkDto) {
-        return this.userService.addRolesToUser(mutateUserRolesBulk.username, mutateUserRolesBulk.roleNames);
-    }
-
-    @ApiBearerAuth("jwt")
-    @ApiForbiddenResponse({ description: 'Forbidden.' })
-    @Delete('roles')
-    removeRoleFromUser(userEmail: string, roleName: string) {
-        return this.userService.removeRoleFromUser(userEmail, roleName);
-    }
-
-    @ApiBearerAuth("jwt")
-    @Delete('/bulk')
-    async deleteMany(@Body() ids: number[]) {
-      return this.userService.deleteMany(ids);
-    }
-  
-  
-    @ApiBearerAuth("jwt")
-    @Delete(':id')
-    remove(@Param('id') id: number) {
-      return this.userService.remove(id);
-    }
-}