@solidxai/core 0.1.2 → 0.1.5-beta.0

package/src/services/chatter-message.service.ts

@@ -18,9 +18,12 @@ import { ChatterMessageDetails } from '../entities/chatter-message-details.entit
 import { ChatterMessage } from '../entities/chatter-message.entity';
 import { getMediaStorageProvider } from './mediaStorageProviders';
 import { RequestContextService } from './request-context.service';
-import { take } from 'rxjs';
+import { Logger } from '@nestjs/common';
+
 @Injectable()
 export class ChatterMessageService extends CRUDService<ChatterMessage> {
+    private readonly _logger = new Logger(ChatterMessageService.name);
+
     constructor(
         @InjectEntityManager()
         readonly entityManager: EntityManager,
@@ -502,16 +505,23 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return populatedEntity;
     }
 
+    private logHeapUsed(label: string) {
+        const mb = () => Math.round(process.memoryUsage().heapUsed / 1024 / 1024);
+        this._logger.log(`heapUsedMB(${label}): ${mb()}`);
+    }
+
     // [2026-02-05T23:31:21.025Z] INFO: [200 OK] 
     // GET /api/chatter-message/getChatterMessages/216/mswipeBoomboxBulkUpload?populateMedia[0]=messageAttachments&populate[0]=user&populate[1]=chatterMessageDetails&limit=25 22747ms
     async getChatterMessages(entityId: number, entityName: string, query: any) {
         const { limit = 25, offset = 0, populate = [], populateMedia = [], filters } = query;
+        this.logHeapUsed('getChatterMessages-start');
 
         const model = await this.modelMetadataRepo.findOne({
             where: {
                 singularName: entityName
             },
         });
+        this.logHeapUsed('getChatterMessages-modelLoaded');
         const oneToManyFields = await this.fieldMetadataRepo.find({
             where: {
                 model: { id: model.id },
@@ -519,11 +529,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                 relationType: 'one-to-many'
             }
         });
+        this.logHeapUsed('getChatterMessages-oneToManyFieldsLoaded');
 
         const relatedEntitiesMap = new Map<string, number[]>();
 
         for (const field of oneToManyFields) {
             if (field.enableAuditTracking === false) {
+                this._logger.log(`Skipping field ${field.name} for chatter message retrieval because audit tracking is disabled`);
                 continue
             }
             const coModelName = field.relationCoModelSingularName;
@@ -552,8 +564,10 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
                 relatedEntitiesMap.set(field.name, relatedIds);
             }
         }
+        this.logHeapUsed('getChatterMessages-relatedEntitiesLoaded');
 
         const qb = await this.repo.createSecurityRuleAwareQueryBuilder('entity');
+        this.logHeapUsed('getChatterMessages-queryBuilderReady');
 
         const orConditions: string[] = [];
         const parameters: any = {};
@@ -602,10 +616,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         qb.skip(offset).take(limit);
 
         const [entities, count] = await qb.getManyAndCount();
+        this.logHeapUsed('getChatterMessages-entitiesLoaded');
 
         if (populateMedia && populateMedia.length > 0) {
             const normalizedPopulateMedia = this.crudHelperService.normalize(populateMedia);
+            this.logHeapUsed('getChatterMessages-beforePopulateMedia');
             await this['handlePopulateMedia'](normalizedPopulateMedia, entities);
+            this.logHeapUsed('getChatterMessages-afterPopulateMedia');
         }
 
         const currentPage = Math.floor(offset / limit) + 1;

package/src/services/crud-helper.service.ts

@@ -3,7 +3,7 @@ import { BasicFilterDto } from "../dtos/basic-filters.dto";
 import { classify } from "@angular-devkit/core/src/utils/strings";
 import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { SolidRegistry } from "src/helpers/solid-registry";
-import { Logger } from "@nestjs/common";
+import { BadRequestException, Logger } from "@nestjs/common";
 import { ERROR_MESSAGES } from "src/constants/error-messages";
 
 export enum FilterCombinator {
@@ -64,88 +64,102 @@ export class CrudHelperService {
                 const primaryFilterObj = normalizedFilters[key];
                 const normalizedPrimaryFilterObj = this.normalizeObjectKeys(primaryFilterObj);
 
+                const [rawField, funcAlias] = key.split(':');
+
                 // Get the operator or field from the key
                 const operatorOrField = Object.keys(normalizedPrimaryFilterObj)[0];
                 // if the key is an operator, then build the query based on the operator
                 if (operatorOrField.startsWith('$')) {
                     const operator = operatorOrField;
-                    this.buildOperatorQuery(qb, alias, key, normalizedPrimaryFilterObj, operator);
+                    let columnExpression: string | undefined;
+                    if (funcAlias) {
+                        try {
+                            columnExpression = this.buildDateGranularityExpression(this.getDriver(selectQb), `${alias}.${rawField}`, funcAlias);
+                        } catch {
+                            throw new BadRequestException(`Unsupported field function '${funcAlias}'. Supported functions are: day, week, month, year.`);
+                        }
+                    }
+                    this.buildOperatorQuery(qb, alias, rawField, normalizedPrimaryFilterObj, operator, columnExpression);
                     return;
                 }
                 else { // Recursively call the applyFilters method to handle nested conditions
-                    const joinField = `${alias}.${key}`;
-                    if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, key);
-                    this.applyFilters(qb, primaryFilterObj, key, selectQb);
+                    if (funcAlias) {
+                        throw new BadRequestException(`Function alias ':${funcAlias}' is not valid on relation field '${rawField}'. It can only be applied to scalar fields.`);
+                    }
+                    const joinField = `${alias}.${rawField}`;
+                    if (!this.isRelationJoined(selectQb, joinField)) selectQb.leftJoin(joinField, rawField);
+                    this.applyFilters(qb, primaryFilterObj, rawField, selectQb);
                 }
             });
         }
     }
 
-    private buildOperatorQuery(qb: any, alias: string, field: string, normalizedPrimaryOperatorObj: any, operator: string) {
+    private buildOperatorQuery(qb: any, alias: string, field: string, normalizedPrimaryOperatorObj: any, operator: string, columnExpression?: string) {
         const uniqueFieldAlias = `${alias}_${field}_${Math.floor(Math.random() * 1000)}`;
+        const colExpr = columnExpression ?? `${alias}.${field}`;
         switch (operator) {
             case '$eq':
-                qb.andWhere(`${alias}.${field} = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eq });
+                qb.andWhere(`${colExpr} = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eq });
                 break;
             case '$eqi':
-                qb.andWhere(`LOWER(${alias}.${field}) = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eqi.toLowerCase() });
+                qb.andWhere(`LOWER(${colExpr}) = :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$eqi.toLowerCase() });
                 break;
             case '$ne':
-                qb.andWhere(`${alias}.${field} != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$ne });
+                qb.andWhere(`${colExpr} != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$ne });
                 break;
             case '$nei':
-                qb.andWhere(`LOWER(${alias}.${field}) != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$nei.toLowerCase() });
+                qb.andWhere(`LOWER(${colExpr}) != :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$nei.toLowerCase() });
                 break;
             case '$gt':
-                qb.andWhere(`${alias}.${field} > :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$gt });
+                qb.andWhere(`${colExpr} > :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$gt });
                 break;
             case '$gte':
-                qb.andWhere(`${alias}.${field} >= :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$gte });
+                qb.andWhere(`${colExpr} >= :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$gte });
                 break;
             case '$lt':
-                qb.andWhere(`${alias}.${field} < :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$lt });
+                qb.andWhere(`${colExpr} < :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$lt });
                 break;
             case '$lte':
-                qb.andWhere(`${alias}.${field} <= :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$lte });
+                qb.andWhere(`${colExpr} <= :${uniqueFieldAlias}`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$lte });
                 break;
             case '$in':
-                qb.andWhere(`${alias}.${field} IN (:...${uniqueFieldAlias})`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$in });
+                qb.andWhere(`${colExpr} IN (:...${uniqueFieldAlias})`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$in });
                 break;
             case '$notIn':
-                qb.andWhere(`${alias}.${field} NOT IN (:...${uniqueFieldAlias})`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$notIn });
+                qb.andWhere(`${colExpr} NOT IN (:...${uniqueFieldAlias})`, { [uniqueFieldAlias]: normalizedPrimaryOperatorObj.$notIn });
                 break;
             case '$contains':
-                qb.andWhere(`${alias}.${field} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$contains}%` });
+                qb.andWhere(`${colExpr} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$contains}%` });
                 break;
             case '$notContains':
-                qb.andWhere(`${alias}.${field} NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContains}%` });
+                qb.andWhere(`${colExpr} NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContains}%` });
                 break;
             case '$containsi':
-                qb.andWhere(`LOWER(${alias}.${field}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$containsi.toLowerCase()}%` });
+                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$containsi.toLowerCase()}%` });
                 break;
             case '$notContainsi':
-                qb.andWhere(`LOWER(${alias}.${field}) NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContainsi.toLowerCase()}%` });
+                qb.andWhere(`LOWER(${colExpr}) NOT LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$notContainsi.toLowerCase()}%` });
                 break;
             case '$null':
-                qb.andWhere(`${alias}.${field} IS NULL`);
+                qb.andWhere(`${colExpr} IS NULL`);
                 break;
             case '$notNull':
-                qb.andWhere(`${alias}.${field} IS NOT NULL`);
+                qb.andWhere(`${colExpr} IS NOT NULL`);
                 break;
             case '$between':
-                qb.andWhere(`${alias}.${field} BETWEEN :${uniqueFieldAlias}0 AND :${uniqueFieldAlias}1`, { [`${uniqueFieldAlias}0`]: normalizedPrimaryOperatorObj.$between[0], [`${uniqueFieldAlias}1`]: normalizedPrimaryOperatorObj.$between[1] });
+                qb.andWhere(`${colExpr} BETWEEN :${uniqueFieldAlias}0 AND :${uniqueFieldAlias}1`, { [`${uniqueFieldAlias}0`]: normalizedPrimaryOperatorObj.$between[0], [`${uniqueFieldAlias}1`]: normalizedPrimaryOperatorObj.$between[1] });
                 break;
             case '$startsWith':
-                qb.andWhere(`${alias}.${field} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWith}%` });
+                qb.andWhere(`${colExpr} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWith}%` });
                 break;
             case '$startsWithi':
-                qb.andWhere(`LOWER(${alias}.${field}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWithi.toLowerCase()}%` });
+                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `${normalizedPrimaryOperatorObj.$startsWithi.toLowerCase()}%` });
                 break;
             case '$endsWith':
-                qb.andWhere(`${alias}.${field} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWith}` });
+                qb.andWhere(`${colExpr} LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWith}` });
                 break;
             case '$endsWithi':
-                qb.andWhere(`LOWER(${alias}.${field}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWithi.toLowerCase()}` });
+                qb.andWhere(`LOWER(${colExpr}) LIKE :${uniqueFieldAlias}`, { [uniqueFieldAlias]: `%${normalizedPrimaryOperatorObj.$endsWithi.toLowerCase()}` });
                 break;
             default:
                 throw new Error(`Operator ${operator} is not supported`);
@@ -588,6 +602,27 @@ export class CrudHelperService {
         }
     }
 
+    private getGroupFieldValues(
+        group: any,
+        groupByFields: string[],
+        groupAliasMap: Record<string, string>
+    ): Array<{ rawVal: any; alias: string; granularity?: string }> {
+        return groupByFields
+            .map(field => {
+                const parts = field.split(':');
+                const granularity = parts[1];
+                const alias = groupAliasMap[field] ?? this.sanitizeAlias(field.replace(/\./g, '_'));
+                const rawVal = group[alias] ?? group[field] ?? group[field.replace(/\./g, '_')];
+                return { rawVal, alias, granularity };
+            })
+            .filter(({ rawVal }) => rawVal !== undefined && rawVal !== null);
+    }
+
+    private normalizeGroupValue(value: any, granularity?: string): any {
+        if (!granularity) return value;
+        return this.formatGroupValue(value, 'YYYY-MM-DD');
+    }
+
     getGroupName(
         group: any,
         aggregateAliases: Set<string>,
@@ -595,22 +630,28 @@ export class CrudHelperService {
         groupAliasMap: Record<string, string>,
         groupFormatMap: Record<string, string | undefined>
     ): string {
-        const orderedValues = groupByFields
-            .map(field => {
-                const alias = groupAliasMap[field] ?? this.sanitizeAlias(field.replace(/\./g, '_'));
-                const rawVal = group[alias] ?? group[field] ?? group[field.replace(/\./g, '_')];
-                return this.formatGroupValue(rawVal, groupFormatMap[alias]);
-            })
-            .filter(v => v !== undefined && v !== null);
+        const fieldValues = this.getGroupFieldValues(group, groupByFields, groupAliasMap);
 
-        if (orderedValues.length === 0) {
+        if (fieldValues.length === 0) {
             return Object.keys(group)
                 .filter(key => !this.isAggregateFieldKey(key, aggregateAliases))
                 .map(key => group[key])
                 .join('_');
         }
 
-        return orderedValues.join('_');
+        return fieldValues
+            .map(({ rawVal, alias }) => this.formatGroupValue(rawVal, groupFormatMap[alias]))
+            .join('_');
+    }
+
+    getGroupValue(  
+        group: any,
+        groupByFields: string[],
+        groupAliasMap: Record<string, string>
+    ): any {
+        const fieldValues = this.getGroupFieldValues(group, groupByFields, groupAliasMap);
+        if (fieldValues.length === 1) return this.normalizeGroupValue(fieldValues[0].rawVal, fieldValues[0].granularity);
+        return fieldValues.map(({ rawVal, granularity }) => this.normalizeGroupValue(rawVal, granularity)).join('_');
     }
 
     createGroupRecords(group: any, aggregateAliases: Set<string>, groupData: any, groupByFields: string[], groupAliasMap: Record<string, string>, groupFormatMap: Record<string, string | undefined>) {
@@ -622,6 +663,7 @@ export class CrudHelperService {
     }
     createGroupMeta(group: any, aggregateAliases: Set<string>, groupByFields: string[], groupAliasMap: Record<string, string>, groupFormatMap: Record<string, string | undefined>) {
         const groupName = this.getGroupName(group, aggregateAliases, groupByFields, groupAliasMap, groupFormatMap);
+        const groupValue = this.getGroupValue(group, groupByFields, groupAliasMap);
         const groupAggregateValues = {}
         for (const key in group) {
             if (group.hasOwnProperty(key) && this.isAggregateFieldKey(key, aggregateAliases)) {
@@ -631,6 +673,7 @@ export class CrudHelperService {
         }
         return {
             groupName,
+            groupValue,
             ...groupAggregateValues
         };
     }

package/src/services/crud.service.ts

@@ -67,6 +67,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
     protected get discoveryService(): DiscoveryService {
         return this._discoveryService ??= this.moduleRef.get(DiscoveryService, { strict: false });
     }
+
     protected get settingService(): SettingService {
         return this._settingService ??= this.moduleRef.get(SettingService, { strict: false });
     }
@@ -128,8 +129,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         });
     }
 
-    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
-        const fieldManager: FieldCrudManager = await this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate);
+    private async validateAndTransformDto(field: FieldMetadata, dto: any, files: Express.Multer.File[], hasMediaFields: boolean, isPartialUpdate: boolean = false, isUpdate: boolean = false, entityId?: number) {
+        const fieldManager: FieldCrudManager = await this.fieldCrudManager(field, this.entityManager, isPartialUpdate, isUpdate, entityId);
         const validationErrors = fieldManager.validate(dto, files);
         const errors = (validationErrors instanceof Promise) ? await validationErrors : validationErrors;
         if (errors.length > 0) {
@@ -210,7 +211,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         // 2. Loop through the fields with a switch statement
         // 3. Handle the fields based on field type
         for (const field of fieldsToProcess) {
-            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate, isUpdate);
+            const transformed = await this.validateAndTransformDto(field, updateDto, files, hasMediaFields, isPartialUpdate, isUpdate, id);
             updateDto = transformed.dto;
             hasMediaFields = transformed.hasMediaFields;
         }
@@ -220,6 +221,8 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         const mergedEntity = this.repo.merge(entity, updateDto);
         const savedEntity = await this.repo.save(mergedEntity) as T;
 
+        //FIXME: Skip the many-to-many, and instead fire differential updates and avoid loading the entire association graph for the ids
+
         // 6. Save the media
         if (hasMediaFields) {
             await this.saveMedia(model, files, savedEntity);
@@ -286,7 +289,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
         }
     }
 
-    private async fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false) {
+    private async fieldCrudManager(fieldMetadata: FieldMetadata, entityManager: EntityManager, isPartialUpdate: boolean = false, isUpdate: boolean = false, entityId?: number) {
         const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate };
         switch (fieldMetadata.type) {
             case SolidFieldType.shortText: {
@@ -377,6 +380,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                         entityManager,
                         inverseFieldName: fieldMetadata.relationCoModelFieldName,
                         inverseRelationCoModelFieldName: fieldMetadata.name,
+                        entityId,
                     }
                     return new OneToManyRelationFieldCrudManager(oneToManyOptions);
                 }
@@ -389,6 +393,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                             isInverseSide: false,
                             entityManager,
                             fieldName: fieldMetadata.name,
+                            entityId,
                         }
                         return new ManyToManyRelationFieldCrudManager(manyToManyOptions);
                     }
@@ -401,6 +406,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                             entityManager,
                             fieldName: fieldMetadata.relationCoModelFieldName,
                             relationCoModelFieldName: fieldMetadata.name,
+                            entityId,
                         }
                         return new ManyToManyRelationFieldCrudManager(inverseManyToManyOptions);
                     }

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

@@ -1290,77 +1290,6 @@ export class FieldMetadataService implements OnApplicationBootstrap {
         return fieldObject;
     }
 
-    // async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
-
-    //     const { modelName, fieldName, fieldValue, s3KeyFieldName } = resolveS3UrlDto;
-
-    //     // ------------------------------------------------
-    //     // 1. Load model metadata
-    //     // ------------------------------------------------
-    //     const modelRepo = this.dataSource.getRepository(ModelMetadata);
-    //     const model = await modelRepo.findOne({
-    //         where: { singularName: modelName },
-    //         relations: ['fields']
-    //     });
-
-    //     if (!model) {
-    //         throw new NotFoundException(`Model ${modelName} not found`);
-    //     }
-
-    //     // ------------------------------------------------
-    //     // 2. Validate the field we are filtering by
-    //     // ------------------------------------------------
-    //     const filterFieldMeta = model.fields.find(f => f.name === fieldName);
-    //     if (!filterFieldMeta) {
-    //         throw new NotFoundException(
-    //             `Field ${fieldName} not found in model ${modelName}`
-    //         );
-    //     }
-
-    //     // ------------------------------------------------
-    //     // 3. Load the actual entity repository
-    //     // ------------------------------------------------
-    //     const entityRepo = this.dataSource.getRepository(model.singularName);
-
-    //     // ------------------------------------------------
-    //     // 4. Query using fieldName = fieldValue
-    //     // ------------------------------------------------
-    //     const record = await entityRepo.findOne({
-    //         where: { [fieldName]: fieldValue }
-    //     });
-
-    //     if (!record) {
-    //         throw new NotFoundException(
-    //             `${modelName} record not found for ${fieldName}="${fieldValue}"`
-    //         );
-    //     }
-
-    //     // ------------------------------------------------
-    //     // 5. Extract S3 key from s3KeyFieldName
-    //     // ------------------------------------------------
-    //     const s3Key = record[s3KeyFieldName];
-
-    //     if (!s3Key) {
-    //         throw new NotFoundException(
-    //             `Field "${s3KeyFieldName}" has no value in ${modelName}.${fieldName}="${fieldValue}"`
-    //         );
-    //     }
-
-    //     // ------------------------------------------------
-    //     // 6. Generate signed or public URL
-    //     // ------------------------------------------------
-    //     let url = "";
-
-    //     // TODO  - get 
-    //     if (resolveS3UrlDto.isPrivate == "true") {
-    //         const expiryInSeconds = 60 * 60;
-    //         url = await this.fileService.getSignedUrl(s3Key, expiryInSeconds, resolveS3UrlDto.bucketName);
-    //     } else {
-    //         url = `https://${resolveS3UrlDto.bucketName}.s3.${this.configService.get('S3_AWS_REGION_NAME')}.amazonaws.com/${s3Key}`;
-    //     }
-    //     return { url: url }
-    // }
-
     async resolveS3Url(resolveS3UrlDto: ResolveS3UrlDto) {
         let url = "";
         const normalizedKey = this.normalizeS3Key(resolveS3UrlDto.s3Key);

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

@@ -9,25 +9,17 @@ import { IFileService, WriteOptions, CopyOptions, UrlOptions } from './file-serv
 /**
  * Disk-based implementation of IFileService.
  * Handles file operations on the local filesystem.
+ * Callers are responsible for providing complete paths (use DiskStoragePathBuilder for primary storage paths).
  */
 @Injectable()
 export class DiskFileService implements IFileService {
   private readonly logger = new Logger(DiskFileService.name);
-  private readonly fileStorageDir: string;
   private readonly baseUrl: string;
 
   constructor() {
-    this.fileStorageDir = process.env.AB_MEDIA_FILE_STORAGE_DIR || 'uploads';
     this.baseUrl = process.env.BASE_URL || '';
   }
 
-  private resolvePath(filePath: string): string {
-    if (path.isAbsolute(filePath)) {
-      return filePath;
-    }
-    return `${this.fileStorageDir}/${filePath}`;
-  }
-
   /**
    * Read file contents as Buffer
    */
@@ -50,10 +42,9 @@ export class DiskFileService implements IFileService {
    * @returns Public URL of the written file
    */
   async write(filePath: string, data: Buffer | string, options?: WriteOptions): Promise<string> {
-    const resolvedPath = this.resolvePath(filePath);
-    await this.ensureDirectoryExists(resolvedPath);
-    await fsPromises.writeFile(resolvedPath, data);
-    return `${this.baseUrl}/${resolvedPath}`;
+    await this.ensureDirectoryExists(filePath);
+    await fsPromises.writeFile(filePath, data);
+    return `${this.baseUrl}/${filePath}`;
   }
 
   /**
@@ -62,12 +53,11 @@ export class DiskFileService implements IFileService {
    * @returns Public URL of the written file
    */
   async writeStream(filePath: string, stream: Readable, options?: WriteOptions): Promise<string> {
-    const resolvedPath = this.resolvePath(filePath);
-    await this.ensureDirectoryExists(resolvedPath);
-    const writeStream = fs.createWriteStream(resolvedPath);
+    await this.ensureDirectoryExists(filePath);
+    const writeStream = fs.createWriteStream(filePath);
     await pipeline(stream, writeStream);
-    this.logger.debug(`File saved via stream: ${resolvedPath}`);
-    return `${this.baseUrl}/${resolvedPath}`;
+    this.logger.debug(`File saved via stream: ${filePath}`);
+    return `${this.baseUrl}/${filePath}`;
   }
 
   /**

package/src/services/file/index.ts

@@ -2,3 +2,4 @@ export * from './file-service.interface';
 export * from './disk-file.service';
 export * from './s3-file.service';
 export * from './file-service.factory';
+export * from './storage-path-builder';

package/src/services/file/storage-path-builder.ts

@@ -0,0 +1,56 @@
+import { Injectable, Provider } from '@nestjs/common';
+import * as path from 'path';
+import { DEFAULT_MEDIA_FILE_STORAGE_DIR } from '../settings/default-settings-provider.service';
+
+export const FILE_STORAGE_PATH_BUILDER = Symbol('FILE_STORAGE_PATH_BUILDER');
+
+export interface IStoragePathBuilder {
+  build(fileName: string): string;
+}
+
+@Injectable()
+export class DiskStoragePathBuilder implements IStoragePathBuilder {
+  private readonly base: string;
+
+  constructor() {
+    this.base = process.env.AB_MEDIA_FILE_STORAGE_DIR || DEFAULT_MEDIA_FILE_STORAGE_DIR;
+  }
+
+  build(fileName: string): string {
+    if (path.isAbsolute(fileName) || fileName.startsWith(`${this.base}/`)) {
+      return fileName;
+    }
+    return `${this.base}/${fileName}`;
+  }
+}
+
+@Injectable()
+export class S3StoragePathBuilder implements IStoragePathBuilder {
+  private readonly bucket: string;
+
+  constructor() {
+    this.bucket = process.env.S3_DEFAULT_BUCKET ?? '';
+  }
+
+  build(fileName: string): string {
+    if (fileName.includes(':')) {
+      return fileName;
+    }
+    return `${this.bucket}:${fileName}`;
+  }
+}
+
+export const StoragePathBuilderFactory: Provider = {
+  provide: FILE_STORAGE_PATH_BUILDER,
+  useFactory: (disk: DiskStoragePathBuilder, s3: S3StoragePathBuilder): IStoragePathBuilder => {
+    const defaultService = process.env.DEFAULT_FILE_SERVICE ?? 'disk';
+    switch (defaultService.toLowerCase()) {
+      case 's3':
+        return s3;
+      case 'disk':
+      default:
+        return disk;
+    }
+  },
+  inject: [DiskStoragePathBuilder, S3StoragePathBuilder],
+};

package/src/services/media.service.ts

@@ -2,6 +2,8 @@ import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/commo
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { EntityManager, In } from 'typeorm';
+import * as path from 'path';
+import { DEFAULT_MEDIA_FILE_STORAGE_DIR } from "src/services/settings/default-settings-provider.service";
 import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
 
 import { ConfigService } from '@nestjs/config';
@@ -52,7 +54,7 @@ export class MediaService extends CRUDService<Media> {
 
       for (const media of data.records) {
         if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-          media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
+          media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${this.getFullFilePathForDisk(media.relativeUri)}`;
         } else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
           media.relativeUri = this.getAwsS3FullFilePath(
             media.relativeUri,
@@ -63,7 +65,7 @@ export class MediaService extends CRUDService<Media> {
       }
       // data.records.forEach((media: Media) => {
       //       if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-      //   media.relativeUri = `${process.env.BASE_URL}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
+      //   media.relativeUri = `${process.env.BASE_URL}/${this.getFileSysytemFullFilePath(media.relativeUri)}`;
       // } else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
       //   media.relativeUri = this.getAwsS3FullFilePath(
       //     media.relativeUri,
@@ -78,7 +80,7 @@ export class MediaService extends CRUDService<Media> {
       for (const group of data.groupRecords) {
         for (const media of group.groupData.records) {
           if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.Filesystem) {
-            media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${await this.getFileSysytemFullFilePath(media.relativeUri)}`;
+            media.relativeUri = `${this.settingService.getConfigValue<SolidCoreSetting>("baseUrl")}/${this.getFullFilePathForDisk(media.relativeUri)}`;
           }
           else if (media.mediaStorageProviderMetadata?.type === MediaStorageProviderType.AwsS3) {
             media.relativeUri = this.getAwsS3FullFilePath(media.relativeUri, media.mediaStorageProviderMetadata.bucketName, media.mediaStorageProviderMetadata.region);
@@ -129,7 +131,7 @@ export class MediaService extends CRUDService<Media> {
 
       switch (createDto.mediaStorageProviderMetadata.type) {
         case MediaStorageProviderType.Filesystem:
-          const fileStoragePath = await this.getFileSysytemFullFilePath(this.getFileName(file));
+          const fileStoragePath = this.getFullFilePathForDisk(this.getFileName(file));
           await this.diskFileService.copy(file.path, fileStoragePath);
           createDto['relativeUri'] = this.getFileName(file);
           break;
@@ -189,9 +191,13 @@ export class MediaService extends CRUDService<Media> {
   }
   //TODO: Move this to a app builder config
 
-  private async getFileSysytemFullFilePath(fileName: string): Promise<string> {
-    const fileStorageDir = this.settingService.getConfigValue<SolidCoreSetting>("fileStorageDir");
-    return `${fileStorageDir}/${fileName}`;
+  private getFullFilePathForDisk(fileName: string): string {
+    const base = this.settingService.getConfigValue<SolidCoreSetting>("fileStorageDir")
+      || DEFAULT_MEDIA_FILE_STORAGE_DIR;
+    if (path.isAbsolute(fileName) || fileName.startsWith(`${base}/`)) {
+      return fileName;
+    }
+    return `${base}/${fileName}`;
   }
 
   private getAwsS3FullFilePath(awsMediaurl: string, bucketName: string, regionName: string): string {

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

@@ -43,7 +43,7 @@ export class FileS3StorageProvider<T> implements MediaStorageProvider<T> {
             const region = this.getEffectiveRegion(storageMeta.region);
             if (storageMeta.isPublic === false) {
                 // Generate signed URL
-                const expiryInSeconds = (storageMeta.signedUrlExpiry ?? 60) * 60; // default 5 min
+                const expiryInSeconds = (storageMeta.signedUrlExpiry ?? 60) * 60;
                 m['_full_url'] = await this.s3FileService.getUrl(`${storageMeta?.bucketName}:${m.relativeUri}`, { expiresIn: expiryInSeconds, region });
             } else {
                 // Public S3 or local filesystem: use normal URL