n8n-nodes-binary-to-url 0.0.11 → 0.1.2

package/README.md

@@ -1,27 +1,21 @@
-# n8n-nodes-binary-to-url
+# Binary to URL - n8n Community Node
 
-<div align="center">
-
-**Binary to URL - n8n Community Node**
-
-Create temporary URLs for binary files within workflow execution
+Create temporary URLs for binary files within n8n workflow execution.
 
 [![npm version](https://badge.fury.io/js/n8n-nodes-binary-to-url.svg)](https://www.npmjs.com/package/n8n-nodes-binary-to-url)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-</div>
-
 ---
 
-## ⚠️ Important Notice
+## Important Notice
 
-**This node is designed for temporary URL sharing within a workflow execution, NOT for long-term file storage or sharing.**
+This node is designed for **temporary URL sharing within workflow execution**, NOT for long-term file storage.
 
-- ❌ **NOT** a file storage service
-- ❌ **NOT** for long-term URL sharing
-- ✅ **FOR** temporary URL passing between workflow nodes
-- ✅ **FOR** short-term external access (minutes to hours)
-- ✅ **FOR** workflow-internal binary data handling
+- ❌ NOT a file storage service
+- ❌ NOT for long-term URL sharing
+- ✅ FOR temporary URL passing between workflow nodes
+- ✅ FOR short-term external access (minutes to hours)
+- ✅ FOR workflow-internal binary data handling
 
 Files are stored in memory and automatically deleted after expiration.
 
@@ -29,123 +23,64 @@ Files are stored in memory and automatically deleted after expiration.
 
 ## Features
 
-- **In-Memory Storage** - Store files temporarily in n8n memory without any external service
-- **Temporary URLs** - Create short-lived URLs for binary data access
-- **Zero Configuration** - No setup required, just upload and get URL
-- **Automatic Cleanup** - Files expire automatically (default: 10 minutes)
-- **Cache Management** - Built-in LRU cache with 100MB limit
-- **Workflow-Internal** - Designed for passing binary data between nodes
-- **File Type Validation** - Security validation for allowed MIME types
-- **Memory Efficient** - Automatic cleanup of expired and old files
-
-## Table of Contents
-
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Configuration](#configuration)
-- [Usage Examples](#usage-examples)
-- [Architecture](#architecture)
-- [API Reference](#api-reference)
-- [Security](#security)
-- [Troubleshooting](#troubleshooting)
-- [Development](#development)
+- **In-Memory Storage** - Store files temporarily in n8n memory
+- **Temporary URLs** - Create short-lived URLs for binary data
+- **Zero Configuration** - No setup required
+- **Automatic Cleanup** - Files expire automatically
+- **Cache Management** - Built-in LRU cache with limits
+- **Workflow Isolation** - Each workflow has isolated storage
 
 ---
 
 ## Installation
 
-### Install via npm
-
 ```bash
 npm install n8n-nodes-binary-to-url
 ```
 
-### Install in n8n
-
-1. Go to your n8n installation directory
-2. Run the npm install command above
-3. Restart n8n
-4. The "Binary to URL" node will appear in the node palette
-
----
+Then restart n8n:
 
-## Quick Start
+```bash
+# If using npm
+n8n restart
 
-### Basic Usage
+# If using Docker
+docker-compose restart n8n
 
-This node creates temporary URLs for binary data that can be accessed within or outside the workflow.
+# If using systemd
+sudo systemctl restart n8n
+```
 
-**Use Case: Pass binary data between nodes**
+---
 
-```yaml
-Workflow:
-  1. HTTP Request Node (download image)
-  2. Binary to URL (create temporary URL)
-  3. HTTP Request Node (send URL to another API)
-  4. Binary to URL (delete file - optional)
-```
+## Quick Start
 
-**Step-by-step:**
+### Upload Operation
 
 1. Add a **Binary to URL** node to your workflow
-2. Select operation **Upload**
-3. Set URL expiration time (default: 600 seconds = 10 minutes)
-4. Connect any node with binary data (e.g., HTTP Request, Read Binary File)
+2. Select **Upload** operation
+3. Configure:
+   - **Binary Property**: `data` (default)
+   - **URL Expiration Time**: `600` (10 minutes)
+4. Connect to a node with binary data (e.g., HTTP Request)
 5. Execute the workflow
 
 **Output:**
 
 ```json
 {
-  "fileKey": "1704801234567-abc123def456",
-  "proxyUrl": "https://your-n8n.com/webhook/123/file/1704801234567-abc123def456",
+  "fileKey": "1736567890123-abc123def456",
+  "proxyUrl": "https://your-n8n.com/webhook/123/file/1736567890123-abc123def456",
   "contentType": "image/jpeg",
   "fileSize": 245678
 }
 ```
 
-**Use the URL:**
-
-- **Within workflow**: Pass `proxyUrl` to subsequent nodes that need file access
-- **External access**: Open `proxyUrl` in browser or API calls (will expire after TTL)
+### Delete Operation
 
-**Note:** The URL is temporary and will stop working after the expiration time.
-
----
-
-## Configuration
-
-### Operations
-
-#### Upload Operation
-
-| Parameter               | Type   | Required | Default | Description                                         |
-| ----------------------- | ------ | -------- | ------- | --------------------------------------------------- |
-| **Binary Property**     | string | ❌ No    | `data`  | Name of binary property containing the file         |
-| **URL Expiration Time** | number | ❌ No    | `600`   | How long URL remains valid (default: 10 minutes)    |
-
-**Recommended TTL values:**
-
-- **60-300 seconds** (1-5 minutes): For workflow-internal use
-- **300-600 seconds** (5-10 minutes): For short-term processing
-- **600-3600 seconds** (10-60 minutes): For longer operations (not recommended)
-
-#### Delete Operation
-
-| Parameter    | Type   | Required | Default | Description               |
-| ------------ | ------ | -------- | ------- | ------------------------- |
-| **File Key** | string | ✅ Yes\* | -       | Key of the file to delete |
-
-\*Can also be provided from previous node via `fileKey` property
-
-### Storage Limits
-
-- **Maximum file size:** 100 MB
-- **Maximum cache size:** 100 MB
-- **Default TTL:** 600 seconds (10 minutes)
-- **Minimum TTL:** 60 seconds (1 minute)
-
-When cache is full, oldest files are automatically removed to make space for new uploads.
+1. Add **Binary to URL** node
+2. Select **Delete** operation
+3. Enter **File Key** (or use from previous node's `fileKey`)
 
 ---
 
@@ -153,290 +88,132 @@ When cache is full, oldest files are automatically removed to make space for new
 
 ### Example 1: Pass Binary Data Between Nodes
 
-**Scenario:** Download an image, process it with an external API, then delete.
-
-```yaml
-Workflow:
-  1. HTTP Request (download image from URL A)
-  2. Binary to URL (TTL: 300 = 5 minutes)
-  3. HTTP Request (send proxyUrl to external API for processing)
-  4. Binary to URL (operation: Delete, cleanup)
 ```
-
-### Example 2: Temporary File for Email Attachment
-
-**Scenario:** Generate a PDF, send via email, then delete.
-
-```yaml
-Workflow:
-  1. Generate PDF report
-  2. Binary to URL (TTL: 600 = 10 minutes)
-  3. Send Email (attach using proxyUrl)
-  4. Binary to URL (operation: Delete, optional - will auto-expire)
+1. HTTP Request (download image)
+2. Binary to URL (Upload, TTL: 300)
+3. HTTP Request (send proxyUrl to API)
+4. Binary to URL (Delete)
 ```
 
-⚠️ **Warning:** Email recipients cannot access the file after TTL expires. For email attachments, consider using a proper file storage service.
+### Example 2: Temporary Email Attachment
 
-### Example 3: Batch Processing
-
-**Scenario:** Process multiple files with an external service.
-
-```yaml
-Workflow:
-  1. Read Binary Files (from folder)
-  2. Split In Batches
-  3. Binary to URL (TTL: 300 = 5 minutes)
-  4. HTTP Request (send to processing API)
-  5. Binary to URL (operation: Delete)
 ```
-
-### Example 4: Temporary Preview URL
-
-**Scenario:** Generate a temporary preview link for a webhook response.
-
-```yaml
-Workflow:
-  1. Webhook (trigger)
-  2. Generate Report
-  3. Binary to URL (TTL: 180 = 3 minutes)
-  4. Respond to Webhook (include proxyUrl in response)
+1. Generate PDF report
+2. Binary to URL (Upload, TTL: 600)
+3. Send Email (use proxyUrl)
+4. Binary to URL (Delete)
 ```
 
-The URL will work for 3 minutes, then automatically expire.
-
----
-
-## Architecture
-
-### In-Memory Storage Pattern
+### Example 3: Batch Processing
 
 ```
-┌─────────────┐      Upload      ┌──────────────┐
-│  n8n Node   │ ───────────────► │   Memory     │
-│  (Binary    │ ◄─────────────── │   Storage    │
-│   to URL)   │    Return URL    │  (n8n RAM)   │
-└──────┬──────┘                  └──────────────┘
-       │
-       │ GET Request (proxy file)
-       ▼
-┌─────────────────────────────────┐
-│  Return file stream to client   │
-│  - Content-Type header          │
-│  - Cache-Control: 24h           │
-│  - Content-Disposition: inline  │
-└─────────────────────────────────┘
+1. Read Binary Files
+2. Split In Batches
+3. Binary to URL (Upload, TTL: 300)
+4. HTTP Request (send to API)
+5. Binary to URL (Delete)
 ```
 
-### Key Advantages
-
-- **Zero External Dependencies** - No S3, no database, nothing to configure
-- **Fast Performance** - In-memory storage is extremely fast
-- **Automatic Cleanup** - Files expire automatically based on TTL
-- **LRU Eviction** - Oldest files removed when cache is full
-- **Secure File Keys** - Timestamp + random string prevents guessing
-- **MIME Type Validation** - White-list of allowed file types for security
-
 ---
 
-## API Reference
+## Configuration
 
-### Upload Response
+### Upload Operation
 
-```typescript
-{
-  fileKey: string;      // Unique file identifier
-  proxyUrl: string;     // Public URL to access file
-  contentType: string;  // MIME type (e.g., "image/jpeg")
-  fileSize: number;     // File size in bytes
-}
-```
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| Binary Property | string | `data` | Name of binary property |
+| URL Expiration Time | number | `600` | TTL in seconds (60-604800) |
 
-### Delete Response
+### Delete Operation
 
-```typescript
-{
-  success: boolean; // true if deletion succeeded
-  deleted: string;  // The file key that was deleted
-}
-```
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| File Key | string | Yes* | Key of file to delete |
 
-### Supported File Types
+*Can be provided from previous node's `fileKey`
 
-**Images:**
-- JPEG, PNG, GIF, WebP, SVG, BMP, TIFF, AVIF
+### Storage Limits
 
-**Videos:**
-- MP4, WebM, MOV, AVI, MKV
+| Limit | Value |
+|-------|-------|
+| Max file size | 100 MB |
+| Max cache per workflow | 100 MB |
+| Global max cache | 500 MB |
+| Min TTL | 60 seconds |
+| Max TTL | 604800 seconds (7 days) |
 
-**Audio:**
-- MP3, WAV, OGG, FLAC
+### Recommended TTL
 
-**Documents:**
-- PDF, ZIP, RAR, 7Z, TXT, CSV, JSON, XML, XLSX, DOCX
+- **60-300s** (1-5 min): Workflow-internal use
+- **300-600s** (5-10 min): Short-term processing
+- **600-3600s** (10-60 min): Longer operations
 
 ---
 
-## Security
-
-### File Type Validation
-
-Files are validated against a white-list of allowed MIME types based on the provided MIME type from binary data.
-
-### File Key Format
-
-File keys follow the pattern: `{timestamp}-{random}`
-
-Example: `1704801234567-abc123def456`
-
-This prevents unauthorized file enumeration.
-
-### File Size Limits
-
-- **Maximum file size:** 100 MB
-- **Maximum total cache:** 100 MB
-- Configurable in source code (`MAX_FILE_SIZE` and `MAX_CACHE_SIZE` constants)
-
-### Access Control
-
-The webhook proxy inherits n8n's authentication and access control mechanisms.
-
-### Automatic Expiration
+## Supported File Types
 
-Files are automatically deleted after their TTL expires. The default TTL is 3600 seconds (1 hour), but can be configured per upload.
+| Category | Types |
+|----------|-------|
+| Images | JPEG, PNG, GIF, WebP, SVG, BMP, TIFF, AVIF |
+| Videos | MP4, WebM, MOV, AVI, MKV |
+| Audio | MP3, WAV, OGG, FLAC |
+| Documents | PDF, ZIP, RAR, 7Z, TXT, CSV, JSON, XML, XLSX, DOCX |
 
 ---
 
 ## Troubleshooting
 
-### Common Issues
+### Node not visible
 
-#### 1. File Returns 404
+1. Check installation: `npm list n8n-nodes-binary-to-url`
+2. **Restart n8n** (most common issue)
+3. Refresh browser page
 
-**Problem:** File not found or expired.
+### File URL returns 404
 
-**Solution:**
+- Ensure workflow is **active** (webhooks only work in active workflows)
+- Check if file expired (TTL passed)
+- Verify fileKey is correct
+- Try uploading again
 
-- Verify the workflow is active (webhooks only work in active workflows)
-- Check if the file has expired (TTL has passed)
-- Ensure the fileKey is correct
-- Try uploading the file again
+### Cache full
 
-#### 2. "Cache Full" Warning
-
-**Problem:** Cache is at maximum capacity (100MB).
-
-**Solution:**
-
-- Wait for some files to expire
+- Wait for files to expire
 - Manually delete old files using Delete operation
-- Increase `MAX_CACHE_SIZE` in source code if you have more RAM available
-
-#### 3. Files Expire Too Quickly
-
-**Problem:** Default TTL of 3600 seconds (1 hour) is too short.
-
-**Solution:**
-
-- Increase the TTL parameter when uploading (e.g., 86400 for 24 hours)
-- Maximum recommended TTL: 604800 seconds (7 days)
+- Increase cache size in source code if you have more RAM
 
-#### 4. Memory Usage Too High
-
-**Problem:** n8n process is consuming too much memory.
-
-**Solution:**
+### Memory usage high
 
 - Reduce TTL to expire files faster
 - Reduce `MAX_CACHE_SIZE` in source code
-- Manually delete files after use instead of relying on auto-expiration
+- Delete files manually after use
 
 ---
 
-## Development
-
-### Project Structure
-
-```
-n8n-nodes-binary-to-url/
-├── nodes/
-│   └── BinaryToUrl/
-│       ├── BinaryToUrl.node.ts    # Main node implementation
-│       └── BinaryToUrl.svg        # Node icon
-├── drivers/
-│   ├── index.ts                   # Driver exports
-│   └── MemoryStorage.ts           # In-memory storage implementation
-├── dist/                          # Compiled output
-├── package.json
-├── tsconfig.json
-└── README.md
-```
-
-### Build
+## Testing
 
-```bash
-npm install
-npm run build
-```
+Create a test workflow:
 
-### Development
+1. **Manual Trigger** node
+2. **HTTP Request** node: GET `https://picsum.photos/200/300`, Response Format: `File`
+3. **Binary to URL** node: Upload, TTL: 600
+4. **Save and activate** the workflow
+5. **Execute** and copy the `proxyUrl`
+6. **Open in browser** to verify
 
-```bash
-npm run dev  # Watch mode
-```
-
-### Lint & Format
-
-```bash
-npm run lint       # Check code quality
-npm run lint:fix   # Auto-fix lint issues
-npm run format     # Format with Prettier
-```
+**Expected result:** Image displays in browser.
 
 ---
 
-## Technical Details
+## Links
 
-- **Node Type:** Transform
-- **Version:** 0.0.9
-- **n8n Version:** >= 1.0.0
-- **Storage:** In-Memory (n8n process memory)
-- **Dependencies:** None (zero external dependencies)
+- **Technical Documentation**: [TECHNICAL.md](TECHNICAL.md)
+- **Repository**: [https://cnb.cool/ksxh-wwrs/n8n-nodes-binary-to-url](https://cnb.cool/ksxh-wwrs/n8n-nodes-binary-to-url)
+- **n8n Community**: [https://community.n8n.io](https://community.n8n.io)
 
 ---
 
 ## License
 
 [MIT](LICENSE)
-
----
-
-## Repository
-
-[https://cnb.cool/ksxh-wwrs/n8n-nodes-binary-to-url](https://cnb.cool/ksxh-wwrs/n8n-nodes-binary-to-url)
-
----
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
----
-
-## Support
-
-- Create an issue in the GitHub repository
-- Check the [n8n community forum](https://community.n8n.io)
-
----
-
-## Changelog
-
-### 0.0.9 (2026-01-10)
-
-- Complete rewrite to use in-memory storage only
-- Removed S3 and external storage dependencies
-- Zero external dependencies
-- Added automatic TTL-based cleanup
-- Added LRU cache eviction
-- Simplified configuration
-- Improved performance with direct memory access

package/dist/drivers/MemoryStorage.d.ts

@@ -1,21 +1,25 @@
 export declare class MemoryStorage {
-    private static cache;
+    private static workflowCaches;
     private static readonly DEFAULT_TTL;
     private static readonly MAX_CACHE_SIZE;
-    private static currentCacheSize;
+    private static readonly GLOBAL_MAX_CACHE_SIZE;
+    private static globalCacheSize;
+    private static getOrCreateWorkflowCache;
     static generateFileKey(): string;
-    static upload(data: Buffer, contentType: string, ttl?: number): Promise<{
+    static upload(workflowId: string, data: Buffer, contentType: string, ttl?: number): Promise<{
         fileKey: string;
         contentType: string;
     }>;
-    static download(fileKey: string): Promise<{
+    static download(workflowId: string, fileKey: string): Promise<{
         data: Buffer;
         contentType: string;
     } | null>;
-    static delete(fileKey: string): Promise<boolean>;
-    static cleanupExpired(): void;
-    static cleanupOldest(requiredSpace: number): void;
-    static getCacheSize(): number;
-    static getCacheCount(): number;
-    static clear(): void;
+    static delete(workflowId: string, fileKey: string): Promise<boolean>;
+    static cleanupWorkflowExpired(workflowId: string): void;
+    static cleanupAllExpired(): void;
+    static cleanupOldestInWorkflow(workflowId: string, requiredSpace: number): void;
+    static cleanupOldestGlobal(requiredSpace: number): void;
+    static getCacheSize(workflowId?: string): number;
+    static getCacheCount(workflowId?: string): number;
+    static clear(workflowId?: string): void;
 }

package/dist/drivers/MemoryStorage.js

@@ -1,25 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryStorage = void 0;
-// Simple in-memory storage with TTL
 class MemoryStorage {
+    static getOrCreateWorkflowCache(workflowId) {
+        if (!this.workflowCaches.has(workflowId)) {
+            this.workflowCaches.set(workflowId, {
+                cache: new Map(),
+                cacheSize: 0,
+            });
+        }
+        return this.workflowCaches.get(workflowId);
+    }
     static generateFileKey() {
         const timestamp = Date.now();
         const random = Math.random().toString(36).substring(2, 15);
         return `${timestamp}-${random}`;
     }
-    static async upload(data, contentType, ttl) {
+    static async upload(workflowId, data, contentType, ttl) {
         const fileKey = this.generateFileKey();
         const now = Date.now();
         const expiresAt = now + (ttl || this.DEFAULT_TTL);
         const fileSize = data.length;
-        // Check if adding this file would exceed max cache size
-        if (this.currentCacheSize + fileSize > this.MAX_CACHE_SIZE) {
-            // Clean up expired files first
-            this.cleanupExpired();
-            // If still too large, remove oldest files
-            if (this.currentCacheSize + fileSize > this.MAX_CACHE_SIZE) {
-                this.cleanupOldest(fileSize);
+        if (this.globalCacheSize + fileSize > this.GLOBAL_MAX_CACHE_SIZE) {
+            this.cleanupAllExpired();
+            if (this.globalCacheSize + fileSize > this.GLOBAL_MAX_CACHE_SIZE) {
+                this.cleanupOldestGlobal(fileSize);
+            }
+        }
+        const workflowCache = this.getOrCreateWorkflowCache(workflowId);
+        if (workflowCache.cacheSize + fileSize > this.MAX_CACHE_SIZE) {
+            this.cleanupWorkflowExpired(workflowId);
+            if (workflowCache.cacheSize + fileSize > this.MAX_CACHE_SIZE) {
+                this.cleanupOldestInWorkflow(workflowId, fileSize);
             }
         }
         const file = {
@@ -28,18 +40,22 @@ class MemoryStorage {
             uploadedAt: now,
             expiresAt,
         };
-        this.cache.set(fileKey, file);
-        this.currentCacheSize += fileSize;
+        workflowCache.cache.set(fileKey, file);
+        workflowCache.cacheSize += fileSize;
+        this.globalCacheSize += fileSize;
         return { fileKey, contentType };
     }
-    static async download(fileKey) {
-        const file = this.cache.get(fileKey);
+    static async download(workflowId, fileKey) {
+        const workflowCache = this.workflowCaches.get(workflowId);
+        if (!workflowCache) {
+            return null;
+        }
+        const file = workflowCache.cache.get(fileKey);
         if (!file) {
             return null;
         }
-        // Check if expired
         if (Date.now() > file.expiresAt) {
-            this.delete(fileKey);
+            this.delete(workflowId, fileKey);
             return null;
         }
         return {
@@ -47,46 +63,106 @@ class MemoryStorage {
             contentType: file.contentType,
         };
     }
-    static async delete(fileKey) {
-        const file = this.cache.get(fileKey);
+    static async delete(workflowId, fileKey) {
+        const workflowCache = this.workflowCaches.get(workflowId);
+        if (!workflowCache)
+            return false;
+        const file = workflowCache.cache.get(fileKey);
         if (!file)
             return false;
-        this.currentCacheSize -= file.data.length;
-        return this.cache.delete(fileKey);
+        workflowCache.cacheSize -= file.data.length;
+        this.globalCacheSize -= file.data.length;
+        return workflowCache.cache.delete(fileKey);
     }
-    static cleanupExpired() {
+    static cleanupWorkflowExpired(workflowId) {
+        const workflowCache = this.workflowCaches.get(workflowId);
+        if (!workflowCache)
+            return;
         const now = Date.now();
-        for (const [key, file] of this.cache.entries()) {
+        for (const [key, file] of workflowCache.cache.entries()) {
             if (now > file.expiresAt) {
-                this.delete(key);
+                this.delete(workflowId, key);
             }
         }
     }
-    static cleanupOldest(requiredSpace) {
-        const entries = Array.from(this.cache.entries());
-        // Sort by upload time (oldest first)
+    static cleanupAllExpired() {
+        const now = Date.now();
+        for (const [workflowId, workflowCache] of this.workflowCaches.entries()) {
+            for (const [key, file] of workflowCache.cache.entries()) {
+                if (now > file.expiresAt) {
+                    this.delete(workflowId, key);
+                }
+            }
+        }
+    }
+    static cleanupOldestInWorkflow(workflowId, requiredSpace) {
+        const workflowCache = this.workflowCaches.get(workflowId);
+        if (!workflowCache)
+            return;
+        const entries = Array.from(workflowCache.cache.entries());
         entries.sort((a, b) => a[1].uploadedAt - b[1].uploadedAt);
         let freedSpace = 0;
         for (const [key, file] of entries) {
             if (freedSpace >= requiredSpace)
                 break;
             freedSpace += file.data.length;
-            this.delete(key);
+            this.delete(workflowId, key);
         }
     }
-    static getCacheSize() {
-        return this.currentCacheSize;
+    static cleanupOldestGlobal(requiredSpace) {
+        const allFiles = [];
+        for (const [workflowId, workflowCache] of this.workflowCaches.entries()) {
+            for (const [fileKey, file] of workflowCache.cache.entries()) {
+                allFiles.push({ workflowId, fileKey, file });
+            }
+        }
+        allFiles.sort((a, b) => a.file.uploadedAt - b.file.uploadedAt);
+        let freedSpace = 0;
+        for (const { workflowId, fileKey, file } of allFiles) {
+            if (freedSpace >= requiredSpace)
+                break;
+            freedSpace += file.data.length;
+            this.delete(workflowId, fileKey);
+        }
+    }
+    static getCacheSize(workflowId) {
+        if (workflowId) {
+            const workflowCache = this.workflowCaches.get(workflowId);
+            return workflowCache?.cacheSize ?? 0;
+        }
+        return this.globalCacheSize;
     }
-    static getCacheCount() {
-        return this.cache.size;
+    static getCacheCount(workflowId) {
+        if (workflowId) {
+            const workflowCache = this.workflowCaches.get(workflowId);
+            return workflowCache?.cache.size ?? 0;
+        }
+        let total = 0;
+        for (const workflowCache of this.workflowCaches.values()) {
+            total += workflowCache.cache.size;
+        }
+        return total;
     }
-    static clear() {
-        this.cache.clear();
-        this.currentCacheSize = 0;
+    static clear(workflowId) {
+        if (workflowId) {
+            const workflowCache = this.workflowCaches.get(workflowId);
+            if (workflowCache) {
+                for (const [, file] of workflowCache.cache.entries()) {
+                    this.globalCacheSize -= file.data.length;
+                }
+                workflowCache.cache.clear();
+                workflowCache.cacheSize = 0;
+            }
+        }
+        else {
+            this.workflowCaches.clear();
+            this.globalCacheSize = 0;
+        }
     }
 }
 exports.MemoryStorage = MemoryStorage;
-MemoryStorage.cache = new Map();
-MemoryStorage.DEFAULT_TTL = 60 * 60 * 1000; // 1 hour
-MemoryStorage.MAX_CACHE_SIZE = 100 * 1024 * 1024; // 100 MB
-MemoryStorage.currentCacheSize = 0;
+MemoryStorage.workflowCaches = new Map();
+MemoryStorage.DEFAULT_TTL = 60 * 60 * 1000;
+MemoryStorage.MAX_CACHE_SIZE = 100 * 1024 * 1024;
+MemoryStorage.GLOBAL_MAX_CACHE_SIZE = 500 * 1024 * 1024;
+MemoryStorage.globalCacheSize = 0;

package/dist/nodes/BinaryToUrl/BinaryToUrl.node.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryToUrl = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const MemoryStorage_1 = require("../../drivers/MemoryStorage");
+const MemoryStorage_js_1 = require("../../drivers/MemoryStorage.js");
 const MAX_FILE_SIZE = 100 * 1024 * 1024;
 const ALLOWED_MIME_TYPES = [
     'image/jpeg',
@@ -54,7 +54,7 @@ class BinaryToUrl {
                     httpMethod: 'GET',
                     responseMode: 'onReceived',
                     path: 'file/:fileKey',
-                    isFullPath: true,
+                    isFullPath: false,
                 },
             ],
             properties: [
@@ -134,6 +134,8 @@ class BinaryToUrl {
     async webhook() {
         const req = this.getRequestObject();
         const fileKey = req.params.fileKey;
+        const workflow = this.getWorkflow();
+        const workflowId = workflow.id;
         if (!fileKey) {
             return {
                 webhookResponse: {
@@ -157,7 +159,7 @@ class BinaryToUrl {
             };
         }
         try {
-            const result = await MemoryStorage_1.MemoryStorage.download(fileKey);
+            const result = await MemoryStorage_js_1.MemoryStorage.download(workflowId, fileKey);
             if (!result) {
                 return {
                     webhookResponse: {
@@ -172,7 +174,7 @@ class BinaryToUrl {
             return {
                 webhookResponse: {
                     status: 200,
-                    body: result.data.toString('base64'),
+                    body: result.data,
                     headers: {
                         'Content-Type': result.contentType,
                         'Cache-Control': 'public, max-age=86400',
@@ -182,6 +184,7 @@ class BinaryToUrl {
             };
         }
         catch (error) {
+            this.logger.error(`Error downloading file: ${error instanceof Error ? error.message : String(error)}`);
             return {
                 webhookResponse: {
                     status: 500,
@@ -198,20 +201,41 @@ exports.BinaryToUrl = BinaryToUrl;
 async function handleUpload(context, items) {
     const binaryPropertyName = context.getNodeParameter('binaryPropertyName', 0);
     const ttl = context.getNodeParameter('ttl', 0);
-    // Build webhook URL using n8n's instance base URL and workflow ID
-    // Format: {baseUrl}/webhook/{workflowId}/file/:fileKey
-    const baseUrl = context.getInstanceBaseUrl();
+    const MIN_TTL = 60;
+    const MAX_TTL = 604800;
+    if (ttl < MIN_TTL) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `TTL must be at least ${MIN_TTL} seconds. Got: ${ttl}`);
+    }
+    if (ttl > MAX_TTL) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `TTL cannot exceed ${MAX_TTL} seconds. Got: ${ttl}`);
+    }
     const workflow = context.getWorkflow();
     const workflowId = workflow.id;
-    const webhookUrl = `${baseUrl}/webhook/${workflowId}/file/:fileKey`;
+    const baseUrl = context.getInstanceBaseUrl();
+    // Remove trailing slash and ensure clean URL
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, '');
+    const webhookUrl = `${cleanBaseUrl}/webhook/${workflowId}/file/:fileKey`;
     const returnData = [];
     for (const item of items) {
         const binaryData = item.binary?.[binaryPropertyName];
         if (!binaryData) {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `No binary data found in property "${binaryPropertyName}"`);
         }
-        const buffer = Buffer.from(binaryData.data, 'base64');
-        // Use provided MIME type or default
+        let buffer;
+        const data = binaryData.data;
+        if (Buffer.isBuffer(data)) {
+            buffer = data;
+        }
+        else if (typeof data === 'string') {
+            buffer = Buffer.from(data, 'base64');
+        }
+        else if (data && typeof data === 'object') {
+            const binaryValue = data.$binary || data;
+            buffer = Buffer.from(binaryValue, 'base64');
+        }
+        else {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Unsupported binary data format: ${typeof data}`);
+        }
         const contentType = binaryData.mimeType || 'application/octet-stream';
         if (!ALLOWED_MIME_TYPES.includes(contentType)) {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `MIME type "${contentType}" is not allowed. Allowed types: ${ALLOWED_MIME_TYPES.join(', ')}`);
@@ -220,9 +244,9 @@ async function handleUpload(context, items) {
         if (fileSize > MAX_FILE_SIZE) {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `File size exceeds maximum limit of ${MAX_FILE_SIZE / 1024 / 1024}MB`);
         }
-        const result = await MemoryStorage_1.MemoryStorage.upload(buffer, contentType, ttl);
-        // Replace the :fileKey placeholder with the actual file key
+        const result = await MemoryStorage_js_1.MemoryStorage.upload(workflowId, buffer, contentType, ttl * 1000);
         const proxyUrl = webhookUrl.replace(':fileKey', result.fileKey);
+        context.logger.info(`File uploaded: ${result.fileKey}, size: ${fileSize}, contentType: ${contentType}, TTL: ${ttl}s`);
         returnData.push({
             json: {
                 fileKey: result.fileKey,
@@ -236,16 +260,24 @@ async function handleUpload(context, items) {
     return [returnData];
 }
 async function handleDelete(context, items) {
+    const workflow = context.getWorkflow();
+    const workflowId = workflow.id;
     const returnData = [];
     for (const item of items) {
         const fileKey = (item.json.fileKey || context.getNodeParameter('fileKey', 0));
         if (!fileKey) {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'File key is required for delete operation');
         }
-        await MemoryStorage_1.MemoryStorage.delete(fileKey);
+        const deleted = await MemoryStorage_js_1.MemoryStorage.delete(workflowId, fileKey);
+        if (deleted) {
+            context.logger.info(`File deleted: ${fileKey}`);
+        }
+        else {
+            context.logger.warn(`File not found for deletion: ${fileKey}`);
+        }
         returnData.push({
             json: {
-                success: true,
+                success: deleted,
                 deleted: fileKey,
             },
         });
@@ -256,6 +288,6 @@ function isValidFileKey(fileKey) {
     if (!fileKey || typeof fileKey !== 'string') {
         return false;
     }
-    const fileKeyPattern = /^[0-9]+-[a-z0-9]+\.[a-z0-9]+$/i;
+    const fileKeyPattern = /^[0-9]+-[a-z0-9]+$/i;
     return fileKeyPattern.test(fileKey);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-binary-to-url",
-  "version": "0.0.11",
+  "version": "0.1.2",
   "description": "n8n community node for creating temporary URLs for binary files within workflow execution",
   "keywords": [
     "n8n-community-node-package",

package/dist/drivers/index.d.ts

@@ -1 +0,0 @@
-export { MemoryStorage } from './MemoryStorage';

package/dist/drivers/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryStorage = void 0;
-var MemoryStorage_1 = require("./MemoryStorage");
-Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return MemoryStorage_1.MemoryStorage; } });