@solidxai/core 0.0.2

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

@@ -0,0 +1,375 @@
+import { BadRequestException, ForbiddenException, Inject, Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as fsPromises from 'fs/promises';
+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 '../repository/setting.repository';
+import { FILE_SERVICE, IFileService } from './file';
+import { Setting } from '../entities/setting.entity';
+import { RequestContextService } from './request-context.service';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ISettingsProvider, NoInfer, SettingDefinition, SettingLevel } from '../interfaces';
+import { ModuleMetadataRepository } from 'src/repository/module-metadata.repository';
+import type { SolidCoreSetting } from './settings/default-settings-provider.service';
+import { Logger } from '@nestjs/common';
+
+
+@Injectable()
+export class SettingService {
+  private readonly _logger = new Logger(SettingService.name);
+
+  private settings: SettingDefinition[] = [];
+  private settingsByKey = new Map<string, SettingDefinition>();
+
+  private readonly arrayKeysToSkip = new Set([
+    'authenticationPasswordRegex',
+    'authenticationPasswordRegexErrorMessage',
+    'authenticationPasswordComplexityDescription',
+  ]);
+
+  constructor(
+    @Inject(FILE_SERVICE) readonly fileService: IFileService,
+    readonly solidRegistry: SolidRegistry,
+    readonly repo: SettingRepository,
+    readonly moduleMetadataRepo: ModuleMetadataRepository,
+    private readonly requestContextService: RequestContextService,
+    @InjectRepository(User) private readonly userRepository: Repository<User>,
+  ) { }
+
+  private async getSettingsFromDb(): Promise<Setting[]> {
+    const settings = await this.repo.find({ relations: ['user'] });
+    return settings;
+  }
+
+  private parseSettingValue(value: string, key: string): any {
+    try {
+      return JSON.parse(value);
+    } catch {
+      if (value === 'true' || value === 'false') {
+        return value === 'true';
+      }
+      if (!isNaN(Number(value)) && value.trim() !== '') {
+        return Number(value);
+      }
+      if (!this.arrayKeysToSkip.has(key) && value.includes(',')) {
+        return value.split(',').map(item => item.trim());
+      }
+      return value;
+    }
+  }
+
+  /**
+   * Reads all registered providers and gathers settings from across the running platform.
+   * This is the superset of all possible settings. 
+   * @returns 
+   */
+  private getAllSettingsFromProviders(): SettingDefinition[] {
+    // get all settings from registry 
+    const allSettingsProviders = this.solidRegistry.getSettingsProviders();
+    const settings: SettingDefinition[] = [];
+    const seenKeys = new Map<string, { setting: SettingDefinition; providerName?: string }>();
+    for (const wrapper of allSettingsProviders) {
+      const instance = wrapper.instance as ISettingsProvider;
+      // if (!instance?.getSettings) continue;
+      for (const setting of instance.getSettings()) {
+        const existing = seenKeys.get(setting.key);
+        if (existing) {
+          throw new Error(
+            `Duplicate setting key detected: ${setting.key}. ` +
+            `First: ${JSON.stringify(existing.setting)} from provider: ${existing.providerName ?? "unknown"}. ` +
+            `Second: ${JSON.stringify(setting)} from provider: ${wrapper.name ?? "unknown"}.`
+          );
+        }
+        seenKeys.set(setting.key, { setting, providerName: wrapper.name });
+        settings.push(setting);
+      }
+    }
+
+    return settings
+  }
+
+  /**
+   * public method that gets all settings in the system, this includes settings from solid-core and any consuming projects.
+   * this means that the settings returned are the ones provided by ISettingsProvider, merged with values if any from the database. 
+   * 
+   * @returns 
+   */
+  getAllSettings(): SettingDefinition[] {
+    return this.settings;
+  }
+
+  async updateSettingsCache(): Promise<void> {
+    this._logger.debug(`updating settings cache...`);
+    const settingsFromDb = await this.getSettingsFromDb();
+    const settingsFromProviders = this.getAllSettingsFromProviders();
+    const settingsFromDbByKey = new Map(settingsFromDb.map(setting => [setting.key, setting]));
+
+    this.settings = settingsFromProviders.map(setting => {
+      const settingFromDb = settingsFromDbByKey.get(setting.key);
+      const valueFromDb = settingFromDb?.value;
+      if (settingFromDb?.key && valueFromDb !== undefined && valueFromDb !== null) {
+        const parsedValue = typeof valueFromDb === 'string' ? this.parseSettingValue(valueFromDb, settingFromDb.key) : valueFromDb;
+        return { ...setting, value: parsedValue };
+      }
+      return setting;
+    });
+
+    // Also keep a key vs SettingDefinition map...
+    this.settingsByKey = new Map(this.settings.map(setting => [setting.key, setting]));
+  }
+
+  private isDisallowedSettingKey(key: string, settingLevelsToDisallow: SettingLevel[]): boolean {
+    if (!key) {
+      return false;
+    }
+    const setting = this.settingsByKey.get(key);
+    // return setting ? [SettingLevel.SystemEnv, SettingLevel.SystemAdminReadonly].includes(setting.level) : false;
+    return setting ? settingLevelsToDisallow.includes(setting.level) : false;
+  }
+
+  /**
+   * 1. 
+   * This method will seed (insert only) settings that are introduced in code but do not already exist in the database. 
+   * Also this method only deals with settings with level system-admin-editable & internal-user.
+   */
+  async seedSystemAdminEditableAndAboveSettings(): Promise<void> {
+    // Seed only settings with level system-admin-editable & internal-user, 
+    // so basically settings which are either system-admin-editable and above.
+    const saEditableAndAbove = this.getAllSettingsFromProviders().filter(i => [SettingLevel.SystemAdminEditable, SettingLevel.InternalUser].includes(i.level));
+
+    // Get hold of the current values from the database.
+    const existingSettingsFromDb: Setting[] = await this.getSettingsFromDb();
+
+    // const existingKeysFromDb = new Set(existingSettingsFromDb.map(s => s.key));
+    const existingSettingsFromDbByKey = new Map(existingSettingsFromDb.map(setting => [setting.key, setting]));
+    const settingsToMutate: Setting[] = [];
+    // const settingsToUpdate: Setting[] = [];
+
+    for (const { key, value, level, moduleName } of saEditableAndAbove) {
+      const moduleMetadata = await this.moduleMetadataRepo.findOneBy({ name: moduleName });
+      if (!existingSettingsFromDbByKey.has(key)) {
+        const setting = new Setting();
+        setting.key = key;
+        setting.level = level;
+        if (moduleMetadata)
+          setting.moduleMetadata = moduleMetadata;
+
+        if (typeof value === 'boolean') {
+          setting.value = value.toString();
+        } else if (Array.isArray(value)) {
+          setting.value = value.join(',');
+        } else if (value === null || value === undefined) {
+          setting.value = null;
+        } else {
+          setting.value = String(value);
+        }
+
+        settingsToMutate.push(setting);
+      }
+      else {
+        const setting = existingSettingsFromDbByKey.get(key);
+        setting.level = level;
+        if (moduleMetadata)
+          setting.moduleMetadata = moduleMetadata;
+        settingsToMutate.push(setting);
+      }
+    }
+
+    if (settingsToMutate.length > 0) {
+      await this.repo.save(settingsToMutate);
+    }
+    // if (settingsToUpdate.length > 0) {
+    //   await this.repo.save(settingsToUpdate);
+    // }
+  }
+
+  /**
+   * 2. 
+   * Method used from the solid-core-ui to fetch available settings. 
+   * Here we are returning settings other than system-env.
+   * 
+   * @returns 
+   */
+  async getSystemAdminReadonlyAndAboveSettings(): Promise<Record<any, any>> {
+    const finalSettings: Record<any, any> = {};
+    const systemAdminReadonlyAndAboveSettings = this.settings.filter(i => i.level !== "system-env");
+    for (const setting of systemAdminReadonlyAndAboveSettings) {
+      finalSettings[setting.key] = setting.value;
+    }
+    return finalSettings;
+  }
+
+  /**
+   * 3. 
+   * This method updates settings from the admin user interface. 
+   * Most likely settings with level system-admin-editable & internal-user are the ones that will get modified here. 
+   * 
+   * @param settings 
+   * @param uploadedFiles 
+   * @returns 
+   */
+  async updateSettings(settings: CreateSettingDto[] = [], uploadedFiles: Array<Express.Multer.File> = []): Promise<Setting[]> {
+    const activeUser = this.requestContextService.getActiveUser();
+    const userId = activeUser?.sub;
+
+    const restrictedKeys = new Set<string>();
+
+    settings.forEach(setting => {
+      if (this.isDisallowedSettingKey(setting.key, [SettingLevel.SystemEnv, SettingLevel.SystemAdminReadonly])) {
+        restrictedKeys.add(setting.key);
+      }
+    });
+    uploadedFiles.forEach(file => {
+      if (this.isDisallowedSettingKey(file.fieldname, [SettingLevel.SystemEnv, SettingLevel.SystemAdminReadonly])) {
+        restrictedKeys.add(file.fieldname);
+      }
+    });
+
+    if (restrictedKeys.size > 0) {
+      throw new BadRequestException(`${ERROR_MESSAGES.FORBIDDEN}: Settings ${Array.from(restrictedKeys).join(', ')} cannot be modified.`);
+    }
+
+    // const existingSettings = await this.repo.find();
+    const existingSettings: Setting[] = await this.getSettingsFromDb();
+
+    const settingsToUpdate: Setting[] = [];
+    const settingsToCreate: Setting[] = [];
+
+    let user: User | null = null;
+    const hasUserSettings = settings.some(dto => dto.type === 'user');
+    if (hasUserSettings && userId) {
+      user = await this.userRepository.findOne({ where: { id: userId } });
+    }
+
+    // Handle uploaded files
+    if (uploadedFiles?.length) {
+      for (const file of uploadedFiles) {
+        const settingKey = file.fieldname;
+        const relativeFileName = `${file.filename}-${file.originalname}`;
+
+        // Read file from local disk (where Multer stores uploads) and write to storage
+        // The file service resolves the storage path and returns the public URL
+        const fileContent = await fsPromises.readFile(file.path);
+        const fileUrl = await this.fileService.write(relativeFileName, fileContent, { contentType: file.mimetype });
+        // Delete the temp file from local disk
+        await fsPromises.unlink(file.path);
+
+        const matchedDto = settings.find(dto => dto.key === settingKey);
+        const settingType = matchedDto?.type ?? 'system';
+
+        const existingSetting = existingSettings.find(s => s.key === settingKey);
+        if (existingSetting) {
+          existingSetting.value = fileUrl;
+          existingSetting.type = settingType;
+          settingsToUpdate.push(existingSetting);
+        } else {
+          const newSetting = new Setting();
+          newSetting.key = settingKey;
+          newSetting.value = fileUrl;
+          newSetting.type = settingType;
+
+          if (settingType === 'user' && user) {
+            newSetting.user = user;
+          }
+
+          settingsToCreate.push(newSetting);
+        }
+      }
+    }
+
+    // Handle non-file settings
+    for (const settingDto of settings) {
+      if (uploadedFiles?.some(file => file.fieldname === settingDto.key)) {
+        continue; // skip if already handled via file
+      }
+
+      const key = settingDto.key;
+      // 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);
+      if (existingSetting) {
+        existingSetting.value = value;
+        existingSetting.type = settingType;
+        settingsToUpdate.push(existingSetting);
+      } else {
+        const newSetting = new Setting();
+        newSetting.key = key;
+        newSetting.value = value;
+        newSetting.type = settingType;
+
+        if (settingType === 'user' && user) {
+          newSetting.user = user;
+        }
+
+        settingsToCreate.push(newSetting);
+      }
+    }
+
+    if (settingsToUpdate.length > 0) {
+      await this.repo.save(settingsToUpdate);
+    }
+
+    if (settingsToCreate.length > 0) {
+      await this.repo.save(settingsToCreate);
+    }
+    await this.updateSettingsCache();
+
+    return [...settingsToUpdate, ...settingsToCreate];
+  }
+
+  /**
+   * 4. 
+   * @param settingKey 
+   * @returns 
+   */
+  getConfigValue<T = never>(settingKey: NoInfer<T>) {
+    const cachedSetting = this.settingsByKey.get(settingKey as string);
+    if (cachedSetting) {
+      return cachedSetting.value;
+    }
+
+    return null;
+
+    // const cachedSetting = this.settings.find(setting => setting.key === settingKey);
+    // if (cachedSetting) {
+    //   return cachedSetting.value;
+    // }
+
+    // // This is probably not needed at all, but leaving it here as a backup for scenarios like 
+    // // if getConfigValue<SolidCoreSetting>() is called before onApplicationBootstrap() runs or if the cache refresh fails. 
+    // const getAllSettings = this.getAllSettingsFromProviders();
+    // const settingValue = getAllSettings.find(i => (i.key == settingKey))
+    // return settingValue?.value;
+  }
+
+  async getMcpUrl(getMcpUrlDto: GetMcpUrlDto, solidRequestContext: any = {}): Promise<any> {
+
+    const { showHeader, inListView } = getMcpUrlDto;
+
+    const mcpEnabled = this.getConfigValue<SolidCoreSetting>('mcpEnabled');
+    if (mcpEnabled === 'false' || mcpEnabled === 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 = this.getConfigValue<SolidCoreSetting>('mcpApiKey');
+    const userId = solidRequestContext.activeUser.sub;
+    const mcpServerUrl = this.getConfigValue<SolidCoreSetting>('mcpServerUrl');
+    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/settings/default-settings-provider.service.ts

@@ -0,0 +1,159 @@
+import { Injectable } from "@nestjs/common";
+import { Environment } from "src/decorators/disallow-in-production.decorator";
+import { SettingsProvider } from "src/decorators/settings-provider.decorator";
+import { ISettingsProvider, SettingDefinition, SettingLevel } from "src/interfaces";
+
+const DEFAULT_MEDIA_UPLOAD_DIR = 'media-uploads';
+const DEFAULT_MEDIA_FILE_STORAGE_DIR = 'media-files-storage';
+
+// 1. 
+const getSolidCoreSettings = (isProd: boolean) => ([
+  { moduleName: "solid-core", key: "iamGoogleOAuthEnabled", value: false, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authPagesLayout", value: "center", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authPagesTheme", value: "light", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appLogo", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "companylogo", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "favicon", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appLogoPosition", value: "in_form_view", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "showAuthContent", value: false, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appTitle", value: process.env.SOLID_APP_NAME || "Solid App", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appSubtitle", value: process.env.SOLID_APP_SUBTITLE || "", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appDescription", value: process.env.SOLID_APP_DESCRIPTION || "", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "showLegalLinks", value: false, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appTnc", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "appPrivacyPolicy", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "enableDarkMode", value: true, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "copyright", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "enableUsername", value: true, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "enabledNotification", value: true, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "contactSupportEmail", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "contactSupportDisplayName", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "contactSupportIcon", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authScreenRightBackgroundImage", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authScreenLeftBackgroundImage", value: null, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authScreenCenterBackgroundImage", value: null, level: SettingLevel.SystemAdminEditable },
+  {
+    moduleName: "solid-core", key: "solidXGenAiCodeBuilderConfig", value: JSON.stringify({
+      defaultProvider: "",
+      availableProviders: []
+    }), level: SettingLevel.SystemAdminEditable
+  },
+  { moduleName: "solid-core", key: "mcpEnabled", value: process.env.MCP_ENABLED || false, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "mcpServerUrl", value: process.env.MCP_SERVER_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "mcpApiKey", value: process.env.MCP_API_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "dateTimeFormat", value: process.env.DATE_TIME_FORMAT || "YYYY-MM-DD HH:mm:ss", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "dateFormat", value: process.env.DATE_FORMAT || "YYYY-MM-DD", level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "baseUrl", value: process.env.BASE_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "solidAppWebsiteUrl", value: process.env.SOLID_APP_WEBSITE_URL, level: SettingLevel.SystemAdminEditable },
+
+  // app-builder-settings-provider.service.ts, app-builder.config.ts
+  { moduleName: "solid-core", key: "moduleMetadataSeederFiles", value: process.env.AB_MODULE_METADATA_SEEDER_FILES ?? '', level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "uploadDir", value: process.env.AB_MEDIA_UPLOAD_DIR ?? DEFAULT_MEDIA_UPLOAD_DIR, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "fileStorageDir", value: process.env.AB_MEDIA_FILE_STORAGE_DIR ?? DEFAULT_MEDIA_FILE_STORAGE_DIR, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "defaultFileService", value: process.env.DEFAULT_FILE_SERVICE ?? 'disk', level: SettingLevel.SystemAdminReadonly },
+
+  // aws-s3-settings-provider.service.ts
+  { moduleName: "solid-core", key: "S3_AWS_ACCESS_KEY", value: process.env.S3_AWS_ACCESS_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "S3_AWS_SECRET_KEY", value: process.env.S3_AWS_SECRET_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "S3_AWS_REGION_NAME", value: process.env.S3_AWS_REGION_NAME, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "S3_DEFAULT_BUCKET", value: process.env.S3_DEFAULT_BUCKET, level: SettingLevel.SystemAdminReadonly },
+
+  // email-settings-provider.service.ts
+  { moduleName: "solid-core", key: "emailProvider", value: process.env.COMMON_EMAIL_PROVIDER ?? "SMTPEMailService", level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "emailTemplateSeederFiles", value: process.env.COMMON_EMAIL_TEMPLATE_SEEDER_FILES, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "shouldQueueEmails", value: (process.env.COMMON_EMAIL_SHOULD_QUEUE ?? 'false') === 'true', level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "smtpMailHost", value: process.env.COMMON_SMTP_EMAIL_SMTP_HOST, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "smtpMailPort", value: +(process.env.COMMON_SMTP_EMAIL_SMTP_PORT ?? 587), level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "smtpMailUsername", value: process.env.COMMON_SMTP_EMAIL_USERNAME, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "smtpMailPassword", value: process.env.COMMON_SMTP_EMAIL_PASSWORD, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "smtpMailFrom", value: process.env.COMMON_SMTP_EMAIL_FROM ?? process.env.COMMON_EMAIL_FROM, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "apiMailKey", value: process.env.COMMON_API_EMAIL_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "apiMailFrom", value: process.env.COMMON_EMAIL_FROM, level: SettingLevel.SystemAdminReadonly },
+
+  // genai-settings-provider.service.ts
+  { moduleName: "solid-core", key: "ragServerUrl", value: process.env.GENAI_RAG_SERVER_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "ragServerLogin", value: process.env.GENAI_RAG_SERVER_LOGIN, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "ragServerPassword", value: process.env.GENAI_RAG_SERVER_PASSWORD, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "mcpPythonExecutable", value: process.env.MCP_PYTHON_EXECUTABLE, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "mcpClient", value: process.env.MCP_CLIENT, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "mcpRestartTouchFile", value: process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch", level: SettingLevel.SystemEnv },
+
+  // google-oauth-settings-provider.service.ts
+  { moduleName: "solid-core", key: "clientID", value: process.env.IAM_GOOGLE_OAUTH_CLIENT_ID, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "clientSecret", value: process.env.IAM_GOOGLE_OAUTH_CLIENT_SECRET, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "callbackURL", value: process.env.IAM_GOOGLE_OAUTH_CALLBACK_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "redirectURL", value: process.env.IAM_GOOGLE_OAUTH_REDIRECT_URL, level: SettingLevel.SystemAdminReadonly },
+
+  // iam-settings-provider.service.ts
+  { moduleName: "solid-core", key: "passwordLessAuth", value: (process.env.IAM_PASSWORD_LESS_AUTH?.trim() ?? 'false') === 'true', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "passwordBasedAuth", value: (process.env.IAM_PASSWORD_BASED_AUTH?.trim() ?? 'true') === 'true', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "passwordlessRegistrationValidateWhat", value: (process.env.IAM_PASSWORD_LESS_REGISTRATION_VALIDATE_WHAT ?? 'email').split(',').map((item) => item.trim()), level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "allowPublicRegistration", value: (process.env.IAM_ALLOW_PUBLIC_REGISTRATION ?? 'true') === 'true', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "activateUserOnRegistration", value: (process.env.IAM_ACTIVATE_USER_ON_REGISTRATION ?? 'true') === 'true', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "autoLoginUserOnRegistration", value: (process.env.IAM_AUTO_LOGIN_USER_ON_REGISTRATION ?? 'false') === 'true', level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "otpExpiry", value: parseInt(process.env.IAM_OTP_EXPIRY ?? '10'), level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "forgotPasswordVerificationTokenExpiry", value: parseInt(process.env.IAM_FORGOT_PASSWORD_VERIFICATION_TOKEN_EXPIRY ?? '10'), level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "defaultRole", value: process.env.IAM_DEFAULT_ROLE ?? 'Public', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "dummyOtp", value: process.env.IAM_OTP_DUMMY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "forgotPasswordSendVerificationTokenOn", value: process.env.IAM_FORGOT_PASSWORD_SEND_VERIFICATION_TOKEN_ON ?? 'email', level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "forceChangePasswordOnFirstLogin", value: false, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authenticationPasswordRegex", value: process.env.PASSWORD_REGEX || '^$|^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[^\\da-zA-Z]).*$', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authenticationPasswordRegexErrorMessage", value: process.env.PASSWORD_REGEX_ERROR_MESSAGE || 'Password must contain at least one uppercase, one lowercase, one number, and one special character.', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "authenticationPasswordComplexityDescription", value: process.env.PASSWORD_COMPLEXITY_DESC || 'Password must contain at least one uppercase, one lowercase, one number, and one special character.', level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "iamAutoGeneratedPassword", value: process.env.IAM_AUTOGENERATED_PASSWORD || true, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "passwordPepper", value: process.env.IAM_PASSWORD_PEPPER || '', level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "showNameFieldsForRegistration", value: process.env.IAM_SHOW_NAME_FIELDS_FOR_REGISTRATION === 'true' ? true : false, level: SettingLevel.SystemAdminEditable },
+  { moduleName: "solid-core", key: "sendWelcomeEmailOnSignup", value: (process.env.IAM_SEND_WELCOME_EMAIL_ON_SIGNUP ?? 'false').toLowerCase() === 'true', level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "sendWelcomeSmsOnSignup", value: (process.env.IAM_SEND_WELCOME_SMS_ON_SIGNUP ?? 'false').toLowerCase() === 'true', level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "frontendLoginPageUrl", value: process.env.IAM_FRONTEND_APP_LOGIN_PAGE_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "frontendForgotPasswordPageUrl", value: process.env.IAM_FRONTEND_APP_FORGOT_PASSWORD_PAGE_URL, level: SettingLevel.SystemAdminReadonly },
+
+  // jwt-settings-provider.service.ts
+  { moduleName: "solid-core", key: "secret", value: process.env.IAM_JWT_SECRET, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "audience", value: process.env.IAM_JWT_TOKEN_AUDIENCE, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "issuer", value: process.env.IAM_JWT_TOKEN_ISSUER, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "accessTokenTtl", value: parseInt(process.env.IAM_JWT_ACCESS_TOKEN_TTL ?? (isProd ? "1200" : "86400"), 10,), level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "refreshTokenTtl", value: parseInt(process.env.IAM_JWT_REFRESH_TOKEN_TTL ?? "604800", 10), level: SettingLevel.SystemEnv },
+
+  // queues-settings-provider.service.ts
+  { moduleName: "solid-core", key: "queuesDefaultBroker", value: process.env.QUEUES_DEFAULT_BROKER || 'database', level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "queuesServiceRole", value: process.env.QUEUES_SERVICE_ROLE, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "queuesRabbitMqUrl", value: process.env.QUEUES_RABBIT_MQ_URL, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "solidCliRunning", value: process.env.SOLID_CLI_RUNNING || "false", level: SettingLevel.SystemEnv },
+
+  // sms-settings-provider.service.ts
+  { moduleName: "solid-core", key: "smsProvider", value: process.env.COMMON_SMS_PROVIDER, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "smsTemplateSeederFiles", value: process.env.COMMON_SMS_TEMPLATE_SEEDER_FILES, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "shouldQueueSms", value: (process.env.COMMON_SMS_SHOULD_QUEUE ?? 'false') === 'true', level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "msg91SmsUrl", value: process.env.COMMON_MSG91_SMS_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "msg91SmsApiKey", value: process.env.COMMON_MSG91_SMS_API_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "twilioAccountSid", value: process.env.COMMON_TWILIO_ACCOUNT_SID, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "twilioAuthToken", value: process.env.COMMON_TWILIO_AUTH_TOKEN, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "twilioNumber", value: process.env.COMMON_TWILIO_NUMBER, level: SettingLevel.SystemAdminReadonly },
+
+  // tiny-url-settings-provider.service.ts
+  { moduleName: "solid-core", key: "tinyUrlApiUrl", value: process.env.COMMON_SHORT_URL_API_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "tinyUrlApiKey", value: process.env.COMMON_SHORT_URL_API_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "tinyUrlDomain", value: process.env.COMMON_SHORT_URL_DOMAIN, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "tinyUrlEnabled", value: (process.env.COMMON_SHORT_URL_ENABLED ?? 'false') === 'true', level: SettingLevel.SystemAdminReadonly },
+
+  // whatsapp-settings-provider.service.ts
+  { moduleName: "solid-core", key: "whatsappProvider", value: process.env.COMMON_WHATSAPP_PROVIDER, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "msg91WhatsappUrl", value: process.env.COMMON_WHATSAPP_API_URL, level: SettingLevel.SystemAdminReadonly },
+  { moduleName: "solid-core", key: "msg91WhatsappApiKey", value: process.env.COMMON_WHATSAPP_API_KEY, level: SettingLevel.SystemEnv },
+  { moduleName: "solid-core", key: "msg91WhatsappIntegratedNumber", value: process.env.COMMON_WHATSAPP_INTEGRATED_NUMBER, level: SettingLevel.SystemAdminReadonly },
+] as const satisfies SettingDefinition[]);
+
+// 2. 
+export type SolidCoreSetting = ReturnType<typeof getSolidCoreSettings>[number]["key"];
+
+// 3. 
+@SettingsProvider()
+@Injectable()
+export class SolidCoreDefaultSettingsProvider implements ISettingsProvider {
+
+  getSettings() {
+    const isProd = (process.env.ENV as Environment) === Environment.Production;
+    return getSolidCoreSettings(isProd);
+  }
+}