@flusys/nestjs-storage 6.0.2 → 6.1.1

package/cjs/controllers/file-manager.controller.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _filemanagercontroller = require("./file-manager.controller");
+function buildFile(overrides = {}) {
+    return {
+        id: 'file-1',
+        name: 'report.pdf',
+        key: 'files/report.pdf',
+        size: 1024,
+        contentType: 'application/pdf',
+        isActive: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('FileManagerController', ()=>{
+    let controller;
+    let mockFileService;
+    beforeEach(()=>{
+        mockFileService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            getFiles: jest.fn()
+        };
+        controller = new _filemanagercontroller.FileManagerController(mockFileService);
+    });
+    describe('insert', ()=>{
+        it('creates a file record and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockFileService.insert.mockResolvedValue(buildFile());
+            const result = await controller.insert({
+                name: 'report.pdf'
+            }, user);
+            expect(mockFileService.insert).toHaveBeenCalledWith({
+                name: 'report.pdf'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'file-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates files and maps the response list', async ()=>{
+            mockFileService.getAll.mockResolvedValue({
+                data: [
+                    buildFile()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockFileService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('getFiles', ()=>{
+        it('resolves signed/public URLs for the requested files using the request protocol and host', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const req = {
+                protocol: 'https',
+                hostname: 'app.example.com',
+                get: jest.fn().mockReturnValue('app.example.com')
+            };
+            mockFileService.getFiles.mockResolvedValue([
+                {
+                    id: 'file-1',
+                    url: 'https://app.example.com/storage/upload/file/report.pdf'
+                }
+            ]);
+            const result = await controller.getFiles([
+                {
+                    id: 'file-1'
+                }
+            ], req, user);
+            expect(mockFileService.getFiles).toHaveBeenCalledWith([
+                {
+                    id: 'file-1'
+                }
+            ], 'https', 'app.example.com', user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual([
+                {
+                    id: 'file-1',
+                    url: 'https://app.example.com/storage/upload/file/report.pdf'
+                }
+            ]);
+        });
+        it('falls back to req.hostname when the host header is absent', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const req = {
+                protocol: 'http',
+                hostname: 'localhost',
+                get: jest.fn().mockReturnValue(undefined)
+            };
+            mockFileService.getFiles.mockResolvedValue([]);
+            await controller.getFiles([
+                {
+                    id: 'file-1'
+                }
+            ], req, user);
+            expect(mockFileService.getFiles).toHaveBeenCalledWith([
+                {
+                    id: 'file-1'
+                }
+            ], 'http', 'localhost', user);
+        });
+        it('rejects an empty file id list without calling the service', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const req = {
+                protocol: 'https',
+                get: jest.fn()
+            };
+            await expect(controller.getFiles([], req, user)).rejects.toThrow(_common.BadRequestException);
+            expect(mockFileService.getFiles).not.toHaveBeenCalled();
+        });
+        it('rejects a null/undefined dto without calling the service', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const req = {
+                protocol: 'https',
+                get: jest.fn()
+            };
+            await expect(controller.getFiles(undefined, req, user)).rejects.toThrow(_common.BadRequestException);
+            expect(mockFileService.getFiles).not.toHaveBeenCalled();
+        });
+    });
+});

package/cjs/controllers/folder.controller.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _foldercontroller = require("./folder.controller");
+function buildFolder(overrides = {}) {
+    return {
+        id: 'folder-1',
+        name: 'Documents',
+        parentId: null,
+        isActive: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('FolderController', ()=>{
+    let controller;
+    let mockFolderService;
+    beforeEach(()=>{
+        mockFolderService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new _foldercontroller.FolderController(mockFolderService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.folderService).toBe(mockFolderService);
+        expect(controller.service).toBe(mockFolderService);
+    });
+    describe('insert', ()=>{
+        it('creates a folder and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockFolderService.insert.mockResolvedValue(buildFolder());
+            const result = await controller.insert({
+                name: 'Documents'
+            }, user);
+            expect(mockFolderService.insert).toHaveBeenCalledWith({
+                name: 'Documents'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'folder-1',
+                name: 'Documents'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates folders and maps the response list', async ()=>{
+            mockFolderService.getAll.mockResolvedValue({
+                data: [
+                    buildFolder()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockFolderService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockFolderService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'folder-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockFolderService.delete).toHaveBeenCalledWith({
+                id: [
+                    'folder-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/storage-config.controller.spec.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _storageconfigcontroller = require("./storage-config.controller");
+function buildStorageConfig(overrides = {}) {
+    return {
+        id: 'storage-config-1',
+        provider: 'local',
+        isActive: true,
+        isDefault: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('StorageConfigController', ()=>{
+    let controller;
+    let mockStorageConfigService;
+    beforeEach(()=>{
+        mockStorageConfigService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new _storageconfigcontroller.StorageConfigController(mockStorageConfigService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.storageConfigService).toBe(mockStorageConfigService);
+        expect(controller.service).toBe(mockStorageConfigService);
+    });
+    describe('insert', ()=>{
+        it('creates a storage config and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockStorageConfigService.insert.mockResolvedValue(buildStorageConfig());
+            const result = await controller.insert({
+                provider: 'local'
+            }, user);
+            expect(mockStorageConfigService.insert).toHaveBeenCalledWith({
+                provider: 'local'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'storage-config-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates storage configs and maps the response list', async ()=>{
+            mockStorageConfigService.getAll.mockResolvedValue({
+                data: [
+                    buildStorageConfig()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockStorageConfigService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockStorageConfigService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'storage-config-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockStorageConfigService.delete).toHaveBeenCalledWith({
+                id: [
+                    'storage-config-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/upload.controller.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _uploadcontroller = require("./upload.controller");
+describe('UploadController', ()=>{
+    let controller;
+    let mockUploadService;
+    beforeEach(()=>{
+        mockUploadService = {
+            bytesToKb: jest.fn((bytes)=>bytes / 1024),
+            uploadSingleFile: jest.fn(),
+            uploadMultipleFiles: jest.fn(),
+            deleteSingleFile: jest.fn(),
+            deleteMultipleFile: jest.fn()
+        };
+        controller = new _uploadcontroller.UploadController(mockUploadService);
+    });
+    describe('uploadSingleFile', ()=>{
+        it('uploads a file and maps the response payload', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const file = {
+                originalname: 'photo.png'
+            };
+            mockUploadService.uploadSingleFile.mockResolvedValue({
+                size: 2048,
+                name: 'photo.png',
+                key: 'files/photo.png',
+                contentType: 'image/png',
+                location: 's3',
+                storageConfigId: 'storage-1'
+            });
+            const result = await controller.uploadSingleFile(file, {
+                folderPath: 'photos'
+            }, user);
+            expect(mockUploadService.uploadSingleFile).toHaveBeenCalledWith(file, {
+                folderPath: 'photos'
+            }, user);
+            expect(mockUploadService.bytesToKb).toHaveBeenCalledWith(2048);
+            expect(result).toEqual({
+                success: true,
+                message: 'File uploaded successfully',
+                messageKey: expect.any(String),
+                data: {
+                    size: 2,
+                    name: 'photo.png',
+                    key: 'files/photo.png',
+                    contentType: 'image/png',
+                    location: 's3',
+                    storageConfigId: 'storage-1'
+                }
+            });
+        });
+        it('defaults location to "local" and storageConfigId to an empty string when absent', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUploadService.uploadSingleFile.mockResolvedValue({
+                size: 100,
+                name: 'file.txt',
+                key: 'files/file.txt',
+                contentType: 'text/plain'
+            });
+            const result = await controller.uploadSingleFile({}, {}, user);
+            expect(result.data.location).toBe('local');
+            expect(result.data.storageConfigId).toBe('');
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads multiple files and maps each response payload', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            const files = [
+                {
+                    originalname: 'a.png'
+                },
+                {
+                    originalname: 'b.png'
+                }
+            ];
+            mockUploadService.uploadMultipleFiles.mockResolvedValue([
+                {
+                    size: 100,
+                    name: 'a.png',
+                    key: 'files/a.png',
+                    contentType: 'image/png'
+                },
+                {
+                    size: 200,
+                    name: 'b.png',
+                    key: 'files/b.png',
+                    contentType: 'image/png'
+                }
+            ]);
+            const result = await controller.uploadMultipleFiles(files, {}, user);
+            expect(mockUploadService.uploadMultipleFiles).toHaveBeenCalledWith(files, {}, user);
+            expect(result.data).toHaveLength(2);
+            expect(result.data[0]).toEqual(expect.objectContaining({
+                name: 'a.png',
+                key: 'files/a.png'
+            }));
+        });
+    });
+    describe('deleteSingleFile', ()=>{
+        it('deletes a file by key and storage config', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUploadService.deleteSingleFile.mockResolvedValue(true);
+            const result = await controller.deleteSingleFile({
+                key: 'files/a.png',
+                storageConfigId: 'storage-1'
+            }, user);
+            expect(mockUploadService.deleteSingleFile).toHaveBeenCalledWith('files/a.png', 'storage-1', user);
+            expect(result.data).toBe(true);
+        });
+    });
+    describe('deleteMultipleFile', ()=>{
+        it('deletes multiple files by keys and storage config', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockUploadService.deleteMultipleFile.mockResolvedValue(true);
+            const result = await controller.deleteMultipleFile({
+                keys: [
+                    'files/a.png',
+                    'files/b.png'
+                ],
+                storageConfigId: 'storage-1'
+            }, user);
+            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
+                'files/a.png',
+                'files/b.png'
+            ], 'storage-1', user);
+            expect(result.data).toBe(true);
+        });
+    });
+});

package/cjs/docs/storage-swagger.config.spec.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _storageswaggerconfig = require("./storage-swagger.config");
+describe('storageSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _storageswaggerconfig.storageSwaggerConfig)();
+        expect(config.title).toBe('Storage API');
+        expect(config.path).toBe('api/docs/storage');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeTags).toEqual([]);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+        expect(config.description).toContain('with multi-tenant support');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'FileManagerResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'FolderResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'StorageConfigResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company isolation and multi-tenant sections only when the company feature is enabled', ()=>{
+        const withCompany = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withCompany.description).toContain('## Examples');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+        expect(withoutCompany.description).not.toContain('## Examples');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _storageswaggerconfig.storageSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+describe('getStorageEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getStorageEntitiesByConfig)(false)).toBe(_index.StorageCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getStorageEntitiesByConfig)(true)).toBe(_index.StorageCompanyEntities);
+    });
+    it('core and company entity sets are disjoint (never mixed)', ()=>{
+        const core = (0, _index.getStorageEntitiesByConfig)(false);
+        const company = (0, _index.getStorageEntitiesByConfig)(true);
+        expect(core.some((e)=>company.includes(e))).toBe(false);
+    });
+});