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

package/cjs/services/folder.service.spec.js

@@ -1,167 +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 _folderservice = require("./folder.service");
-const _storageconfigservice = require("./storage-config.service");
-const _storagedatasourceprovider = require("./storage-datasource.provider");
-const _entities = require("../entities");
-describe('FolderService', ()=>{
-    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)
-        };
-        module = await _testing.Test.createTestingModule({
-            providers: [
-                _folderservice.FolderService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: _modules.UtilsService,
-                    useValue: {}
-                },
-                {
-                    provide: _storageconfigservice.StorageConfigService,
-                    useValue: mockStorageConfig
-                },
-                {
-                    provide: _storagedatasourceprovider.StorageDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(_folderservice.FolderService);
-    });
-    describe('entity selection', ()=>{
-        it('uses Folder when the company feature is disabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(_folderservice.FolderService);
-            expect(built['_entity']).toBe(_entities.Folder);
-        });
-        it('uses FolderWithCompany when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(_folderservice.FolderService);
-            expect(built['_entity']).toBe(_entities.FolderWithCompany);
-        });
-    });
-    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: 'Invoices'
-            }, (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: 'Invoices'
-            }, (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-7'
-            }));
-            expect(entity.companyId).toBe('company-7');
-        });
-        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: 'Invoices'
-            }, null);
-            expect(entity.companyId).toBeNull();
-        });
-        it('loads and merges the existing entity when updating (dto has an id)', async ()=>{
-            const existing = {
-                id: 'folder-1',
-                name: 'Old Name'
-            };
-            mockRepo.findOne.mockResolvedValue(existing);
-            const entity = await service.convertSingleDtoToEntity({
-                id: 'folder-1',
-                name: 'New Name'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(mockRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'folder-1'
-                }
-            });
-            expect(entity.name).toBe('New Name');
-        });
-        it('throws NotFoundException when updating a folder that does not exist', async ()=>{
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.convertSingleDtoToEntity({
-                id: 'missing-id',
-                name: 'x'
-            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
-        });
-    });
-    describe('getSelectQuery', ()=>{
-        it('selects the default field set (id, name, slug, createdAt, deletedAt) when none is provided', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)());
-            expect(query.select).toHaveBeenCalledWith([
-                'folder.id',
-                'folder.name',
-                'folder.slug',
-                'folder.createdAt',
-                'folder.deletedAt'
-            ]);
-        });
-        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('folder.companyId');
-        });
-        it('respects an explicitly provided select list', async ()=>{
-            const query = {
-                select: jest.fn().mockReturnThis()
-            };
-            await service.getSelectQuery(query, (0, _loggedusermock.buildMockUser)(), [
-                'id'
-            ]);
-            expect(query.select).toHaveBeenCalledWith([
-                'folder.id'
-            ]);
-        });
-    });
-    describe('getExtraManipulateQuery', ()=>{
-        it('applies the company filter when company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-3'
-            }));
-            expect(query.andWhere).toHaveBeenCalledWith('folder.companyId = :companyId', {
-                companyId: 'company-3'
-            });
-        });
-        it('does not apply a company filter when company feature is disabled', async ()=>{
-            const query = {
-                andWhere: jest.fn().mockReturnThis()
-            };
-            await service.getExtraManipulateQuery(query, {}, (0, _loggedusermock.buildMockUser)());
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-    });
-});

package/cjs/services/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./file-manager.service"), exports);
-_export_star(require("./folder.service"), exports);
-_export_star(require("./storage-config.service"), exports);
-_export_star(require("./storage-provider-config.service"), exports);
-_export_star(require("./storage-datasource.provider"), exports);
-_export_star(require("./upload.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

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

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "StorageConfigService", {
-    enumerable: true,
-    get: function() {
-        return StorageConfigService;
-    }
-});
-const _common = require("@nestjs/common");
-const _config = require("../config");
-const _storageconstants = require("../config/storage.constants");
-const _interfaces = require("../interfaces");
-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);
-    };
-}
-const BYTES_PER_MB = 1024 * 1024;
-const DEFAULT_LOCAL_PATH = './uploads';
-const DEFAULT_PORT = '3000';
-let StorageConfigService = class StorageConfigService {
-    // ─── IModuleConfigService Implementation ────────────────────────────────────
-    isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    // ─── Config Getters ─────────────────────────────────────────────────────────
-    getMaxFileSize() {
-        return this.options.config?.maxFileSize ?? _storageconstants.DEFAULT_MAX_FILE_SIZE;
-    }
-    getAllowedFileTypes() {
-        return this.options.config?.allowedFileTypes ?? _storageconstants.DEFAULT_ALLOWED_FILE_TYPES;
-    }
-    getOptions() {
-        return this.options;
-    }
-    getDefaultLocalStoragePath() {
-        return this.options.config?.localStoragePath ?? DEFAULT_LOCAL_PATH;
-    }
-    getAppUrl() {
-        return this.options.config?.appUrl ?? process.env.APP_URL ?? `http://localhost:${process.env.PORT ?? DEFAULT_PORT}`;
-    }
-    // ─── Validation Methods ─────────────────────────────────────────────────────
-    isFileTypeAllowed(mimeType) {
-        const allowedTypes = this.getAllowedFileTypes();
-        if (allowedTypes.includes('*/*')) {
-            return true;
-        }
-        return allowedTypes.some((type)=>type.endsWith('/*') ? mimeType.startsWith(type.slice(0, -2)) : type === mimeType);
-    }
-    validateFileSize(fileSize) {
-        const maxSize = this.getMaxFileSize();
-        if (fileSize > maxSize) {
-            return {
-                valid: false,
-                message: `File size (${this.toMB(fileSize)}MB) exceeds maximum ${this.toMB(maxSize)}MB`,
-                messageKey: _config.UPLOAD_MESSAGES.FILE_TOO_LARGE,
-                messageVariables: {
-                    fileSize: this.toMB(fileSize),
-                    maxSize: this.toMB(maxSize)
-                }
-            };
-        }
-        return {
-            valid: true
-        };
-    }
-    validateFileType(mimeType) {
-        if (!this.isFileTypeAllowed(mimeType)) {
-            return {
-                valid: false,
-                message: `File type "${mimeType}" not allowed. Allowed: ${this.getAllowedFileTypes().join(', ')}`,
-                messageKey: _config.UPLOAD_MESSAGES.INVALID_TYPE,
-                messageVariables: {
-                    mimeType,
-                    allowedTypes: this.getAllowedFileTypes().join(', ')
-                }
-            };
-        }
-        return {
-            valid: true
-        };
-    }
-    // ─── Private Helpers ────────────────────────────────────────────────────────
-    toMB(bytes) {
-        return (bytes / BYTES_PER_MB).toFixed(2);
-    }
-    constructor(options){
-        _define_property(this, "options", void 0);
-        this.options = options;
-    }
-};
-StorageConfigService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_storageconstants.STORAGE_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _interfaces.StorageModuleOptions === "undefined" ? Object : _interfaces.StorageModuleOptions
-    ])
-], StorageConfigService);

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

@@ -1,257 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _storageconfigservice = require("./storage-config.service");
-const _config = require("../config");
-function buildOptions(overrides = {}) {
-    return {
-        bootstrapAppConfig: {
-            databaseMode: 'single',
-            enableCompanyFeature: false
-        },
-        config: {},
-        ...overrides
-    };
-}
-describe('StorageConfigService', ()=>{
-    describe('bootstrap config getters', ()=>{
-        it('reflects enableCompanyFeature from bootstrap config', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-        });
-        it('defaults enableCompanyFeature to false when bootstrapAppConfig is absent', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-        it('defaults databaseMode to single when bootstrapAppConfig is absent', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.getDatabaseMode()).toBe('single');
-        });
-        it('reports isMultiTenant() true only in multi-tenant mode', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(true);
-        });
-        it('reports isMultiTenant() false in single mode', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions());
-            expect(service.isMultiTenant()).toBe(false);
-        });
-    });
-    describe('getMaxFileSize', ()=>{
-        it('returns the configured max file size', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    maxFileSize: 5000
-                }
-            }));
-            expect(service.getMaxFileSize()).toBe(5000);
-        });
-        it('falls back to the default max file size (100MB) when not configured', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getMaxFileSize()).toBe(100 * 1024 * 1024);
-        });
-    });
-    describe('getAllowedFileTypes', ()=>{
-        it('returns configured allowed types', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/png'
-                    ]
-                }
-            }));
-            expect(service.getAllowedFileTypes()).toEqual([
-                'image/png'
-            ]);
-        });
-        it('defaults to */* when not configured', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getAllowedFileTypes()).toEqual([
-                '*/*'
-            ]);
-        });
-    });
-    describe('getDefaultLocalStoragePath', ()=>{
-        it('returns the configured local storage path', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    localStoragePath: './custom-uploads'
-                }
-            }));
-            expect(service.getDefaultLocalStoragePath()).toBe('./custom-uploads');
-        });
-        it('defaults to ./uploads when not configured', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getDefaultLocalStoragePath()).toBe('./uploads');
-        });
-    });
-    describe('getAppUrl', ()=>{
-        const originalAppUrl = process.env.APP_URL;
-        const originalPort = process.env.PORT;
-        afterEach(()=>{
-            process.env.APP_URL = originalAppUrl;
-            process.env.PORT = originalPort;
-        });
-        it('returns the explicitly configured appUrl', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    appUrl: 'https://files.example.com'
-                }
-            }));
-            expect(service.getAppUrl()).toBe('https://files.example.com');
-        });
-        it('falls back to process.env.APP_URL when config.appUrl is absent', ()=>{
-            delete process.env.APP_URL;
-            process.env.APP_URL = 'https://env.example.com';
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getAppUrl()).toBe('https://env.example.com');
-        });
-        it('falls back to localhost with PORT when neither config nor env var is set', ()=>{
-            delete process.env.APP_URL;
-            process.env.PORT = '4000';
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getAppUrl()).toBe('http://localhost:4000');
-        });
-    });
-    describe('isFileTypeAllowed', ()=>{
-        it('allows any type when */* is configured', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        '*/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
-        });
-        it('allows types matching a category wildcard', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('image/png')).toBe(true);
-        });
-        it('rejects types outside the allow-list', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('application/pdf')).toBe(false);
-        });
-        it('allows an exact MIME type match', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'application/pdf'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
-        });
-    });
-    describe('validateFileSize', ()=>{
-        it('passes when file size is within the limit', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    maxFileSize: 1000
-                }
-            }));
-            expect(service.validateFileSize(500)).toEqual({
-                valid: true
-            });
-        });
-        it('passes at the exact boundary size', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    maxFileSize: 1000
-                }
-            }));
-            expect(service.validateFileSize(1000).valid).toBe(true);
-        });
-        it('fails when file size exceeds the limit by one byte', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    maxFileSize: 1000
-                }
-            }));
-            const result = service.validateFileSize(1001);
-            expect(result.valid).toBe(false);
-            expect(result.messageKey).toBe(_config.UPLOAD_MESSAGES.FILE_TOO_LARGE);
-            expect(result.messageVariables).toEqual({
-                fileSize: '0.00',
-                maxSize: '0.00'
-            });
-        });
-        it('reports MB-converted size values in the failure message', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    maxFileSize: 1 * 1024 * 1024
-                }
-            }));
-            const result = service.validateFileSize(2 * 1024 * 1024);
-            expect(result.message).toContain('2.00MB');
-            expect(result.message).toContain('1.00MB');
-        });
-    });
-    describe('validateFileType', ()=>{
-        it('passes for an allowed type', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            expect(service.validateFileType('image/png')).toEqual({
-                valid: true
-            });
-        });
-        it('fails for a disallowed type with a descriptive message and messageKey', ()=>{
-            const service = new _storageconfigservice.StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            const result = service.validateFileType('application/pdf');
-            expect(result.valid).toBe(false);
-            expect(result.messageKey).toBe(_config.UPLOAD_MESSAGES.INVALID_TYPE);
-            expect(result.message).toContain('application/pdf');
-            expect(result.messageVariables).toEqual({
-                mimeType: 'application/pdf',
-                allowedTypes: 'image/*'
-            });
-        });
-    });
-});