@flusys/nestjs-storage 1.1.0-beta → 1.1.0

package/fesm/entities/folder.entity.js

@@ -20,13 +20,29 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import { Entity, OneToMany } from 'typeorm';
-import { FolderBase } from './folder-base.entity';
-export class Folder extends FolderBase {
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { Column, Entity, OneToMany } from 'typeorm';
+export class Folder extends Identity {
     constructor(...args){
-        super(...args), _define_property(this, "fileManager", void 0);
+        super(...args), _define_property(this, "name", void 0), _define_property(this, "slug", void 0), _define_property(this, "fileManager", void 0);
     }
 }
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Folder.prototype, "name", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Folder.prototype, "slug", void 0);
 _ts_decorate([
     OneToMany('FileManager', (fileManager)=>fileManager.folder),
     _ts_metadata("design:type", Array)

package/fesm/entities/index.js

@@ -1,7 +1,3 @@
-// Base entities
-export * from './file-manager-base.entity';
-export * from './folder-base.entity';
-export * from './storage-config-base.entity';
 // Entities without company feature
 export * from './file-manager.entity';
 export * from './folder.entity';
@@ -28,14 +24,10 @@ export const StorageCompanyEntities = [
     FolderWithCompany,
     StorageConfigWithCompany
 ];
-// All entities
-export const StorageAllEntities = [
-    ...StorageCoreEntities,
-    ...StorageCompanyEntities
-];
-/**
- * Get Storage entities based on configuration
- * @param enableCompanyFeature - Whether company feature is enabled
- */ export function getStorageEntitiesByConfig(enableCompanyFeature) {
+export function getStorageEntitiesByConfig(enableCompanyFeature) {
     return enableCompanyFeature ? StorageCompanyEntities : StorageCoreEntities;
 }
+// Base type aliases for backwards compatibility with services
+export { FileManager as FileManagerBase } from './file-manager.entity';
+export { Folder as FolderBase } from './folder.entity';
+export { StorageConfig as StorageConfigBase } from './storage-config.entity';

package/fesm/entities/storage-config-with-company.entity.js

@@ -21,11 +21,10 @@ function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 import { Column, Entity } from 'typeorm';
-import { StorageConfigBase } from './storage-config-base.entity';
-export class StorageConfigWithCompany extends StorageConfigBase {
+import { StorageConfig } from './storage-config.entity';
+export class StorageConfigWithCompany extends StorageConfig {
     constructor(...args){
-        super(...args), // Company ID - used when company feature is enabled
-        _define_property(this, "companyId", void 0);
+        super(...args), _define_property(this, "companyId", void 0);
     }
 }
 _ts_decorate([

package/fesm/entities/storage-config.entity.js

@@ -1,15 +1,85 @@
+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 _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { Entity } from 'typeorm';
-import { StorageConfigBase } from './storage-config-base.entity';
-export class StorageConfig extends StorageConfigBase {
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { Column, Entity, Index } from 'typeorm';
+export class StorageConfig extends Identity {
+    constructor(...args){
+        super(...args), _define_property(this, "name", void 0), _define_property(this, "storage", void 0), _define_property(this, "config", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0);
+    }
 }
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], StorageConfig.prototype, "name", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 50,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], StorageConfig.prototype, "storage", void 0);
+_ts_decorate([
+    Column({
+        type: 'json',
+        nullable: false
+    }),
+    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], StorageConfig.prototype, "config", void 0);
+_ts_decorate([
+    Column({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    _ts_metadata("design:type", Boolean)
+], StorageConfig.prototype, "isActive", void 0);
+_ts_decorate([
+    Column({
+        type: 'boolean',
+        default: false,
+        name: 'is_default'
+    }),
+    _ts_metadata("design:type", Boolean)
+], StorageConfig.prototype, "isDefault", void 0);
 StorageConfig = _ts_decorate([
     Entity({
         name: 'storage_config'
-    })
+    }),
+    Index([
+        'name'
+    ]),
+    Index([
+        'storage'
+    ]),
+    Index([
+        'isActive'
+    ]),
+    Index([
+        'isDefault'
+    ])
 ], StorageConfig);

package/fesm/interfaces/index.js

@@ -1,5 +1,4 @@
 export * from './file-manager.interface';
-export * from './file-upload-response.interface';
 export * from './folder.interface';
 export * from './storage-config.interface';
 export * from './storage-module-options.interface';

package/fesm/interfaces/storage-config.interface.js

@@ -1,3 +1 @@
-/**
- * SFTP Configuration
- */ export { };
+export { };

package/fesm/middlewares/file-serve.middleware.js

@@ -20,132 +20,145 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Injectable, Logger, NotFoundException, Inject } from '@nestjs/common';
 import { createReadStream, existsSync, statSync } from 'fs';
 import { join, resolve } from 'path';
 import * as mime from 'mime-types';
 import { UploadService } from '../services/upload.service';
+/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
+    'image/',
+    'video/',
+    'audio/',
+    'text/',
+    'application/pdf',
+    'application/json',
+    'application/xml'
+];
 export class FileServeMiddleware {
     async use(req, res, next) {
         try {
-            const uploadDir = process.cwd();
-            // Extract path after /storage/upload/file/
-            const urlPath = req.path || req.url;
-            const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
-            const normalizedPath = match ? match[1] : '';
-            if (!normalizedPath) {
-                throw new NotFoundException('File path is required');
-            }
-            this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
-            // Get the local storage basePath for fallback lookups
-            const basePath = await this.uploadService.getLocalStorageBasePath();
-            const normalizedBasePath = basePath ? basePath.replace(/^\.\//, '').replace(/\/$/, '') : null;
-            // Strategy 1: Try path relative to CWD (new format: key includes basePath)
-            let fullPath = join(uploadDir, normalizedPath);
-            let resolvedPath = resolve(fullPath);
-            this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
-            // Validate path is inside the project directory (prevent path traversal)
-            if (!resolvedPath.startsWith(uploadDir)) {
-                throw new NotFoundException('Invalid file path');
-            }
-            // Check if file exists
-            if (!existsSync(fullPath)) {
-                // Strategy 2: If key already starts with basePath, try using basePath directly
-                if (basePath && normalizedBasePath) {
-                    const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
-                    if (pathStartsWithBase) {
-                        const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
-                        const fallbackPath = join(basePath, remainingPath);
-                        this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
-                        if (existsSync(fallbackPath)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = resolve(fullPath);
-                        }
-                    } else {
-                        // Old format: key doesn't include basePath, prepend it
-                        const fallbackPath = join(basePath, normalizedPath);
-                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
-                        if (existsSync(fallbackPath)) {
-                            fullPath = fallbackPath;
-                            resolvedPath = resolve(fullPath);
-                        }
-                    }
-                }
-                // Final check if file was found
-                if (!existsSync(fullPath)) {
-                    throw new NotFoundException(`File not found: ${normalizedPath}`);
-                }
-            }
+            const normalizedPath = this.extractFilePath(req);
+            const fullPath = await this.resolveFilePath(normalizedPath);
             const stats = statSync(fullPath);
             if (!stats.isFile()) {
                 throw new NotFoundException(`Not a file: ${normalizedPath}`);
             }
-            // Enhanced MIME type detection
-            let mimeType = mime.lookup(fullPath) || 'application/octet-stream';
-            // Special handling for SVG files
-            if (fullPath.toLowerCase().endsWith('.svg')) {
-                mimeType = 'image/svg+xml';
-            }
-            // Determine if file should be displayed inline or downloaded
-            const viewableTypes = [
-                'image/',
-                'video/',
-                'audio/',
-                'text/',
-                'application/pdf',
-                'application/json',
-                'application/xml'
-            ];
-            const isViewable = viewableTypes.some((type)=>mimeType.startsWith(type));
-            const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(normalizedPath.split('/').pop() || 'download')}"`;
-            // Set headers
-            res.set({
-                'Content-Type': mimeType,
-                'Content-Length': stats.size,
-                'Content-Disposition': contentDisposition,
-                'Cache-Control': 'public, max-age=3600',
-                'Accept-Ranges': 'bytes',
-                'Cross-Origin-Resource-Policy': 'cross-origin',
-                'Access-Control-Allow-Origin': '*',
-                'X-Content-Type-Options': 'nosniff'
-            });
-            // Stream the file
-            const stream = createReadStream(fullPath);
-            stream.pipe(res);
-            stream.on('error', (err)=>{
-                this.logger.error('File stream error', err);
-                if (!res.headersSent) {
-                    res.status(404).json({
-                        message: `Failed to serve file: ${normalizedPath}`,
-                        error: 'Not Found',
-                        statusCode: 404
-                    });
-                }
-            });
-            // Handle client disconnection
-            res.on('close', ()=>{
-                stream.destroy();
-            });
+            const mimeType = this.getMimeType(fullPath);
+            this.setResponseHeaders(res, stats.size, mimeType, normalizedPath);
+            this.streamFile(res, fullPath, normalizedPath);
         } catch (error) {
-            this.logger.error('File retrieval error:', error);
+            this.sendErrorResponse(res, error);
+        }
+    }
+    /** Extract and validate file path from request URL */ extractFilePath(req) {
+        const urlPath = req.path || req.url;
+        const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
+        const normalizedPath = match ? match[1] : '';
+        if (!normalizedPath) {
+            throw new NotFoundException('File path is required');
+        }
+        this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
+        return normalizedPath;
+    }
+    /** Resolve file path using multiple fallback strategies */ async resolveFilePath(normalizedPath) {
+        // Strategy 1: Path relative to CWD (new format: key includes basePath)
+        let fullPath = join(this.uploadDir, normalizedPath);
+        const resolvedPath = resolve(fullPath);
+        this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
+        // Prevent path traversal attacks
+        if (!resolvedPath.startsWith(this.uploadDir)) {
+            throw new NotFoundException('Invalid file path');
+        }
+        if (existsSync(fullPath)) {
+            return fullPath;
+        }
+        // Try fallback strategies with basePath
+        const basePath = await this.uploadService.getLocalStorageBasePath();
+        if (basePath) {
+            const fallbackPath = this.tryFallbackPaths(normalizedPath, basePath);
+            if (fallbackPath) {
+                return fallbackPath;
+            }
+        }
+        throw new NotFoundException(`File not found: ${normalizedPath}`);
+    }
+    /** Try basePath-based fallback strategies */ tryFallbackPaths(normalizedPath, basePath) {
+        const normalizedBasePath = basePath.replace(/^\.\//, '').replace(/\/$/, '');
+        const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
+        if (pathStartsWithBase) {
+            // Strategy 2: basePath + remaining path
+            const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
+            const fallbackPath = join(basePath, remainingPath);
+            this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
+            if (existsSync(fallbackPath)) return fallbackPath;
+        } else {
+            // Strategy 3: Old format - prepend basePath
+            const fallbackPath = join(basePath, normalizedPath);
+            this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
+            if (existsSync(fallbackPath)) return fallbackPath;
+        }
+        return null;
+    }
+    /** Get MIME type with SVG special handling */ getMimeType(fullPath) {
+        if (fullPath.toLowerCase().endsWith('.svg')) {
+            return 'image/svg+xml';
+        }
+        return mime.lookup(fullPath) || 'application/octet-stream';
+    }
+    /** Set response headers for file serving */ setResponseHeaders(res, size, mimeType, normalizedPath) {
+        const isViewable = VIEWABLE_TYPE_PREFIXES.some((type)=>mimeType.startsWith(type));
+        const filename = normalizedPath.split('/').pop() || 'download';
+        const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(filename)}"`;
+        res.set({
+            'Content-Type': mimeType,
+            'Content-Length': size,
+            'Content-Disposition': contentDisposition,
+            'Cache-Control': 'public, max-age=3600',
+            'Accept-Ranges': 'bytes',
+            'Cross-Origin-Resource-Policy': 'cross-origin',
+            'Access-Control-Allow-Origin': '*',
+            'X-Content-Type-Options': 'nosniff'
+        });
+    }
+    /** Stream file to response with error handling */ streamFile(res, fullPath, normalizedPath) {
+        const stream = createReadStream(fullPath);
+        stream.pipe(res);
+        stream.on('error', (err)=>{
+            this.logger.error('File stream error', err);
             if (!res.headersSent) {
-                res.status(404).json({
-                    message: error instanceof NotFoundException ? error.message : `File not found`,
-                    error: 'Not Found',
-                    statusCode: 404
-                });
+                this.sendErrorResponse(res, new NotFoundException(`Failed to serve file: ${normalizedPath}`));
             }
+        });
+        res.on('close', ()=>stream.destroy());
+    }
+    /** Send consistent error response */ sendErrorResponse(res, error) {
+        this.logger.error('File retrieval error:', error);
+        if (!res.headersSent) {
+            const message = error instanceof NotFoundException ? error.message : 'File not found';
+            res.status(404).json({
+                message,
+                error: 'Not Found',
+                statusCode: 404
+            });
         }
     }
     constructor(uploadService){
         _define_property(this, "uploadService", void 0);
         _define_property(this, "logger", void 0);
+        _define_property(this, "uploadDir", void 0);
         this.uploadService = uploadService;
         this.logger = new Logger(FileServeMiddleware.name);
+        this.uploadDir = process.cwd();
     }
 }
 FileServeMiddleware = _ts_decorate([
     Injectable(),
+    _ts_param(0, Inject(UploadService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof UploadService === "undefined" ? Object : UploadService