@flusys/nestjs-storage 1.1.0-beta → 2.0.0

package/fesm/services/file-manager.service.js

@@ -25,168 +25,134 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter, ErrorHandler } from '@flusys/nestjs-shared/utils';
 import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
 import { Brackets, In } from 'typeorm';
-import { StorageConfigService } from '../config';
+import { StorageConfigService } from './storage-config.service';
 import { FileManager, FileManagerWithCompany, Folder, FolderWithCompany } from '../entities';
 import { FileLocationEnum } from '../enums/file-location.enum';
 import { StorageDataSourceProvider } from './storage-datasource.provider';
 import { UploadService } from './upload.service';
-// Storage-specific constants
-const USER_ACTION_PERMISSION_CACHE_KEY = 'user_action_permission';
-const SHOW_PRIVATE_FILE_ACTION = 'storage.file.viewPrivate';
+const PERMISSION_CACHE_KEY = 'user_action_permission';
+const VIEW_PRIVATE_ACTION = 'storage.file.viewPrivate';
+const URL_EXPIRY_SECONDS = 3600;
+const DEFAULT_SELECT_FIELDS = [
+    'id',
+    'name',
+    'contentType',
+    'size',
+    'key',
+    'url',
+    'location',
+    'storageConfigId',
+    'isPrivate',
+    'createdAt',
+    'deletedAt'
+];
 export class FileManagerService extends RequestScopedApiService {
-    /**
-   * Get base URL for file serving
-   * Priority: appUrl config > request headers
-   */ getFileBaseUrl(protocol, host) {
-        const appUrl = this.storageConfig.getAppUrl();
-        return appUrl?.replace(/\/$/, '') ?? `${protocol}://${host}`;
+    resolveEntity() {
+        return this.storageConfig.isCompanyFeatureEnabled() ? FileManagerWithCompany : FileManager;
     }
-    /**
-   * Resolve entity class for this service
-   * @returns FileManager or FileManagerWithCompany based on configuration
-   */ resolveEntity() {
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        return enableCompanyFeature ? FileManagerWithCompany : FileManager;
-    }
-    /**
-   * Get DataSource provider for this service
-   * @returns StorageDataSourceProvider instance
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
+    // ─── Override Methods ───────────────────────────────────────────────────────
     async convertSingleDtoToEntity(dto, user) {
-        let fileManager = {};
-        // NOTE: Using 'id' in dto check instead of instanceof - instanceof may not work after esbuild bundling
+        let entity = {};
         if ('id' in dto && dto.id && typeof dto.id === 'string') {
-            const dbData = await this.repository.findOne({
+            const existing = await this.repository.findOne({
                 where: {
                     id: dto.id
                 }
             });
-            if (!dbData) {
-                throw new NotFoundException('No such entity data found for update! Please, Try Again.');
-            }
-            fileManager = dbData;
-        }
-        // Validate folder exists if folderId is provided
-        let validatedFolder = null;
-        if (dto.folderId) {
-            const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-            const folderEntity = enableCompanyFeature ? FolderWithCompany : Folder;
-            const folderRepository = await this.dataSourceProvider.getRepository(folderEntity);
-            const whereCondition = {
-                id: dto.folderId
-            };
-            // Filter by company if company feature is enabled
-            if (enableCompanyFeature && user?.companyId) {
-                whereCondition.companyId = user.companyId;
-            }
-            const folder = await folderRepository.findOne({
-                where: whereCondition
-            });
-            if (!folder) {
-                throw new BadRequestException(`Folder with ID ${dto.folderId} does not exist or you don't have access to it.`);
-            }
-            validatedFolder = {
-                id: dto.folderId
-            };
-        }
-        // Get storage location from storage config
-        let storageLocation = dto.location || FileLocationEnum.LOCAL; // Default to LOCAL if not provided
-        // If storageConfigId is provided, get the location from storage config
-        if (dto.storageConfigId) {
-            try {
-                const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-                const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
-                const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
-                const whereCondition = {
-                    id: dto.storageConfigId
-                };
-                // Filter by company if company feature is enabled
-                if (enableCompanyFeature && user?.companyId) {
-                    whereCondition.companyId = user.companyId;
-                }
-                const storageConfig = await storageConfigRepository.findOne({
-                    where: whereCondition
-                });
-                if (storageConfig) {
-                    storageLocation = storageConfig.storage;
-                }
-            } catch (error) {
-                this.logger.warn(`Failed to get storage location from config: ${error}`);
-            // Fall back to DTO location or default
-            }
+            if (!existing) throw new NotFoundException('Entity not found for update');
+            entity = existing;
         }
-        // Set basic fields
-        fileManager = {
-            ...fileManager,
+        const validatedFolder = dto.folderId ? await this.validateFolder(dto.folderId, user) : null;
+        const storageLocation = await this.resolveStorageLocation(dto, user);
+        const merged = {
+            ...entity,
             ...dto,
             location: storageLocation,
             folder: validatedFolder
         };
-        // Only set company fields if they exist on the entity (when company feature is enabled)
-        if ('companyId' in fileManager) {
-            fileManager.companyId = user?.companyId ?? null;
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            merged.companyId = user?.companyId ?? null;
         }
-        return fileManager;
+        return merged;
     }
     async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
-            select = [
-                'id',
-                'name',
-                'contentType',
-                'size',
-                'key',
-                'url',
-                'location',
-                'storageConfigId',
-                'isPrivate',
-                'createdAt',
-                'deletedAt'
-            ];
-        }
-        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
-        // Add company context fields if company feature is enabled
+        const fields = (select?.length ? select : DEFAULT_SELECT_FIELDS).map((f)=>`${this.entityName}.${f}`);
         if (this.storageConfig.isCompanyFeatureEnabled()) {
-            selectFields.push('file_manager.companyId');
+            fields.push('file_manager.companyId');
         }
-        // Join folder
-        selectFields.push('folder.id');
-        selectFields.push('folder.name');
-        query.leftJoinAndSelect('file_manager.folder', 'folder');
-        query.select(selectFields);
+        fields.push('folder.id', 'folder.name');
+        query.leftJoinAndSelect('file_manager.folder', 'folder').select(fields);
         return {
             query,
             isRaw: false
         };
     }
-    /**
-   * Enrich file list with provider names from storage_config table
-   * Call this method to add providerName to the list results
-   */ async enrichWithProviderNames(items) {
-        // Get unique storage config IDs
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'contentType') {
+                this.applyContentTypeFilter(query, value);
+            } else {
+                query.andWhere(`${this.entityName}.${key} = :value`, {
+                    value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'file_manager'
+        }, user);
+        await this.applyPrivateFileFilter(query, user);
+        return result;
+    }
+    async beforeDeleteOperation(dto, user, _qr) {
+        if (dto.type !== 'permanent') return;
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        const files = await this.repository.findBy({
+            id: In(ids)
+        });
+        const grouped = this.groupFilesByConfig(files);
+        for (const [configId, { keys, location }] of grouped){
+            let deleteKeys = keys;
+            if (location === FileLocationEnum.LOCAL && configId !== 'default') {
+                const basePath = await this.getStorageConfigBasePath(configId);
+                if (basePath) {
+                    deleteKeys = keys.map((k)=>k.includes('/') ? k : `${basePath}/${k}`);
+                }
+            }
+            await this.uploadService.deleteMultipleFile(deleteKeys, configId === 'default' ? undefined : configId, user ?? undefined, location);
+        }
+    }
+    // ─── Public Methods ─────────────────────────────────────────────────────────
+    async enrichWithProviderNames(items) {
         const configIds = [
-            ...new Set(items.map((item)=>item.storageConfigId).filter(Boolean))
+            ...new Set(items.map((i)=>i.storageConfigId).filter(Boolean))
         ];
-        this.logger.debug(`enrichWithProviderNames: items count=${items.length}, configIds=${JSON.stringify(configIds)}`);
-        if (configIds.length === 0) {
-            this.logger.debug('enrichWithProviderNames: No storage config IDs found in items');
+        if (!configIds.length) {
             return items.map((item)=>({
                     ...item,
                     providerName: undefined
                 }));
         }
-        // Fetch storage config names
         try {
-            const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-            const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
-            const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
-            const configs = await storageConfigRepository.find({
+            const repo = await this.getStorageConfigRepository();
+            const configs = await repo.find({
                 where: {
                     id: In(configIds)
                 },
@@ -195,239 +161,188 @@ export class FileManagerService extends RequestScopedApiService {
                     'name'
                 ]
             });
-            this.logger.debug(`enrichWithProviderNames: Found ${configs.length} configs: ${JSON.stringify(configs)}`);
-            // Create a map for quick lookup
-            const configNameMap = new Map(configs.map((c)=>[
+            const nameMap = new Map(configs.map((c)=>[
                     c.id,
                     c.name
                 ]));
-            // Enrich items with provider names
-            const enrichedItems = items.map((item)=>({
+            return items.map((item)=>({
                     ...item,
-                    providerName: item.storageConfigId ? configNameMap.get(item.storageConfigId) : undefined
+                    providerName: item.storageConfigId ? nameMap.get(item.storageConfigId) : undefined
                 }));
-            this.logger.debug(`enrichWithProviderNames: First enriched item: ${JSON.stringify(enrichedItems[0])}`);
-            return enrichedItems;
         } catch (error) {
-            this.logger.warn(`Failed to fetch provider names: ${error}`);
+            this.logger.warn(`Failed to fetch provider names: ${ErrorHandler.getErrorMessage(error)}`);
             return items.map((item)=>({
                     ...item,
                     providerName: undefined
                 }));
         }
     }
-    async getFilterQuery(query, filter, _user) {
-        Object.entries(filter).forEach(([key, value])=>{
-            if (key === 'contentType') {
-                const types = value.split(',').map((t)=>t.trim());
-                const patterns = types.map((t)=>t.replace('*', '%'));
-                query.where(new Brackets((qb1)=>{
-                    patterns.forEach((p, i)=>{
-                        const param = `p${i}`;
-                        if (i === 0) qb1.where(`${this.entityName}.contentType LIKE :${param}`, {
-                            [param]: p
-                        });
-                        else qb1.orWhere(`${this.entityName}.contentType LIKE :${param}`, {
-                            [param]: p
-                        });
-                    });
-                }));
-                return;
+    async getFiles(dtos, protocol, host, user) {
+        await this.ensureRepositoryInitialized();
+        const ids = dtos.map((d)=>d.id).filter(Boolean);
+        if (!ids.length) throw new BadRequestException('No valid file IDs provided');
+        const files = await this.repository.findBy({
+            id: In(ids)
+        });
+        const now = Date.now();
+        const updatedFiles = [];
+        const responses = await Promise.all(files.map(async (file)=>{
+            const updated = await this.refreshFileUrl(file, protocol, host, now, user);
+            if (updated) updatedFiles.push(file);
+            return this.toFileResponse(file);
+        }));
+        if (updatedFiles.length) {
+            try {
+                await this.repository.save(updatedFiles);
+            } catch (error) {
+                this.logger.error(`Failed to save updated URLs: ${ErrorHandler.getErrorMessage(error)}`);
             }
-            query.andWhere(`${this.entityName}.${key} = :value`, {
-                value
+        }
+        return responses;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    async getStorageConfigRepository() {
+        const entity = this.storageConfig.isCompanyFeatureEnabled() ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
+        return this.dataSourceProvider.getRepository(entity);
+    }
+    buildWhereWithCompany(id, user) {
+        const where = {
+            id
+        };
+        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return where;
+    }
+    async getStorageConfigBasePath(configId) {
+        try {
+            const repo = await this.getStorageConfigRepository();
+            const config = await repo.findOne({
+                where: {
+                    id: configId
+                },
+                select: [
+                    'id',
+                    'config'
+                ]
             });
+            return config?.config?.basePath?.replace(/^\.\//, '') ?? null;
+        } catch (error) {
+            this.logger.warn(`Failed to get basePath for ${configId}: ${ErrorHandler.getErrorMessage(error)}`);
+            return null;
+        }
+    }
+    async validateFolder(folderId, user) {
+        const entity = this.storageConfig.isCompanyFeatureEnabled() ? FolderWithCompany : Folder;
+        const repo = await this.dataSourceProvider.getRepository(entity);
+        const folder = await repo.findOne({
+            where: this.buildWhereWithCompany(folderId, user)
         });
-        return {
-            query,
-            isRaw: false
-        };
+        if (!folder) {
+            throw new BadRequestException(`Folder ${folderId} not found or access denied`);
+        }
+        return folder;
     }
-    /**
-   * Override: Extra query manipulation - Auto-filter by user's company and private file permissions
-   */ async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        // If company feature enabled and user has companyId, filter by user's company
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
-            query.andWhere('file_manager.companyId = :companyId', {
-                companyId: user.companyId
+    async resolveStorageLocation(dto, user) {
+        const configId = dto.storageConfigId;
+        if (!configId) return dto.location || FileLocationEnum.LOCAL;
+        try {
+            const repo = await this.getStorageConfigRepository();
+            const config = await repo.findOne({
+                where: this.buildWhereWithCompany(configId, user)
             });
+            return config?.storage || dto.location || FileLocationEnum.LOCAL;
+        } catch (error) {
+            this.logger.warn(`Failed to resolve storage location: ${ErrorHandler.getErrorMessage(error)}`);
+            return dto.location || FileLocationEnum.LOCAL;
         }
-        // Check if user has permission to see private files
-        if (user) {
-            const cacheKey = enableCompanyFeature ? `${USER_ACTION_PERMISSION_CACHE_KEY}_${user.id}_${user.companyId}` : `${USER_ACTION_PERMISSION_CACHE_KEY}_${user.id}`;
-            const userActions = await this.cacheManager.get(cacheKey);
-            if (userActions) {
-                const userActionUrls = userActions.map((item)=>item.url);
-                if (!userActionUrls.includes(SHOW_PRIVATE_FILE_ACTION)) {
-                    query.andWhere('file_manager.isPrivate = :isPrivate', {
-                        isPrivate: false
-                    });
-                }
-            } else {
-                query.andWhere('file_manager.isPrivate = :isPrivate', {
-                    isPrivate: false
+    }
+    applyContentTypeFilter(query, value) {
+        const patterns = value.split(',').map((t)=>t.trim().replace('*', '%'));
+        query.where(new Brackets((qb)=>{
+            patterns.forEach((p, i)=>{
+                const method = i === 0 ? 'where' : 'orWhere';
+                qb[method](`${this.entityName}.contentType LIKE :p${i}`, {
+                    [`p${i}`]: p
                 });
-            }
-        } else {
-            // No user - only show public files
+            });
+        }));
+    }
+    async applyPrivateFileFilter(query, user) {
+        if (!user) {
             query.andWhere('file_manager.isPrivate = :isPrivate', {
                 isPrivate: false
             });
+            return;
         }
-        return result;
-    }
-    async beforeDeleteOperation(dto, user, _queryRunner) {
-        if (dto.type === 'permanent') {
-            const ids = Array.isArray(dto.id) ? dto.id : [
-                dto.id
-            ];
-            const fileManager = await this.repository.findBy({
-                id: In(ids)
-            });
-            // Group files by storage config for batch deletion
-            const filesByConfig = new Map();
-            fileManager.forEach((file)=>{
-                const configId = file.storageConfigId || 'default';
-                if (!filesByConfig.has(configId)) {
-                    filesByConfig.set(configId, {
-                        keys: [],
-                        location: file.location
-                    });
-                }
-                filesByConfig.get(configId).keys.push(file.key);
+        const cacheKey = this.storageConfig.isCompanyFeatureEnabled() ? `${PERMISSION_CACHE_KEY}_${user.id}_${user.companyId}` : `${PERMISSION_CACHE_KEY}_${user.id}`;
+        const actions = await this.cacheManager.get(cacheKey);
+        const canViewPrivate = actions?.some((a)=>a.url === VIEW_PRIVATE_ACTION) ?? false;
+        if (!canViewPrivate) {
+            query.andWhere('file_manager.isPrivate = :isPrivate', {
+                isPrivate: false
             });
-            // Delete files from each storage config
-            for (const [configId, { keys, location }] of filesByConfig){
-                // For local files with old key format (no '/'), we need to prefix with basePath
-                let deleteKeys = keys;
-                if (location === FileLocationEnum.LOCAL && configId !== 'default') {
-                    try {
-                        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-                        const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
-                        const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
-                        const config = await storageConfigRepository.findOne({
-                            where: {
-                                id: configId
-                            },
-                            select: [
-                                'id',
-                                'config'
-                            ]
-                        });
-                        if (config && config.config?.basePath) {
-                            const basePath = config.config.basePath.replace(/^\.\//, '');
-                            // Convert old keys to new format
-                            deleteKeys = keys.map((key)=>{
-                                if (!key.includes('/')) {
-                                    return `${basePath}/${key}`;
-                                }
-                                return key;
-                            });
-                        }
-                    } catch (error) {
-                        this.logger.warn(`Failed to get basePath for delete: ${error}`);
-                    }
-                }
-                await this.uploadService.deleteMultipleFile(deleteKeys, configId === 'default' ? undefined : configId, user ?? undefined, location);
-            }
         }
     }
-    /**
-   * Get multiple files and ensure URLs are valid
-   * Now supports dynamic storage providers (AWS, Azure, SFTP)
-   */ async getFiles(dtos, protocol, host, user) {
-        await this.ensureRepositoryInitialized();
-        const ids = dtos.map((d)=>d.id).filter(Boolean);
-        if (!ids.length) throw new BadRequestException('No valid file IDs provided');
-        const files = await this.repository.findBy({
-            id: In(ids)
-        });
-        const now = Date.now();
-        const expiresIn = this.FILE_URL_EXPIRY_SECONDS;
-        const updatedFiles = [];
-        const responses = await Promise.all(files.map(async (file)=>{
-            let shouldUpdate = false;
-            // Check if file has storage config ID
-            if (!file.storageConfigId) {
-                this.logger.warn(`File ${file.id} has no storageConfigId. Please update this file with a valid storage config.`);
-            }
-            // Generate URL if expired or missing
-            const needsNewUrl = !file.url || file.location === FileLocationEnum.AWS && (typeof file.expiresAt !== 'number' || now >= file.expiresAt) || file.location === FileLocationEnum.AZURE && (typeof file.expiresAt !== 'number' || now >= file.expiresAt);
-            if (needsNewUrl && file.storageConfigId) {
-                try {
-                    file.url = await this.uploadService.makeFileUrl(file.key, file.storageConfigId, expiresIn, user);
-                    file.expiresAt = now + expiresIn * 1000;
-                    shouldUpdate = true;
-                } catch (error) {
-                    this.logger.error(`Failed to generate URL for file ${file.id}: ${error?.message || 'Unknown error'}`);
-                    // Use fallback URL with appUrl from config
-                    const baseUrl = this.getFileBaseUrl(protocol, host);
-                    file.url = `${baseUrl}/storage/upload/file/${file.key}`;
-                }
-            }
-            // SFTP/Local files - always construct full URL (no expiry, but need full path)
-            if (file.location === FileLocationEnum.SFTP || file.location === FileLocationEnum.LOCAL) {
-                // For backward compatibility: if key doesn't include basePath, look it up from config
-                let fileKey = file.key;
-                // Check if key looks like it's missing the basePath (old format)
-                // Old format: "uuid-filename.png"
-                // New format: "uploads/uuid-filename.png" or "uploads/company1/uuid-filename.png"
-                if (!fileKey.includes('/') && file.storageConfigId) {
-                    try {
-                        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-                        const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
-                        const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
-                        const config = await storageConfigRepository.findOne({
-                            where: {
-                                id: file.storageConfigId
-                            },
-                            select: [
-                                'id',
-                                'config'
-                            ]
-                        });
-                        if (config && config.config?.basePath) {
-                            const basePath = config.config.basePath.replace(/^\.\//, ''); // Remove leading ./
-                            fileKey = `${basePath}/${file.key}`;
-                            this.logger.debug(`Prefixed old key with basePath: ${fileKey}`);
-                        }
-                    } catch (error) {
-                        this.logger.warn(`Failed to get basePath for file ${file.id}: ${error}`);
-                    }
-                }
-                const baseUrl = this.getFileBaseUrl(protocol, host);
-                const expectedUrl = `${baseUrl}/storage/upload/file/${fileKey}`;
-                if (file.url !== expectedUrl) {
-                    file.url = expectedUrl;
-                    shouldUpdate = true;
-                }
+    groupFilesByConfig(files) {
+        const grouped = new Map();
+        for (const file of files){
+            const configId = file.storageConfigId || 'default';
+            if (!grouped.has(configId)) {
+                grouped.set(configId, {
+                    keys: [],
+                    location: file.location
+                });
             }
-            if (shouldUpdate) updatedFiles.push(file);
-            return {
-                id: file.id,
-                name: file.name,
-                contentType: file.contentType,
-                url: file.url || '',
-                location: file.location,
-                storageConfigId: file.storageConfigId || undefined
-            };
-        }));
-        // Save only changed records
-        if (updatedFiles.length > 0) {
+            grouped.get(configId).keys.push(file.key);
+        }
+        return grouped;
+    }
+    getFileBaseUrl(protocol, host) {
+        return this.storageConfig.getAppUrl()?.replace(/\/$/, '') ?? `${protocol}://${host}`;
+    }
+    async refreshFileUrl(file, protocol, host, now, user) {
+        if (!file.storageConfigId) {
+            this.logger.warn(`File ${file.id} has no storageConfigId`);
+        }
+        const isCloudProvider = file.location === FileLocationEnum.AWS || file.location === FileLocationEnum.AZURE;
+        const needsNewUrl = !file.url || isCloudProvider && (typeof file.expiresAt !== 'number' || now >= file.expiresAt);
+        if (needsNewUrl && file.storageConfigId) {
             try {
-                await this.repository.save(updatedFiles);
+                file.url = await this.uploadService.makeFileUrl(file.key, file.storageConfigId, URL_EXPIRY_SECONDS, user);
+                file.expiresAt = now + URL_EXPIRY_SECONDS * 1000;
+                return true;
             } catch (error) {
-                this.logger.error(`Failed to save updated file URLs: ${error?.message || 'Unknown error'}`);
+                this.logger.error(`Failed to generate URL for ${file.id}: ${ErrorHandler.getErrorMessage(error)}`);
+                file.url = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${file.key}`;
             }
         }
-        return responses;
+        if (file.location === FileLocationEnum.SFTP || file.location === FileLocationEnum.LOCAL) {
+            let fileKey = file.key;
+            if (!fileKey.includes('/') && file.storageConfigId) {
+                const basePath = await this.getStorageConfigBasePath(file.storageConfigId);
+                if (basePath) fileKey = `${basePath}/${file.key}`;
+            }
+            const expectedUrl = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${fileKey}`;
+            if (file.url !== expectedUrl) {
+                file.url = expectedUrl;
+                return true;
+            }
+        }
+        return false;
+    }
+    toFileResponse(file) {
+        return {
+            id: file.id,
+            name: file.name,
+            contentType: file.contentType,
+            url: file.url || '',
+            location: file.location,
+            storageConfigId: file.storageConfigId || undefined
+        };
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
     constructor(cacheManager, utilsService, uploadService, storageConfig, dataSourceProvider){
-        // Repository will be set asynchronously by RequestScopedApiService
-        super('file_manager', null, cacheManager, utilsService, FileManagerService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "uploadService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "FILE_URL_EXPIRY_SECONDS", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider, this.FILE_URL_EXPIRY_SECONDS = 3600;
+        super('file_manager', null, cacheManager, utilsService, FileManagerService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "uploadService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
     }
 }
 FileManagerService = _ts_decorate([