n8n-nodes-binary-to-url 0.0.1

package/README.md

@@ -0,0 +1,89 @@
+# n8n-nodes-binary-bridge
+
+n8n community node for binary file to public URL bridge with S3 storage.
+
+## Features
+
+- **Upload Mode**: Upload binary files to S3 storage and get public proxy URL
+- **Delete Mode**: Delete files from S3 storage
+- **Webhook Proxy**: Built-in webhook acts as file stream forwarding server
+- **Streaming**: High-performance streaming to avoid memory overflow
+- **S3 Compatible**: Supports AWS S3 and S3-compatible services (MinIO, DigitalOcean Spaces, etc.)
+- **Custom Endpoint**: Configure custom S3 endpoint for S3-compatible services
+- **Path Style**: Support both virtual-hosted and path-style addressing
+
+## Installation
+
+```bash
+npm install n8n-nodes-binary-bridge
+```
+
+## Usage
+
+### Upload Mode
+
+1. Add a **Binary Bridge** node to your workflow
+2. Configure AWS S3 credentials
+3. Set operation to **Upload**
+4. Configure bucket name and region
+5. (Optional) Set custom endpoint for S3-compatible services
+6. (Optional) Enable force path style if needed
+7. Connect a node with binary data to the Binary Bridge node
+8. Execute the workflow
+9. The node will return:
+   - `fileKey`: Unique file identifier
+   - `proxyUrl`: Public URL to access the file
+   - `contentType`: MIME type of the file
+
+### Delete Mode
+
+1. Add a **Binary Bridge** node to your workflow
+2. Configure AWS S3 credentials
+3. Set operation to **Delete**
+4. Configure bucket name and region
+5. Set file key to delete (or use from previous upload)
+6. Execute the workflow
+7. The node will return:
+   - `success`: True if deletion succeeded
+   - `deleted`: The file key that was deleted
+
+### Webhook Proxy
+
+The webhook URL is automatically generated and can be used to access uploaded files:
+
+```
+https://your-n8n-instance/webhook/{workflowId}/binarybridge/file/{fileKey}
+```
+
+The webhook supports:
+
+- **GET** requests to download files
+- **Content-Type** header with correct MIME type
+- **Cache-Control**: 24-hour cache
+- **Content-Disposition**: inline for browser preview
+
+## Architecture
+
+This node implements a **Single-Node Proxy** architecture:
+
+- Handles file upload to S3 storage
+- Acts as a webhook server for file streaming
+- Creates a data loop without external dependencies
+- Uses streaming to avoid memory issues in n8n Cloud
+
+## Technical Details
+
+- **Node Type**: Transform
+- **Version**: 1
+- **n8n Version**: >= 1.0.0
+- **Dependencies**: @aws-sdk/client-s3 (no external dependencies for n8n compatibility)
+- **Streaming**: Uses ReadableStream for efficient file handling
+- **File Key Generation**: Timestamp + random string for security
+
+## License
+
+MIT
+
+## Repository
+
+https://cnb.cool/ksxh-wwrs/n8n-nodes-binary-bridge

package/dist/drivers/S3Storage.d.ts

@@ -0,0 +1,27 @@
+import { Readable } from 'stream';
+export interface StorageConfig {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+    bucket: string;
+    endpoint?: string;
+    forcePathStyle?: boolean;
+}
+export interface UploadResult {
+    fileKey: string;
+    contentType: string;
+}
+export interface DownloadResult {
+    stream: Readable;
+    contentType: string;
+}
+export declare class S3Storage {
+    private s3Client;
+    private bucket;
+    constructor(config: StorageConfig);
+    uploadStream(stream: Readable, contentType: string, metadata?: Record<string, string>): Promise<UploadResult>;
+    downloadStream(fileKey: string): Promise<DownloadResult>;
+    deleteFile(fileKey: string): Promise<void>;
+    private generateFileKey;
+    private getExtensionFromMimeType;
+}

package/dist/drivers/S3Storage.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Storage = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const stream_1 = require("stream");
+class S3Storage {
+    constructor(config) {
+        this.s3Client = new client_s3_1.S3Client({
+            region: config.region,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+            endpoint: config.endpoint,
+            forcePathStyle: config.forcePathStyle ?? false,
+        });
+        this.bucket = config.bucket;
+    }
+    async uploadStream(stream, contentType, metadata) {
+        const fileKey = this.generateFileKey(contentType);
+        try {
+            const command = new client_s3_1.PutObjectCommand({
+                Bucket: this.bucket,
+                Key: fileKey,
+                Body: stream,
+                ContentType: contentType,
+                Metadata: metadata || {},
+            });
+            await this.s3Client.send(command);
+            return {
+                fileKey,
+                contentType,
+            };
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.S3ServiceException) {
+                if (error.name === 'NoSuchBucket') {
+                    throw new Error(`S3 bucket "${this.bucket}" does not exist or is not accessible`);
+                }
+                if (error.name === 'AccessDenied') {
+                    throw new Error(`Access denied to S3 bucket "${this.bucket}". Check your credentials and bucket permissions`);
+                }
+                throw new Error(`S3 upload failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async downloadStream(fileKey) {
+        try {
+            const command = new client_s3_1.GetObjectCommand({
+                Bucket: this.bucket,
+                Key: fileKey,
+            });
+            const response = await this.s3Client.send(command);
+            if (!response.Body) {
+                throw new Error(`File not found: ${fileKey}`);
+            }
+            const body = response.Body;
+            const stream = body instanceof stream_1.Readable ? body : stream_1.Readable.from(response.Body);
+            return {
+                stream,
+                contentType: response.ContentType || 'application/octet-stream',
+            };
+        }
+        catch (error) {
+            if (error instanceof client_s3_1.S3ServiceException) {
+                if (error.name === 'NoSuchKey' || error.name === 'NotFound') {
+                    throw new Error(`File not found: ${fileKey}`);
+                }
+                if (error.name === 'AccessDenied') {
+                    throw new Error(`Access denied to S3 bucket "${this.bucket}". Check your credentials and bucket permissions`);
+                }
+                throw new Error(`S3 download failed: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async deleteFile(fileKey) {
+        const command = new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: fileKey,
+        });
+        await this.s3Client.send(command);
+    }
+    generateFileKey(contentType) {
+        const ext = this.getExtensionFromMimeType(contentType);
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 15);
+        return `${timestamp}-${random}${ext}`;
+    }
+    getExtensionFromMimeType(mimeType) {
+        const mimeToExt = {
+            'image/jpeg': '.jpg',
+            'image/png': '.png',
+            'image/gif': '.gif',
+            'image/webp': '.webp',
+            'image/svg+xml': '.svg',
+            'image/bmp': '.bmp',
+            'image/tiff': '.tiff',
+            'image/avif': '.avif',
+            'video/mp4': '.mp4',
+            'video/webm': '.webm',
+            'video/quicktime': '.mov',
+            'video/x-msvideo': '.avi',
+            'video/x-matroska': '.mkv',
+            'application/pdf': '.pdf',
+            'application/zip': '.zip',
+            'application/x-rar-compressed': '.rar',
+            'application/x-7z-compressed': '.7z',
+            'audio/mpeg': '.mp3',
+            'audio/wav': '.wav',
+            'audio/ogg': '.ogg',
+            'audio/flac': '.flac',
+            'text/plain': '.txt',
+            'text/csv': '.csv',
+            'application/json': '.json',
+            'application/xml': '.xml',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+        };
+        return mimeToExt[mimeType] || '.bin';
+    }
+}
+exports.S3Storage = S3Storage;

package/dist/drivers/SupabaseStorage.d.ts

@@ -0,0 +1,26 @@
+import { Readable } from 'stream';
+export interface SupabaseConfig {
+    projectUrl: string;
+    apiKey: string;
+    bucket: string;
+}
+export interface UploadResult {
+    fileKey: string;
+    contentType: string;
+}
+export interface DownloadResult {
+    stream: Readable;
+    contentType: string;
+}
+export declare class SupabaseStorage {
+    private client;
+    private bucket;
+    constructor(config: SupabaseConfig);
+    uploadStream(stream: Readable, contentType: string, metadata?: Record<string, string>): Promise<UploadResult>;
+    downloadStream(fileKey: string): Promise<DownloadResult>;
+    deleteFile(fileKey: string): Promise<void>;
+    private streamToBuffer;
+    private generateFileKey;
+    private getExtensionFromMimeType;
+    private getContentTypeFromKey;
+}

package/dist/drivers/SupabaseStorage.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseStorage = void 0;
+const supabase_js_1 = require("@supabase/supabase-js");
+const stream_1 = require("stream");
+class SupabaseStorage {
+    constructor(config) {
+        this.client = (0, supabase_js_1.createClient)(config.projectUrl, config.apiKey);
+        this.bucket = config.bucket;
+    }
+    async uploadStream(stream, contentType, metadata) {
+        const fileKey = this.generateFileKey(contentType);
+        try {
+            // Supabase SDK doesn't support streaming uploads directly
+            // We need to buffer the stream, but add a warning about memory usage
+            // For large files, consider using S3 instead which supports true streaming
+            const buffer = await this.streamToBuffer(stream);
+            // Warn if file is large (> 10MB)
+            if (buffer.length > 10 * 1024 * 1024) {
+                console.warn(`Large file (${(buffer.length / 1024 / 1024).toFixed(2)}MB) being uploaded to Supabase. Consider using S3 for better streaming support.`);
+            }
+            const { error } = await this.client.storage.from(this.bucket).upload(fileKey, buffer, {
+                contentType,
+                upsert: false,
+                cacheControl: '86400',
+                metadata,
+            });
+            if (error) {
+                if (error.message.includes('Bucket not found')) {
+                    throw new Error(`Supabase bucket "${this.bucket}" does not exist or is not accessible`);
+                }
+                if (error.message.includes('Permission denied')) {
+                    throw new Error(`Access denied to Supabase bucket "${this.bucket}". Check your API key and bucket permissions`);
+                }
+                throw new Error(`Supabase upload failed: ${error.message}`);
+            }
+            return {
+                fileKey,
+                contentType,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Supabase upload failed: ${String(error)}`);
+        }
+    }
+    async downloadStream(fileKey) {
+        try {
+            // Use signed URL for true streaming download
+            const { data: signedUrlData, error: signedUrlError } = await this.client.storage
+                .from(this.bucket)
+                .createSignedUrl(fileKey, 60); // 60 seconds validity
+            if (signedUrlError || !signedUrlData) {
+                throw new Error(`Failed to create signed URL: ${signedUrlError?.message || 'Unknown error'}`);
+            }
+            // Fetch the file using the signed URL to get proper streaming support
+            const response = await fetch(signedUrlData.signedUrl);
+            if (!response.ok) {
+                throw new Error(`Failed to download file: ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error(`Response body is empty`);
+            }
+            // Convert Web Stream to Node Stream
+            const nodeStream = stream_1.Readable.fromWeb(response.body);
+            const contentType = response.headers.get('content-type') || this.getContentTypeFromKey(fileKey);
+            return {
+                stream: nodeStream,
+                contentType,
+            };
+        }
+        catch (error) {
+            // Fallback to the old method if signed URL fails
+            try {
+                const { data, error } = await this.client.storage.from(this.bucket).download(fileKey);
+                if (error) {
+                    if (error.message.includes('Object not found') || error.message.includes('Not Found')) {
+                        throw new Error(`File not found: ${fileKey}`);
+                    }
+                    if (error.message.includes('Permission denied')) {
+                        throw new Error(`Access denied to Supabase bucket "${this.bucket}". Check your API key and bucket permissions`);
+                    }
+                    throw new Error(`Supabase download failed: ${error.message}`);
+                }
+                if (!data) {
+                    throw new Error(`File not found: ${fileKey}`);
+                }
+                const buffer = await data.arrayBuffer();
+                const stream = stream_1.Readable.from(Buffer.from(buffer));
+                const contentType = this.getContentTypeFromKey(fileKey);
+                return {
+                    stream,
+                    contentType,
+                };
+            }
+            catch (fallbackError) {
+                if (fallbackError instanceof Error) {
+                    throw fallbackError;
+                }
+                throw new Error(`Supabase download failed: ${String(fallbackError)}`);
+            }
+        }
+    }
+    async deleteFile(fileKey) {
+        try {
+            const { error } = await this.client.storage.from(this.bucket).remove([fileKey]);
+            if (error) {
+                if (error.message.includes('Object not found')) {
+                    return;
+                }
+                if (error.message.includes('Permission denied')) {
+                    throw new Error(`Access denied to Supabase bucket "${this.bucket}". Check your API key and bucket permissions`);
+                }
+                throw new Error(`Supabase delete failed: ${error.message}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw error;
+            }
+            throw new Error(`Supabase delete failed: ${String(error)}`);
+        }
+    }
+    async streamToBuffer(stream) {
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    generateFileKey(contentType) {
+        const ext = this.getExtensionFromMimeType(contentType);
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 15);
+        return `${timestamp}-${random}${ext}`;
+    }
+    getExtensionFromMimeType(mimeType) {
+        const mimeToExt = {
+            'image/jpeg': '.jpg',
+            'image/png': '.png',
+            'image/gif': '.gif',
+            'image/webp': '.webp',
+            'image/svg+xml': '.svg',
+            'image/bmp': '.bmp',
+            'image/tiff': '.tiff',
+            'image/avif': '.avif',
+            'video/mp4': '.mp4',
+            'video/webm': '.webm',
+            'video/quicktime': '.mov',
+            'video/x-msvideo': '.avi',
+            'video/x-matroska': '.mkv',
+            'application/pdf': '.pdf',
+            'application/zip': '.zip',
+            'application/x-rar-compressed': '.rar',
+            'application/x-7z-compressed': '.7z',
+            'audio/mpeg': '.mp3',
+            'audio/wav': '.wav',
+            'audio/ogg': '.ogg',
+            'audio/flac': '.flac',
+            'text/plain': '.txt',
+            'text/csv': '.csv',
+            'application/json': '.json',
+            'application/xml': '.xml',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
+        };
+        return mimeToExt[mimeType] || '.bin';
+    }
+    getContentTypeFromKey(fileKey) {
+        const ext = fileKey.split('.').pop()?.toLowerCase() || 'bin';
+        const extToMime = {
+            jpg: 'image/jpeg',
+            jpeg: 'image/jpeg',
+            png: 'image/png',
+            gif: 'image/gif',
+            webp: 'image/webp',
+            svg: 'image/svg+xml',
+            bmp: 'image/bmp',
+            tiff: 'image/tiff',
+            avif: 'image/avif',
+            mp4: 'video/mp4',
+            webm: 'video/webm',
+            mov: 'video/quicktime',
+            avi: 'video/x-msvideo',
+            mkv: 'video/x-matroska',
+            pdf: 'application/pdf',
+            zip: 'application/zip',
+            rar: 'application/x-rar-compressed',
+            '7z': 'application/x-7z-compressed',
+            mp3: 'audio/mpeg',
+            wav: 'audio/wav',
+            ogg: 'audio/ogg',
+            flac: 'audio/flac',
+            txt: 'text/plain',
+            csv: 'text/csv',
+            json: 'application/json',
+            xml: 'application/xml',
+            xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        };
+        return extToMime[ext] || 'application/octet-stream';
+    }
+}
+exports.SupabaseStorage = SupabaseStorage;

package/dist/drivers/index.d.ts

@@ -0,0 +1,17 @@
+import { IExecuteFunctions, IWebhookFunctions } from 'n8n-workflow';
+export { S3Storage } from './S3Storage';
+export type { StorageConfig as S3StorageConfig } from './S3Storage';
+export { SupabaseStorage } from './SupabaseStorage';
+export type { SupabaseConfig } from './SupabaseStorage';
+export interface StorageDriver {
+    uploadStream(stream: any, contentType: string, metadata?: Record<string, string>): Promise<{
+        fileKey: string;
+        contentType: string;
+    }>;
+    downloadStream(fileKey: string): Promise<{
+        stream: any;
+        contentType: string;
+    }>;
+    deleteFile(fileKey: string): Promise<void>;
+}
+export declare function createStorageDriver(context: IExecuteFunctions | IWebhookFunctions, storageDriver: string, bucket: string): Promise<StorageDriver>;

package/dist/drivers/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseStorage = exports.S3Storage = void 0;
+exports.createStorageDriver = createStorageDriver;
+const S3Storage_1 = require("./S3Storage");
+const SupabaseStorage_1 = require("./SupabaseStorage");
+var S3Storage_2 = require("./S3Storage");
+Object.defineProperty(exports, "S3Storage", { enumerable: true, get: function () { return S3Storage_2.S3Storage; } });
+var SupabaseStorage_2 = require("./SupabaseStorage");
+Object.defineProperty(exports, "SupabaseStorage", { enumerable: true, get: function () { return SupabaseStorage_2.SupabaseStorage; } });
+async function createStorageDriver(context, storageDriver, bucket) {
+    if (storageDriver === 's3') {
+        const credentials = await context.getCredentials('awsS3Api');
+        if (!credentials) {
+            throw new Error('AWS S3 credentials are required');
+        }
+        const region = context.getNodeParameter('region', 0);
+        const endpoint = context.getNodeParameter('endpoint', 0);
+        const forcePathStyle = context.getNodeParameter('forcePathStyle', 0);
+        const config = {
+            accessKeyId: credentials.accessKeyId,
+            secretAccessKey: credentials.secretAccessKey,
+            region,
+            bucket,
+            endpoint: endpoint || undefined,
+            forcePathStyle,
+        };
+        return new S3Storage_1.S3Storage(config);
+    }
+    else if (storageDriver === 'supabase') {
+        const credentials = await context.getCredentials('supabaseApi');
+        if (!credentials) {
+            throw new Error('Supabase credentials are required');
+        }
+        const projectUrl = context.getNodeParameter('projectUrl', 0);
+        const config = {
+            projectUrl,
+            apiKey: credentials.apiKey,
+            bucket,
+        };
+        return new SupabaseStorage_1.SupabaseStorage(config);
+    }
+    throw new Error(`Unknown storage driver: ${storageDriver}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { BinaryBridge } from './nodes/BinaryBridge/BinaryBridge.node';
+export declare const nodeClasses: (typeof BinaryBridge)[];

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeClasses = void 0;
+const BinaryBridge_node_1 = require("./nodes/BinaryBridge/BinaryBridge.node");
+exports.nodeClasses = [BinaryBridge_node_1.BinaryBridge];

package/dist/nodes/BinaryBridge/BinaryBridge.node.d.ts

@@ -0,0 +1,6 @@
+import { INodeType, INodeTypeDescription, IExecuteFunctions, IWebhookFunctions, IWebhookResponseData, INodeExecutionData } from 'n8n-workflow';
+export declare class BinaryBridge implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}