@flusys/nestjs-storage 7.1.0 → 8.0.0

package/cjs/services/storage-provider-config.service.spec.js

@@ -1,265 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _testing = require("@nestjs/testing");
-const _modules = require("@flusys/nestjs-shared/modules");
-const _repositorymock = require("@test-utils/mocks/repository.mock");
-const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
-const _storageproviderconfigservice = require("./storage-provider-config.service");
-const _storageconfigservice = require("./storage-config.service");
-const _storagedatasourceprovider = require("./storage-datasource.provider");
-const _entities = require("../entities");
-function buildStorageConfig(overrides = {}) {
-    return {
-        id: 'config-uuid-1',
-        name: 'Default Local',
-        storage: 'local',
-        config: {
-            basePath: './uploads'
-        },
-        isActive: true,
-        isDefault: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('StorageProviderConfigService', ()=>{
-    let service;
-    let module;
-    let mockRepo;
-    let mockStorageConfig;
-    beforeEach(async ()=>{
-        mockRepo = (0, _repositorymock.createMockRepository)();
-        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
-        mockStorageConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false),
-            getAppUrl: jest.fn().mockReturnValue('http://localhost:2002')
-        };
-        module = await _testing.Test.createTestingModule({
-            providers: [
-                _storageproviderconfigservice.StorageProviderConfigService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: _modules.UtilsService,
-                    useValue: {}
-                },
-                {
-                    provide: _storageconfigservice.StorageConfigService,
-                    useValue: mockStorageConfig
-                },
-                {
-                    provide: _storagedatasourceprovider.StorageDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(_storageproviderconfigservice.StorageProviderConfigService);
-    });
-    describe('entity selection', ()=>{
-        it('uses StorageConfig when the company feature is disabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(_storageproviderconfigservice.StorageProviderConfigService);
-            expect(built['_entity']).toBe(_entities.StorageConfig);
-        });
-        it('uses StorageConfigWithCompany when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(_storageproviderconfigservice.StorageProviderConfigService);
-            expect(built['_entity']).toBe(_entities.StorageConfigWithCompany);
-        });
-    });
-    describe('convertSingleDtoToEntity', ()=>{
-        beforeEach(async ()=>{
-            mockRepo.create.mockReturnValue({});
-            await service.ensureDataSourceRepository();
-        });
-        it('does not attach companyId when the company feature is disabled', async ()=>{
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'AWS S3',
-                storage: 'aws',
-                config: {}
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(entity.companyId).toBeUndefined();
-        });
-        it('attaches the current user companyId when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'AWS S3',
-                storage: 'aws',
-                config: {}
-            }, (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-42'
-            }));
-            expect(entity.companyId).toBe('company-42');
-        });
-        it('defaults companyId to null when company feature is enabled but user has none', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const entity = await service.convertSingleDtoToEntity({
-                name: 'AWS S3',
-                storage: 'aws',
-                config: {}
-            }, null);
-            expect(entity.companyId).toBeNull();
-        });
-    });
-    describe('getSelectQuery', ()=>{
-        it('selects the default field set when none is provided', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
-            expect(query.select).toHaveBeenCalledWith([
-                'storageConfig.id',
-                'storageConfig.name',
-                'storageConfig.storage',
-                'storageConfig.config',
-                'storageConfig.isActive',
-                'storageConfig.isDefault',
-                'storageConfig.createdAt',
-                'storageConfig.updatedAt'
-            ]);
-        });
-        it('adds companyId to the default select list when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
-            const selected = query.select.mock.calls[0][0];
-            expect(selected).toContain('storageConfig.companyId');
-        });
-        it('respects an explicitly provided select list', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)(), [
-                'id',
-                'name'
-            ]);
-            expect(query.select).toHaveBeenCalledWith([
-                'storageConfig.id',
-                'storageConfig.name'
-            ]);
-        });
-    });
-    describe('findByIdDirect', ()=>{
-        it('bypasses company filtering and returns the raw entity by id', async ()=>{
-            const config = buildStorageConfig();
-            mockRepo.findOne.mockResolvedValue(config);
-            const result = await service.findByIdDirect('config-uuid-1');
-            expect(mockRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'config-uuid-1'
-                }
-            });
-            expect(result).toEqual(config);
-        });
-        it('returns null when no config exists for the given id', async ()=>{
-            mockRepo.findOne.mockResolvedValue(null);
-            const result = await service.findByIdDirect('missing-id');
-            expect(result).toBeNull();
-        });
-    });
-    describe('getDefaultConfig', ()=>{
-        it('returns the config explicitly flagged isDefault when one exists', async ()=>{
-            const defaultConfig = buildStorageConfig({
-                id: 'default-1',
-                isDefault: true
-            });
-            mockRepo.findOne.mockResolvedValueOnce(defaultConfig);
-            const result = await service.getDefaultConfig((0, _loggedusermock.buildMockUser)());
-            expect(result).toEqual(defaultConfig);
-            expect(mockRepo.findOne).toHaveBeenCalledTimes(1);
-        });
-        it('falls back to the oldest active config when no default is flagged', async ()=>{
-            const fallbackConfig = buildStorageConfig({
-                id: 'fallback-1'
-            });
-            mockRepo.findOne.mockResolvedValueOnce(null).mockResolvedValueOnce(fallbackConfig);
-            const result = await service.getDefaultConfig((0, _loggedusermock.buildMockUser)());
-            expect(result).toEqual(fallbackConfig);
-            expect(mockRepo.findOne).toHaveBeenCalledTimes(2);
-        });
-        it('returns null when there is no default and no active config at all', async ()=>{
-            mockRepo.findOne.mockResolvedValue(null);
-            const result = await service.getDefaultConfig((0, _loggedusermock.buildMockUser)());
-            expect(result).toBeNull();
-        });
-        it('scopes the query to the user company when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockRepo.findOne.mockResolvedValue(null);
-            await service.getDefaultConfig((0, _loggedusermock.buildMockUser)({
-                companyId: 'company-9'
-            }));
-            expect(mockRepo.findOne).toHaveBeenCalledWith(expect.objectContaining({
-                where: expect.objectContaining({
-                    companyId: 'company-9',
-                    isActive: true
-                })
-            }));
-        });
-    });
-    describe('getConfigByType', ()=>{
-        it('returns active configs matching the requested storage type', async ()=>{
-            const localConfigs = [
-                buildStorageConfig({
-                    storage: 'local'
-                })
-            ];
-            mockRepo.find.mockResolvedValue(localConfigs);
-            const result = await service.getConfigByType('local', (0, _loggedusermock.buildMockUser)());
-            expect(mockRepo.find).toHaveBeenCalledWith({
-                where: {
-                    storage: 'local',
-                    isActive: true
-                }
-            });
-            expect(result).toEqual(localConfigs);
-        });
-        it('scopes the lookup to the current company when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            mockRepo.find.mockResolvedValue([]);
-            await service.getConfigByType('aws', (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-5'
-            }));
-            expect(mockRepo.find).toHaveBeenCalledWith({
-                where: {
-                    storage: 'aws',
-                    isActive: true,
-                    companyId: 'company-5'
-                }
-            });
-        });
-        it('returns an empty array when no configs match', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            const result = await service.getConfigByType('azure');
-            expect(result).toEqual([]);
-        });
-    });
-    describe('beforeDeleteOperation', ()=>{
-        it('rejects deleting the default storage config', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildStorageConfig({
-                    isDefault: true
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).rejects.toThrow('Cannot delete the default storage config');
-        });
-        it('allows deleting a non-default storage config', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            await expect(service.beforeDeleteOperation({
-                id: 'config-uuid-1'
-            }, null, {})).resolves.toBeUndefined();
-        });
-    });
-});

package/cjs/services/upload.service.js

@@ -1,376 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "UploadService", {
-    enumerable: true,
-    get: function() {
-        return UploadService;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _classes = require("@flusys/nestjs-shared/classes");
-const _interfaces = require("@flusys/nestjs-shared/interfaces");
-const _utils = require("@flusys/nestjs-shared/utils");
-const _common = require("@nestjs/common");
-const _config = require("../config");
-const _uploaddto = require("../dtos/upload.dto");
-const _filelocationenum = require("../enums/file-location.enum");
-const _storagefactoryservice = require("../providers/storage-factory.service");
-const _filevalidatorutil = require("../utils/file-validator.util");
-const _storageconfigservice = require("./storage-config.service");
-const _storageproviderconfigservice = require("./storage-provider-config.service");
-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);
-    };
-}
-let UploadService = class UploadService {
-    /**
-   * Validate file before upload - includes size, type, and content validation.
-   * Uses magic bytes to verify file content matches declared MIME type.
-   */ validateFile(file) {
-        // Validate file size
-        const sizeValidation = this.storageConfigService.validateFileSize(file.size);
-        if (!sizeValidation.valid) {
-            throw new _common.BadRequestException({
-                message: sizeValidation.message,
-                messageKey: sizeValidation.messageKey,
-                messageVariables: sizeValidation.messageVariables
-            });
-        }
-        // Validate declared file type (MIME)
-        const typeValidation = this.storageConfigService.validateFileType(file.mimetype);
-        if (!typeValidation.valid) {
-            throw new _common.BadRequestException({
-                message: typeValidation.message,
-                messageKey: typeValidation.messageKey,
-                messageVariables: typeValidation.messageVariables
-            });
-        }
-        // Validate file content matches declared type (magic bytes check)
-        // This prevents MIME type spoofing attacks
-        const allowedTypes = this.storageConfigService.getAllowedFileTypes();
-        const contentValidation = _filevalidatorutil.FileValidator.validateFileContent(file.buffer, file.mimetype, allowedTypes);
-        if (!contentValidation.valid) {
-            throw new _common.BadRequestException({
-                message: contentValidation.message || 'File content validation failed',
-                messageKey: _config.UPLOAD_MESSAGES.INVALID_TYPE,
-                messageVariables: {
-                    mimeType: file.mimetype,
-                    allowedTypes: allowedTypes.join(', ')
-                }
-            });
-        }
-        // Sanitize filename to prevent path traversal attacks
-        file.originalname = _filevalidatorutil.FileValidator.sanitizeFilename(file.originalname);
-    }
-    /**
-   * Create provider from storage config entity
-   */ async createProviderFromConfig(config) {
-        return this.storageFactory.createProvider({
-            provider: config.storage,
-            config: config.config
-        });
-    }
-    /**
-   * Create fallback local provider
-   */ async createFallbackLocalProvider() {
-        return this.storageFactory.createProvider({
-            provider: _filelocationenum.FileLocationEnum.LOCAL,
-            config: {
-                basePath: this.storageConfigService.getDefaultLocalStoragePath()
-            }
-        });
-    }
-    /**
-   * Get storage provider and config info based on storage config ID
-   * Validates company ownership when company feature is enabled
-   */ async getStorageProviderWithConfig(storageConfigId, user) {
-        let storageConfig;
-        // Get storage config from database
-        if (storageConfigId) {
-            // Use direct lookup (bypasses company filtering, returns null instead of throwing)
-            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
-            if (!config) {
-                throw new _common.NotFoundException({
-                    message: 'Storage configuration not found',
-                    messageKey: _config.UPLOAD_MESSAGES.CONFIG_NOT_FOUND
-                });
-            }
-            // Validate company ownership using shared utility
-            (0, _utils.validateCompanyOwnership)(config, user, this.storageConfigService.isCompanyFeatureEnabled(), 'Storage configuration');
-            storageConfig = config;
-        } else {
-            // Use default config (scoped to user's company/branch)
-            const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
-            if (!defaultConfig) {
-                throw new _common.NotFoundException({
-                    message: 'No default storage configuration found for your company/branch. Please create one.',
-                    messageKey: _config.UPLOAD_MESSAGES.CONFIG_NOT_FOUND
-                });
-            }
-            storageConfig = defaultConfig;
-        }
-        const provider = await this.createProviderFromConfig(storageConfig);
-        return {
-            provider,
-            location: storageConfig.storage,
-            configId: storageConfig.id
-        };
-    }
-    /**
-   * Get storage provider for delete operations with fallback
-   * If the original storage config doesn't exist, falls back based on locationHint
-   */ async getStorageProviderForDelete(storageConfigId, user, locationHint) {
-        // Try to find by storageConfigId
-        if (storageConfigId) {
-            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
-            if (config) {
-                return this.createProviderFromConfig(config);
-            }
-        }
-        // Fallback: Use locationHint to find a matching config
-        if (locationHint) {
-            const matchingConfigs = await this.storageProviderConfigService.getConfigByType(locationHint, user);
-            if (matchingConfigs.length > 0) {
-                return this.createProviderFromConfig(matchingConfigs[0]);
-            }
-            if (locationHint === _filelocationenum.FileLocationEnum.LOCAL) {
-                return this.createFallbackLocalProvider();
-            }
-        }
-        // Last resort: Try default config
-        const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
-        if (defaultConfig) {
-            return this.createProviderFromConfig(defaultConfig);
-        }
-        return this.createFallbackLocalProvider();
-    }
-    async uploadSingleFile(file, options, user) {
-        this.validateFile(file);
-        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
-        const result = await provider.uploadFile(file, options);
-        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.UPLOADED, [
-            result.key
-        ], user, {
-            location,
-            storageConfigId: configId,
-            totalSize: result.size,
-            count: 1
-        });
-        return {
-            ...result,
-            location,
-            storageConfigId: configId
-        };
-    }
-    async uploadMultipleFiles(files, options, user) {
-        for (const file of files){
-            this.validateFile(file);
-        }
-        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
-        const results = await provider.uploadMultipleFiles(files, options);
-        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.UPLOADED, results.map((result)=>result.key), user, {
-            location,
-            storageConfigId: configId,
-            totalSize: results.reduce((sum, result)=>sum + (result.size ?? 0), 0),
-            count: results.length
-        });
-        return results.map((result)=>({
-                ...result,
-                location,
-                storageConfigId: configId
-            }));
-    }
-    async deleteSingleFile(key, storageConfigId, user, locationHint) {
-        if (!key) throw new _common.BadRequestException({
-            message: 'No file path provided',
-            messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
-        });
-        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-        await provider.deleteFile(key);
-        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.REMOVED, [
-            key
-        ], user, {
-            storageConfigId,
-            count: 1
-        });
-        return true;
-    }
-    async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
-        if (!keys || !keys.length) throw new _common.BadRequestException({
-            message: 'No file paths provided',
-            messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
-        });
-        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
-        await provider.deleteMultipleFiles(keys);
-        await this.publishFileEvent(_config.STORAGE_EVENT_ACTIONS.REMOVED, keys, user, {
-            storageConfigId,
-            count: keys.length
-        });
-        return true;
-    }
-    async publishFileEvent(action, keys, user, metadata) {
-        await (0, _classes.publishDomainEvent)({
-            module: _config.STORAGE_EVENT_MODULE,
-            entity: _config.STORAGE_EVENT_ENTITIES.FILE,
-            action,
-            ids: keys,
-            metadata,
-            user: user ?? null
-        });
-    }
-    bytesToKb(bytes) {
-        return Number((bytes * 0.001).toFixed(2));
-    }
-    /**
-   * Get local storage basePath from DB config
-   * Initializes local provider if not cached, ensuring basePath is from DB
-   */ async getLocalStorageBasePath() {
-        try {
-            // First check if already cached
-            const cachedPath = this.storageFactory.getLocalProviderBasePath();
-            if (cachedPath) {
-                return cachedPath;
-            }
-            // Get local config from DB (without user context for public access)
-            const localConfigs = await this.storageProviderConfigService.getConfigByType(_filelocationenum.FileLocationEnum.LOCAL);
-            if (localConfigs.length > 0) {
-                const localConfig = localConfigs[0];
-                // Initialize provider to cache it
-                await this.storageFactory.createProvider({
-                    provider: _filelocationenum.FileLocationEnum.LOCAL,
-                    config: localConfig.config
-                });
-                // Now get the cached basePath
-                return this.storageFactory.getLocalProviderBasePath();
-            }
-            return null;
-        } catch  {
-            return null;
-        }
-    }
-    async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
-        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
-        // Check if provider supports presigned URLs
-        if (provider.generatePresignedUrl) {
-            return await provider.generatePresignedUrl(key, expiresIn);
-        }
-        // For SFTP or other providers without presigned URLs
-        return key;
-    }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(storageFactory, storageConfigService, storageProviderConfigService){
-        _define_property(this, "storageFactory", void 0);
-        _define_property(this, "storageConfigService", void 0);
-        _define_property(this, "storageProviderConfigService", void 0);
-        this.storageFactory = storageFactory;
-        this.storageConfigService = storageConfigService;
-        this.storageProviderConfigService = storageProviderConfigService;
-    }
-};
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'storage.uploadSingle',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Express === "undefined" || typeof Express.Multer === "undefined" || typeof Express.Multer.File === "undefined" ? Object : Express.Multer.File,
-        typeof _uploaddto.UploadOptionsDto === "undefined" ? Object : _uploaddto.UploadOptionsDto,
-        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "uploadSingleFile", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'storage.uploadMultiple',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        typeof _uploaddto.UploadOptionsDto === "undefined" ? Object : _uploaddto.UploadOptionsDto,
-        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "uploadMultipleFiles", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'storage.deleteSingle',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "deleteSingleFile", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'storage.deleteMultiple',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Array,
-        String,
-        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "deleteMultipleFile", null);
-_ts_decorate([
-    (0, _nestjsshared.LogAction)({
-        action: 'storage.makeFileUrl',
-        module: 'storage'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String,
-        Number,
-        typeof _interfaces.ILoggedUserInfo === "undefined" ? Object : _interfaces.ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadService.prototype, "makeFileUrl", null);
-UploadService = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Inject)(_storagefactoryservice.StorageFactoryService)),
-    _ts_param(1, (0, _common.Inject)(_storageconfigservice.StorageConfigService)),
-    _ts_param(2, (0, _common.Inject)(_storageproviderconfigservice.StorageProviderConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _storagefactoryservice.StorageFactoryService === "undefined" ? Object : _storagefactoryservice.StorageFactoryService,
-        typeof _storageconfigservice.StorageConfigService === "undefined" ? Object : _storageconfigservice.StorageConfigService,
-        typeof _storageproviderconfigservice.StorageProviderConfigService === "undefined" ? Object : _storageproviderconfigservice.StorageProviderConfigService
-    ])
-], UploadService);