@solidstarters/solid-core 1.2.200 → 1.2.201

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

@@ -22,9 +22,10 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     ) { }
 
     async retrieve(entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
+        //@ts-ignore
         const media = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
         // Add the full URL to the media
         media.forEach(m => {
@@ -34,9 +35,9 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async store(files: Express.Multer.File[], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
         const result: Media[] = [];
         for (const file of files) {
             // Store the file in the configured file storage directory
@@ -46,7 +47,8 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
 
             // Create an entry in the media table
             const mediaEntity = await this.mediaRepository.createMedia({
-                entityId: entity.id,
+                //@ts-ignore
+                entityId: entity.id, 
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: this.getFileName(file),
                 mimeType: file.mimetype,
@@ -62,15 +64,16 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
         const result: Media[] = [];
         for (const pair of streamPairs) {
             const stream = pair[0];
             const fileName = pair[1];
             this.fileService.writeStreamToFile(stream, this.getFullFilePath(fileName));
             const mediaEntity = await this.mediaRepository.createMedia({
+                //@ts-ignore
                 entityId: entity.id,
                 modelMetadataId: mediaFieldMetadata.model.id,
                 relativeUri: fileName,
@@ -83,10 +86,12 @@ export class FileStorageProvider<T> implements MediaStorageProvider<T> {
     }
 
     async delete(entity: T, mediaFieldMetadata: FieldMetadata): Promise<void> {
-        if (!(entity instanceof CommonEntity)) {
-            throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
-        }
+        // if (!(entity instanceof CommonEntity)) {
+        //     throw new Error("Entity must be an instance of CommonEntity"); //FIXME This needs to be handled through generics. e.g T extends CommonEntity
+        // }
+        //@ts-ignore
         const existingMedia = await this.mediaRepository.findByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id, ['mediaStorageProviderMetadata']);
+        //@ts-ignore
         this.mediaRepository.deleteByEntityIdAndFieldIdAndModelMetadataId(entity.id, mediaFieldMetadata.id, mediaFieldMetadata.model.id);
         existingMedia.forEach(media => {
             this.fileService.deleteFile(this.getFullFilePath(media.relativeUri));

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

@@ -1,7 +1,7 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { EntityManager, In, Repository } from 'typeorm';
 import { CRUDService } from 'src/services/crud.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
@@ -21,6 +21,7 @@ import { SavedFiltersRepository } from 'src/repository/saved-filters.repository'
 @Injectable()
 export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -165,6 +166,9 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
           if (!i.parentMenuItem) {
             return true
           } else {
+            if(i.action.type === 'custom'){
+              return true;
+            }
             return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
           }
         });

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

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+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 { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
@@ -39,6 +39,7 @@ export class ModelMetadataService {
     // private readonly modelMetadataRepo: Repository<ModelMetadata>,
     // @InjectRepository(FieldMetadata)
     // private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+    @Inject(forwardRef(() => ModelMetadataRepository))
     private readonly modelMetadataRepo: ModelMetadataRepository,
     private readonly fieldMetadataRepo: FieldMetadataRepository,
     private readonly schematicService: SchematicService,
@@ -610,57 +611,62 @@ export class ModelMetadataService {
       }
     }
 
+    await this.dataSource.query(
+      `CALL cleanup_model_metadata($1, $2)`,
+      [modelEntity.singularName, true],
+    );
+
     // Delete the permissions, menu, actions & views related to this model.
-    const controllerName = `${classify(modelEntity.singularName)}Controller`;
-    const permissionNames = [
-      `${controllerName}.delete`,
-      `${controllerName}.deleteMany`,
-      `${controllerName}.findOne`,
-      `${controllerName}.findMany`,
-      `${controllerName}.recover`,
-      `${controllerName}.recoverMany`,
-      `${controllerName}.partialUpdate`,
-      `${controllerName}.update`,
-      `${controllerName}.insertMany`,
-      `${controllerName}.create`,
-    ];
-    const permissionsRepo = this.dataSource.getRepository(PermissionMetadata);
-    const permissionsToDelete = await permissionsRepo.find({
-      where: { name: In(permissionNames) },
-      relations: ['roles'],
-    });
+    // const controllerName = `${classify(modelEntity.singularName)}Controller`;
+    // const permissionNames = [
+    //   `${controllerName}.delete`,
+    //   `${controllerName}.deleteMany`,
+    //   `${controllerName}.findOne`,
+    //   `${controllerName}.findMany`,
+    //   `${controllerName}.recover`,
+    //   `${controllerName}.recoverMany`,
+    //   `${controllerName}.partialUpdate`,
+    //   `${controllerName}.update`,
+    //   `${controllerName}.insertMany`,
+    //   `${controllerName}.create`,
+    // ];
+    // const permissionsRepo = this.dataSource.getRepository(PermissionMetadata);
+    // const permissionsToDelete = await permissionsRepo.find({
+    //   where: { name: In(permissionNames) },
+    //   relations: ['roles'],
+    // });
 
     // Remove role associations first
-    for (const permission of permissionsToDelete) {
-      if (permission.roles?.length) {
-        await this.dataSource
-          .createQueryBuilder()
-          .relation(PermissionMetadata, 'roles')
-          .of(permission) // permission instance or its ID
-          .remove(permission.roles); // remove all linked roles
-      }
-    }
+    // for (const permission of permissionsToDelete) {
+    //   if (permission.roles?.length) {
+    //     await this.dataSource
+    //       .createQueryBuilder()
+    //       .relation(PermissionMetadata, 'roles')
+    //       .of(permission) // permission instance or its ID
+    //       .remove(permission.roles); // remove all linked roles
+    //   }
+    // }
 
-    await permissionsRepo.remove(permissionsToDelete);
+    // await permissionsRepo.remove(permissionsToDelete);
 
     // Delete actions
-    const actionRepo = this.dataSource.getRepository(ActionMetadata);
-    const action = await actionRepo.findOne({ where: { model: { id: modelEntity.id } } });
-    await actionRepo.delete({ model: { id: modelEntity.id } });
-
-    // Delete menu items
-    const menuItemRepo = this.dataSource.getRepository(MenuItemMetadata);
-    if (action) {
-      const menuItems = await menuItemRepo.find({ where: { action: { id: action.id } } });
-      for (let i = 0; i < menuItems.length; i++) {
-        const menuItem = menuItems[i];
-        await menuItemRepo.remove(menuItem);
-      }
-    }
+    // const actionRepo = this.dataSource.getRepository(ActionMetadata);
+    // const action = await actionRepo.findOne({ where: { model: { id: modelEntity.id } } });
+    // await actionRepo.delete({ model: { id: modelEntity.id } });
+
+    // // Delete menu items
+    // const menuItemRepo = this.dataSource.getRepository(MenuItemMetadata);
+    // if (action) {
+    //   const menuItems = await menuItemRepo.find({ where: { action: { id: action.id } } });
+    //   for (let i = 0; i < menuItems.length; i++) {
+    //     const menuItem = menuItems[i];
+    //     await menuItemRepo.remove(menuItem);
+    //   }
+    // }
 
     // Delete view 
-    const viewRepo = this.dataSource.getRepository(ViewMetadata);
-    await viewRepo.delete({ model: { id: modelEntity.id } })
+    // const viewRepo = this.dataSource.getRepository(ViewMetadata);
+    // await viewRepo.delete({ model: { id: modelEntity.id } })
 
     // <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);

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef  } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+
+import { ModelSequence } from '../entities/model-sequence.entity';
+import { ModelSequenceRepository } from '../repository/model-sequence.repository';
+
+@Injectable()
+export class ModelSequenceService extends CRUDService<ModelSequence>{
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: ModelSequenceRepository,
+    readonly moduleRef: ModuleRef
+
+ ) {
+   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'modelSequence', 'solid-core', moduleRef);
+ }
+}

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

@@ -4,7 +4,7 @@ import { DataSource, EntityManager, Repository, SelectQueryBuilder } from 'typeo
 import { CreateModuleMetadataDto } from '../dtos/create-module-metadata.dto';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 
-import { classify } from '@angular-devkit/core/src/utils/strings';
+import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
 import { ConfigService } from '@nestjs/config';
 import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
@@ -320,7 +320,54 @@ export class ModuleMetadataService {
 
   async remove(id: number) {
     const entity = await this.findOne(id);
-    return this.moduleMetadataRepo.remove(entity);
+    await this.cleanupOnDelete(entity.id);
+    const r = await this.moduleMetadataRepo.remove(entity);
+    return r
+
+  }
+
+
+  async cleanupOnDelete(moduleEntityId: number) {
+    const moduleEntity = await this.moduleMetadataRepo.findOne({
+      where: {
+        // @ts-ignore
+        id: moduleEntityId,
+      }
+    });
+
+    if (!moduleEntity) {
+      this.logger.log(`Invalid moduleEntityId: ${moduleEntityId} unable to resolve model metadata`);
+      return;
+    }
+    if (moduleEntity.id !== moduleEntityId) {
+      this.logger.log(`Invalid moduleEntityId: ${moduleEntityId} unable to resolve model metadata id ${moduleEntity.id} not matching with the one passed as argument ${moduleEntityId}`);
+      return;
+    }
+
+    this.logger.log(`Cleaning up for module: ${moduleEntity.name}.`);
+
+    const modulePath = await this.moduleMetadataHelperService.getModulePath(moduleEntity.name);
+    if (modulePath) {
+
+      this.logger.log(`Module path: ${modulePath}`);
+
+      // Metadata file to be deleted
+      const moduleMetadataPAth = await this.moduleMetadataHelperService.getModuleMetadataFolderPath(moduleEntity.name)
+      this.logger.log(`About to delete module metadata path: ${moduleMetadataPAth}`);
+
+      try {
+        await fs.rm(modulePath, { recursive: true, force: true });
+        await fs.rm(moduleMetadataPAth, { recursive: true, force: true });
+        this.logger.log(`Deleted file: ${moduleMetadataPAth}`);
+      } catch (error) {
+        this.logger.error(`Error deleting file: ${moduleMetadataPAth}`, error);
+        throw new Error(ERROR_MESSAGES.FILE_DELETE_FAILED); // Trigger rollback
+      }
+    }
+    await this.dataSource.query(
+      `CALL cleanup_module_metadata($1, $2)`,
+      [moduleEntity.name, true],
+    );
   }
 
   async deleteMany(ids: number[]): Promise<any> {

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

@@ -1,23 +1,22 @@
-import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, In, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { CrudHelperService } from "src/services/crud-helper.service";
 import { CRUDService } from 'src/services/crud.service';
+import { FileService } from "src/services/file.service";
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from "src/services/file.service";
-import { CrudHelperService } from "src/services/crud-helper.service";
+import { EntityManager, In } from 'typeorm';
 
 
-import { PermissionMetadata } from '../entities/permission-metadata.entity';
-import { ActiveUserData } from '../interfaces/active-user-data.interface';
-import { classify } from '@angular-devkit/core/src/utils/strings';
 import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
+import { PermissionMetadata } from '../entities/permission-metadata.entity';
 
 @Injectable()
 export class PermissionMetadataService extends CRUDService<PermissionMetadata> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/queues/database-subscriber.service.ts

@@ -99,8 +99,10 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
 
     async onModuleInit(): Promise<void> {
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+
         // we will start subscriber only if the current service role is subscriber. 
-        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database') {
+        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database' && solidCliRunning === "false") {
 
             const options = this.options();
 

package/src/services/queues/rabbitmq-subscriber.service.ts

@@ -52,8 +52,10 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     }
 
     async onModuleInit(): Promise<void> {
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+
         // we will start subscriber only if the current service role is subscriber. 
-        if (this.url && ['both', 'subscriber'].includes(this.serviceRole)) {
+        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false") {
 
             // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
             // const connection = await amqp.connect(this.url);
@@ -92,7 +94,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 async (rawMessage) => {
                     if (rawMessage) {
                         const messageContentString = rawMessage.content.toString();
-                        this.logger.debug(`RabbitMqSubscriber Received raw message: ${messageContentString}`);
+                        // this.logger.debug(`RabbitMqSubscriber Received raw message: ${messageContentString}`);
 
                         let message: QueueMessage<T> = null;
 

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

@@ -23,6 +23,7 @@ export class RoleMetadataService extends CRUDService<RoleMetadata> {
   constructor(
     @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
+    @Inject(forwardRef(() => ModuleMetadataService))
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
     readonly fileService: FileService,

package/src/services/scheduled-job.service.ts

@@ -1,22 +1,22 @@
-import { Injectable } from '@nestjs/common';
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
-import { EntityManager, Repository } from 'typeorm';
+import { InjectEntityManager } from '@nestjs/typeorm';
 import { ScheduledJob } from 'src/entities/scheduled-job.entity';
-import { ModelMetadataService } from './model-metadata.service';
-import { ModuleMetadataService } from './module-metadata.service';
-import { ConfigService } from '@nestjs/config';
-import { FileService } from './file.service';
+import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
+import { EntityManager } from 'typeorm';
 import { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { Logger } from '@nestjs/common';
-import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
+import { FileService } from './file.service';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
 
 @Injectable()
 export class ScheduledJobService extends CRUDService<ScheduledJob> {
   private readonly logger = new Logger(ScheduledJobService.name);
 
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -20,6 +20,11 @@ export class SchedulerServiceImpl implements ISchedulerService {
 
     @Cron(CronExpression.EVERY_MINUTE)
     async runScheduledJobs(): Promise<void> {
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
+        if (solidCliRunning === "true") {
+            return;
+        }
+
         const now = new Date();
 
         // this.logger.log(`[${now.getTime()}]: scheduler service started run...`);

package/src/services/security-rule.service.ts

@@ -18,6 +18,7 @@ import { SecurityRuleRepository } from 'src';
 @Injectable()
 export class SecurityRuleService extends CRUDService<SecurityRule> implements OnApplicationBootstrap {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,

package/src/services/selection-providers/list-of-models-selection-provider.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from "@nestjs/common";
+import { forwardRef, Inject, Injectable } from "@nestjs/common";
 import { ModelMetadataService } from "src/services/model-metadata.service";
 import { SelectionProvider } from "src/decorators/selection-provider.decorator";
 import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
@@ -8,7 +8,10 @@ import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues
 @Injectable()
 export class ListOfModelsSelectionProvider implements ISelectionProvider<ISelectionProviderContext> {
     private readonly modelMetadataService: ModelMetadataService;
-    constructor(modelMetadataService: ModelMetadataService) {
+    constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
+        modelMetadataService: ModelMetadataService
+    ) {
         this.modelMetadataService = modelMetadataService;
     }
     help(): string {

package/src/services/setting.service.ts

@@ -1,25 +1,28 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, forwardRef, Inject, Injectable } from '@nestjs/common';
 import { DiscoveryService, ModuleRef } from "@nestjs/core";
 import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
 import { EntityManager, Repository } from 'typeorm';
 
 import { ConfigService, ConfigType } from '@nestjs/config';
+import commonConfig from 'src/config/common.config';
+import { iamConfig } from 'src/config/iam.config';
+import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { CreateSettingDto } from 'src/dtos/create-setting.dto';
+import { GetMcpUrlDto } from 'src/dtos/get-mcp-url.dto';
+import { User } from 'src/entities/user.entity';
+import { SettingRepository } from 'src/repository/setting.repository';
 import { CrudHelperService } from 'src/services/crud-helper.service';
 import { CRUDService } from 'src/services/crud.service';
 import { FileService } from 'src/services/file.service';
 import { ModelMetadataService } from 'src/services/model-metadata.service';
 import { ModuleMetadataService } from 'src/services/module-metadata.service';
-import commonConfig from 'src/config/common.config';
-import { iamConfig } from 'src/config/iam.config';
 import { Setting } from '../entities/setting.entity';
 import { RequestContextService } from './request-context.service';
-import { User } from 'src/entities/user.entity';
-import { CreateSettingDto } from 'src/dtos/create-setting.dto';
-import { SettingRepository } from 'src/repository/setting.repository';
 
 @Injectable()
 export class SettingService extends CRUDService<Setting> {
   constructor(
+    @Inject(forwardRef(() => ModelMetadataService))
     readonly modelMetadataService: ModelMetadataService,
     readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
@@ -44,6 +47,7 @@ export class SettingService extends CRUDService<Setting> {
 
   async seedDefaultSettings(): Promise<void> {
     const settingsSeederData = {
+      passwordlessRegistrationValidateWhat: this.iamConfiguration.passwordlessRegistrationValidateWhat,
       allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
       passwordBasedAuth: this.iamConfiguration.passwordBasedAuth,
       passwordLessAuth: this.iamConfiguration.passwordLessAuth,
@@ -163,6 +167,7 @@ export class SettingService extends CRUDService<Setting> {
 
   private getDefaultSettings(): Record<string, any> {
     return {
+      passwordlessRegistrationValidateWhat: this.iamConfiguration.passwordlessRegistrationValidateWhat,
       allowPublicRegistration: this.iamConfiguration.allowPublicRegistration,
       passwordBasedAuth: this.iamConfiguration.passwordBasedAuth,
       passwordLessAuth: this.iamConfiguration.passwordLessAuth,
@@ -372,4 +377,26 @@ export class SettingService extends CRUDService<Setting> {
     return { system, user };
   }
 
+  async getMcpUrl(getMcpUrlDto: GetMcpUrlDto, solidRequestContext: any = {}): Promise<any> {
+
+    const { showHeader, inListView } = getMcpUrlDto;
+
+    if(process.env.MCP_ENABLED === 'false') {
+        throw new ForbiddenException(ERROR_MESSAGES.FORBIDDEN);
+    }
+
+    if (solidRequestContext.activeUser) {
+      const permissionNames = ["SettingController.getMcpUrl"];
+      const matchingPermssions = solidRequestContext.activeUser.permissions.filter((p: any) => permissionNames.includes(p));
+      const hasPermission = matchingPermssions.length > 0;
+      if (!hasPermission) {
+        throw new BadRequestException(ERROR_MESSAGES.FORBIDDEN);
+      }
+    }
+    const apiKey = process.env.MCP_API_KEY;
+    const userId = solidRequestContext.activeUser.sub;
+    const mcpServerUrl = process.env.MCP_SERVER_URL;
+    return { mcpUrl: `${mcpServerUrl}/static/frontend.html?solidx-mcp-api-key=${apiKey}&solidx-user-id=${userId}&solidx-show-header=${showHeader}&solidx-in-list-view=${inListView}` };
+  }
+
 }

package/src/services/sms-template.service.ts

@@ -1,25 +1,23 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 
-import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
-import { PaginationQueryDto } from 'src/dtos/pagination-query.dto';
+import { ConfigService } from '@nestjs/config';
+import { DiscoveryService, ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { SmsTemplateRepository } from 'src/repository/sms-template.repository';
+import { EntityManager } from 'typeorm';
 import { SmsTemplate } from '../entities/sms-template.entity';
-import { CreateSmsTemplateDto } from '../dtos/create-sms-template.dto';
-import { UpdateSmsTemplateDto } from '../dtos/update-sms-template.dto';
+import { CrudHelperService } from './crud-helper.service';
 import { CRUDService } from './crud.service';
-import { ModelMetadataService } from './model-metadata.service';
-import { ModuleMetadataService } from './module-metadata.service';
-import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
-import { ConfigService } from '@nestjs/config';
 import { FileService } from './file.service';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
 import { MediaService } from './media.service';
-import { DiscoveryService, ModuleRef } from '@nestjs/core';
-import { CrudHelperService } from './crud-helper.service';
-import { SmsTemplateRepository } from 'src/repository/sms-template.repository';
+import { ModelMetadataService } from './model-metadata.service';
+import { ModuleMetadataService } from './module-metadata.service';
 
 @Injectable()
 export class SmsTemplateService extends CRUDService<SmsTemplate>{
     constructor(
+        @Inject(forwardRef(() => ModelMetadataService))
         readonly modelMetadataService: ModelMetadataService,
             readonly moduleMetadataService: ModuleMetadataService,
             readonly mediaStorageProviderService: MediaStorageProviderMetadataService,

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

@@ -1,5 +1,5 @@
 import { classify } from '@angular-devkit/core/src/utils/strings';
-import { forwardRef, Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, ModuleRef, Reflector } from '@nestjs/core';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { getDataSourceToken } from '@nestjs/typeorm';
@@ -14,16 +14,12 @@ import { IS_SELECTION_PROVIDER } from 'src/decorators/selection-provider.decorat
 import { IS_SOLID_DATABASE_MODULE } from 'src/decorators/solid-database-module.decorator';
 import { IS_WA_PROVIDER } from 'src/decorators/whatsapp-provider.decorator';
 import { SolidRegistry } from 'src/helpers/solid-registry';
-import { DataSource } from 'typeorm';
-import { CRUDService } from './crud.service';
-import { RequestContextService } from './request-context.service';
-import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated-by.subscriber';
 import { AuditSubscriber } from 'src/subscribers/audit.subscriber';
-import { ComputedEntityFieldSubscriber, ComputedFieldEvaluationPayload } from 'src/subscribers/computed-entity-field.subscriber';
+import { ComputedEntityFieldSubscriber } from 'src/subscribers/computed-entity-field.subscriber';
+import { CreatedByUpdatedBySubscriber } from 'src/subscribers/created-by-updated-by.subscriber';
 import { SoftDeleteAwareEventSubscriber } from 'src/subscribers/soft-delete-aware-event.subscriber';
-import { ChatterMessageService } from './chatter-message.service';
-import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
-import { ModelMetadataHelperService, PublisherFactory } from 'src';
+import { DataSource } from 'typeorm';
+import { CRUDService } from './crud.service';
 
 export const coreSubscriberClasses = [
   AuditSubscriber,
@@ -40,20 +36,11 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     private readonly metadataScanner: MetadataScanner,
     private readonly solidRegistry: SolidRegistry,
     private readonly moduleRef: ModuleRef,
-    private readonly requestContextService: RequestContextService,
-    // AuditSubscribe related dependencies
-    private readonly chatterMessageService: ChatterMessageService,
-    private readonly modelMetadataHelperService: ModelMetadataHelperService,
-    private readonly modelMetadataRepo: ModelMetadataRepository,
-    // ComputedEntityFieldSubscriber related dependencies
-   @Inject(forwardRef(() => PublisherFactory))
-    private readonly publisherFactory: PublisherFactory<any>,
-    
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
   async onApplicationBootstrap() {
-    this.logger.log('Introspecting the application for Solid metadata');
+    this.logger.debug('Introspecting the application for Solid metadata');
 
     // Register all seeders
     const seeders = this.discoveryService