@ackplus/nest-file-storage 0.1.51 → 1.1.0

package/src/lib/storage/s3.storage.ts

@@ -0,0 +1,242 @@
+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 `${uuidv4()}-${file.originalname}`;
+        });
+
+        this.fileDistFunction = options.fileDist || ((_file, _req) => {
+            return path.join('uploads', moment().format('YYYY'), moment().format('MM'), moment().format('DD'));
+        });
+
+        this.s3 = new S3({
+            ...(this.options.endpoint ? { endpoint: this.options.endpoint } : {}),
+            region: this.options.region,
+            credentials: {
+                accessKeyId: this.options.accessKeyId,
+                secretAccessKey: this.options.secretAccessKey,
+            },
+        });
+    }
+
+    async _handleFile(
+        req: any,
+        file: Express.Multer.File,
+        cb: (error?: any, info?: any) => void,
+    ): Promise<void> {
+        // Collect file chunks to determine size
+        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 = join(dist, key);
+
+                const uploadedFile = await this.putFile(buffer, filePath);
+
+                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) {
+                cb(err);
+            }
+        });
+
+        file.stream.on('error', (err) => cb(err));
+    }
+
+    _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: string) {
+        if (this.options?.cloudFrontUrl) {
+            return `${this.options.cloudFrontUrl}/${key}`;
+        }
+        return `https://${this.options.bucket}.s3.amazonaws.com/${key}`;
+    }
+
+    async getSignedUrl(key: string, objectConfig?: Partial<GetObjectCommandInput>): Promise<string> {
+        if (key) {
+            const url = await getSignedUrl(
+                this.s3 as any,
+                new GetObjectCommand({
+                    Bucket: this.options.bucket,
+                    Key: key,
+                    ...(objectConfig && { ...objectConfig }),
+                }),
+            );
+            return url;
+        }
+        return '';
+    }
+
+    async getFile(key: string): Promise<Buffer> {
+        if (!key) {
+            throw new Error('Key is required to fetch the file from S3.');
+        }
+
+        try {
+            const command = new GetObjectCommand({
+                Bucket: this.options.bucket,
+                Key: key,
+            });
+
+            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 Readable) {
+                return await this.streamToBuffer(data.Body);
+            }
+
+            throw new Error('Unexpected data.Body type received from S3.');
+        } catch (error) {
+            console.error(`Error fetching file (${key}) from S3:`, error);
+            throw error;
+        }
+    }
+
+
+    async putFile(fileContent: Buffer, key: string): Promise<any> {
+        try {
+            const fileName = basename(key);
+            const fileKey = key || (Math.random() + 1).toString(36).substring(12);
+
+            // Upload the file
+            const putParams = {
+                Bucket: this.options.bucket,
+                Key: fileKey,
+                Body: fileContent,
+                ContentDisposition: `inline; ${fileName}`,
+            };
+
+            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 HeadObjectCommand(headParams));
+            const fileSize = headObject.ContentLength || 0;
+
+            // Construct response object
+            const fileData: UploadedFile = {
+                originalName: fileName,
+                fileName: fileName,
+                size: fileSize,
+                buffer: fileContent,
+                fullPath: fileKey,
+                key: fileKey,
+                url: this.getUrl(fileKey),
+            };
+            return fileData;
+        } catch (error) {
+            console.error('Error uploading file to S3:', error);
+            throw error;
+        }
+    }
+
+
+    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 DeleteObjectCommand(deleteParams));
+        } catch (error) {
+            console.error(`Error deleting file (${key}) from S3:`, error);
+            throw error;
+        }
+    }
+
+
+    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: string, newKey: string): Promise<UploadedFile> {
+        try {
+            await this.s3.send(new CopyObjectCommand({
+                Bucket: this.options.bucket,
+                CopySource: `/${this.options.bucket}/${oldKey}`,
+                Key: newKey,
+            }));
+
+            const headObject = await this.s3.send(new HeadObjectCommand({
+                Bucket: this.options.bucket,
+                Key: newKey,
+            }));
+
+            return {
+                originalName: basename(newKey),
+                size: headObject.ContentLength || 0,
+                fileName: basename(newKey),
+                key: newKey,
+                fullPath: newKey,
+                url: this.getUrl(newKey),
+            };
+        } catch (error) {
+            console.error('Error copying file in S3:', error);
+            throw error;
+        }
+    }
+
+
+}

package/src/lib/storage.factory.ts

@@ -0,0 +1,58 @@
+import { AzureStorageOptions, FileStorageEnum, LocalStorageOptions, S3StorageOptions, StorageOptions } from './types';
+import { StorageEngine } from 'multer';
+import { Storage } from './types';
+
+export class StorageFactory {
+    private static storageInstances = new Map<string, StorageEngine & Storage>();
+
+    static async createStorage(storageType: FileStorageEnum, options: StorageOptions): Promise<StorageEngine & Storage> {
+        const cacheKey = `${storageType}-${JSON.stringify(options)}`;
+
+        // if (this.storageInstances.has(cacheKey)) {
+        //     return this.storageInstances.get(cacheKey)!;
+        // }
+
+        let storageInstance: StorageEngine & Storage;
+
+        switch (storageType) {
+            case FileStorageEnum.LOCAL:
+                const { LocalStorage } = await import('./storage/local.storage');
+                storageInstance = new LocalStorage(options as LocalStorageOptions);
+                break;
+
+            case FileStorageEnum.AZURE:
+                try {
+                    const { AzureStorage } = await import('./storage/azure.storage');
+                    storageInstance = new AzureStorage(options as AzureStorageOptions);
+                } catch (error) {
+                    throw new Error(
+                        'Azure Storage SDK (@azure/storage-blob) is required when using AzureStorage. ' +
+                        'Please install it: npm install @azure/storage-blob'
+                    );
+                }
+                break;
+
+            case FileStorageEnum.S3:
+                try {
+                    const { S3Storage } = await import('./storage/s3.storage');
+                    storageInstance = new S3Storage(options as S3StorageOptions);
+                } catch (error) {
+                    throw new Error(
+                        'AWS SDK (@aws-sdk/client-s3 and @aws-sdk/s3-request-presigner) is required when using S3Storage. ' +
+                        'Please install them: npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner'
+                    );
+                }
+                break;
+
+            default:
+                throw new Error(`Unsupported storage type: ${storageType}`);
+        }
+
+        this.storageInstances.set(cacheKey, storageInstance);
+        return storageInstance;
+    }
+
+    static clearCache() {
+        this.storageInstances.clear();
+    }
+}

package/src/lib/{types.d.ts → types.ts}

@@ -1,16 +1,20 @@
 import { ModuleMetadata, Type } from '@nestjs/common';
 import { Request } from 'express';
-export declare enum FileStorageEnum {
-    LOCAL = "local",
-    S3 = "s3",
-    AZURE = "azure"
+
+
+export enum FileStorageEnum {
+    LOCAL = 'local',
+    S3 = 's3',
+    AZURE = 'azure',
 }
+
 export interface FileStorageOptions {
     prefix?: string;
-    fileName?: (file: any, req: Request) => string;
-    fileDist?: (file: any, req: Request) => string;
+    fileName?: (file: any, req: Request) => string; // Custom file key
+    fileDist?: (file: any, req: Request) => string; // Custom file dist
     transformUploadedFileObject?: (file: any) => any;
 }
+
 export interface S3StorageOptions extends FileStorageOptions {
     accessKeyId: string;
     secretAccessKey: string;
@@ -19,53 +23,75 @@ export interface S3StorageOptions extends FileStorageOptions {
     endpoint?: string;
     cloudFrontUrl?: string;
 }
+
 export interface LocalStorageOptions extends FileStorageOptions {
     rootPath: string;
     baseUrl: string;
 }
+
 export interface AzureStorageOptions extends FileStorageOptions {
     account: string;
     accountKey: string;
     container: string;
 }
+
 export type StorageOptions = S3StorageOptions | AzureStorageOptions | LocalStorageOptions;
-export type FileStorageConfigOptions = {
-    storage: FileStorageEnum.LOCAL;
-    localConfig: LocalStorageOptions;
-} | {
-    storage: FileStorageEnum.S3;
-    s3Config: S3StorageOptions;
-} | {
-    storage: FileStorageEnum.AZURE;
-    azureConfig: AzureStorageOptions;
-};
+
+// Define discriminated union types - Configuration-based approach
+export type FileStorageConfigOptions =
+    | { storage: FileStorageEnum.LOCAL; localConfig: LocalStorageOptions; }
+    | { storage: FileStorageEnum.S3; s3Config: S3StorageOptions; }
+    | { storage: FileStorageEnum.AZURE; azureConfig: AzureStorageOptions; };
+
+// Class factory approach - for direct storage instance usage
 export interface FileStorageClassOptions {
     storageFactory: () => Promise<new (...args: any[]) => Storage> | (new (...args: any[]) => Storage);
     options?: any;
 }
+
+// Combined module options
 export type FileStorageModuleOptions = FileStorageConfigOptions | FileStorageClassOptions;
+
+
 export interface FileStorageAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * The `useExisting` syntax allows you to create aliases for existing providers.
+     */
     useExisting?: Type<FileStorageOptionsFactory>;
+    /**
+     * The `useClass` syntax allows you to dynamically determine a class
+     * that a token should resolve to.
+     */
     useClass?: Type<FileStorageOptionsFactory>;
+    /**
+     * The `useFactory` syntax allows for creating providers dynamically.
+     */
     useFactory?: (...args: any[]) => Promise<FileStorageModuleOptions> | FileStorageModuleOptions;
+    /**
+     * Optional list of providers to be injected into the context of the Factory function.
+     */
     inject?: any[];
 }
+
 export interface FileStorageOptionsFactory {
     createFileStorageOptions(): Promise<FileStorageModuleOptions> | FileStorageModuleOptions;
 }
+
+
 export interface UploadedFile {
     fieldName?: string;
     fieldname?: string;
     fileName: string;
-    originalName: string;
-    size: number;
+    originalName: string; // original file name
+    size: number; // files in bytes
     mimetype?: string;
     buffer?: Buffer;
-    key: string;
-    url: string;
-    fullPath: string;
+    key: string; // path of the file in storage
+    url: string; // file public url
+    fullPath: string; // Full path of the file
     encoding?: string;
 }
+
 export interface Storage {
     getFile(key: string): Promise<Buffer> | Buffer;
     deleteFile(key: string): Promise<void> | void;
@@ -73,5 +99,5 @@ export interface Storage {
     path?(filePath: string): Promise<string> | string;
     getUrl(key: string): Promise<string> | string;
     getSignedUrl?(key: string, options: any): Promise<string> | string;
-    copyFile(oldKey: string, newKey: string): Promise<UploadedFile>;
+    copyFile(oldKey: string, newKey: string): Promise<UploadedFile>
 }

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"],
+    "target": "es2021",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/src/index.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/nest-file-storage.module"), exports);
-tslib_1.__exportStar(require("./lib/file-storage.service"), exports);
-tslib_1.__exportStar(require("./lib/interceptor/file-storage.interceptor"), exports);
-tslib_1.__exportStar(require("./lib/types"), exports);
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/nest-file-storage/src/index.ts"],"names":[],"mappings":";;;AAAA,yEAA+C;AAC/C,qEAA2C;AAC3C,qFAA2D;AAC3D,sDAA4B"}

package/src/lib/constants.d.ts

@@ -1 +0,0 @@
-export declare const FILE_STORAGE_OPTIONS = "FileStorageOptions";

package/src/lib/constants.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FILE_STORAGE_OPTIONS = void 0;
-exports.FILE_STORAGE_OPTIONS = 'FileStorageOptions';
-//# sourceMappingURL=constants.js.map

package/src/lib/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../../packages/nest-file-storage/src/lib/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,oBAAoB,GAAG,oBAAoB,CAAC"}

package/src/lib/file-storage.service.d.ts

@@ -1,7 +0,0 @@
-import { FileStorageEnum, FileStorageModuleOptions } from './types';
-export declare class FileStorageService {
-    private static options;
-    static setOptions(options: FileStorageModuleOptions): void;
-    static getOptions(): FileStorageModuleOptions;
-    static getStorage(storageType?: FileStorageEnum): Promise<import("./types").Storage>;
-}

package/src/lib/file-storage.service.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileStorageService = void 0;
-const tslib_1 = require("tslib");
-const storage_factory_1 = require("./storage.factory");
-class FileStorageService {
-    static setOptions(options) {
-        FileStorageService.options = options;
-    }
-    static getOptions() {
-        return FileStorageService.options;
-    }
-    static getStorage(storageType) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const options = this.getOptions();
-            if ('storageFactory' in options) {
-                const classOptions = options;
-                const StorageClass = yield classOptions.storageFactory();
-                return new StorageClass(classOptions.options);
-            }
-            const configOptions = options;
-            if (!storageType) {
-                storageType = configOptions.storage;
-            }
-            const config = configOptions[`${storageType}Config`];
-            return yield storage_factory_1.StorageFactory.createStorage(storageType, config);
-        });
-    }
-}
-exports.FileStorageService = FileStorageService;
-//# sourceMappingURL=file-storage.service.js.map

package/src/lib/file-storage.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-storage.service.js","sourceRoot":"","sources":["../../../../../packages/nest-file-storage/src/lib/file-storage.service.ts"],"names":[],"mappings":";;;;AAAA,uDAAmD;AAInD,MAAa,kBAAkB;IAI3B,MAAM,CAAC,UAAU,CAAC,OAAiC;QAC/C,kBAAkB,CAAC,OAAO,GAAG,OAAO,CAAC;IACzC,CAAC;IAED,MAAM,CAAC,UAAU;QACb,OAAO,kBAAkB,CAAC,OAAO,CAAC;IACtC,CAAC;IAED,MAAM,CAAO,UAAU,CAAC,WAA6B;;YACjD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAGlC,IAAI,gBAAgB,IAAI,OAAO,EAAE,CAAC;gBAC9B,MAAM,YAAY,GAAG,OAAkC,CAAC;gBACxD,MAAM,YAAY,GAAG,MAAM,YAAY,CAAC,cAAc,EAAE,CAAC;gBACzD,OAAO,IAAI,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAClD,CAAC;YAGD,MAAM,aAAa,GAAG,OAAmC,CAAC;YAC1D,IAAI,CAAC,WAAW,EAAE,CAAC;gBACf,WAAW,GAAG,aAAa,CAAC,OAAO,CAAC;YACxC,CAAC;YACD,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,WAAW,QAAQ,CAAC,CAAC;YACrD,OAAO,MAAM,gCAAc,CAAC,aAAa,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QACnE,CAAC;KAAA;CAEJ;AA/BD,gDA+BC"}

package/src/lib/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./nest-file-storage.module"), exports);
-tslib_1.__exportStar(require("./types"), exports);
-tslib_1.__exportStar(require("./storage.factory"), exports);
-tslib_1.__exportStar(require("./interceptor/file-storage.interceptor"), exports);
-tslib_1.__exportStar(require("./file-storage.service"), exports);
-//# sourceMappingURL=index.js.map

package/src/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/nest-file-storage/src/lib/index.ts"],"names":[],"mappings":";;;AAAA,qEAA2C;AAC3C,kDAAwB;AACxB,4DAAkC;AAClC,iFAAuD;AACvD,iEAAuC"}

package/src/lib/interceptor/file-storage.interceptor.d.ts

@@ -1,21 +0,0 @@
-import { NestInterceptor } from '@nestjs/common';
-import { Request } from 'express';
-import { FileStorageEnum, StorageOptions } from '../types';
-export type FileUploadConfig = {
-    type: 'single' | 'array' | 'fields';
-    fieldName?: string;
-    maxCount?: number;
-    fields?: {
-        name: string;
-        maxCount?: number;
-    }[];
-};
-export type FileStorageInterceptorOptions = {
-    fileName?: (file: any, req?: Request) => string;
-    fileDist?: (file: any, req?: Request) => string;
-    prefix?: string;
-    storageType?: FileStorageEnum;
-    storageOptions?: StorageOptions;
-    mapToRequestBody?: (file: any, fieldName: string, req?: Request) => any;
-};
-export declare function FileStorageInterceptor(fileConfig: FileUploadConfig | string, interceptorOptions?: FileStorageInterceptorOptions): NestInterceptor;