@ackplus/nest-file-storage 1.0.1 → 1.1.1

package/{dist/lib/storage/local.storage.js → src/lib/storage/local.storage.ts}

@@ -1,175 +1,182 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalStorage = void 0;
-const concat_stream_1 = __importDefault(require("concat-stream"));
-const fs = __importStar(require("fs"));
-const moment_1 = __importDefault(require("moment"));
-const path_1 = require("path");
-const uuid_1 = require("uuid");
-class LocalStorage {
+import concat from 'concat-stream';
+import * as fs from 'fs';
+import moment from 'moment';
+import { StorageEngine } from 'multer';
+import * as path from 'path';
+import { basename, dirname, join, normalize, sep } from 'path';
+import { join as posixJoin } from 'path/posix';
+import { v4 as uuidv4 } from 'uuid';
+
+import { LocalStorageOptions, Storage, UploadedFile } from '../types';
+
+
+export class LocalStorage implements StorageEngine, Storage {
+
+    private rootPath: string;
+    private fileNameFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+    private fileDistFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+
     /**
      * Convert OS-specific file path to URL-friendly key
      * This ensures keys are consistent across all platforms
      * Windows: C:\uploads\2024\01\file.jpg -> 2024/01/file.jpg
      * Unix: /uploads/2024/01/file.jpg -> 2024/01/file.jpg
      */
-    pathToUrl(filePath) {
-        if (!filePath)
-            return '';
+    private pathToUrl(filePath: string): string {
+        if (!filePath) return '';
+
         // Remove rootPath if present
         let relativePath = filePath;
         if (filePath.startsWith(this.rootPath)) {
             relativePath = filePath.substring(this.rootPath.length);
         }
+
         // Convert backslashes to forward slashes and remove leading slash
         return relativePath.replace(/\\/g, '/').replace(/^\/+/, '');
     }
+
     /**
      * Convert URL-friendly key to OS-specific file path
      * This converts stored keys back to valid file system paths
      * 2024/01/file.jpg -> Windows: 2024\01\file.jpg, Unix: 2024/01/file.jpg
      */
-    urlToPath(urlKey) {
-        if (!urlKey)
-            return '';
+    private urlToPath(urlKey: string): string {
+        if (!urlKey) return '';
+
         // Split by forward slashes and rejoin with OS-specific separator
         const parts = urlKey.split('/').filter(part => part.length > 0);
-        return parts.join(path_1.sep);
+        return parts.join(sep);
     }
+
     /**
      * Get full file system path from URL-friendly key
      */
-    getFullPath(urlKey) {
+    private getFullPath(urlKey: string): string {
         const osPath = this.urlToPath(urlKey);
-        return (0, path_1.join)(this.rootPath, osPath);
+        return join(this.rootPath, osPath);
     }
-    constructor(options) {
-        this.options = options;
+
+    constructor(private options: LocalStorageOptions) {
         // Normalize path for the current OS
-        this.rootPath = (0, path_1.normalize)(options.rootPath || (0, path_1.join)(process.cwd(), 'public'));
+        this.rootPath = normalize(options.rootPath || join(process.cwd(), 'public'));
+
         this.fileNameFunction = options.fileName || ((file, _req) => {
-            return `${(0, uuid_1.v4)()}-${file.originalname}`;
+            return `${uuidv4()}-${file.originalname}`;
         });
+
         this.fileDistFunction = options.fileDist || ((_file, _req) => {
-            return (0, path_1.join)(this.rootPath, (0, moment_1.default)().format('YYYY'), (0, moment_1.default)().format('MM'), (0, moment_1.default)().format('DD'));
+            return join(this.rootPath, moment().format('YYYY'), moment().format('MM'), moment().format('DD'));
         });
+
+
         // Ensure the rootPath directory exists
         if (!fs.existsSync(this.rootPath)) {
             fs.mkdirSync(this.rootPath, { recursive: true });
         }
     }
-    async _handleFile(req, file, cb) {
+
+    async _handleFile(
+        req: any,
+        file: Express.Multer.File,
+        cb: (error?: any, info?: any) => void,
+    ) {
         try {
             const dist = await this.fileDistFunction(file, req);
             const fileName = await this.fileNameFunction(file, req);
-            const filePath = (0, path_1.join)(dist, fileName);
+
+            const filePath = join(dist, fileName);
             // Convert to URL-friendly key for storage
             const urlKey = this.pathToUrl(filePath);
-            file.stream.pipe((0, concat_stream_1.default)({ encoding: 'buffer' }, async (buffer) => {
+
+            file.stream.pipe(concat({ encoding: 'buffer' }, async (buffer) => {
                 const uploadedFile = await this.putFile(buffer, urlKey);
-                const fileInfo = {
+
+                const fileInfo: UploadedFile = {
                     ...uploadedFile,
                     fieldName: file.fieldname,
                     originalName: file.originalname,
                     mimetype: file.mimetype,
                 };
                 let transformData = fileInfo;
+
                 if (this.options?.transformUploadedFileObject) {
                     transformData = await this.options.transformUploadedFileObject(fileInfo);
                 }
                 cb(null, transformData);
             }));
-        }
-        catch (error) {
+        } catch (error) {
             console.error('error', error);
             cb(error);
         }
     }
-    _removeFile(_req, file, cb) {
+
+    _removeFile(
+        _req: any,
+        file: any,
+        cb: (error: Error | null) => void,
+    ) {
         const filePath = file.path;
+
         fs.unlink(filePath, (err) => {
             if (err) {
                 cb(err);
-            }
-            else {
+            } else {
                 cb(null);
             }
         });
     }
-    getUrl(urlKey) {
+
+    getUrl(urlKey: string): string {
         if (urlKey && urlKey.startsWith('http')) {
             return urlKey;
         }
         if (!urlKey) {
-            return null;
+            return '';
         }
+
         // Key is already in URL format (forward slashes)
         // Ensure baseUrl doesn't end with slash and key doesn't start with slash
         const baseUrl = this.options.baseUrl.replace(/\/$/, '');
         const cleanKey = urlKey.replace(/^\//, '');
+
         return `${baseUrl}/${cleanKey}`;
     }
-    async getFile(urlKey) {
+
+    async getFile(urlKey: string): Promise<Buffer> {
         // Convert URL key to OS-specific path
         const fullPath = this.getFullPath(urlKey);
         return fs.promises.readFile(fullPath);
     }
-    async deleteFile(urlKey) {
+
+    async deleteFile(urlKey: string): Promise<void> {
         // Convert URL key to OS-specific path
         const fullPath = this.getFullPath(urlKey);
         return fs.promises.unlink(fullPath);
     }
-    async putFile(fileContent, urlKey) {
+
+    async putFile(
+        fileContent: Buffer,
+        urlKey: string,
+    ): Promise<UploadedFile> {
         return new Promise((putFileResolve, reject) => {
             // Convert URL key to OS-specific path
             const filePath = this.getFullPath(urlKey);
-            const directoryPath = (0, path_1.dirname)(filePath);
+
+            const directoryPath = dirname(filePath);
+
             // Create the directory if it doesn't exist
             fs.mkdirSync(directoryPath, { recursive: true });
+
             fs.writeFile(filePath, fileContent, (err) => {
                 if (err) {
                     reject(err);
                     return;
                 }
+
                 const stats = fs.statSync(filePath);
                 const fileName = urlKey.split('/').pop() || urlKey;
-                const fileInfo = {
+
+                const fileInfo: UploadedFile = {
                     originalName: fileName,
                     size: stats.size,
                     fileName: fileName,
@@ -181,28 +188,35 @@ class LocalStorage {
             });
         });
     }
-    path(urlKey) {
+
+
+    path(urlKey: string): string {
         if (!urlKey) {
-            return null;
+            return '';
         }
         // Convert URL key to full OS-specific path
         return this.getFullPath(urlKey);
     }
-    async copyFile(oldUrlKey, newUrlKey) {
+
+    async copyFile(oldUrlKey: string, newUrlKey: string): Promise<UploadedFile> {
         return new Promise((resolve, reject) => {
             // Convert URL keys to OS-specific paths
             const oldPath = this.getFullPath(oldUrlKey);
             const newPath = this.getFullPath(newUrlKey);
-            const directoryPath = (0, path_1.dirname)(newPath);
+
+            const directoryPath = dirname(newPath);
             fs.mkdirSync(directoryPath, { recursive: true });
+
             fs.copyFile(oldPath, newPath, (err) => {
                 if (err) {
                     reject(err);
                     return;
                 }
+
                 const stats = fs.statSync(newPath);
                 const fileName = newUrlKey.split('/').pop() || newUrlKey;
-                const fileInfo = {
+
+                const fileInfo: UploadedFile = {
                     originalName: fileName,
                     size: stats.size,
                     fileName: fileName,
@@ -214,6 +228,6 @@ class LocalStorage {
             });
         });
     }
+
+
 }
-exports.LocalStorage = LocalStorage;
-//# sourceMappingURL=local.storage.js.map

package/{dist/lib/storage/s3.storage.js → src/lib/storage/s3.storage.ts}

@@ -1,60 +1,33 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Storage = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const client_s3_2 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
-const moment_1 = __importDefault(require("moment"));
-const path_1 = __importStar(require("path"));
-const stream_1 = require("stream");
-const uuid_1 = require("uuid");
-class S3Storage {
-    constructor(options) {
-        this.options = options;
+import { CopyObjectCommand, GetObjectCommandInput, S3 } from '@aws-sdk/client-s3';
+import { DeleteObjectCommand, GetObjectCommand, GetObjectCommandOutput, HeadObjectCommand, PutObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import moment from 'moment';
+import { StorageEngine } from 'multer';
+import path, { basename, join } from 'path';
+import { Readable } from 'stream';
+import { v4 as uuidv4 } from 'uuid';
+
+
+import { S3StorageOptions, Storage, UploadedFile } from '../types';
+
+
+export class S3Storage implements StorageEngine, Storage {
+
+    private s3: S3;
+    private fileNameFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+    private fileDistFunction: (file: Express.Multer.File, req?: any) => string | Promise<string>;
+
+    constructor(private options: S3StorageOptions) {
         this.fileNameFunction = options.fileName || ((file, _req) => {
-            return `${(0, uuid_1.v4)()}-${file.originalname}`;
+            return `${uuidv4()}-${file.originalname}`;
         });
+
         this.fileDistFunction = options.fileDist || ((_file, _req) => {
-            return path_1.default.join('uploads', (0, moment_1.default)().format('YYYY'), (0, moment_1.default)().format('MM'), (0, moment_1.default)().format('DD'));
+            return path.join('uploads', moment().format('YYYY'), moment().format('MM'), moment().format('DD'));
         });
-        this.s3 = new client_s3_1.S3({
-            endpoint: this.options.endpoint || null,
+
+        this.s3 = new S3({
+            ...(this.options.endpoint ? { endpoint: this.options.endpoint } : {}),
             region: this.options.region,
             credentials: {
                 accessKeyId: this.options.accessKeyId,
@@ -62,90 +35,118 @@ class S3Storage {
             },
         });
     }
-    async _handleFile(req, file, cb) {
+
+    async _handleFile(
+        req: any,
+        file: Express.Multer.File,
+        cb: (error?: any, info?: any) => void,
+    ): Promise<void> {
         // Collect file chunks to determine size
-        const chunks = [];
+        const chunks: Uint8Array[] = [];
         file.stream.on('data', (chunk) => chunks.push(chunk));
         file.stream.on('end', async () => {
             const buffer = Buffer.concat(chunks);
+
             try {
                 const dist = await this.fileDistFunction(file, req);
                 const key = await this.fileNameFunction(file, req);
-                const filePath = (0, path_1.join)(dist, key);
+                const filePath = join(dist, key);
+
                 const uploadedFile = await this.putFile(buffer, filePath);
-                const fileInfo = {
+
+                const fileInfo: UploadedFile = {
                     ...uploadedFile,
                     fieldName: file.fieldname,
                     originalName: file.originalname,
                     mimetype: file.mimetype,
                 };
                 let transformData = fileInfo;
+
                 if (this.options?.transformUploadedFileObject) {
                     transformData = await this.options.transformUploadedFileObject(fileInfo);
                 }
                 cb(null, transformData);
-            }
-            catch (err) {
+            } catch (err) {
                 cb(err);
             }
         });
+
         file.stream.on('error', (err) => cb(err));
     }
-    _removeFile(_req, file, cb) {
+
+    _removeFile(
+        _req: any,
+        file: any,
+        cb: (error: Error | null) => void,
+    ): void {
         const params = {
             Bucket: this.options.bucket,
             Key: file.key,
         };
+
         this.s3
             .deleteObject(params)
             .then(() => cb(null))
             .catch((err) => cb(err));
     }
-    getUrl(key) {
+
+    getUrl(key: string) {
         if (this.options?.cloudFrontUrl) {
             return `${this.options.cloudFrontUrl}/${key}`;
         }
         return `https://${this.options.bucket}.s3.amazonaws.com/${key}`;
     }
-    async getSignedUrl(key, objectConfig) {
+
+    async getSignedUrl(key: string, objectConfig?: Partial<GetObjectCommandInput>): Promise<string> {
         if (key) {
-            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, new client_s3_2.GetObjectCommand({
-                Bucket: this.options.bucket,
-                Key: key,
-                ...(objectConfig && { ...objectConfig }),
-            }));
+            const url = await getSignedUrl(
+                this.s3 as any,
+                new GetObjectCommand({
+                    Bucket: this.options.bucket,
+                    Key: key,
+                    ...(objectConfig && { ...objectConfig }),
+                }),
+            );
             return url;
         }
-        return null;
+        return '';
     }
-    async getFile(key) {
+
+    async getFile(key: string): Promise<Buffer> {
         if (!key) {
             throw new Error('Key is required to fetch the file from S3.');
         }
+
         try {
-            const command = new client_s3_2.GetObjectCommand({
+            const command = new GetObjectCommand({
                 Bucket: this.options.bucket,
                 Key: key,
             });
-            const data = await this.s3.send(command);
+
+            const data: GetObjectCommandOutput = await this.s3.send(command);
+
             if (!data.Body) {
                 throw new Error('Empty response received from S3.');
             }
+
             // Handle both Buffer and Readable Stream responses
-            if (data.Body instanceof stream_1.Readable) {
+            if (data.Body instanceof Readable) {
                 return await this.streamToBuffer(data.Body);
             }
+
             throw new Error('Unexpected data.Body type received from S3.');
-        }
-        catch (error) {
+        } catch (error) {
             console.error(`Error fetching file (${key}) from S3:`, error);
             throw error;
         }
     }
-    async putFile(fileContent, key) {
+
+
+    async putFile(fileContent: Buffer, key: string): Promise<any> {
         try {
-            const fileName = (0, path_1.basename)(key);
+            const fileName = basename(key);
             const fileKey = key || (Math.random() + 1).toString(36).substring(12);
+
             // Upload the file
             const putParams = {
                 Bucket: this.options.bucket,
@@ -153,16 +154,20 @@ class S3Storage {
                 Body: fileContent,
                 ContentDisposition: `inline; ${fileName}`,
             };
-            await this.s3.send(new client_s3_2.PutObjectCommand(putParams));
+
+            await this.s3.send(new PutObjectCommand(putParams));
+
             // Fetch file metadata to get size
             const headParams = {
                 Bucket: this.options.bucket,
                 Key: fileKey,
             };
-            const headObject = await this.s3.send(new client_s3_2.HeadObjectCommand(headParams));
+
+            const headObject = await this.s3.send(new HeadObjectCommand(headParams));
             const fileSize = headObject.ContentLength || 0;
+
             // Construct response object
-            const fileData = {
+            const fileData: UploadedFile = {
                 originalName: fileName,
                 fileName: fileName,
                 size: fileSize,
@@ -172,60 +177,66 @@ class S3Storage {
                 url: this.getUrl(fileKey),
             };
             return fileData;
-        }
-        catch (error) {
+        } catch (error) {
             console.error('Error uploading file to S3:', error);
             throw error;
         }
     }
-    async deleteFile(key) {
+
+
+    async deleteFile(key: string): Promise<void> {
         if (!key) {
             throw new Error('File key is required for deletion.');
         }
+
         try {
             const deleteParams = {
                 Bucket: this.options.bucket,
                 Key: key,
             };
-            await this.s3.send(new client_s3_2.DeleteObjectCommand(deleteParams));
-        }
-        catch (error) {
+
+            await this.s3.send(new DeleteObjectCommand(deleteParams));
+        } catch (error) {
             console.error(`Error deleting file (${key}) from S3:`, error);
             throw error;
         }
     }
-    async streamToBuffer(stream) {
-        const chunks = [];
+
+
+    private async streamToBuffer(stream: Readable): Promise<Buffer> {
+        const chunks: Uint8Array[] = [];
         for await (const chunk of stream) {
             chunks.push(chunk);
         }
         return Buffer.concat(chunks);
     }
-    async copyFile(oldKey, newKey) {
+
+    async copyFile(oldKey: string, newKey: string): Promise<UploadedFile> {
         try {
-            await this.s3.send(new client_s3_1.CopyObjectCommand({
+            await this.s3.send(new CopyObjectCommand({
                 Bucket: this.options.bucket,
                 CopySource: `/${this.options.bucket}/${oldKey}`,
                 Key: newKey,
             }));
-            const headObject = await this.s3.send(new client_s3_2.HeadObjectCommand({
+
+            const headObject = await this.s3.send(new HeadObjectCommand({
                 Bucket: this.options.bucket,
                 Key: newKey,
             }));
+
             return {
-                originalName: (0, path_1.basename)(newKey),
+                originalName: basename(newKey),
                 size: headObject.ContentLength || 0,
-                fileName: (0, path_1.basename)(newKey),
+                fileName: basename(newKey),
                 key: newKey,
                 fullPath: newKey,
                 url: this.getUrl(newKey),
             };
-        }
-        catch (error) {
+        } catch (error) {
             console.error('Error copying file in S3:', error);
             throw error;
         }
     }
+
+
 }
-exports.S3Storage = S3Storage;
-//# sourceMappingURL=s3.storage.js.map