@flusys/nestjs-storage 7.1.0 → 8.0.0-beta.1

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

@@ -1,336 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { ApiService, FILE_PERMISSIONS, HybridCache } from '@flusys/nestjs-shared/classes';
-import { SharedPermissionCacheService, UtilsService } from '@flusys/nestjs-shared/modules';
-import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
-import { Brackets, In } from 'typeorm';
-import { FILE_MESSAGES, FOLDER_MESSAGES, STORAGE_EVENT_ENTITIES, STORAGE_EVENT_MODULE, UPLOAD_MESSAGES } from '../config';
-import { FileManager, FileManagerWithCompany, Folder, FolderWithCompany } from '../entities';
-import { FileLocationEnum } from '../enums/file-location.enum';
-import { StorageConfigService } from './storage-config.service';
-import { StorageDataSourceProvider } from './storage-datasource.provider';
-import { UploadService } from './upload.service';
-const URL_EXPIRY_SECONDS = 3600;
-const DEFAULT_SELECT_FIELDS = [
-    'id',
-    'name',
-    'contentType',
-    'size',
-    'key',
-    'url',
-    'location',
-    'storageConfigId',
-    'isPrivate',
-    'createdAt',
-    'deletedAt'
-];
-export class FileManagerService extends ApiService {
-    // ─── Override Methods ───────────────────────────────────────────────────────
-    async convertSingleDtoToEntity(dto, user) {
-        let entity = {};
-        if ('id' in dto && dto.id && typeof dto.id === 'string') {
-            const existing = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!existing) throw new NotFoundException({
-                message: 'Entity not found for update',
-                messageKey: FILE_MESSAGES.NOT_FOUND
-            });
-            entity = existing;
-        }
-        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
-        };
-        if (this.storageConfig.isCompanyFeatureEnabled()) {
-            merged.companyId = user?.companyId ?? null;
-        }
-        return merged;
-    }
-    async getSelectQuery(query, _user, select) {
-        const fields = (select?.length ? select : DEFAULT_SELECT_FIELDS).map((f)=>`${this.entityName}.${f}`);
-        if (this.storageConfig.isCompanyFeatureEnabled()) {
-            fields.push('file_manager.companyId');
-        }
-        fields.push('folder.id', 'folder.name');
-        query.leftJoinAndSelect('file_manager.folder', 'folder').select(fields);
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getFilterQuery(query, filter, _user) {
-        for (const [key, value] of Object.entries(filter)){
-            if (key === 'contentType' && typeof value === 'string') {
-                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 getFiles(dtos, protocol, host, user) {
-        await this.ensureDataSourceRepository();
-        const ids = dtos.map((d)=>d.id).filter(Boolean);
-        if (!ids.length) throw new BadRequestException({
-            message: 'No valid file IDs provided',
-            messageKey: UPLOAD_MESSAGES.NO_FILES_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);
-                await Promise.all([
-                    this.clearCacheForAll(),
-                    this.clearCacheForId(updatedFiles)
-                ]);
-            } catch  {
-            // Silent failure - URL update is non-critical
-            }
-        }
-        return responses;
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    buildWhereWithCompany(id, user) {
-        const where = {
-            id
-        };
-        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            where.companyId = user.companyId;
-        }
-        return where;
-    }
-    async getStorageConfigRepository() {
-        const entity = this.storageConfig.isCompanyFeatureEnabled() ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
-        return this.dataSourceProvider.getRepository(entity);
-    }
-    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  {
-            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)
-        });
-        if (!folder) {
-            throw new BadRequestException({
-                message: `Folder "${folderId}" not found or access denied`,
-                messageKey: FOLDER_MESSAGES.NOT_FOUND,
-                messageVariables: {
-                    folderId
-                }
-            });
-        }
-        return folder;
-    }
-    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  {
-            return dto.location || FileLocationEnum.LOCAL;
-        }
-    }
-    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
-                });
-            });
-        }));
-    }
-    async applyPrivateFileFilter(query, user) {
-        if (!user) {
-            query.andWhere('file_manager.isPrivate = :isPrivate', {
-                isPrivate: false
-            });
-            return;
-        }
-        const canViewPrivate = await this.permissionCacheService.hasPermission({
-            userId: user.id,
-            companyId: user.companyId,
-            branchId: user.branchId
-        }, FILE_PERMISSIONS.VIEW_PRIVATE_ACTION);
-        if (!canViewPrivate) {
-            query.andWhere('file_manager.isPrivate = :isPrivate', {
-                isPrivate: false
-            });
-        }
-    }
-    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
-                });
-            }
-            grouped.get(configId).keys.push(file.key);
-        }
-        return grouped;
-    }
-    getFileBaseUrl(protocol, host) {
-        const appUrl = this.storageConfig.getAppUrl()?.replace(/\/$/, '');
-        return appUrl || `${protocol}://${host}`;
-    }
-    async refreshFileUrl(file, protocol, host, now, user) {
-        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 {
-                file.url = await this.uploadService.makeFileUrl(file.key, file.storageConfigId, URL_EXPIRY_SECONDS, user);
-                file.expiresAt = now + URL_EXPIRY_SECONDS * 1000;
-                return true;
-            } catch  {
-                file.url = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${file.key}`;
-            }
-        }
-        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
-        };
-    }
-    constructor(cacheManager, utilsService, uploadService, storageConfig, dataSourceProvider, permissionCacheService){
-        super(STORAGE_EVENT_ENTITIES.FILE, cacheManager, utilsService, FileManagerService.name, true, STORAGE_EVENT_MODULE, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? FileManagerWithCompany : FileManager), _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, "permissionCacheService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider, this.permissionCacheService = permissionCacheService;
-    }
-}
-FileManagerService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(UploadService)),
-    _ts_param(3, Inject(StorageConfigService)),
-    _ts_param(4, Inject(StorageDataSourceProvider)),
-    _ts_param(5, Inject(SharedPermissionCacheService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof UploadService === "undefined" ? Object : UploadService,
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
-        typeof StorageDataSourceProvider === "undefined" ? Object : StorageDataSourceProvider,
-        typeof SharedPermissionCacheService === "undefined" ? Object : SharedPermissionCacheService
-    ])
-], FileManagerService);