@ackplus/nest-file-storage 1.1.1 → 1.1.2

package/src/lib/nest-file-storage.module.ts

@@ -1,78 +0,0 @@
-import { Module, DynamicModule, Provider } from '@nestjs/common';
-
-import { FILE_STORAGE_OPTIONS } from './constants';
-import { FileStorageService } from './file-storage.service';
-import { FileStorageAsyncOptions, FileStorageModuleOptions, FileStorageOptionsFactory } from './types';
-
-
-@Module({})
-export class NestFileStorageModule {
-
-    static forRoot(options: FileStorageModuleOptions): DynamicModule {
-        return {
-            module: NestFileStorageModule,
-            providers: [
-                {
-                    provide: FILE_STORAGE_OPTIONS,
-                    useFactory: async () => {
-                        FileStorageService.setOptions(options); // ✅ Store globally
-                        return options;
-                    },
-                    inject: [],
-                },
-                FileStorageService,
-            ],
-            exports: [],
-        };
-    }
-
-    static forRootAsync(options: FileStorageAsyncOptions): DynamicModule {
-        const asyncProviders: Provider[] = this.createAsyncProviders(options);
-
-        return {
-            module: NestFileStorageModule,
-            imports: options.imports || [],
-            providers: [...asyncProviders, FileStorageService],
-            exports: [],
-        };
-    }
-
-    private static createAsyncProviders(options: FileStorageAsyncOptions): Provider[] {
-        if (options.useExisting || options.useFactory) {
-            return [this.createAsyncOptionsProvider(options)];
-        }
-
-        return [
-            this.createAsyncOptionsProvider(options),
-            {
-                provide: options.useClass!,
-                useClass: options.useClass!,
-            },
-        ];
-    }
-
-    private static createAsyncOptionsProvider(options: FileStorageAsyncOptions): Provider {
-        if (options.useFactory) {
-            return {
-                provide: FILE_STORAGE_OPTIONS,
-                useFactory: async (...args: any[]) => {
-                    const fileStorageOptions = await options.useFactory!(...args);
-                    FileStorageService.setOptions(fileStorageOptions);
-                    return fileStorageOptions;
-                },
-                inject: options.inject || [],
-            };
-        }
-
-        return {
-            provide: FILE_STORAGE_OPTIONS,
-            useFactory: async (optionsFactory: FileStorageOptionsFactory) => {
-                const fileStorageOptions = await optionsFactory.createFileStorageOptions();
-                FileStorageService.setOptions(fileStorageOptions);
-                return fileStorageOptions;
-            },
-            inject: [options.useExisting || options.useClass!],
-        };
-    }
-
-}

package/src/lib/storage/azure.storage.ts

@@ -1,214 +0,0 @@
-import {
-    BlobSASPermissions,
-    BlobSASSignatureValues,
-    BlobServiceClient,
-    generateBlobSASQueryParameters,
-    SASProtocol,
-    StorageSharedKeyCredential,
-} from '@azure/storage-blob';
-import concat from 'concat-stream';
-import moment from 'moment';
-import { StorageEngine } from 'multer';
-import path, { basename, join } from 'path';
-import { v4 as uuidv4 } from 'uuid';
-
-import { AzureStorageOptions, Storage, UploadedFile } from '../types';
-
-
-export class AzureStorage implements StorageEngine, Storage {
-
-    private blobServiceClient: BlobServiceClient;
-
-    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: AzureStorageOptions) {
-        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'));
-        });
-
-        const sharedKeyCredential = new StorageSharedKeyCredential(
-            options.account,
-            options.accountKey,
-        );
-
-        this.blobServiceClient = new BlobServiceClient(
-            `https://${options.account}.blob.core.windows.net`,
-            sharedKeyCredential,
-        );
-    }
-
-    async _handleFile(
-        req: any,
-        file: any,
-        cb: (error?: any, info?: any) => void,
-    ): Promise<void> {
-        try {
-            const dist = await this.fileDistFunction(file, req);
-            const key = await this.fileNameFunction(file, req);
-            const filePath = join(dist, key);
-
-            file.stream.pipe(concat({ encoding: 'buffer' }, async (buffer) => {
-                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 (error) {
-            cb(error);
-        }
-
-        file.stream.on('error', (err: any) => cb(err));
-    }
-
-    async _removeFile(
-        _req: any,
-        file: any,
-        cb: (error: Error | null) => void,
-    ): Promise<void> {
-        try {
-            const blobClient = this.blobServiceClient
-                .getContainerClient(this.options.container)
-                .getBlobClient(file.key);
-
-            await blobClient.delete();
-            cb(null);
-        } catch (error) {
-            cb(error);
-        }
-    }
-
-    getUrl(key: string): string {
-        return `https://${this.options.account}.blob.core.windows.net/${this.options.container}/${key}`;
-    }
-
-
-    getSignedUrl(key: string, signatureValues: Partial<Omit<BlobSASSignatureValues, 'containerName'>> = {}): string {
-        if (!key) return '';
-
-        const cloudFrontDomain = process.env['AZURE_CDN_DOMAIN_NAME'];
-
-        if (cloudFrontDomain) {
-            return `${cloudFrontDomain}/${key}`;
-        }
-
-        const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
-        const blobClient = containerClient.getBlobClient(key);
-
-        const sharedKeyCredential = new StorageSharedKeyCredential(
-            this.options.account,
-            this.options.accountKey,
-        );
-
-        // Set the SAS token options
-        const expiresOn = new Date();
-        expiresOn.setHours(expiresOn.getHours() + 1); // Set expiration time to 1 hour from now
-
-        const sasToken = generateBlobSASQueryParameters(
-            {
-                containerName: this.options.container,
-                blobName: key,
-                permissions: BlobSASPermissions.parse('r'), // Read permissions
-                protocol: SASProtocol.Https, // HTTPS only
-                startsOn: new Date(), // Start time (now)
-                expiresOn, // Expiration time
-                ...signatureValues,
-            },
-            sharedKeyCredential,
-        ).toString();
-
-        return `${blobClient.url}?${sasToken}`;
-    }
-
-    async getFile(key: string): Promise<Buffer> {
-        const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
-        const blobClient = containerClient.getBlobClient(key);
-        const downloadResponse = await blobClient.download();
-        const stream = downloadResponse.readableStreamBody;
-
-        return new Promise((resolve, reject) => {
-            const chunks: Buffer[] = [];
-            stream?.on('data', (chunk) => chunks.push(chunk));
-            stream?.on('end', () => resolve(Buffer.concat(chunks)));
-            stream?.on('error', reject);
-        });
-    }
-
-    async putFile(buffer: Buffer, key: string): Promise<UploadedFile> {
-        try {
-            const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
-            const blockBlobClient = containerClient.getBlockBlobClient(key);
-
-            await blockBlobClient.uploadData(buffer);
-
-            const fileInfo: UploadedFile = {
-                originalName: basename(key),
-                fileName: basename(key),
-                size: buffer.length,
-                buffer,
-                key,
-                fullPath: key,
-                url: this.getUrl(key),
-            };
-
-            return fileInfo;
-        } catch (error) {
-            console.error(`Error uploading file "${key}":`, error);
-            throw error;
-        }
-    }
-
-    async deleteFile(key: string) {
-        try {
-            const blobClient = this.blobServiceClient
-                .getContainerClient(this.options.container)
-                .getBlobClient(key);
-
-            await blobClient.delete();
-        } catch (error) {
-            console.error(`Error deleting blob "${key}":`, error);
-        }
-    }
-
-    async copyFile(oldKey: string, newKey: string): Promise<UploadedFile> {
-        try {
-            const containerClient = this.blobServiceClient.getContainerClient(this.options.container);
-            const sourceBlobClient = containerClient.getBlobClient(oldKey);
-            const destinationBlobClient = containerClient.getBlobClient(newKey);
-
-            const copyPoller = await destinationBlobClient.beginCopyFromURL(sourceBlobClient.url);
-            await copyPoller.pollUntilDone();
-
-            const properties = await destinationBlobClient.getProperties();
-
-            return {
-                originalName: basename(newKey),
-                size: properties.contentLength || 0,
-                fileName: basename(newKey),
-                key: newKey,
-                fullPath: newKey,
-                url: this.getUrl(newKey),
-            };
-        } catch (error) {
-            console.error('Error copying file in Azure Blob Storage:', error);
-            throw error;
-        }
-    }
-
-
-}

package/src/lib/storage/local.storage.ts

@@ -1,233 +0,0 @@
-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
-     */
-    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
-     */
-    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(sep);
-    }
-
-    /**
-     * Get full file system path from URL-friendly key
-     */
-    private getFullPath(urlKey: string): string {
-        const osPath = this.urlToPath(urlKey);
-        return join(this.rootPath, osPath);
-    }
-
-    constructor(private options: LocalStorageOptions) {
-        // Normalize path for the current OS
-        this.rootPath = normalize(options.rootPath || join(process.cwd(), 'public'));
-
-        this.fileNameFunction = options.fileName || ((file, _req) => {
-            return `${uuidv4()}-${file.originalname}`;
-        });
-
-        this.fileDistFunction = options.fileDist || ((_file, _req) => {
-            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: 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 = join(dist, fileName);
-            // Convert to URL-friendly key for storage
-            const urlKey = this.pathToUrl(filePath);
-
-            file.stream.pipe(concat({ encoding: 'buffer' }, async (buffer) => {
-                const uploadedFile = await this.putFile(buffer, urlKey);
-
-                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) {
-            console.error('error', error);
-            cb(error);
-        }
-    }
-
-    _removeFile(
-        _req: any,
-        file: any,
-        cb: (error: Error | null) => void,
-    ) {
-        const filePath = file.path;
-
-        fs.unlink(filePath, (err) => {
-            if (err) {
-                cb(err);
-            } else {
-                cb(null);
-            }
-        });
-    }
-
-    getUrl(urlKey: string): string {
-        if (urlKey && urlKey.startsWith('http')) {
-            return urlKey;
-        }
-        if (!urlKey) {
-            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: string): Promise<Buffer> {
-        // Convert URL key to OS-specific path
-        const fullPath = this.getFullPath(urlKey);
-        return fs.promises.readFile(fullPath);
-    }
-
-    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: Buffer,
-        urlKey: string,
-    ): Promise<UploadedFile> {
-        return new Promise((putFileResolve, reject) => {
-            // Convert URL key to OS-specific path
-            const filePath = this.getFullPath(urlKey);
-
-            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: UploadedFile = {
-                    originalName: fileName,
-                    size: stats.size,
-                    fileName: fileName,
-                    key: urlKey,
-                    url: this.getUrl(urlKey),
-                    fullPath: filePath,
-                };
-                putFileResolve(fileInfo);
-            });
-        });
-    }
-
-
-    path(urlKey: string): string {
-        if (!urlKey) {
-            return '';
-        }
-        // Convert URL key to full OS-specific path
-        return this.getFullPath(urlKey);
-    }
-
-    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 = 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: UploadedFile = {
-                    originalName: fileName,
-                    size: stats.size,
-                    fileName: fileName,
-                    key: newUrlKey,
-                    fullPath: newPath,
-                    url: this.getUrl(newUrlKey),
-                };
-                resolve(fileInfo);
-            });
-        });
-    }
-
-
-}