@ackplus/nest-file-storage 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ack Solutions
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,409 @@
+# @ackplus/nest-file-storage
+
+A flexible file storage library for NestJS that supports multiple storage providers with simple file mapping capabilities.
+
+## Installation
+
+```bash
+npm install @ackplus/nest-file-storage
+```
+
+## Storage Providers
+
+This library supports multiple storage providers. You only need to install the dependencies for the storage providers you plan to use.
+
+### Local Storage
+
+No additional dependencies required. Works out of the box.
+
+### Azure Blob Storage
+
+To use Azure Blob Storage, install the Azure SDK:
+
+```bash
+npm install @azure/storage-blob
+```
+
+### AWS S3 Storage
+
+To use AWS S3 Storage, install the AWS SDK:
+
+```bash
+npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner
+```
+
+## Usage
+
+The library supports two approaches: **Configuration-based** and **Class Factory**.
+
+### Configuration-based Approach (Recommended)
+
+This approach uses lazy loading and only loads the storage provider when needed.
+
+#### Local Storage
+
+```typescript
+import { NestFileStorageModule, FileStorageEnum } from '@ackplus/nest-file-storage';
+
+@Module({
+  imports: [
+    NestFileStorageModule.forRoot({
+      storage: FileStorageEnum.LOCAL,
+      localConfig: {
+        destination: './uploads'
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+#### Azure Blob Storage
+
+```typescript
+import { NestFileStorageModule, FileStorageEnum } from '@ackplus/nest-file-storage';
+
+@Module({
+  imports: [
+    NestFileStorageModule.forRoot({
+      storage: FileStorageEnum.AZURE,
+      azureConfig: {
+        account: 'your-storage-account',
+        accountKey: 'your-account-key',
+        container: 'your-container'
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+#### AWS S3 Storage
+
+```typescript
+import { NestFileStorageModule, FileStorageEnum } from '@ackplus/nest-file-storage';
+
+@Module({
+  imports: [
+    NestFileStorageModule.forRoot({
+      storage: FileStorageEnum.S3,
+      s3Config: {
+        region: 'us-east-1',
+        bucket: 'your-bucket',
+        accessKeyId: 'your-access-key',
+        secretAccessKey: 'your-secret-key'
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+### Class Factory Approach
+
+This approach allows you to provide your own storage class directly.
+
+```typescript
+import { NestFileStorageModule } from '@ackplus/nest-file-storage';
+
+@Module({
+  imports: [
+    NestFileStorageModule.forRoot({
+      storageFactory: async () => {
+        // Lazy load the storage class
+        const { AzureStorage } = await import('@ackplus/nest-file-storage/lib/storage/azure.storage');
+        return AzureStorage;
+      },
+      options: {
+        account: 'your-storage-account',
+        accountKey: 'your-account-key',
+        container: 'your-container'
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+#### Custom Storage Class
+
+You can also provide your own custom storage implementation:
+
+```typescript
+import { NestFileStorageModule, Storage } from '@ackplus/nest-file-storage';
+
+class CustomStorage implements Storage {
+  // Implement your custom storage logic
+  async getFile(key: string): Promise<Buffer> { /* ... */ }
+  async deleteFile(key: string): Promise<void> { /* ... */ }
+  async putFile(fileContent: Buffer, key: string): Promise<UploadedFile> { /* ... */ }
+  getUrl(key: string): string { /* ... */ }
+  async copyFile(oldKey: string, newKey: string): Promise<UploadedFile> { /* ... */ }
+}
+
+@Module({
+  imports: [
+    NestFileStorageModule.forRoot({
+      storageFactory: () => CustomStorage,
+      options: {
+        // Your custom options
+      }
+    })
+  ]
+})
+export class AppModule {}
+```
+
+### When to Use Each Approach
+
+**Configuration-based Approach:**
+- ✅ Recommended for most use cases
+- ✅ Automatic lazy loading
+- ✅ Built-in error handling for missing dependencies
+- ✅ Simpler configuration
+- ✅ Better for switching between providers
+- ✅ Supports async configuration with dependency injection
+
+**Class Factory Approach:**
+- ✅ More control over storage instantiation
+- ✅ Custom storage implementations
+- ✅ Advanced use cases
+- ✅ Still supports lazy loading if implemented correctly
+- ⚠️ More complex configuration
+- ⚠️ Manual dependency management
+
+**Async Configuration (forRootAsync):**
+- ✅ Full dependency injection support
+- ✅ `useFactory`, `useClass`, and `useExisting` patterns
+- ✅ Integration with ConfigService and other providers
+- ✅ Environment-based configuration
+- ✅ Perfect for complex application setups
+
+### Async Configuration (forRootAsync)
+
+For more advanced scenarios, you can use `forRootAsync` with dependency injection:
+
+#### Using useFactory
+
+```typescript
+import { NestFileStorageModule, FileStorageEnum } from '@ackplus/nest-file-storage';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    ConfigModule,
+    NestFileStorageModule.forRootAsync({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        storage: FileStorageEnum.S3,
+        s3Config: {
+          region: configService.get('AWS_REGION'),
+          bucket: configService.get('AWS_BUCKET'),
+          accessKeyId: configService.get('AWS_ACCESS_KEY_ID'),
+          secretAccessKey: configService.get('AWS_SECRET_ACCESS_KEY'),
+        }
+      }),
+      inject: [ConfigService],
+    })
+  ]
+})
+export class AppModule {}
+```
+
+#### Using useClass
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { NestFileStorageModule, FileStorageOptionsFactory, FileStorageModuleOptions, FileStorageEnum } from '@ackplus/nest-file-storage';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class FileStorageConfigService implements FileStorageOptionsFactory {
+  constructor(private configService: ConfigService) {}
+
+  createFileStorageOptions(): FileStorageModuleOptions {
+    return {
+      storage: FileStorageEnum.AZURE,
+      azureConfig: {
+        account: this.configService.get('AZURE_STORAGE_ACCOUNT'),
+        accountKey: this.configService.get('AZURE_STORAGE_KEY'),
+        container: this.configService.get('AZURE_STORAGE_CONTAINER'),
+      }
+    };
+  }
+}
+
+@Module({
+  imports: [
+    ConfigModule,
+    NestFileStorageModule.forRootAsync({
+      imports: [ConfigModule],
+      useClass: FileStorageConfigService,
+    })
+  ]
+})
+export class AppModule {}
+```
+
+#### Using useExisting
+
+```typescript
+@Module({
+  imports: [
+    ConfigModule,
+    NestFileStorageModule.forRootAsync({
+      imports: [ConfigModule],
+      useExisting: FileStorageConfigService,
+    })
+  ],
+  providers: [FileStorageConfigService]
+})
+export class AppModule {}
+```
+
+### Direct Usage with Storage Factory
+
+You can also use the storage factory directly for more control:
+
+```typescript
+import { StorageFactory, FileStorageEnum } from '@ackplus/nest-file-storage';
+
+// This will lazy load only the Azure storage provider
+const azureStorage = await StorageFactory.createStorage(FileStorageEnum.AZURE, {
+  account: 'your-storage-account',
+  accountKey: 'your-account-key',
+  container: 'your-container'
+});
+
+// Use the storage instance
+const uploadedFile = await azureStorage.putFile(buffer, 'path/to/file.jpg');
+```
+
+## Flexible File Mapping
+
+The library includes flexible file mapping functionality that allows you to define custom logic for how uploaded files are transformed and stored in the request body.
+
+**Default Behavior**: Without any configuration, uploaded files are automatically mapped to their storage key (path) in the request body.
+
+### Default Behavior (No Configuration)
+
+```typescript
+import { FileStorageInterceptor } from '@ackplus/nest-file-storage';
+
+@Controller('upload')
+export class UploadController {
+    @Post('document')
+    @UseInterceptors(FileStorageInterceptor('document'))
+    async uploadDocument(@Body() body: any) {
+        // body.document will contain the file key (storage path)
+        console.log(body.document); // "documents/2024/1/1234567890-resume.pdf"
+        return { message: 'Document uploaded', data: body };
+    }
+}
+```
+
+### Return File URL String (Custom Logic)
+
+```typescript
+@Post('avatar')
+@UseInterceptors(FileStorageInterceptor('avatar', {
+    mapToRequestBody: (file, fieldName, req) => {
+        // Return just the URL string for direct DB storage
+        return file.url;
+    }
+}))
+async uploadAvatar(@Body() body: any) {
+    // body.avatar will be a string URL
+    console.log(body.avatar); // "http://localhost:3000/uploads/images/avatar.jpg"
+    return { message: 'Avatar uploaded', data: body };
+}
+```
+
+### Return Custom Object with Business Logic
+
+```typescript
+@Post('document')
+@UseInterceptors(FileStorageInterceptor('document', {
+    mapToRequestBody: (file, fieldName, req) => {
+        // Return custom object with business logic
+        return {
+            fileId: `file_${Date.now()}`,
+            url: file.url,
+            originalName: file.originalName,
+            uploadedBy: req.user?.id || 'anonymous',
+            uploadedAt: new Date().toISOString(),
+            isPublic: req.body.isPublic === 'true'
+        };
+    }
+}))
+async uploadDocument(@Body() body: any) {
+    // body.document will be a custom object
+    console.log(body.document);
+    return { message: 'Document uploaded', data: body };
+}
+```
+
+### Multiple Files with Custom Logic
+
+```typescript
+@Post('gallery')
+@UseInterceptors(FileStorageInterceptor({
+    type: 'array',
+    fieldName: 'images',
+    maxCount: 5
+}, {
+    mapToRequestBody: (files, fieldName, req) => {
+        // Return array of custom objects
+        return files.map((file, index) => ({
+            id: `img_${Date.now()}_${index}`,
+            url: file.url,
+            isPrimary: index === 0,
+            alt: req.body.imageAlts?.[index] || `Image ${index + 1}`
+        }));
+    }
+}))
+async uploadGallery(@Body() body: any) {
+    // body.images will be an array of custom objects
+    console.log(body.images);
+    return { message: 'Gallery uploaded', data: body };
+}
+```
+
+**Key Features**:
+- **Return anything**: String, object, array, or custom structure
+- **Access request data**: Use `req` parameter for user info, body data, etc.
+- **Field-specific logic**: Use `fieldName` to handle different fields differently
+- **Business logic**: Implement any custom transformation you need
+
+For detailed examples, see [FILE_KEY_MAPPING.md](./docs/FILE_KEY_MAPPING.md).
+
+## Error Handling
+
+If you try to use a storage provider without installing its required dependencies, you'll get a clear error message:
+
+- **Azure Storage**: `Azure Storage SDK (@azure/storage-blob) is required when using AzureStorage. Please install it: npm install @azure/storage-blob`
+- **S3 Storage**: `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`
+
+## How Lazy Loading Works
+
+The library uses dynamic imports to load storage providers only when they're actually needed:
+
+1. **At build time**: Only the storage factory and types are bundled
+2. **At runtime**: When you use a storage provider, it's dynamically imported
+3. **Caching**: Once loaded, storage instances are cached for reuse
+4. **Error handling**: Missing dependencies are caught and provide clear error messages
+
+This means:
+- If you only use local storage, Azure/S3 code is never loaded
+- If you only use Azure storage, S3 code is never loaded
+- Your bundle size stays minimal regardless of how many storage providers are available
+
+## Benefits
+
+- **Lazy Loading**: Storage providers are only loaded when actually used
+- **Smaller bundle size**: Only install the dependencies you need
+- **Flexible**: Switch between storage providers easily
+- **Clear error messages**: Know exactly what to install if a dependency is missing
+- **TypeScript support**: Full type safety for all storage providers
+- **Caching**: Storage instances are cached to avoid repeated initialization
+- **Zero overhead**: Unused storage providers don't affect your application

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/nest-file-storage.module';
+export * from './lib/file-storage.service';
+export * from './lib/interceptor/file-storage.interceptor';
+export * from './lib/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/nest-file-storage.module"), exports);
+__exportStar(require("./lib/file-storage.service"), exports);
+__exportStar(require("./lib/interceptor/file-storage.interceptor"), exports);
+__exportStar(require("./lib/types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iEAA+C;AAC/C,6DAA2C;AAC3C,6EAA2D;AAC3D,8CAA4B"}

package/dist/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const FILE_STORAGE_OPTIONS = "FileStorageOptions";
+//# sourceMappingURL=constants.d.ts.map

package/dist/lib/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/lib/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,uBAAuB,CAAC"}

package/dist/lib/constants.js

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

package/dist/lib/constants.js.map

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

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

@@ -0,0 +1,8 @@
+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>;
+}
+//# sourceMappingURL=file-storage.service.d.ts.map

package/dist/lib/file-storage.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-storage.service.d.ts","sourceRoot":"","sources":["../../src/lib/file-storage.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAqD,MAAM,SAAS,CAAC;AAGvH,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,MAAM,CAAC,OAAO,CAA2B;IAEjD,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,wBAAwB;IAInD,MAAM,CAAC,UAAU,IAAI,wBAAwB;WAIhC,UAAU,CAAC,WAAW,CAAC,EAAE,eAAe;CAmBxD"}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStorageService = void 0;
+const storage_factory_1 = require("./storage.factory");
+class FileStorageService {
+    static setOptions(options) {
+        FileStorageService.options = options;
+    }
+    static getOptions() {
+        return FileStorageService.options;
+    }
+    static async getStorage(storageType) {
+        const options = this.getOptions();
+        // Check if it's a class factory approach
+        if ('storageFactory' in options) {
+            const classOptions = options;
+            const StorageClass = await classOptions.storageFactory();
+            return new StorageClass(classOptions.options);
+        }
+        // Configuration-based approach
+        const configOptions = options;
+        if (!storageType) {
+            storageType = configOptions.storage;
+        }
+        const config = configOptions[`${storageType}Config`];
+        return await storage_factory_1.StorageFactory.createStorage(storageType, config);
+    }
+}
+exports.FileStorageService = FileStorageService;
+//# sourceMappingURL=file-storage.service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-storage.service.js","sourceRoot":"","sources":["../../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,CAAC,KAAK,CAAC,UAAU,CAAC,WAA6B;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAElC,yCAAyC;QACzC,IAAI,gBAAgB,IAAI,OAAO,EAAE,CAAC;YAC9B,MAAM,YAAY,GAAG,OAAkC,CAAC;YACxD,MAAM,YAAY,GAAG,MAAM,YAAY,CAAC,cAAc,EAAE,CAAC;YACzD,OAAO,IAAI,YAAY,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAClD,CAAC;QAED,+BAA+B;QAC/B,MAAM,aAAa,GAAG,OAAmC,CAAC;QAC1D,IAAI,CAAC,WAAW,EAAE,CAAC;YACf,WAAW,GAAG,aAAa,CAAC,OAAO,CAAC;QACxC,CAAC;QACD,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,WAAW,QAAQ,CAAC,CAAC;QACrD,OAAO,MAAM,gCAAc,CAAC,aAAa,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;CAEJ;AA/BD,gDA+BC"}

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './nest-file-storage.module';
+export * from './types';
+export * from './storage.factory';
+export * from './interceptor/file-storage.interceptor';
+export * from './file-storage.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAClC,cAAc,wCAAwC,CAAC;AACvD,cAAc,wBAAwB,CAAC"}

package/dist/lib/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./nest-file-storage.module"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./storage.factory"), exports);
+__exportStar(require("./interceptor/file-storage.interceptor"), exports);
+__exportStar(require("./file-storage.service"), exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lib/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,0CAAwB;AACxB,oDAAkC;AAClC,yEAAuD;AACvD,yDAAuC"}

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

@@ -0,0 +1,25 @@
+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;
+};
+/**
+ * Function-based interceptor that accepts storage options dynamically.
+ */
+export declare function FileStorageInterceptor(fileConfig: FileUploadConfig | string, interceptorOptions?: FileStorageInterceptorOptions): NestInterceptor;
+//# sourceMappingURL=file-storage.interceptor.d.ts.map

package/dist/lib/interceptor/file-storage.interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-storage.interceptor.d.ts","sourceRoot":"","sources":["../../../src/lib/interceptor/file-storage.interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiC,MAAM,gBAAgB,CAAC;AAChF,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAMlC,OAAO,EAAE,eAAe,EAAE,cAAc,EAA0C,MAAM,UAAU,CAAC;AAGnG,MAAM,MAAM,gBAAgB,GAAG;IAC3B,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAClD,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IACxC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IAChD,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,cAAc,CAAC,EAAE,cAAc,CAAC;IAGhC,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,KAAK,GAAG,CAAC;CAC3E,CAAC;AA2DF;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,UAAU,EAAE,gBAAgB,GAAG,MAAM,EACrC,kBAAkB,CAAC,EAAE,6BAA6B,GACnD,eAAe,CAkFjB"}