@flusys/nestjs-storage 7.1.0 → 8.0.0

package/cjs/providers/local-provider.js

@@ -1,230 +0,0 @@
-/**
- * LOCAL File System Provider
- *
- * This provider uses Node.js built-in 'fs' module - NO external dependencies required!
- * Perfect for same-server storage scenarios.
- *
- * Usage:
- * import { LocalProvider } from '@flusys/nestjs-storage/providers/local-provider';
- * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
- *
- * StorageProviderRegistry.register(FileLocationEnum.LOCAL, LocalProvider);
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LocalProvider", {
-    enumerable: true,
-    get: function() {
-        return LocalProvider;
-    }
-});
-const _common = require("@nestjs/common");
-const _constants = require("@flusys/nestjs-shared/constants");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-const _promises = /*#__PURE__*/ _interop_require_wildcard(require("fs/promises"));
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-const _uuid = require("uuid");
-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 LocalProvider = class LocalProvider {
-    /**
-   * SECURITY: Validates that a target path does not escape the base directory
-   * Prevents path traversal attacks using ../ sequences
-   * @throws Error if path traversal is detected
-   */ validatePathWithinBase(targetPath) {
-        const normalizedBasePath = _path.resolve(this.basePath);
-        const normalizedTargetPath = _path.resolve(targetPath);
-        if (!normalizedTargetPath.startsWith(normalizedBasePath + _path.sep) && normalizedTargetPath !== normalizedBasePath) {
-            throw new _common.BadRequestException({
-                message: 'Invalid path: Path traversal attempt detected',
-                messageKey: _constants.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
-            });
-        }
-    }
-    /**
-   * SECURITY: Validates file key format to prevent malicious input
-   * @throws Error if key contains suspicious patterns
-   */ validateKeyFormat(key) {
-        if (!key || typeof key !== 'string' || key.trim().length === 0) {
-            throw new _common.BadRequestException({
-                message: 'Invalid file key: empty or invalid',
-                messageKey: _constants.SYSTEM_MESSAGES.INVALID_FILE_KEY
-            });
-        }
-        if (key.includes('\0')) {
-            throw new _common.BadRequestException({
-                message: 'Invalid file key: contains null bytes',
-                messageKey: _constants.SYSTEM_MESSAGES.INVALID_FILE_KEY
-            });
-        }
-    }
-    /**
-   * Initialize Local File System provider with configuration
-   * @param config.basePath - Base path for file storage (default: './uploads')
-   * @param config.baseUrl - Optional base URL for generating file URLs
-   */ async initialize(config) {
-        // Store original relative path for key generation
-        this.relativeBasePath = config?.basePath || './uploads';
-        // Resolve to absolute path for file operations
-        this.basePath = _path.resolve(this.relativeBasePath);
-        this.baseUrl = config?.baseUrl || '';
-        // Ensure base directory exists
-        await _promises.mkdir(this.basePath, {
-            recursive: true
-        });
-    }
-    async uploadFile(file, options) {
-        let processedBuffer = file.buffer;
-        let contentType = file.mimetype;
-        const fileName = `${(0, _uuid.v4)()}-${file.originalname}`;
-        // Compress image if needed
-        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;
-        }
-        // Build file path
-        const folderPath = options.folderPath ? _path.join(this.basePath, options.folderPath) : this.basePath;
-        // SECURITY: Validate path does not escape base directory
-        this.validatePathWithinBase(folderPath);
-        const filePath = _path.join(folderPath, fileName);
-        // SECURITY: Double-check final file path
-        this.validatePathWithinBase(filePath);
-        // Ensure directory exists
-        await _promises.mkdir(folderPath, {
-            recursive: true
-        });
-        // Write file to disk
-        await _promises.writeFile(filePath, processedBuffer);
-        // Generate key that includes the base path (relative to cwd)
-        // This makes the key self-contained for serving files
-        const relativeKey = _path.join(this.relativeBasePath, options.folderPath || '', fileName).replace(/\\/g, '/'); // Normalize path separators
-        return {
-            name: fileName,
-            key: relativeKey,
-            size: processedBuffer.length,
-            contentType
-        };
-    }
-    async uploadMultipleFiles(files, options) {
-        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
-    }
-    async deleteFile(key) {
-        try {
-            // SECURITY: Validate key format first
-            this.validateKeyFormat(key);
-            // Key now includes the basePath, resolve from cwd
-            let filePath = _path.resolve(key);
-            // SECURITY: Validate resolved path is within base directory
-            this.validatePathWithinBase(filePath);
-            // Check if file exists at the resolved path
-            try {
-                await _promises.access(filePath);
-            } catch  {
-                // Fallback: try with basePath prefix (for old keys without basePath)
-                const fallbackPath = _path.join(this.basePath, key);
-                // SECURITY: Validate fallback path as well
-                this.validatePathWithinBase(fallbackPath);
-                try {
-                    await _promises.access(fallbackPath);
-                    filePath = fallbackPath;
-                } catch  {
-                    // File doesn't exist at either location - silent return
-                    return;
-                }
-            }
-            await _promises.unlink(filePath);
-        } catch (error) {
-            // Re-throw security errors
-            if (error instanceof Error && error.message.includes('Invalid')) {
-                throw error;
-            }
-        // Silent failure for other errors
-        }
-    }
-    async deleteMultipleFiles(keys) {
-        await Promise.all(keys.map((key)=>this.deleteFile(key)));
-    }
-    async generatePresignedUrl(key, _expiresInSeconds) {
-        // Return public URL or relative path
-        // Note: Local storage doesn't support true presigned URLs
-        // If baseUrl is provided, return full URL with file serving endpoint, otherwise return relative path
-        if (this.baseUrl) {
-            // Construct URL with the file serving endpoint
-            const baseUrlWithoutTrailingSlash = this.baseUrl.replace(/\/$/, '');
-            return `${baseUrlWithoutTrailingSlash}/storage/upload/file/${key}`;
-        }
-        return `/storage/upload/file/${key}`;
-    }
-    async healthCheck() {
-        try {
-            await _promises.access(this.basePath);
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    constructor(){
-        _define_property(this, "basePath", '');
-        _define_property(this, "baseUrl", '');
-        _define_property(this, "relativeBasePath", ''); // Path relative to cwd for key generation
-    }
-};

package/cjs/providers/local-provider.spec.js

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-const _localprovider = require("./local-provider");
-const _imagecompressorutil = require("../utils/image-compressor.util");
-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;
-}
-const mockMkdir = jest.fn();
-const mockWriteFile = jest.fn();
-const mockAccess = jest.fn();
-const mockUnlink = jest.fn();
-jest.mock('fs/promises', ()=>({
-        mkdir: (...args)=>mockMkdir(...args),
-        writeFile: (...args)=>mockWriteFile(...args),
-        access: (...args)=>mockAccess(...args),
-        unlink: (...args)=>mockUnlink(...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('LocalProvider', ()=>{
-    let provider;
-    beforeEach(async ()=>{
-        jest.clearAllMocks();
-        mockMkdir.mockResolvedValue(undefined);
-        mockWriteFile.mockResolvedValue(undefined);
-        mockAccess.mockResolvedValue(undefined);
-        mockUnlink.mockResolvedValue(undefined);
-        provider = new _localprovider.LocalProvider();
-        await provider.initialize({
-            basePath: './uploads-test',
-            baseUrl: 'http://localhost:2002'
-        });
-    });
-    describe('initialize', ()=>{
-        it('resolves the base path and ensures the directory exists', async ()=>{
-            expect(mockMkdir).toHaveBeenCalledWith(_path.resolve('./uploads-test'), expect.objectContaining({
-                recursive: true
-            }));
-        });
-        it('defaults basePath to ./uploads when not provided', async ()=>{
-            mockMkdir.mockClear();
-            const defaultProvider = new _localprovider.LocalProvider();
-            await defaultProvider.initialize({});
-            expect(mockMkdir).toHaveBeenCalledWith(_path.resolve('./uploads'), expect.objectContaining({
-                recursive: true
-            }));
-        });
-    });
-    describe('uploadFile', ()=>{
-        it('writes the file to disk and returns metadata with a self-contained key', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {});
-            expect(mockWriteFile).toHaveBeenCalled();
-            expect(result.name).toMatch(/photo\.jpg$/);
-            expect(result.key).toContain('uploads-test');
-            expect(result.size).toBe(file.buffer.length);
-            expect(result.contentType).toBe('image/jpeg');
-        });
-        it('nests the file under folderPath when provided', async ()=>{
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                folderPath: 'avatars'
-            });
-            expect(result.key).toContain('avatars');
-            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('avatars'), expect.objectContaining({
-                recursive: true
-            }));
-        });
-        it('compresses image files when options.compress is true', async ()=>{
-            _imagecompressorutil.ImageCompressor.compress.mockResolvedValue({
-                buffer: Buffer.from('compressed'),
-                format: 'image/webp'
-            });
-            const file = buildMulterFile();
-            const result = await provider.uploadFile(file, {
-                compress: true,
-                maxWidth: 800,
-                maxHeight: 600,
-                quality: 70
-            });
-            expect(_imagecompressorutil.ImageCompressor.compress).toHaveBeenCalledWith(file.buffer, 'image/jpeg', expect.objectContaining({
-                maxWidth: 800,
-                maxHeight: 600,
-                quality: 70
-            }));
-            expect(result.contentType).toBe('image/webp');
-            expect(result.size).toBe(Buffer.from('compressed').length);
-        });
-        it('does not compress non-image mimetypes even when compress=true', async ()=>{
-            const file = buildMulterFile({
-                mimetype: 'application/pdf',
-                originalname: 'doc.pdf'
-            });
-            await provider.uploadFile(file, {
-                compress: true
-            });
-            expect(_imagecompressorutil.ImageCompressor.compress).not.toHaveBeenCalled();
-        });
-        it('rejects a folderPath that attempts to escape the base directory via path traversal', async ()=>{
-            const file = buildMulterFile();
-            await expect(provider.uploadFile(file, {
-                folderPath: '../../../etc'
-            })).rejects.toThrow();
-        });
-    });
-    describe('uploadMultipleFiles', ()=>{
-        it('uploads all files and returns their metadata', async ()=>{
-            const files = [
-                buildMulterFile({
-                    originalname: 'a.jpg'
-                }),
-                buildMulterFile({
-                    originalname: 'b.jpg'
-                })
-            ];
-            const results = await provider.uploadMultipleFiles(files, {});
-            expect(results).toHaveLength(2);
-            expect(mockWriteFile).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('deleteFile', ()=>{
-        it('deletes a file that exists at the resolved key path', async ()=>{
-            const key = _path.join('uploads-test', 'some-uuid-photo.jpg');
-            await provider.deleteFile(key);
-            expect(mockUnlink).toHaveBeenCalled();
-        });
-        it('falls back to basePath-prefixed lookup when the direct key path does not exist', async ()=>{
-            mockAccess.mockRejectedValueOnce(new Error('ENOENT')).mockResolvedValueOnce(undefined);
-            await provider.deleteFile('uploads-test/some-uuid-photo.jpg');
-            expect(mockUnlink).toHaveBeenCalled();
-        });
-        it('silently returns (no throw, no unlink) when the file does not exist at either location', async ()=>{
-            mockAccess.mockRejectedValue(new Error('ENOENT'));
-            await expect(provider.deleteFile('uploads-test/missing-file.jpg')).resolves.toBeUndefined();
-            expect(mockUnlink).not.toHaveBeenCalled();
-        });
-        it('rejects an empty key', async ()=>{
-            await expect(provider.deleteFile('')).rejects.toThrow();
-        });
-        it('rejects a key containing a null byte', async ()=>{
-            await expect(provider.deleteFile('evil\0.txt')).rejects.toThrow();
-        });
-        it('re-throws path traversal security errors rather than silently swallowing them', async ()=>{
-            await expect(provider.deleteFile('../../../etc/passwd')).rejects.toThrow(/Invalid/);
-        });
-    });
-    describe('deleteMultipleFiles', ()=>{
-        it('deletes every provided key', async ()=>{
-            await provider.deleteMultipleFiles([
-                'uploads-test/a.jpg',
-                'uploads-test/b.jpg'
-            ]);
-            expect(mockUnlink).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('generatePresignedUrl', ()=>{
-        it('builds a full URL using the configured baseUrl', async ()=>{
-            const url = await provider.generatePresignedUrl('uploads-test/photo.jpg');
-            expect(url).toBe('http://localhost:2002/storage/upload/file/uploads-test/photo.jpg');
-        });
-        it('returns a relative path when no baseUrl was configured', async ()=>{
-            const noUrlProvider = new _localprovider.LocalProvider();
-            await noUrlProvider.initialize({
-                basePath: './uploads-test2'
-            });
-            const url = await noUrlProvider.generatePresignedUrl('uploads-test2/photo.jpg');
-            expect(url).toBe('/storage/upload/file/uploads-test2/photo.jpg');
-        });
-    });
-    describe('healthCheck', ()=>{
-        it('returns true when the base path is accessible', async ()=>{
-            mockAccess.mockResolvedValue(undefined);
-            await expect(provider.healthCheck()).resolves.toBe(true);
-        });
-        it('returns false when the base path is not accessible', async ()=>{
-            mockAccess.mockRejectedValue(new Error('ENOENT'));
-            await expect(provider.healthCheck()).resolves.toBe(false);
-        });
-    });
-});

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

@@ -1,175 +0,0 @@
-/**
- * Optional AWS S3 Storage Provider
- * Requires: npm install @aws-sdk/client-s3 @aws-sdk/lib-storage @aws-sdk/s3-request-presigner
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "S3Provider", {
-    enumerable: true,
-    get: function() {
-        return S3Provider;
-    }
-});
-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 S3Provider = class S3Provider {
-    async initialize(config) {
-        try {
-            const { S3Client } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
-            this.region = config.region;
-            this.bucketName = config.bucket;
-            this.s3 = new S3Client({
-                region: config.region,
-                endpoint: config.endpoint,
-                credentials: config.accessKeyId && config.secretAccessKey ? {
-                    accessKeyId: config.accessKeyId,
-                    secretAccessKey: config.secretAccessKey
-                } : undefined
-            });
-        } catch  {
-            throw new _common.InternalServerErrorException({
-                message: 'AWS SDK not found',
-                messageKey: _constants.SYSTEM_MESSAGES.SDK_NOT_INSTALLED,
-                messageVariables: {
-                    sdk: '@aws-sdk/client-s3'
-                }
-            });
-        }
-    }
-    async uploadFile(file, options) {
-        const { Upload } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/lib-storage")));
-        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 key = options.folderPath ? `${options.folderPath}/${fileName}` : fileName;
-        await new Upload({
-            client: this.s3,
-            params: {
-                Bucket: this.bucketName,
-                Key: key,
-                Body: processedBuffer,
-                ContentType: contentType
-            }
-        }).done();
-        return {
-            name: fileName,
-            key,
-            size: processedBuffer.length,
-            contentType
-        };
-    }
-    async uploadMultipleFiles(files, options) {
-        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
-    }
-    async deleteFile(key) {
-        const { DeleteObjectCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
-        await this.s3.send(new DeleteObjectCommand({
-            Bucket: this.bucketName,
-            Key: key
-        }));
-    }
-    async deleteMultipleFiles(keys) {
-        const { DeleteObjectsCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
-        await this.s3.send(new DeleteObjectsCommand({
-            Bucket: this.bucketName,
-            Delete: {
-                Objects: keys.map((key)=>({
-                        Key: key
-                    }))
-            }
-        }));
-    }
-    async generatePresignedUrl(key, expiresInSeconds = 3600) {
-        const { GetObjectCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
-        const { getSignedUrl } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/s3-request-presigner")));
-        return getSignedUrl(this.s3, new GetObjectCommand({
-            Bucket: this.bucketName,
-            Key: key
-        }), {
-            expiresIn: expiresInSeconds
-        });
-    }
-    async healthCheck() {
-        try {
-            const { HeadBucketCommand } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("@aws-sdk/client-s3")));
-            await this.s3.send(new HeadBucketCommand({
-                Bucket: this.bucketName
-            }));
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    constructor(){
-        _define_property(this, "s3", void 0);
-        _define_property(this, "bucketName", '');
-        _define_property(this, "region", '');
-    }
-};