@flusys/nestjs-storage 0.1.0-beta.2 → 1.0.0-beta

package/fesm/providers/local-provider.js

@@ -33,14 +33,19 @@ import { v4 as uuidv4 } from 'uuid';
  */ export class LocalProvider {
     /**
    * 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) {
-        this.basePath = path.resolve(config.basePath);
-        this.baseUrl = config.baseUrl || '';
+        // 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 fs.mkdir(this.basePath, {
             recursive: true
         });
-        this.logger.log(`Local Provider initialized: ${this.basePath}`);
+        this.logger.log(`Local Provider initialized: ${this.basePath} (relative: ${this.relativeBasePath})`);
     }
     async uploadFile(file, options) {
         let processedBuffer = file.buffer;
@@ -66,8 +71,9 @@ import { v4 as uuidv4 } from 'uuid';
         });
         // Write file to disk
         await fs.writeFile(filePath, processedBuffer);
-        // Generate relative key (for URL generation and deletion)
-        const relativeKey = path.relative(this.basePath, filePath);
+        // 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
         this.logger.log(`Uploaded file to local storage: ${relativeKey}`);
         return {
             name: fileName,
@@ -81,7 +87,24 @@ import { v4 as uuidv4 } from 'uuid';
     }
     async deleteFile(key) {
         try {
-            const filePath = path.join(this.basePath, key);
+            // Key now includes the basePath, resolve from cwd
+            let filePath = path.resolve(key);
+            // Check if file exists at the resolved path
+            try {
+                await fs.access(filePath);
+            } catch  {
+                // Fallback: try with basePath prefix (for old keys without basePath)
+                const fallbackPath = path.join(this.basePath, key);
+                try {
+                    await fs.access(fallbackPath);
+                    filePath = fallbackPath;
+                    this.logger.debug(`Using fallback path for delete: ${fallbackPath}`);
+                } catch  {
+                    // File doesn't exist at either location
+                    this.logger.warn(`File not found for deletion: ${key}`);
+                    return;
+                }
+            }
             await fs.unlink(filePath);
             this.logger.log(`Deleted file from local storage: ${key}`);
         } catch (_error) {
@@ -95,8 +118,13 @@ import { v4 as uuidv4 } from 'uuid';
     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, otherwise return relative path
-        return this.baseUrl ? `${this.baseUrl}/${key}` : `/${key}`;
+        // 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 {
@@ -108,14 +136,16 @@ import { v4 as uuidv4 } from 'uuid';
     }
     /**
    * Get the absolute path for a file key
+   * Key now includes basePath, so resolve from cwd
    */ getAbsolutePath(key) {
-        return path.join(this.basePath, key);
+        return path.resolve(key);
     }
     /**
    * Check if a file exists
    */ async fileExists(key) {
         try {
-            const filePath = path.join(this.basePath, key);
+            // Key now includes basePath, resolve from cwd
+            const filePath = path.resolve(key);
             await fs.access(filePath);
             return true;
         } catch  {
@@ -125,7 +155,8 @@ import { v4 as uuidv4 } from 'uuid';
     /**
    * Get file stats
    */ async getFileStats(key) {
-        const filePath = path.join(this.basePath, key);
+        // Key now includes basePath, resolve from cwd
+        const filePath = path.resolve(key);
         const stats = await fs.stat(filePath);
         return {
             size: stats.size,
@@ -137,5 +168,6 @@ import { v4 as uuidv4 } from 'uuid';
         _define_property(this, "logger", new Logger(LocalProvider.name));
         _define_property(this, "basePath", '');
         _define_property(this, "baseUrl", '');
+        _define_property(this, "relativeBasePath", ''); // Path relative to cwd for key generation
     }
 }

package/fesm/providers/storage-factory.service.js

@@ -17,9 +17,18 @@ function _ts_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;
 }
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
 import { StorageProviderRegistry } from './storage-provider.registry';
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import * as crypto from 'crypto';
+import { StorageConfigService } from '../config';
 export class StorageFactoryService {
     /**
    * Generate a stable cache key for provider configuration
@@ -49,7 +58,19 @@ export class StorageFactoryService {
             const instance = new ProviderClass();
             // Initialize if method exists
             if ('initialize' in instance && typeof instance.initialize === 'function') {
-                await instance.initialize(config.config);
+                // For local provider, inject appUrl as fallback for baseUrl
+                let initConfig = config.config;
+                if (config.provider === 'local' && !config.config?.baseUrl) {
+                    const appUrl = this.storageConfigService.getAppUrl();
+                    if (appUrl) {
+                        initConfig = {
+                            ...config.config,
+                            baseUrl: appUrl
+                        };
+                        this.logger.debug(`Using appUrl from config as baseUrl: ${appUrl}`);
+                    }
+                }
+                await instance.initialize(initConfig);
             }
             // Cache the instance
             this.providerCache.set(providerKey, instance);
@@ -91,6 +112,20 @@ export class StorageFactoryService {
         return StorageProviderRegistry.getAll();
     }
     /**
+   * Get the basePath from cached local provider
+   * Returns null if no local provider is cached
+   */ getLocalProviderBasePath() {
+        // Find cached local provider
+        const localKey = Array.from(this.providerCache.keys()).find((key)=>key.startsWith('local'));
+        if (localKey) {
+            const provider = this.providerCache.get(localKey);
+            if (provider && 'basePath' in provider) {
+                return provider.basePath;
+            }
+        }
+        return null;
+    }
+    /**
    * Cleanup all cached provider connections on module destroy
    * Ensures SFTP connections and other resources are properly released
    */ async onModuleDestroy() {
@@ -106,11 +141,20 @@ export class StorageFactoryService {
         this.providerCache.clear();
         this.logger.log('Storage provider cleanup complete');
     }
-    constructor(){
-        _define_property(this, "logger", new Logger(StorageFactoryService.name));
-        _define_property(this, "providerCache", new Map());
+    constructor(storageConfigService){
+        _define_property(this, "storageConfigService", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "providerCache", void 0);
+        this.storageConfigService = storageConfigService;
+        this.logger = new Logger(StorageFactoryService.name);
+        this.providerCache = new Map();
     }
 }
 StorageFactoryService = _ts_decorate([
-    Injectable()
+    Injectable(),
+    _ts_param(0, Inject(StorageConfigService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof StorageConfigService === "undefined" ? Object : StorageConfigService
+    ])
 ], StorageFactoryService);

package/fesm/services/file-manager.service.js

@@ -39,6 +39,13 @@ const USER_ACTION_PERMISSION_CACHE_KEY = 'user_action_permission';
 const SHOW_PRIVATE_FILE_ACTION = 'storage.file.viewPrivate';
 export class FileManagerService extends RequestScopedApiService {
     /**
+   * Get base URL for file serving
+   * Priority: appUrl config > request headers
+   */ getFileBaseUrl(protocol, host) {
+        const appUrl = this.storageConfig.getAppUrl();
+        return appUrl?.replace(/\/$/, '') ?? `${protocol}://${host}`;
+    }
+    /**
    * Resolve entity class for this service
    * @returns FileManager or FileManagerWithCompany based on configuration
    */ resolveEntity() {
@@ -137,6 +144,7 @@ export class FileManagerService extends RequestScopedApiService {
                 'key',
                 'url',
                 'location',
+                'storageConfigId',
                 'isPrivate',
                 'createdAt',
                 'deletedAt'
@@ -147,6 +155,7 @@ export class FileManagerService extends RequestScopedApiService {
         if (this.storageConfig.isCompanyFeatureEnabled()) {
             selectFields.push('file_manager.companyId');
         }
+        // Join folder
         selectFields.push('folder.id');
         selectFields.push('folder.name');
         query.leftJoinAndSelect('file_manager.folder', 'folder');
@@ -156,6 +165,57 @@ export class FileManagerService extends RequestScopedApiService {
             isRaw: false
         };
     }
+    /**
+   * Enrich file list with provider names from storage_config table
+   * Call this method to add providerName to the list results
+   */ async enrichWithProviderNames(items) {
+        // Get unique storage config IDs
+        const configIds = [
+            ...new Set(items.map((item)=>item.storageConfigId).filter(Boolean))
+        ];
+        this.logger.debug(`enrichWithProviderNames: items count=${items.length}, configIds=${JSON.stringify(configIds)}`);
+        if (configIds.length === 0) {
+            this.logger.debug('enrichWithProviderNames: No storage config IDs found in items');
+            return items.map((item)=>({
+                    ...item,
+                    providerName: undefined
+                }));
+        }
+        // Fetch storage config names
+        try {
+            const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
+            const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
+            const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
+            const configs = await storageConfigRepository.find({
+                where: {
+                    id: In(configIds)
+                },
+                select: [
+                    'id',
+                    'name'
+                ]
+            });
+            this.logger.debug(`enrichWithProviderNames: Found ${configs.length} configs: ${JSON.stringify(configs)}`);
+            // Create a map for quick lookup
+            const configNameMap = new Map(configs.map((c)=>[
+                    c.id,
+                    c.name
+                ]));
+            // Enrich items with provider names
+            const enrichedItems = items.map((item)=>({
+                    ...item,
+                    providerName: item.storageConfigId ? configNameMap.get(item.storageConfigId) : undefined
+                }));
+            this.logger.debug(`enrichWithProviderNames: First enriched item: ${JSON.stringify(enrichedItems[0])}`);
+            return enrichedItems;
+        } catch (error) {
+            this.logger.warn(`Failed to fetch provider names: ${error}`);
+            return items.map((item)=>({
+                    ...item,
+                    providerName: undefined
+                }));
+        }
+    }
     async getFilterQuery(query, filter, _user) {
         Object.entries(filter).forEach(([key, value])=>{
             if (key === 'contentType') {
@@ -218,7 +278,7 @@ export class FileManagerService extends RequestScopedApiService {
         }
         return result;
     }
-    async beforeDeleteOperation(dto, _user, _queryRunner) {
+    async beforeDeleteOperation(dto, user, _queryRunner) {
         if (dto.type === 'permanent') {
             const ids = Array.isArray(dto.id) ? dto.id : [
                 dto.id
@@ -231,13 +291,46 @@ export class FileManagerService extends RequestScopedApiService {
             fileManager.forEach((file)=>{
                 const configId = file.storageConfigId || 'default';
                 if (!filesByConfig.has(configId)) {
-                    filesByConfig.set(configId, []);
+                    filesByConfig.set(configId, {
+                        keys: [],
+                        location: file.location
+                    });
                 }
-                filesByConfig.get(configId).push(file.key);
+                filesByConfig.get(configId).keys.push(file.key);
             });
             // Delete files from each storage config
-            for (const [configId, keys] of filesByConfig){
-                await this.uploadService.deleteMultipleFile(keys, configId === 'default' ? undefined : configId);
+            for (const [configId, { keys, location }] of filesByConfig){
+                // For local files with old key format (no '/'), we need to prefix with basePath
+                let deleteKeys = keys;
+                if (location === FileLocationEnum.LOCAL && configId !== 'default') {
+                    try {
+                        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
+                        const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
+                        const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
+                        const config = await storageConfigRepository.findOne({
+                            where: {
+                                id: configId
+                            },
+                            select: [
+                                'id',
+                                'config'
+                            ]
+                        });
+                        if (config && config.config?.basePath) {
+                            const basePath = config.config.basePath.replace(/^\.\//, '');
+                            // Convert old keys to new format
+                            deleteKeys = keys.map((key)=>{
+                                if (!key.includes('/')) {
+                                    return `${basePath}/${key}`;
+                                }
+                                return key;
+                            });
+                        }
+                    } catch (error) {
+                        this.logger.warn(`Failed to get basePath for delete: ${error}`);
+                    }
+                }
+                await this.uploadService.deleteMultipleFile(deleteKeys, configId === 'default' ? undefined : configId, user ?? undefined, location);
             }
         }
     }
@@ -269,13 +362,43 @@ export class FileManagerService extends RequestScopedApiService {
                     shouldUpdate = true;
                 } catch (error) {
                     this.logger.error(`Failed to generate URL for file ${file.id}: ${error?.message || 'Unknown error'}`);
-                    // Use fallback URL
-                    file.url = `${protocol}://${host}/storage/upload/file/${file.key}`;
+                    // Use fallback URL with appUrl from config
+                    const baseUrl = this.getFileBaseUrl(protocol, host);
+                    file.url = `${baseUrl}/storage/upload/file/${file.key}`;
                 }
             }
             // SFTP/Local files - always construct full URL (no expiry, but need full path)
             if (file.location === FileLocationEnum.SFTP || file.location === FileLocationEnum.LOCAL) {
-                const expectedUrl = `${protocol}://${host}/storage/upload/file/${file.key}`;
+                // For backward compatibility: if key doesn't include basePath, look it up from config
+                let fileKey = file.key;
+                // Check if key looks like it's missing the basePath (old format)
+                // Old format: "uuid-filename.png"
+                // New format: "uploads/uuid-filename.png" or "uploads/company1/uuid-filename.png"
+                if (!fileKey.includes('/') && file.storageConfigId) {
+                    try {
+                        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
+                        const storageConfigEntity = enableCompanyFeature ? (await import('../entities')).StorageConfigWithCompany : (await import('../entities')).StorageConfig;
+                        const storageConfigRepository = await this.dataSourceProvider.getRepository(storageConfigEntity);
+                        const config = await storageConfigRepository.findOne({
+                            where: {
+                                id: file.storageConfigId
+                            },
+                            select: [
+                                'id',
+                                'config'
+                            ]
+                        });
+                        if (config && config.config?.basePath) {
+                            const basePath = config.config.basePath.replace(/^\.\//, ''); // Remove leading ./
+                            fileKey = `${basePath}/${file.key}`;
+                            this.logger.debug(`Prefixed old key with basePath: ${fileKey}`);
+                        }
+                    } catch (error) {
+                        this.logger.warn(`Failed to get basePath for file ${file.id}: ${error}`);
+                    }
+                }
+                const baseUrl = this.getFileBaseUrl(protocol, host);
+                const expectedUrl = `${baseUrl}/storage/upload/file/${fileKey}`;
                 if (file.url !== expectedUrl) {
                     file.url = expectedUrl;
                     shouldUpdate = true;
@@ -286,7 +409,9 @@ export class FileManagerService extends RequestScopedApiService {
                 id: file.id,
                 name: file.name,
                 contentType: file.contentType,
-                url: file.url || ''
+                url: file.url || '',
+                location: file.location,
+                storageConfigId: file.storageConfigId || undefined
             };
         }));
         // Save only changed records

package/fesm/services/folder.service.js

@@ -27,51 +27,29 @@ function _ts_param(paramIndex, decorator) {
 }
 import { RequestScopedApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { Inject, Injectable, Scope } from '@nestjs/common';
 import { StorageConfigService } from '../config';
 import { Folder, FolderWithCompany } from '../entities';
 import { StorageDataSourceProvider } from './storage-datasource.provider';
 export class FolderService extends RequestScopedApiService {
-    /**
-   * Resolve entity class for this service
-   * @returns Folder or FolderWithCompany based on configuration
-   */ resolveEntity() {
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        return enableCompanyFeature ? FolderWithCompany : Folder;
+    resolveEntity() {
+        return this.storageConfig.isCompanyFeatureEnabled() ? FolderWithCompany : Folder;
     }
-    /**
-   * Get DataSource provider for this service
-   * @returns StorageDataSourceProvider instance
-   */ getDataSourceProvider() {
+    getDataSourceProvider() {
         return this.dataSourceProvider;
     }
+    // Entity Conversion
     async convertSingleDtoToEntity(dto, user) {
-        let folder = {};
-        // NOTE: Using 'id' in dto check instead of instanceof - instanceof may not work after esbuild bundling
-        if ('id' in dto && dto.id && typeof dto.id === 'string') {
-            const dbData = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!dbData) {
-                throw new NotFoundException('No such entity data found for update! Please, Try Again.');
-            }
-            folder = dbData;
-        }
-        // Set company/branch IDs if company feature is enabled
-        folder = {
-            ...folder,
-            ...dto
-        };
-        // Only set company fields if they exist on the entity (when company feature is enabled)
-        if ('companyId' in folder) {
-            folder.companyId = user?.companyId ?? null;
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        // Set companyId from user context if company feature enabled
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
         }
-        return folder;
+        return entity;
     }
+    // Query Customization
     async getSelectQuery(query, _user, select) {
-        if (!select || !select.length) {
+        if (!select?.length) {
             select = [
                 'id',
                 'name',
@@ -79,35 +57,26 @@ export class FolderService extends RequestScopedApiService {
                 'createdAt',
                 'deletedAt'
             ];
+            if (this.storageConfig.isCompanyFeatureEnabled()) {
+                select.push('companyId');
+            }
         }
-        const selectFields = select.map((field)=>`${this.entityName}.${field}`);
-        // Add company context fields if company feature is enabled
-        // The entity will have these fields only if company feature is enabled
-        if (this.storageConfig.isCompanyFeatureEnabled()) {
-            selectFields.push('folder.companyId');
-        }
-        query.select(selectFields);
+        query.select(select.map((f)=>`${this.entityName}.${f}`));
         return {
             query,
             isRaw: false
         };
     }
-    /**
-   * Override: Extra query manipulation - Auto-filter by user's company
-   */ async getExtraManipulateQuery(query, filterDto, user) {
+    async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        // If company feature enabled and user has companyId, filter by user's company
-        const enableCompanyFeature = this.storageConfig.isCompanyFeatureEnabled();
-        if (enableCompanyFeature && user?.companyId) {
+        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
             query.andWhere('folder.companyId = :companyId', {
                 companyId: user.companyId
             });
         }
         return result;
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
     constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
-        // Repository will be set asynchronously by RequestScopedApiService
         super('folder', null, cacheManager, utilsService, FolderService.name, true), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "storageConfig", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider;
     }
 }

package/fesm/services/storage-datasource.provider.js

@@ -32,10 +32,8 @@ import { Request } from 'express';
 import { StorageModuleOptions } from '../interfaces';
 import { STORAGE_MODULE_OPTIONS } from '../config/storage.constants';
 export class StorageDataSourceProvider extends MultiTenantDataSourceService {
-    // ==================== Factory Methods ====================
-    /**
-   * Build parent options from StorageModuleOptions
-   */ static buildParentOptions(options) {
+    // Factory Methods
+    /** Build parent options from StorageModuleOptions */ static buildParentOptions(options) {
         return {
             bootstrapAppConfig: options.bootstrapAppConfig,
             defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
@@ -43,10 +41,8 @@ export class StorageDataSourceProvider extends MultiTenantDataSourceService {
             tenants: options.config?.tenants
         };
     }
-    // ==================== Feature Flags ====================
-    /**
-   * Get global enable company feature flag
-   */ getEnableCompanyFeature() {
+    // Feature Flags
+    /** Get global enable company feature flag */ getEnableCompanyFeature() {
         return this.storageOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
     }
     /**
@@ -60,11 +56,11 @@ export class StorageDataSourceProvider extends MultiTenantDataSourceService {
    */ getEnableCompanyFeatureForCurrentTenant() {
         return this.getEnableCompanyFeatureForTenant(this.getCurrentTenant() ?? undefined);
     }
-    // ==================== Entity Management ====================
+    // Entity Management
     /**
-   * Get storage entities for migrations based on company feature flag
-   * Note: For TypeORM repositories, we always use the base entities (FileManager, etc.)
-   * But for migrations, we need the correct entity based on the feature flag
+   * Get storage entities for migrations based on company feature flag.
+   * For TypeORM repositories, we always use the base entities (FileManager, etc.)
+   * but for migrations, we need the correct entity based on the feature flag.
    */ async getStorageEntities(enableCompanyFeature) {
         const enable = enableCompanyFeature ?? this.getEnableCompanyFeature();
         const { FileManager, Folder, StorageConfig } = await import('../entities');
@@ -84,10 +80,8 @@ export class StorageDataSourceProvider extends MultiTenantDataSourceService {
             StorageConfig
         ];
     }
-    // ==================== Overrides ====================
-    /**
-   * Override to dynamically set entities based on tenant config
-   */ async createDataSourceFromConfig(config) {
+    // Overrides
+    /** Override to dynamically set entities based on tenant config */ async createDataSourceFromConfig(config) {
         const currentTenant = this.getCurrentTenant();
         const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
         const entities = await this.getStorageEntities(enableCompanyFeature);