@solidstarters/solid-core 1.2.193 → 1.2.201

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/mq-message.service.ts

@@ -70,17 +70,17 @@ export class MqMessageService extends CRUDService<MqMessage> {
     });
   }
 
-/**
- * Wait until a queue message reaches a terminal status (succeeded/failed).
- *
- * @param messageId string – the external message id you store in `ss_mq_message.messageId`
- * @param opts.timeoutMs total time to wait before giving up (default 60s)
- * @param opts.intervalMs initial poll interval (default 500ms)
- * @param opts.maxIntervalMs cap for exponential backoff (default 2000ms)
- * @param opts.throwOnFailure if true, throws when stage === 'failed' (default false)
- * @param opts.parseJson try JSON.parse on `output` and `error` (default true)
- * @returns resolves with the final MqMessage row when terminal, rejects on timeout (or failure if throwOnFailure)
- */
+  /**
+   * Wait until a queue message reaches a terminal status (succeeded/failed).
+   *
+   * @param messageId string – the external message id you store in `ss_mq_message.messageId`
+   * @param opts.timeoutMs total time to wait before giving up (default 60s)
+   * @param opts.intervalMs initial poll interval (default 500ms)
+   * @param opts.maxIntervalMs cap for exponential backoff (default 2000ms)
+   * @param opts.throwOnFailure if true, throws when stage === 'failed' (default false)
+   * @param opts.parseJson try JSON.parse on `output` and `error` (default true)
+   * @returns resolves with the final MqMessage row when terminal, rejects on timeout (or failure if throwOnFailure)
+   */
   async waitForTerminalStatus(
     messageId: string,
     opts?: {
@@ -139,14 +139,15 @@ export class MqMessageService extends CRUDService<MqMessage> {
       } else if (rec.stage === 'succeeded' || rec.stage === 'failed') {
         // Optionally parse output/error if they contain JSON strings
         if (parseJson) {
-          rec.output = this.safeJsonParse(rec.output);
-          rec.error = this.safeJsonParse(rec.error);
+          // rec.output = this.safeJsonParse(rec.output);
+          rec.output = rec.output;
+          // rec.error = this.safeJsonParse(rec.error);
+          rec.error = rec.error;
         }
 
         if (rec.stage === 'failed' && throwOnFailure) {
           throw new Error(
-            `Queue message ${messageId} failed` +
-            (rec.error ? `: ${JSON.stringify(rec.error).slice(0, 500)}` : '')
+            `Queue message ${messageId} failed` + (rec.error ? `: ${JSON.stringify(rec.error).slice(0, 500)}` : '')
           );
         }
         return rec;

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/publisher-factory.service.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@nestjs/common';
+import { forwardRef, Inject, Logger } from '@nestjs/common';
 import { Injectable } from '@nestjs/common';
 
 import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
@@ -11,6 +11,7 @@ export class PublisherFactory<T> {
     private readonly logger = new Logger(PublisherFactory.name);
 
     constructor(
+        @Inject(forwardRef(() => SolidIntrospectService))
         private readonly solidIntrospectionService: SolidIntrospectService
     ) {
     }

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/{providers → services/selection-providers}/list-of-values-selection-providers.service.ts

@@ -1,9 +1,9 @@
 
-import { ListOfValuesService } from "../services/list-of-values.service";
+import { ListOfValuesService } from "../list-of-values.service";
 import { PaginationQueryDto } from "src/dtos/pagination-query.dto";
 import { SelectionProvider } from "src/decorators/selection-provider.decorator";
 import { Injectable } from "@nestjs/common";
-import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../interfaces";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
 import { filter } from "rxjs";
 import { BasicFilterDto } from "src/dtos/basic-filters.dto";
 

package/src/services/selection-providers/pseudo-foreign-key-selection-provider.service.ts

@@ -0,0 +1,94 @@
+import { ListOfValuesService } from "../list-of-values.service";
+import { SelectionProvider } from "src/decorators/selection-provider.decorator";
+import { BadRequestException, Injectable } from "@nestjs/common";
+import { ISelectionProvider, ISelectionProviderContext, ISelectionProviderValues } from "../../interfaces";
+import { BasicFilterDto } from "src/dtos/basic-filters.dto";
+import { SolidIntrospectService } from "../solid-introspect.service";
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { CRUDService } from "../crud.service";
+
+interface PseudoForeignKeySelectionProviderContext extends ISelectionProviderContext {
+    modelName: string;
+    // ['countryName', 'countryCode'] - IN|INR
+    whereClauseFields: string[];
+    labelFieldName: string;
+    valueFieldName: string;
+}
+
+const DEFAULT_LIMIT = 100;
+
+@SelectionProvider()
+@Injectable()
+export class PseudoForeignKeySelectionProvider implements ISelectionProvider<PseudoForeignKeySelectionProviderContext> {
+    constructor(
+        private readonly listOfValuesService: ListOfValuesService,
+        readonly introspectService: SolidIntrospectService,
+    ) { }
+
+    name(): string {
+        return 'PseudoForeignKeySelectionProvider';
+    }
+
+    help(): string {
+        return "# Use this provider to implement pseudo foreign key style relationships.";
+    }
+
+    async value(optionValue: string, ctxt: PseudoForeignKeySelectionProviderContext): Promise<ISelectionProviderValues | any> {
+        const basicFilterQuery = new BasicFilterDto(DEFAULT_LIMIT, 0);
+        basicFilterQuery.filters = {
+            [ctxt.valueFieldName]: {
+                $eq: optionValue
+            }
+        };
+
+        const modelServiceInstanceWrapper = this.introspectService.getProvider(`${classify(ctxt.modelName)}Service`);
+        if (!modelServiceInstanceWrapper) {
+            throw new BadRequestException(`Invalid model name (${ctxt.modelName}) specified in PseudoForeignKeySelectionProvider context.`);
+        }
+
+        const modelService: CRUDService<any> = modelServiceInstanceWrapper.instance;
+        const recs = await modelService.find(basicFilterQuery);
+        if (!recs.records || recs.records.length == 0) {
+            throw new Error(`Invalid optionValue=${optionValue}, for PseudoForeignKeySelectionProvider with context: ${JSON.stringify(ctxt)}`)
+            // return null;
+        }
+
+        return {
+            label: recs.records[0][ctxt.labelFieldName],
+            value: recs.records[0][ctxt.valueFieldName]
+        }
+    }
+
+    async values(query: string, ctxt: PseudoForeignKeySelectionProviderContext): Promise<readonly ISelectionProviderValues[]> {
+        const basicFilterQuery = new BasicFilterDto(ctxt.limit, ctxt.offset);
+
+        // Next we get hold of the userkey field in the parent model.
+        if (query) {
+            basicFilterQuery.filters = {
+                $or: ctxt.whereClauseFields.map((whereClauseField) => {
+                    return {
+                        [whereClauseField]: {
+                            $containsi: `%${query}%`
+                        }
+                    }
+                })
+            };
+        }
+
+        const modelServiceInstanceWrapper = this.introspectService.getProvider(`${classify(ctxt.modelName)}Service`);
+        if (!modelServiceInstanceWrapper) {
+            throw new BadRequestException(`Invalid model name (${ctxt.modelName}) specified in PseudoForeignKeySelectionProvider context.`);
+        }
+
+        const modelService: CRUDService<any> = modelServiceInstanceWrapper.instance;
+
+        const recs = await modelService.find(basicFilterQuery);
+        const selectionValues = recs.records.map(rec => {
+            return {
+                label: rec[ctxt.labelFieldName],
+                value: rec[ctxt.valueFieldName]
+            }
+        });
+        return selectionValues;
+    }
+}

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,
@@ -79,10 +83,10 @@ export class SettingService extends CRUDService<Setting> {
       authenticationPasswordRegexErrorMessage: this.iamConfiguration.PASSWORD_REGEX_ERROR_MESSAGE,
       authenticationPasswordComplexityDescription: this.iamConfiguration.PASSWORD_COMPLEXITY_DESC,
       solidXGenAiCodeBuilderConfig: JSON.stringify({
-            defaultProvider: "",
-            availableProviders: []
-        }),
-      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration,
+        defaultProvider: "",
+        availableProviders: []
+      }),
+      showNameFieldsForRegistration: this.iamConfiguration.showNameFieldsForRegistration,
       forceChangePasswordOnFirstLogin: this.iamConfiguration.forceChangePasswordOnFirstLogin
     };
 
@@ -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,
@@ -199,11 +204,11 @@ export class SettingService extends CRUDService<Setting> {
       authenticationPasswordRegexErrorMessage: this.iamConfiguration.PASSWORD_REGEX_ERROR_MESSAGE,
       authenticationPasswordComplexityDescription: this.iamConfiguration.PASSWORD_COMPLEXITY_DESC,
       solidXGenAiCodeBuilderConfig: JSON.stringify({
-            defaultProvider: "",
-            availableProviders: []
-        }),
-      iamAutoGeneratedPassword:this.iamConfiguration.iamAutoGeneratedPassword,
-      showNameFieldsForRegistration:this.iamConfiguration.showNameFieldsForRegistration
+        defaultProvider: "",
+        availableProviders: []
+      }),
+      iamAutoGeneratedPassword: this.iamConfiguration.iamAutoGeneratedPassword,
+      showNameFieldsForRegistration: this.iamConfiguration.showNameFieldsForRegistration
     };
   }
 
@@ -297,7 +302,10 @@ export class SettingService extends CRUDService<Setting> {
       }
 
       const key = settingDto.key;
-      const value = settingDto.value ?? '';
+      // const value = settingDto.value ?? '';
+      const rawValue = settingDto.value;
+      const value = rawValue === null || rawValue === undefined ? null : String(rawValue);
+
       const settingType = settingDto.type ?? 'system';
 
       const existingSetting = existingSettings.find(s => s.key === key);
@@ -369,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,