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

package/cjs/modules/storage.module.spec.js

@@ -1,184 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _storagemodule = require("./storage.module");
-const _storageconstants = require("../config/storage.constants");
-const _controllers = require("../controllers");
-const _middlewares = require("../middlewares");
-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 providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('StorageModule', ()=>{
-    describe('forRoot', ()=>{
-        it('should default to a non-global module with all controllers registered', ()=>{
-            const dynamicModule = _storagemodule.StorageModule.forRoot({});
-            expect(dynamicModule.module).toBe(_storagemodule.StorageModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                _controllers.FileManagerController,
-                _controllers.FolderController,
-                _controllers.StorageConfigController,
-                _controllers.UploadController
-            ]);
-        });
-        it('should respect global: true', ()=>{
-            expect(_storagemodule.StorageModule.forRoot({
-                global: true
-            }).global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            expect(_storagemodule.StorageModule.forRoot({
-                includeController: false
-            }).controllers).toEqual([]);
-        });
-        it('should register controllers when includeController is anything other than exactly false', ()=>{
-            expect(_storagemodule.StorageModule.forRoot({
-                includeController: true
-            }).controllers).toHaveLength(4);
-            expect(_storagemodule.StorageModule.forRoot({}).controllers).toHaveLength(4);
-        });
-        it('should register a STORAGE_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            };
-            const dynamicModule = _storagemodule.StorageModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
-            expect(provider.useValue).toBe(options);
-        });
-        it('should always export the same fixed set of services', ()=>{
-            const dynamicModule = _storagemodule.StorageModule.forRoot({});
-            expect(dynamicModule.exports).toHaveLength(7);
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                includeController: false
-            });
-            expect(dynamicModule.controllers).toEqual([]);
-        });
-        it('useFactory: builds a STORAGE_MODULE_OPTIONS provider that merges resolved config into the static options', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                maxFileSize: 1024
-            });
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
-            expect(provider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-            const resolved = await provider.useFactory('injected');
-            expect(useFactory).toHaveBeenCalledWith('injected');
-            expect(resolved.config).toEqual({
-                maxFileSize: 1024
-            });
-        });
-        it('useClass: registers both the class provider and an options provider calling createStorageOptions()', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
-                        maxFileSize: 2048
-                    }));
-                }
-            };
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
-            const instance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(instance);
-            expect(instance.createStorageOptions).toHaveBeenCalled();
-            expect(resolved.config).toEqual({
-                maxFileSize: 2048
-            });
-        });
-        it('useExisting: registers a single options provider without a duplicate class registration', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
-                        maxFileSize: 4096
-                    }));
-                }
-            };
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useExisting: MyOptionsFactory
-            });
-            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _storageconstants.STORAGE_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-        });
-        it('should register no STORAGE_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {}
-            });
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_storageconstants.STORAGE_MODULE_OPTIONS);
-        });
-        it('should still register the fixed exported services as providers alongside async options', ()=>{
-            const dynamicModule = _storagemodule.StorageModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useFactory: jest.fn()
-            });
-            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
-                ...dynamicModule.exports
-            ]));
-        });
-    });
-    describe('configure (NestModule)', ()=>{
-        it('should wire FileServeMiddleware to the file GET route', ()=>{
-            const forRoutes = jest.fn();
-            const apply = jest.fn().mockReturnValue({
-                forRoutes
-            });
-            const consumer = {
-                apply
-            };
-            new _storagemodule.StorageModule().configure(consumer);
-            expect(apply).toHaveBeenCalledWith(_middlewares.FileServeMiddleware);
-            expect(forRoutes).toHaveBeenCalledWith({
-                path: 'storage/upload/file/*',
-                method: expect.anything()
-            });
-        });
-    });
-});

package/cjs/providers/azure-provider.optional.js

@@ -1,155 +0,0 @@
-/**
- * Optional Azure Blob Storage Provider
- * Requires: npm install @azure/storage-blob
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AzureProvider", {
-    enumerable: true,
-    get: function() {
-        return AzureProvider;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("@flusys/nestjs-shared/constants");
-const _uuid = require("uuid");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-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 _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;
-}
-let AzureProvider = class AzureProvider {
-    async initialize(config) {
-        try {
-            const { BlobServiceClient, StorageSharedKeyCredential } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
-            this.accountName = config.accountName;
-            this.containerName = config.containerName;
-            this.blobServiceClient = config.connectionString ? BlobServiceClient.fromConnectionString(config.connectionString) : new BlobServiceClient(`https://${config.accountName}.blob.core.windows.net`, new StorageSharedKeyCredential(config.accountName, config.accountKey));
-            this.containerClient = this.blobServiceClient.getContainerClient(config.containerName);
-            await this.containerClient.createIfNotExists();
-        } catch  {
-            throw new _common.InternalServerErrorException({
-                message: 'Azure Storage SDK not found',
-                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: '@azure/storage-blob'
-                }
-            });
-        }
-    }
-    async uploadFile(file, options) {
-        let processedBuffer = file.buffer;
-        let contentType = file.mimetype;
-        const fileName = `${(0, _uuid.v4)()}-${file.originalname}`;
-        if (options.compress && file.mimetype.startsWith('image/')) {
-            const result = await _imagecompressorutil.ImageCompressor.compress(file.buffer, file.mimetype, {
-                maxWidth: options.maxWidth,
-                maxHeight: options.maxHeight,
-                quality: options.quality,
-                format: options.format
-            });
-            processedBuffer = result.buffer;
-            contentType = result.format;
-        }
-        const blobName = options.folderPath ? `${options.folderPath}/${fileName}` : fileName;
-        await this.containerClient.getBlockBlobClient(blobName).upload(processedBuffer, processedBuffer.length, {
-            blobHTTPHeaders: {
-                blobContentType: contentType
-            }
-        });
-        return {
-            name: fileName,
-            key: blobName,
-            size: processedBuffer.length,
-            contentType
-        };
-    }
-    async uploadMultipleFiles(files, options) {
-        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
-    }
-    async deleteFile(key) {
-        await this.containerClient.getBlockBlobClient(key).deleteIfExists();
-    }
-    async deleteMultipleFiles(keys) {
-        await Promise.all(keys.map((key)=>this.deleteFile(key)));
-    }
-    async generatePresignedUrl(key, expiresInSeconds = 3600) {
-        const { BlobSASPermissions, generateBlobSASQueryParameters } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@azure/storage-blob")));
-        const blockBlobClient = this.containerClient.getBlockBlobClient(key);
-        const startsOn = new Date();
-        const expiresOn = new Date(startsOn.getTime() + expiresInSeconds * 1000);
-        const sasToken = generateBlobSASQueryParameters({
-            containerName: this.containerName,
-            blobName: key,
-            permissions: BlobSASPermissions.parse('r'),
-            startsOn,
-            expiresOn
-        }, blockBlobClient.credential).toString();
-        return `${blockBlobClient.url}?${sasToken}`;
-    }
-    async healthCheck() {
-        try {
-            await this.containerClient.exists();
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    constructor(){
-        _define_property(this, "blobServiceClient", void 0);
-        _define_property(this, "containerClient", void 0);
-        _define_property(this, "containerName", '');
-        _define_property(this, "accountName", '');
-    }
-};

package/cjs/providers/azure-provider.optional.spec.js

@@ -1,228 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _azureprovideroptional = require("./azure-provider.optional");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-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;
-}
-const mockCreateIfNotExists = jest.fn();
-const mockBlockBlobUpload = jest.fn();
-const mockDeleteIfExists = jest.fn();
-const mockContainerExists = jest.fn();
-function buildBlockBlobClient() {
-    return {
-        upload: mockBlockBlobUpload,
-        deleteIfExists: mockDeleteIfExists,
-        url: 'https://account.blob.core.windows.net/container/blob-key.jpg',
-        credential: 'shared-key-credential'
-    };
-}
-const mockGetBlockBlobClient = jest.fn().mockImplementation(()=>buildBlockBlobClient());
-const mockGetContainerClient = jest.fn().mockImplementation(()=>({
-        createIfNotExists: mockCreateIfNotExists,
-        getBlockBlobClient: mockGetBlockBlobClient,
-        exists: mockContainerExists
-    }));
-const mockFromConnectionString = jest.fn().mockImplementation(()=>({
-        getContainerClient: mockGetContainerClient
-    }));
-const mockBlobServiceClientCtor = jest.fn().mockImplementation(()=>({
-        getContainerClient: mockGetContainerClient
-    }));
-mockBlobServiceClientCtor.fromConnectionString = mockFromConnectionString;
-const mockGenerateBlobSASQueryParameters = jest.fn().mockReturnValue({
-    toString: ()=>'sv=2022&sig=abc123'
-});
-let MockStorageSharedKeyCredential = class MockStorageSharedKeyCredential {
-    constructor(accountName, accountKey){
-        _define_property(this, "accountName", void 0);
-        _define_property(this, "accountKey", void 0);
-        this.accountName = accountName;
-        this.accountKey = accountKey;
-    }
-};
-let MockBlobSASPermissions = class MockBlobSASPermissions {
-    static parse(input) {
-        return {
-            permissions: input
-        };
-    }
-};
-jest.mock('@azure/storage-blob', ()=>({
-        BlobServiceClient: mockBlobServiceClientCtor,
-        StorageSharedKeyCredential: MockStorageSharedKeyCredential,
-        BlobSASPermissions: MockBlobSASPermissions,
-        generateBlobSASQueryParameters: (...args)=>mockGenerateBlobSASQueryParameters(...args)
-    }));
-jest.mock('../utils/image-compressor.util', ()=>({
-        ImageCompressor: {
-            compress: jest.fn()
-        }
-    }));
-function buildMulterFile(overrides = {}) {
-    return {
-        fieldname: 'file',
-        originalname: 'photo.jpg',
-        encoding: '7bit',
-        mimetype: 'image/jpeg',
-        buffer: Buffer.from('file-bytes'),
-        size: 10,
-        stream: undefined,
-        destination: '',
-        filename: '',
-        path: '',
-        ...overrides
-    };
-}
-describe('AzureProvider', ()=>{
-    let provider;
-    beforeEach(async ()=>{
-        jest.clearAllMocks();
-        mockCreateIfNotExists.mockResolvedValue(undefined);
-        mockBlockBlobUpload.mockResolvedValue(undefined);
-        mockDeleteIfExists.mockResolvedValue(undefined);
-        mockContainerExists.mockResolvedValue(true);
-        mockGetBlockBlobClient.mockImplementation(()=>buildBlockBlobClient());
-        mockGetContainerClient.mockImplementation(()=>({
-                createIfNotExists: mockCreateIfNotExists,
-                getBlockBlobClient: mockGetBlockBlobClient,
-                exists: mockContainerExists
-            }));
-        provider = new _azureprovideroptional.AzureProvider();
-        await provider.initialize({
-            accountName: 'myaccount',
-            accountKey: 'key123',
-            containerName: 'my-container'
-        });
-    });
-    describe('initialize', ()=>{
-        it('builds a BlobServiceClient using an account key credential when no connection string is given', ()=>{
-            expect(mockBlobServiceClientCtor).toHaveBeenCalledWith('https://myaccount.blob.core.windows.net', expect.any(MockStorageSharedKeyCredential));
-            expect(mockCreateIfNotExists).toHaveBeenCalled();
-        });
-        it('builds a BlobServiceClient from a connection string when provided', async ()=>{
-            jest.clearAllMocks();
-            mockCreateIfNotExists.mockResolvedValue(undefined);
-            const p = new _azureprovideroptional.AzureProvider();
-            await p.initialize({
-                accountName: 'acct2',
-                accountKey: 'key2',
-                containerName: 'container2',
-                connectionString: 'DefaultEndpointsProtocol=https;AccountName=acct2;AccountKey=key2'
-            });
-            expect(mockFromConnectionString).toHaveBeenCalledWith('DefaultEndpointsProtocol=https;AccountName=acct2;AccountKey=key2');
-        });
-        it('throws InternalServerErrorException when the Azure SDK cannot be initialized', async ()=>{
-            mockBlobServiceClientCtor.mockImplementationOnce(()=>{
-                throw new Error('boom');
-            });
-            const brokenProvider = new _azureprovideroptional.AzureProvider();
-            await expect(brokenProvider.initialize({
-                accountName: 'a',
-                accountKey: 'b',
-                containerName: 'c'
-            })).rejects.toThrow('Azure Storage SDK not found');
-        });
-    });
-    describe('uploadFile', ()=>{
-        it('uploads the blob and returns file metadata', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {});
-            expect(mockBlockBlobUpload).toHaveBeenCalledWith(file.buffer, file.buffer.length, expect.objectContaining({
-                blobHTTPHeaders: {
-                    blobContentType: 'image/jpeg'
-                }
-            }));
-            expect(result.name).toMatch(/photo\.jpg$/);
-            expect(result.key).toBe(result.name);
-        });
-        it('prefixes blob name with folderPath when provided', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                folderPath: 'docs'
-            });
-            expect(result.key).toMatch(/^docs\//);
-        });
-        it('compresses image files when options.compress is true', async ()=>{
-            _imagecompressorutil.ImageCompressor.compress.mockResolvedValue({
-                buffer: Buffer.from('small'),
-                format: 'image/webp'
-            });
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                compress: true
-            });
-            expect(_imagecompressorutil.ImageCompressor.compress).toHaveBeenCalled();
-            expect(result.contentType).toBe('image/webp');
-        });
-    });
-    describe('uploadMultipleFiles', ()=>{
-        it('uploads all files', async ()=>{
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            const results = await provider.uploadMultipleFiles(files, {});
-            expect(results).toHaveLength(2);
-            expect(mockBlockBlobUpload).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('deleteFile', ()=>{
-        it('calls deleteIfExists on the block blob client for the given key', async ()=>{
-            await provider.deleteFile('blob-key.jpg');
-            expect(mockGetBlockBlobClient).toHaveBeenCalledWith('blob-key.jpg');
-            expect(mockDeleteIfExists).toHaveBeenCalled();
-        });
-    });
-    describe('deleteMultipleFiles', ()=>{
-        it('deletes every provided key', async ()=>{
-            await provider.deleteMultipleFiles([
-                'a.jpg',
-                'b.jpg'
-            ]);
-            expect(mockDeleteIfExists).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('generatePresignedUrl', ()=>{
-        it('generates a SAS URL appended with the query string', async ()=>{
-            const url = await provider.generatePresignedUrl('blob-key.jpg', 1800);
-            expect(mockGenerateBlobSASQueryParameters).toHaveBeenCalledWith(expect.objectContaining({
-                containerName: 'my-container',
-                blobName: 'blob-key.jpg'
-            }), 'shared-key-credential');
-            expect(url).toBe('https://account.blob.core.windows.net/container/blob-key.jpg?sv=2022&sig=abc123');
-        });
-        it('defaults the expiry window to 3600 seconds', async ()=>{
-            await provider.generatePresignedUrl('blob-key.jpg');
-            const call = mockGenerateBlobSASQueryParameters.mock.calls[0][0];
-            const diffSeconds = (call.expiresOn.getTime() - call.startsOn.getTime()) / 1000;
-            expect(diffSeconds).toBeCloseTo(3600, 0);
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns true when the container exists', async ()=>{
-            mockContainerExists.mockResolvedValue(true);
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when checking existence throws', async ()=>{
-            mockContainerExists.mockRejectedValue(new Error('network error'));
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-});

package/cjs/providers/index.js

@@ -1,26 +0,0 @@
-// Core exports
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./storage-factory.service"), exports);
-_export_star(require("./storage-provider.registry"), exports);
-_export_star(require("./local-provider"), 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;
-}
- // Note: Optional storage providers are loaded dynamically
- // Import them directly from their files when needed:
- // - import { S3Provider } from '@flusys/nestjs-storage/providers/s3-provider.optional';
- // - import { AzureProvider } from '@flusys/nestjs-storage/providers/azure-provider.optional';
- // - import { SftpProvider } from '@flusys/nestjs-storage/providers/sftp-provider.optional';