@solidstarters/solid-core 1.2.204 → 1.2.206

package/src/services/file/file-service.interface.ts

@@ -0,0 +1,74 @@
+import { Readable } from 'stream';
+
+export interface WriteOptions {
+  contentType?: string;
+}
+
+export interface CopyOptions {
+  contentType?: string;
+  /** Whether to overwrite existing file (default: true) */
+  overwrite?: boolean;
+}
+
+export interface UrlOptions {
+  /** Expiry time in seconds (relevant for S3 signed URLs) */
+  expiresIn?: number;
+}
+
+/**
+ * Unified interface for file operations.
+ * Implementations: DiskFileService, S3FileService
+ */
+export interface IFileService {
+  /**
+   * Read file contents as Buffer
+   * @param path - File path (disk) or key (S3)
+   */
+  read(path: string): Promise<Buffer>;
+
+  /**
+   * Write data to a file
+   * @param path - File path (disk) or key (S3)
+   * @param data - Content to write
+   * @param options - Optional write options (e.g., contentType for S3)
+   */
+  write(path: string, data: Buffer | string, options?: WriteOptions): Promise<void>;
+
+  /**
+   * Write a stream to a file
+   * @param path - File path (disk) or key (S3)
+   * @param stream - Readable stream
+   * @param options - Optional write options (e.g., contentType for S3)
+   */
+  writeStream(path: string, stream: Readable, options?: WriteOptions): Promise<void>;
+
+  /**
+   * Delete a file
+   * @param path - File path (disk) or key (S3)
+   */
+  delete(path: string): Promise<void>;
+
+  /**
+   * Check if file exists
+   * @param path - File path (disk) or key (S3)
+   */
+  exists(path: string): Promise<boolean>;
+
+  /**
+   * Copy a file from source to destination
+   * @param sourcePath - Source file path
+   * @param destinationPath - Destination file path
+   * @param options - Optional copy options
+   */
+  copy(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;
+
+  /**
+   * Get an accessible URL for the file
+   * For S3: returns signed URL; For disk: returns the file path
+   * @param path - File path (disk) or key (S3)
+   * @param options - URL options (e.g., expiresIn for S3)
+   */
+  getUrl(path: string, options?: UrlOptions): Promise<string>;
+}
+
+export const FILE_SERVICE = Symbol('FILE_SERVICE');

package/src/services/file.service.ts

@@ -3,11 +3,11 @@ import * as fs from 'fs';
 // import * as AWS from 'aws-sdk';
 import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL, GetObjectCommand } from '@aws-sdk/client-s3';
 import { ConfigType } from '@nestjs/config';
-import commonConfig, { AwsS3Config } from '../config/common.config';
 import path from 'path';
 import { Readable } from 'stream';
 import { getSignedUrl as awsGetSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
+import { AwsS3Config } from 'src/interfaces';
 
 @Injectable()
 export class FileService {
@@ -16,16 +16,19 @@ export class FileService {
   private readonly logger = new Logger(FileService.name);
 
   constructor(
-    @Inject(commonConfig.KEY)
-    private readonly commonConfiguration: ConfigType<typeof commonConfig>,
 
   ) {
-    if (!this.isValidS3Config(this.commonConfiguration.awsS3Credentials)) { return }
+    const awsS3Credentials = {
+      S3_AWS_ACCESS_KEY: process.env.S3_AWS_ACCESS_KEY,
+      S3_AWS_SECRET_KEY: process.env.S3_AWS_SECRET_KEY,
+      S3_AWS_REGION_NAME: process.env.S3_AWS_REGION_NAME
+    }
+    if (!this.isValidS3Config(awsS3Credentials)) { return }
     this.s3Client = new S3Client({
-      region: this.commonConfiguration.awsS3Credentials.S3_AWS_REGION_NAME,
+      region: process.env.S3_AWS_REGION_NAME,
       credentials: {
-        accessKeyId: this.commonConfiguration.awsS3Credentials.S3_AWS_ACCESS_KEY,
-        secretAccessKey: this.commonConfiguration.awsS3Credentials.S3_AWS_SECRET_KEY,
+        accessKeyId: process.env.S3_AWS_ACCESS_KEY,
+        secretAccessKey: process.env.S3_AWS_SECRET_KEY,
       },
     });
   }

package/src/services/genai/r2r-helper.service.ts

@@ -1,6 +1,8 @@
 import { Injectable, Logger } from '@nestjs/common';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 import { r2rClient } from 'r2r-js';
+import { SettingService } from '../setting.service';
 
 
 
@@ -8,17 +10,19 @@ import { r2rClient } from 'r2r-js';
 export class R2RHelperService {
     private readonly logger = new Logger(R2RHelperService.name);
 
-    constructor() { }
+    constructor(private readonly settingService: SettingService) { }
 
     async getClient() {
-        this.logger.debug(`Attempting to create RAG client with url: ${process.env.GENAI_RAG_SERVER_URL}`);
-        const client = new r2rClient(process.env.GENAI_RAG_SERVER_URL);
+        const ragServerUrl = this.settingService.getConfigValue<SolidCoreSetting>('ragServerUrl');
+        this.logger.debug(`Attempting to create RAG client with url: ${ragServerUrl}`);
+        const client = new r2rClient(ragServerUrl);
 
+        const ragServerLogin = this.settingService.getConfigValue<SolidCoreSetting>('ragServerLogin');
         // @ts-ignore
-        this.logger.debug(`Attempting to login to our RAG server with user ${process.env.GENAI_RAG_SERVER_LOGIN}`)
+        this.logger.debug(`Attempting to login to our RAG server with user ${ragServerLogin}`)
         await client.users.login({
-            email: process.env.GENAI_RAG_SERVER_LOGIN,
-            password: process.env.GENAI_RAG_SERVER_PASSWORD
+            email: ragServerLogin,
+            password: this.settingService.getConfigValue<SolidCoreSetting>('ragServerPassword')
         });
 
         return client;

package/src/services/import-transaction-error-log.service.ts

@@ -1,14 +1,9 @@
-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 { Injectable } from '@nestjs/common';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { ModuleRef } from "@nestjs/core";
+import { EntityManager } 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 { ImportTransactionErrorLog } from '../entities/import-transaction-error-log.entity';
@@ -17,13 +12,6 @@ import { ImportTransactionErrorLogRepository } from 'src/repository/import-trans
 @Injectable()
 export class ImportTransactionErrorLogService extends CRUDService<ImportTransactionErrorLog>{
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ImportTransactionErrorLog, 'default')
@@ -32,6 +20,6 @@ export class ImportTransactionErrorLogService extends CRUDService<ImportTransact
     readonly moduleRef: ModuleRef
 
  ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'importTransactionErrorLog', 'solid-core', moduleRef);
+   super(entityManager, repo, 'importTransactionErrorLog', 'solid-core', moduleRef);
  }
 }

package/src/services/import-transaction.service.ts

@@ -1,14 +1,9 @@
-import { BadRequestException, ForbiddenException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { BadRequestException, ForbiddenException, Injectable, Logger } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-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 { classify } from '@angular-devkit/core/src/utils/strings';
@@ -94,13 +89,6 @@ interface ImportRecordsResult {
 @Injectable()
 export class ImportTransactionService extends CRUDService<ImportTransaction> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ImportTransaction, 'default')
@@ -114,7 +102,7 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
     private readonly modelMetadataHelperService: ModelMetadataHelperService,
     // readonly fieldMetadataService: FieldMetadataService,
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'importTransaction', 'solid-core', moduleRef);
+    super(entityManager, repo, 'importTransaction', 'solid-core', moduleRef);
   }
 
   private readonly logger = new Logger(ImportTransactionService.name);

package/src/services/list-of-values.service.ts

@@ -1,14 +1,9 @@
-import { forwardRef, Inject, Injectable } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
-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 * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
@@ -24,14 +19,6 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
   // moduleMetadataHelperService: any;
   // listOfValuesMapper: any;
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
-    
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(ListOfValues, 'default')
@@ -42,7 +29,7 @@ export class ListOfValuesService extends CRUDService<ListOfValues> {
     readonly listOfValuesMapper: ListOfValuesMapper,
 
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'listOfValues', 'solid-core', moduleRef);
+    super(entityManager, repo, 'listOfValues', 'solid-core', moduleRef);
   }
   async findOneByValueAndType(lovValue: string, lovType: string) {
     return await this.repo.findOne({

package/src/services/locale.service.ts

@@ -1,28 +1,16 @@
-import { forwardRef, Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager } from 'typeorm';
 
-import { ConfigService } from '@nestjs/config';
 import { Locale } from 'src/entities/locale.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { LocaleRepository } from 'src/repository/locale.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 { RequestContextService } from './request-context.service';
 @Injectable()
 export class LocaleService extends CRUDService<Locale> implements OnApplicationBootstrap{
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
-    readonly configService: ConfigService,
-    readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(Locale, 'default')
@@ -36,7 +24,7 @@ export class LocaleService extends CRUDService<Locale> implements OnApplicationB
     readonly requestContextService: RequestContextService,
     readonly solidRegistry: SolidRegistry,
  ) {
-   super(modelMetadataService, moduleMetadataService,  configService, fileService,  discoveryService, crudHelperService,entityManager, repo, 'locale', 'solid-core', moduleRef);
+   super(entityManager, repo, 'locale', 'solid-core', moduleRef);
  }
   private readonly logger = new Logger(LocaleService.name)
   onApplicationBootstrap() {

package/src/services/mail/elastic-email.service.ts

@@ -1,7 +1,6 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import Handlebars from "handlebars";
-import commonConfig from 'src/config/common.config';
 import { EmailAttachment } from 'src/entities/email-attachment.entity';
 import { QueueMessage } from 'src/interfaces/mq';
 import { EmailTemplateService } from '../email-template.service';
@@ -10,6 +9,8 @@ import { FileService } from '../file.service';
 import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
 import { PublisherFactory } from '../queues/publisher-factory.service';
 import { MailProvider } from 'src/decorators/mail-provider.decorator';
+import { SettingService } from '../setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 const ElasticEmail = require('@elasticemail/elasticemail-client');
 
@@ -20,17 +21,16 @@ export class ElasticEmailService implements IMail {
     private readonly emailsApi;
 
     constructor(
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
         // private readonly emailPublisher: ApiEmailQueuePublisher,
         private readonly publisherFactory: PublisherFactory<any>,
         private readonly emailTemplateService: EmailTemplateService,
         private readonly pdfService: PdfService,
         private readonly fileService: FileService,
+        private readonly settingService: SettingService
     ) {
         const client = ElasticEmail.ApiClient.instance;
         const apikey = client.authentications['apikey'];
-        apikey.apiKey = commonConfiguration.apiMail.key;
+        apikey.apiKey = process.env.COMMON_API_EMAIL_KEY;
         this.emailsApi = new ElasticEmail.EmailsApi();
     }
 
@@ -64,7 +64,7 @@ export class ElasticEmailService implements IMail {
     async sendEmail(to: string, subject: string, body: string, shouldQueueEmails = false, parentEntity = null, parentEntityId = null, wrapperAttachments: MailAttachmentWrapper[] = []): Promise<void> {
         const message = {
             payload: {
-                from: this.commonConfiguration.smtpMail.from,
+                from: this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom"),
                 to: to,
                 subject: subject,
                 body: body,
@@ -79,7 +79,7 @@ export class ElasticEmailService implements IMail {
             this.sendEmailAsynchronously(message);
         }
         // If developer has not, however system config mandates that we send using queue, still we send.
-        else if (shouldQueueEmails == false && this.commonConfiguration.shouldQueueEmails === true) {
+        else if (shouldQueueEmails == false && this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueEmails") === true) {
             this.sendEmailAsynchronously(message);
         }
         // Else we send synch
@@ -88,7 +88,7 @@ export class ElasticEmailService implements IMail {
         }
     }
 
-    async sendEmailAsynchronously(message: QueueMessage<any>) {
+    sendEmailAsynchronously(message: QueueMessage<any>) {
         const { to, subject, body } = message.payload;
         // this.notificationPublisherService.publish(message);
         // this.emailPublisher.publish(message);

package/src/services/mail/smtp-email.service.ts

@@ -1,12 +1,13 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigType } from '@nestjs/config';
 import Handlebars from "handlebars";
-import commonConfig from 'src/config/common.config';
 import { MailProvider } from 'src/decorators/mail-provider.decorator';
 import { QueueMessage } from 'src/interfaces/mq';
 import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
 import { EmailTemplateService } from '../email-template.service';
 import { PublisherFactory } from '../queues/publisher-factory.service';
+import { SettingService } from '../setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 const nodemailer = require("nodemailer");
 
@@ -17,20 +18,27 @@ export class SMTPEMailService implements IMail {
     private readonly transporter: any;
 
     constructor(
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
         // private readonly emailPublisher: EmailQueuePublisher,
         // private readonly emailDbPublisher: EmailQueueDbPublisher,
         private readonly publisherFactory: PublisherFactory<any>,
         private readonly emailTemplateService: EmailTemplateService,
+        private readonly settingService: SettingService
+
     ) {
+
+        const host = process.env.COMMON_SMTP_EMAIL_SMTP_HOST;
+        const port = +(process.env.COMMON_SMTP_EMAIL_SMTP_PORT ?? 587);
+        const username = process.env.COMMON_SMTP_EMAIL_USERNAME;
+        const password = process.env.COMMON_SMTP_EMAIL_PASSWORD;
+        const from = process.env.COMMON_SMTP_EMAIL_FROM ?? process.env.COMMON_EMAIL_FROM;
+
         this.transporter = nodemailer.createTransport({
-            host: this.commonConfiguration.smtpMail.host,
-            port: this.commonConfiguration.smtpMail.port,
-            secure: this.commonConfiguration.smtpMail.port === 465,
+            host: host,
+            port: port,
+            secure: port === 465,
             auth: {
-                user: this.commonConfiguration.smtpMail.username,
-                pass: this.commonConfiguration.smtpMail.password
+                user: username,
+                pass: password
             }
         });
     }
@@ -81,7 +89,7 @@ export class SMTPEMailService implements IMail {
     ) {
         const message = {
             payload: {
-                from: from || this.commonConfiguration.smtpMail.from,
+                from: from || this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom"),
                 to: to,
                 subject: subject,
                 body: body,
@@ -98,7 +106,7 @@ export class SMTPEMailService implements IMail {
             return this.sendEmailAsynchronously(message);
         }
         // If developer has not, however system config mandates that we send using queue, still we send.
-        else if (shouldQueueEmails == false && this.commonConfiguration.shouldQueueEmails === true) {
+        else if (shouldQueueEmails == false && this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueEmails") === true) {
             return this.sendEmailAsynchronously(message);
         }
         // Else we send synchronously
@@ -117,7 +125,7 @@ export class SMTPEMailService implements IMail {
         let from;
         const { to, subject, body, attachments = [], cc, bcc } = message.payload;
 
-        const envFrom = this.commonConfiguration.smtpMail.from;
+        const envFrom = this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom");
         if (envFrom) {
             from = envFrom;
         }

package/src/services/media-storage-provider-metadata.service.ts

@@ -16,6 +16,10 @@ export class MediaStorageProviderMetadataService {
         private readonly crudHelperService: CrudHelperService
     ) { }
 
+    async find(basicFilterDto: BasicFilterDto) {
+        return this.findMany(basicFilterDto);
+    }
+
     async findMany(basicFilterDto: BasicFilterDto) {
         const alias = 'mediaStorageProviderMetadata';
         // Extract the required keys from the input query

package/src/services/media.service.ts

@@ -1,14 +1,12 @@
 import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
-import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager, In } from 'typeorm';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 import { ConfigService } from '@nestjs/config';
-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 { ERROR_MESSAGES } from 'src/constants/error-messages';
@@ -25,13 +23,8 @@ import { getMediaStorageProvider } from "./mediaStorageProviders";
 @Injectable()
 export class MediaService extends CRUDService<Media> {
   constructor(
-    @Inject(forwardRef(() => ModelMetadataService))
-    readonly modelMetadataService: ModelMetadataService,
-    readonly moduleMetadataService: ModuleMetadataService,
     readonly configService: ConfigService,
     readonly fileService: FileService,
-    readonly discoveryService: DiscoveryService,
-    readonly crudHelperService: CrudHelperService,
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(Media, 'default')
@@ -49,15 +42,16 @@ export class MediaService extends CRUDService<Media> {
     private readonly fieldMetadataRepo: FieldMetadataRepository,
     readonly moduleRef: ModuleRef,
   ) {
-    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'media', 'solid-core', moduleRef);
+    super(entityManager, repo, 'media', 'solid-core', moduleRef);
   }
 
   async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
     const data = await super.find(basicFilterDto, solidRequestContext);
     if (data.records) {
-      data.records.forEach((media: Media) => {
+
+      for (const media of data.records) {
         if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-          media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+          media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
         } else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
           media.relativeUri = this.getAwsS3FullFilePath(
             media.relativeUri,
@@ -65,19 +59,42 @@ export class MediaService extends CRUDService<Media> {
             media.mediaStorageProviderMetadata.region
           );
         }
-      });
+      }
+      // data.records.forEach((media: Media) => {
+      //       if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
+      //   media.relativeUri = `${process.env.BASE_URL}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
+      // } else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
+      //   media.relativeUri = this.getAwsS3FullFilePath(
+      //     media.relativeUri,
+      //     media.mediaStorageProviderMetadata.bucketName,
+      //     media.mediaStorageProviderMetadata.region
+      //   );
+      // }
+      // });
     }
     if (data.groupRecords) {
-      data.groupRecords.forEach((group) => {
-        group.groupData.records.forEach((media) => {
+
+      for (const group of data.groupRecords) {
+        for (const media of group.groupData.records) {
           if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-            media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+            media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
           }
           else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
             media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
           }
-        });
-      });
+        }
+      }
+
+      // data.groupRecords.forEach((group) => {
+      //   group.groupData.records.forEach((media) => {
+      //     if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
+      //       media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
+      //     }
+      //     else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
+      //       media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
+      //     }
+      //   });
+      // });
     }
     return data
   }
@@ -111,7 +128,7 @@ export class MediaService extends CRUDService<Media> {
 
       switch (createDto.mediaStorageProviderMetadata.type) {
         case MediaStorageProviderType.Filesystem:
-          const fileStoragePath = this.getFileSysytemFullFilePath(this.getFileName(file));
+          const fileStoragePath = await this.getFileSysytemFullFilePath(this.getFileName(file));
           await this.fileService.copyFile(file.path, fileStoragePath);
           createDto['relativeUri'] = this.getFileName(file);
           break;
@@ -171,11 +188,11 @@ export class MediaService extends CRUDService<Media> {
   }
   //TODO: Move this to a app builder config
 
-  private getFileSysytemFullFilePath(fileName: string): string {
-    return `${this.configService.get('app-builder.fileStorageDir')}/${fileName}`;
+  private async getFileSysytemFullFilePath(fileName: string): Promise<string> {
+    const fileStorageDir = this.settingService.getConfigValue<SolidCoreSetting>("fileStorageDir");
+    return `${fileStorageDir}/${fileName}`;
   }
 
-
   private getAwsS3FullFilePath(awsMediaurl: string, bucketName: string, regionName: string): string {
     // https://lunarismedia.s3.ap-south-1.amazonaws.com/LUNARIS_CP_REGISTRATION_CREATIVE.jpg
     return `https://${bucketName}.s3.${regionName}.amazonaws.com/${awsMediaurl}`;

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

@@ -9,7 +9,6 @@ import { MediaStorageProvider } from "src/interfaces";
 import { FileService } from "src/services/file.service";
 import { Readable } from "stream";
 import { MediaRepository } from "src/repository/media.repository";
-import commonConfig from "src/config/common.config";
 
 @Injectable()
 export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
@@ -21,8 +20,6 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
         private readonly configService: ConfigService,
         readonly fileService: FileService,
         readonly mediaRepository: MediaRepository,
-        @Inject(commonConfig.KEY)
-        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
     ) { }
 
     storeStreams(streamPairs: [Readable, string][], entity: T, mediaFieldMetadata: FieldMetadata): Promise<Media[]> {