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

package/cjs/utils/image-compressor.util.js

@@ -1,162 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "ImageCompressor", {
-    enumerable: true,
-    get: function() {
-        return ImageCompressor;
-    }
-});
-const _sharp = /*#__PURE__*/ _interop_require_wildcard(require("sharp"));
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-// Handle ESM/CJS interop - sharp exports differently in each module system
-const sharp = _sharp.default || _sharp;
-let ImageCompressor = class ImageCompressor {
-    /**
-   * Dynamically compresses an image based on its format and provided options.
-   * - Preserves original format if not overridden
-   * - Adjusts compression settings for each codec
-   */ static async compress(buffer, mimetype, options = {}) {
-        const { maxWidth = 1280, maxHeight = 1280, quality = 85, format = 'original' } = options;
-        // Skip processing for SVG
-        if (mimetype === 'image/svg+xml') {
-            return {
-                buffer,
-                format: mimetype
-            };
-        }
-        // Initialize sharp with improved error handling
-        const image = sharp(buffer, {
-            failOnError: false,
-            density: 300
-        });
-        // Apply initial resize
-        image.resize({
-            width: maxWidth,
-            height: maxHeight,
-            fit: 'inside',
-            withoutEnlargement: true
-        });
-        // Determine target format
-        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
-        // Format-specific optimizations
-        switch(targetFormat.toLowerCase()){
-            case 'jpeg':
-            case 'jpg':
-                image.jpeg({
-                    quality,
-                    mozjpeg: true,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'png':
-                image.png({
-                    compressionLevel: 9,
-                    adaptiveFiltering: true,
-                    palette: true,
-                    quality,
-                    colors: 256,
-                    dither: 1.0
-                });
-                break;
-            case 'webp':
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6,
-                    lossless: quality === 100
-                });
-                break;
-            case 'avif':
-                image.avif({
-                    quality,
-                    effort: 6,
-                    chromaSubsampling: '4:4:4'
-                });
-                break;
-            case 'tiff':
-                image.tiff({
-                    quality,
-                    compression: 'lzw',
-                    predictor: 'horizontal',
-                    pyramid: true
-                });
-                break;
-            case 'gif':
-                image.gif({
-                    colours: 256,
-                    effort: 10,
-                    dither: 1
-                });
-                break;
-            case 'jp2':
-                image.jp2({
-                    quality,
-                    lossless: quality === 100
-                });
-                break;
-            default:
-                // Fallback to WebP for best compression/quality ratio
-                targetFormat = 'webp';
-                image.webp({
-                    quality,
-                    smartSubsample: true,
-                    effort: 6
-                });
-                break;
-        }
-        try {
-            const compressedBuffer = await image.toBuffer();
-            return {
-                buffer: compressedBuffer,
-                format: `image/${targetFormat}`
-            };
-        } catch  {
-            return {
-                buffer,
-                format: mimetype
-            };
-        }
-    }
-};

package/cjs/utils/image-compressor.util.spec.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _imagecompressorutil = require("./image-compressor.util");
-const mockToBuffer = jest.fn();
-const mockJpeg = jest.fn();
-const mockPng = jest.fn();
-const mockWebp = jest.fn();
-const mockAvif = jest.fn();
-const mockTiff = jest.fn();
-const mockGif = jest.fn();
-const mockJp2 = jest.fn();
-const mockResize = jest.fn();
-function buildChainableImage() {
-    const image = {};
-    image.resize = mockResize.mockReturnValue(image);
-    image.jpeg = mockJpeg.mockReturnValue(image);
-    image.png = mockPng.mockReturnValue(image);
-    image.webp = mockWebp.mockReturnValue(image);
-    image.avif = mockAvif.mockReturnValue(image);
-    image.tiff = mockTiff.mockReturnValue(image);
-    image.gif = mockGif.mockReturnValue(image);
-    image.jp2 = mockJp2.mockReturnValue(image);
-    image.toBuffer = mockToBuffer;
-    return image;
-}
-const mockSharpFactory = jest.fn();
-jest.mock('sharp', ()=>{
-    const factory = (...args)=>mockSharpFactory(...args);
-    return {
-        __esModule: true,
-        default: factory
-    };
-});
-describe('ImageCompressor', ()=>{
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        mockSharpFactory.mockImplementation(()=>buildChainableImage());
-        mockToBuffer.mockResolvedValue(Buffer.from('compressed-image-data'));
-    });
-    it('returns the buffer unchanged for image/svg+xml without invoking sharp', async ()=>{
-        const buffer = Buffer.from('<svg></svg>');
-        const result = await _imagecompressorutil.ImageCompressor.compress(buffer, 'image/svg+xml');
-        expect(result.buffer).toBe(buffer);
-        expect(result.format).toBe('image/svg+xml');
-        expect(mockSharpFactory).not.toHaveBeenCalled();
-    });
-    it('resizes using default maxWidth/maxHeight when no options are provided', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('jpeg-bytes'), 'image/jpeg');
-        expect(mockResize).toHaveBeenCalledWith(expect.objectContaining({
-            width: 1280,
-            height: 1280,
-            fit: 'inside',
-            withoutEnlargement: true
-        }));
-    });
-    it('resizes using custom maxWidth/maxHeight when provided', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('jpeg-bytes'), 'image/jpeg', {
-            maxWidth: 500,
-            maxHeight: 600
-        });
-        expect(mockResize).toHaveBeenCalledWith(expect.objectContaining({
-            width: 500,
-            height: 600
-        }));
-    });
-    it('preserves the original format (derived from mimetype) when format is "original"', async ()=>{
-        const result = await _imagecompressorutil.ImageCompressor.compress(Buffer.from('png-bytes'), 'image/png', {
-            format: 'original'
-        });
-        expect(mockPng).toHaveBeenCalled();
-        expect(result.format).toBe('image/png');
-    });
-    it('applies jpeg-specific compression options with quality', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg', {
-            quality: 70
-        });
-        expect(mockJpeg).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 70,
-            mozjpeg: true
-        }));
-    });
-    it('applies png-specific compression options', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/png', {
-            quality: 90
-        });
-        expect(mockPng).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 90,
-            colors: 256
-        }));
-    });
-    it('applies webp-specific options and sets lossless=true only when quality is 100', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/webp', {
-            quality: 100,
-            format: 'webp'
-        });
-        expect(mockWebp).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 100,
-            lossless: true
-        }));
-    });
-    it('applies webp-specific options with lossless=false for quality < 100', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/webp', {
-            quality: 80,
-            format: 'webp'
-        });
-        expect(mockWebp).toHaveBeenCalledWith(expect.objectContaining({
-            quality: 80,
-            lossless: false
-        }));
-    });
-    it('applies avif-specific compression options', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/avif', {
-            format: 'avif'
-        });
-        expect(mockAvif).toHaveBeenCalled();
-    });
-    it('applies tiff-specific compression options', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/tiff', {
-            format: 'tiff'
-        });
-        expect(mockTiff).toHaveBeenCalled();
-    });
-    it('applies gif-specific compression options', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/gif', {
-            format: 'gif'
-        });
-        expect(mockGif).toHaveBeenCalled();
-    });
-    it('applies jp2-specific compression options', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/jp2', {
-            format: 'jp2'
-        });
-        expect(mockJp2).toHaveBeenCalled();
-    });
-    it('falls back to webp for an unrecognized target format', async ()=>{
-        const result = await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/unknownformat', {
-            format: 'original'
-        });
-        expect(mockWebp).toHaveBeenCalled();
-        expect(result.format).toBe('image/webp');
-    });
-    it('returns the compressed buffer and content-type prefixed format on success', async ()=>{
-        mockToBuffer.mockResolvedValue(Buffer.from('final-bytes'));
-        const result = await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg', {
-            format: 'jpeg'
-        });
-        expect(result.buffer).toEqual(Buffer.from('final-bytes'));
-        expect(result.format).toBe('image/jpeg');
-    });
-    it('falls back to the original buffer and mimetype when sharp processing throws', async ()=>{
-        const originalBuffer = Buffer.from('original-bytes');
-        mockToBuffer.mockRejectedValue(new Error('corrupt image'));
-        const result = await _imagecompressorutil.ImageCompressor.compress(originalBuffer, 'image/png');
-        expect(result.buffer).toBe(originalBuffer);
-        expect(result.format).toBe('image/png');
-    });
-    it('initializes sharp with failOnError=false and a density hint', async ()=>{
-        await _imagecompressorutil.ImageCompressor.compress(Buffer.from('bytes'), 'image/jpeg');
-        expect(mockSharpFactory).toHaveBeenCalledWith(expect.any(Buffer), expect.objectContaining({
-            failOnError: false,
-            density: 300
-        }));
-    });
-});

package/cjs/utils/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./image-compressor.util"), 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/fesm/config/event-actions.js

@@ -1,13 +0,0 @@
-/**
- * Domain event actions published by the storage module, alongside the CRUD
- * lifecycle actions every ApiService emits.
- */ export const STORAGE_EVENT_ACTIONS = {
-    UPLOADED: 'uploaded',
-    REMOVED: 'removed'
-};
-/** Every entity the storage module publishes under, ApiService backed or not */ export const STORAGE_EVENT_ENTITIES = {
-    FILE: 'file_manager',
-    FOLDER: 'folder',
-    STORAGE_CONFIG: 'storageConfig'
-};
-export const STORAGE_EVENT_MODULE = 'storage';

package/fesm/config/message-keys.js

@@ -1,22 +0,0 @@
-// ==================== STORAGE MODULE MESSAGE KEYS ====================
-export const FILE_MESSAGES = {
-    GET_ALL_SUCCESS: 'file.get.all.success',
-    DELETE_SUCCESS: 'file.delete.success',
-    NOT_FOUND: 'file.not.found'
-};
-export const STORAGE_CONFIG_MESSAGES = {
-    DEFAULT_DELETE_FORBIDDEN: 'storage.config.default.delete.forbidden'
-};
-export const FOLDER_MESSAGES = {
-    NOT_FOUND: 'folder.not.found'
-};
-export const UPLOAD_MESSAGES = {
-    SUCCESS: 'upload.success',
-    MANY_SUCCESS: 'upload.many.success',
-    FILE_TOO_LARGE: 'upload.file.too.large',
-    INVALID_TYPE: 'upload.invalid.type',
-    NO_FILES_PROVIDED: 'upload.no.files.provided',
-    NO_FILE_PATH: 'upload.no.file.path',
-    INVALID_FILE_PATH: 'upload.invalid.file.path',
-    CONFIG_NOT_FOUND: 'upload.config.not.found'
-};

package/fesm/config/storage.constants.js

@@ -1,7 +0,0 @@
-/**
- * Storage Module Constants
- */ export const STORAGE_MODULE_OPTIONS = 'STORAGE_MODULE_OPTIONS';
-export const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
-export const DEFAULT_ALLOWED_FILE_TYPES = [
-    '*/*'
-]; // All file types

package/fesm/controllers/file-manager.controller.js

@@ -1,142 +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 { BadRequestException, Body, Controller, HttpCode, Inject, Post, Req, UseGuards } from '@nestjs/common';
-import { createApiController, FILE_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { FILE_MESSAGES, UPLOAD_MESSAGES } from '../config';
-import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { SingleResponseDto } from '@flusys/nestjs-shared/dtos';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { CreateFileManagerDto, FileManagerResponseDto, GetFilesRequestDto, UpdateFileManagerDto } from '../dtos';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { Request } from 'express';
-import { FileManagerService } from '../services/file-manager.service';
-export class FileManagerController extends createApiController(CreateFileManagerDto, UpdateFileManagerDto, FileManagerResponseDto, {
-    entityName: 'file',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                FILE_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async getFiles(dto, req, user) {
-        if (!dto || !dto.length) {
-            throw new BadRequestException({
-                message: 'No files provided',
-                messageKey: UPLOAD_MESSAGES.NO_FILES_PROVIDED
-            });
-        }
-        // Fetch files from service
-        const files = await this.fileService.getFiles(dto, req.protocol, req.get('host') || req.hostname, user);
-        return {
-            success: true,
-            message: 'Files retrieved successfully',
-            messageKey: FILE_MESSAGES.GET_ALL_SUCCESS,
-            data: files
-        };
-    }
-    constructor(fileService){
-        super(fileService), _define_property(this, "fileService", void 0), this.fileService = fileService;
-    }
-}
-_ts_decorate([
-    Post('get-files'),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    HttpCode(200),
-    ApiBody({
-        type: GetFilesRequestDto,
-        isArray: true
-    }),
-    ApiOperation({
-        summary: 'Get multiple files by IDs with authentication (local or S3)'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Files retrieved successfully',
-        type: SingleResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, Req()),
-    _ts_param(2, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Array === "undefined" ? Object : Array,
-        typeof Request === "undefined" ? Object : Request,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], FileManagerController.prototype, "getFiles", null);
-FileManagerController = _ts_decorate([
-    ApiTags('Files'),
-    Controller('storage/file-manager'),
-    _ts_param(0, Inject(FileManagerService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof FileManagerService === "undefined" ? Object : FileManagerService
-    ])
-], FileManagerController);

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

@@ -1,131 +0,0 @@
-import { BadRequestException } from '@nestjs/common';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { FileManagerController } from './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(mockFileService);
-    });
-    describe('insert', ()=>{
-        it('creates a file record and returns the mapped response', async ()=>{
-            const user = 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({}, buildMockUser(), '');
-            expect(mockFileService.getAll).toHaveBeenCalledWith('', {}, 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 = 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 = 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 = buildMockUser();
-            const req = {
-                protocol: 'https',
-                get: jest.fn()
-            };
-            await expect(controller.getFiles([], req, user)).rejects.toThrow(BadRequestException);
-            expect(mockFileService.getFiles).not.toHaveBeenCalled();
-        });
-        it('rejects a null/undefined dto without calling the service', async ()=>{
-            const user = buildMockUser();
-            const req = {
-                protocol: 'https',
-                get: jest.fn()
-            };
-            await expect(controller.getFiles(undefined, req, user)).rejects.toThrow(BadRequestException);
-            expect(mockFileService.getFiles).not.toHaveBeenCalled();
-        });
-    });
-});