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

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

@@ -1,163 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { FolderService } from './folder.service';
-import { StorageConfigService } from './storage-config.service';
-import { StorageDataSourceProvider } from './storage-datasource.provider';
-import { Folder, FolderWithCompany } from '../entities';
-describe('FolderService', ()=>{
-    let service;
-    let module;
-    let mockRepo;
-    let mockStorageConfig;
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        mockStorageConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        module = await Test.createTestingModule({
-            providers: [
-                FolderService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: UtilsService,
-                    useValue: {}
-                },
-                {
-                    provide: StorageConfigService,
-                    useValue: mockStorageConfig
-                },
-                {
-                    provide: StorageDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(FolderService);
-    });
-    describe('entity selection', ()=>{
-        it('uses Folder when the company feature is disabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(FolderService);
-            expect(built['_entity']).toBe(Folder);
-        });
-        it('uses FolderWithCompany when the company feature is enabled', async ()=>{
-            mockStorageConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(FolderService);
-            expect(built['_entity']).toBe(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'
-            }, 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'
-            }, 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'
-            }, 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'
-            }, 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, 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, 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, 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, {}, 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, {}, buildMockUser());
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,119 +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 { Inject, Injectable } from '@nestjs/common';
-import { UPLOAD_MESSAGES } from '../config';
-import { DEFAULT_ALLOWED_FILE_TYPES, DEFAULT_MAX_FILE_SIZE, STORAGE_MODULE_OPTIONS } from '../config/storage.constants';
-import { StorageModuleOptions } from '../interfaces';
-const BYTES_PER_MB = 1024 * 1024;
-const DEFAULT_LOCAL_PATH = './uploads';
-const DEFAULT_PORT = '3000';
-export 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 ?? DEFAULT_MAX_FILE_SIZE;
-    }
-    getAllowedFileTypes() {
-        return this.options.config?.allowedFileTypes ?? 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: 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: 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([
-    Injectable(),
-    _ts_param(0, Inject(STORAGE_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof StorageModuleOptions === "undefined" ? Object : StorageModuleOptions
-    ])
-], StorageConfigService);

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

@@ -1,253 +0,0 @@
-import { StorageConfigService } from './storage-config.service';
-import { UPLOAD_MESSAGES } from '../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(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-        });
-        it('defaults enableCompanyFeature to false when bootstrapAppConfig is absent', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-        it('defaults databaseMode to single when bootstrapAppConfig is absent', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.getDatabaseMode()).toBe('single');
-        });
-        it('reports isMultiTenant() true only in multi-tenant mode', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(true);
-        });
-        it('reports isMultiTenant() false in single mode', ()=>{
-            const service = new StorageConfigService(buildOptions());
-            expect(service.isMultiTenant()).toBe(false);
-        });
-    });
-    describe('getMaxFileSize', ()=>{
-        it('returns the configured max file size', ()=>{
-            const service = new 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(buildOptions({
-                config: {}
-            }));
-            expect(service.getMaxFileSize()).toBe(100 * 1024 * 1024);
-        });
-    });
-    describe('getAllowedFileTypes', ()=>{
-        it('returns configured allowed types', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/png'
-                    ]
-                }
-            }));
-            expect(service.getAllowedFileTypes()).toEqual([
-                'image/png'
-            ]);
-        });
-        it('defaults to */* when not configured', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {}
-            }));
-            expect(service.getAllowedFileTypes()).toEqual([
-                '*/*'
-            ]);
-        });
-    });
-    describe('getDefaultLocalStoragePath', ()=>{
-        it('returns the configured local storage path', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {
-                    localStoragePath: './custom-uploads'
-                }
-            }));
-            expect(service.getDefaultLocalStoragePath()).toBe('./custom-uploads');
-        });
-        it('defaults to ./uploads when not configured', ()=>{
-            const service = new 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(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(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(buildOptions({
-                config: {}
-            }));
-            expect(service.getAppUrl()).toBe('http://localhost:4000');
-        });
-    });
-    describe('isFileTypeAllowed', ()=>{
-        it('allows any type when */* is configured', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        '*/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('application/pdf')).toBe(true);
-        });
-        it('allows types matching a category wildcard', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('image/png')).toBe(true);
-        });
-        it('rejects types outside the allow-list', ()=>{
-            const service = new StorageConfigService(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            expect(service.isFileTypeAllowed('application/pdf')).toBe(false);
-        });
-        it('allows an exact MIME type match', ()=>{
-            const service = new 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(buildOptions({
-                config: {
-                    maxFileSize: 1000
-                }
-            }));
-            expect(service.validateFileSize(500)).toEqual({
-                valid: true
-            });
-        });
-        it('passes at the exact boundary size', ()=>{
-            const service = new 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(buildOptions({
-                config: {
-                    maxFileSize: 1000
-                }
-            }));
-            const result = service.validateFileSize(1001);
-            expect(result.valid).toBe(false);
-            expect(result.messageKey).toBe(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(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(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(buildOptions({
-                config: {
-                    allowedFileTypes: [
-                        'image/*'
-                    ]
-                }
-            }));
-            const result = service.validateFileType('application/pdf');
-            expect(result.valid).toBe(false);
-            expect(result.messageKey).toBe(UPLOAD_MESSAGES.INVALID_TYPE);
-            expect(result.message).toContain('application/pdf');
-            expect(result.messageVariables).toEqual({
-                mimeType: 'application/pdf',
-                allowedTypes: 'image/*'
-            });
-        });
-    });
-});

package/fesm/services/storage-datasource.provider.js

@@ -1,86 +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 { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { StorageConfigService } from './storage-config.service';
-export class StorageDataSourceProvider extends MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-    }
-    async getStorageEntities(enableCompanyFeature) {
-        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-        const entities = await import('../entities');
-        return enable ? [
-            entities.FileManagerWithCompany,
-            entities.FolderWithCompany,
-            entities.StorageConfigWithCompany
-        ] : [
-            entities.FileManager,
-            entities.Folder,
-            entities.StorageConfig
-        ];
-    }
-    async createDataSourceFromConfig(config) {
-        const currentTenant = this.getCurrentTenant();
-        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
-        const entities = await this.getStorageEntities(enableCompanyFeature);
-        return super.createDataSourceFromConfig(config, entities);
-    }
-    constructor(configService, request){
-        super(StorageDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
-    }
-}
-_define_property(StorageDataSourceProvider, "tenantConnections", new Map());
-_define_property(StorageDataSourceProvider, "singleDataSource", null);
-_define_property(StorageDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(StorageDataSourceProvider, "initialized", false);
-_define_property(StorageDataSourceProvider, "connectionLocks", new Map());
-_define_property(StorageDataSourceProvider, "singleConnectionLock", null);
-StorageDataSourceProvider = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(StorageConfigService)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof StorageConfigService === "undefined" ? Object : StorageConfigService,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], StorageDataSourceProvider);