n8n-nodes-binary-to-url 0.0.4 → 0.0.6

package/dist/credentials/S3StorageApi.credentials.d.ts

@@ -0,0 +1,15 @@
+import type { Icon, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class S3StorageApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: Icon;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    test: {
+        request: {
+            baseURL: string;
+            url: string;
+            method: "GET";
+        };
+    };
+}

package/dist/credentials/S3StorageApi.credentials.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3StorageApi = void 0;
+class S3StorageApi {
+    constructor() {
+        this.name = 's3StorageApi';
+        this.displayName = 'S3 Storage API';
+        this.icon = 'file:../icons/BinaryToUrl.svg';
+        this.documentationUrl = 'https://docs.aws.amazon.com/AmazonS3/latest/userguide/AccessCredentials.html';
+        this.properties = [
+            {
+                displayName: 'Access Key ID',
+                name: 'accessKeyId',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+            },
+            {
+                displayName: 'Secret Access Key',
+                name: 'secretAccessKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+            },
+        ];
+        this.test = {
+            request: {
+                baseURL: '={{$credentials.endpoint}}',
+                url: '=/',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.S3StorageApi = S3StorageApi;

package/dist/drivers/S3Storage.js

@@ -1,6 +1,72 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.S3Storage = void 0;
+// Use Node.js crypto in Node environment, Web Crypto API in browser
+const crypto = __importStar(require("node:crypto"));
+let cryptoInstance;
+if (typeof window !== 'undefined' && window?.crypto) {
+    // Browser environment (n8n Cloud)
+    cryptoInstance = window.crypto;
+}
+else {
+    // Node.js environment
+    // Create a Web Crypto API compatible wrapper
+    cryptoInstance = {
+        subtle: {
+            digest: async (algorithm, data) => {
+                const hash = crypto.createHash(algorithm.replace('-', '').toLowerCase());
+                hash.update(Buffer.from(data));
+                return Buffer.from(hash.digest()).buffer;
+            },
+            importKey: async (format, keyData, algorithm, extractable, usages) => {
+                return {
+                    algorithm,
+                    extractable,
+                    usages,
+                    data: format === 'raw' ? keyData : keyData,
+                };
+            },
+            sign: async (algorithm, key, data) => {
+                const hmac = crypto.createHmac('sha256', key.data);
+                hmac.update(Buffer.from(data));
+                return Buffer.from(hmac.digest()).buffer;
+            },
+        },
+    };
+}
 class S3Storage {
     constructor(config) {
         this.config = config;
@@ -163,15 +229,15 @@ class S3Storage {
     async sha256(message) {
         const encoder = new TextEncoder();
         const data = encoder.encode(message);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashBuffer = await cryptoInstance.subtle.digest('SHA-256', data);
         const hashArray = Array.from(new Uint8Array(hashBuffer));
         return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
     }
     async hmac(key, message) {
-        const cryptoKey = await crypto.subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const cryptoKey = await cryptoInstance.subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
         const encoder = new TextEncoder();
         const data = encoder.encode(message);
-        const signature = await crypto.subtle.sign('HMAC', cryptoKey, data);
+        const signature = await cryptoInstance.subtle.sign('HMAC', cryptoKey, data);
         const signatureArray = Array.from(new Uint8Array(signature));
         return signatureArray.map((b) => b.toString(16).padStart(2, '0')).join('');
     }
@@ -186,8 +252,8 @@ class S3Storage {
         const keyBuffer = typeof key === 'string' ? Buffer.from(key) : key;
         const encoder = new TextEncoder();
         const data = encoder.encode(message);
-        const cryptoKey = await crypto.subtle.importKey('raw', keyBuffer, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-        const signature = await crypto.subtle.sign('HMAC', cryptoKey, data);
+        const cryptoKey = await cryptoInstance.subtle.importKey('raw', keyBuffer, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const signature = await cryptoInstance.subtle.sign('HMAC', cryptoKey, data);
         return Buffer.from(signature);
     }
     generateFileKey(contentType) {

package/dist/drivers/index.js

@@ -6,7 +6,7 @@ const S3Storage_1 = require("./S3Storage");
 var S3Storage_2 = require("./S3Storage");
 Object.defineProperty(exports, "S3Storage", { enumerable: true, get: function () { return S3Storage_2.S3Storage; } });
 async function createStorageDriver(context, bucket) {
-    const credentials = await context.getCredentials('awsS3');
+    const credentials = await context.getCredentials('s3StorageApi');
     if (!credentials) {
         throw new Error('No S3 credentials found. Please configure S3 credentials.');
     }

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,5 +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];
+const BinaryToUrl_node_1 = require("./nodes/BinaryToUrl/BinaryToUrl.node");
+exports.nodeClasses = [BinaryToUrl_node_1.BinaryToUrl];

package/dist/nodes/{BinaryBridge/BinaryBridge.node.d.ts → BinaryToUrl/BinaryToUrl.node.d.ts}

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

package/dist/nodes/{BinaryBridge/BinaryBridge.node.js → BinaryToUrl/BinaryToUrl.node.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryBridge = void 0;
+exports.BinaryToUrl = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const drivers_1 = require("../../drivers");
 const MAX_FILE_SIZE = 100 * 1024 * 1024;
@@ -33,7 +33,7 @@ const ALLOWED_MIME_TYPES = [
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
 ];
-class BinaryBridge {
+class BinaryToUrl {
     constructor() {
         this.description = {
             displayName: 'Binary to URL',
@@ -50,7 +50,7 @@ class BinaryBridge {
             outputs: ['main'],
             credentials: [
                 {
-                    name: 'awsS3',
+                    name: 's3StorageApi',
                     required: true,
                 },
             ],
@@ -142,9 +142,10 @@ class BinaryBridge {
                     name: 'forcePathStyle',
                     type: 'boolean',
                     default: false,
-                    description: 'Use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
+                    description: 'Whether to use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
                 },
             ],
+            usableAsTool: true,
         };
     }
     async execute() {
@@ -237,7 +238,7 @@ class BinaryBridge {
                 },
             };
         }
-        catch (error) {
+        catch {
             return {
                 webhookResponse: {
                     status: 404,
@@ -250,7 +251,7 @@ class BinaryBridge {
         }
     }
 }
-exports.BinaryBridge = BinaryBridge;
+exports.BinaryToUrl = BinaryToUrl;
 async function handleUpload(context, items, storage) {
     const binaryPropertyName = context.getNodeParameter('binaryPropertyName', 0);
     const webhookBaseUrl = buildWebhookUrl(context, 'default', 'file');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-binary-to-url",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "n8n community node for binary file to public URL bridge with S3 storage",
   "keywords": [
     "n8n-community-node-package",
@@ -24,37 +24,35 @@
   },
   "main": "dist/index.js",
   "scripts": {
-    "build": "tsc && cp -r nodes dist/",
-    "dev": "tsc --watch",
+    "build": "n8n-node build",
+    "build:watch": "tsc --watch",
+    "dev": "n8n-node dev",
     "format": "prettier --write \"**/*.{js,ts,json,md}\"",
-    "lint": "eslint --ext .js,.ts .",
-    "lintfix": "eslint --fix --ext .js,.ts .",
-    "prepublishOnly": "npm run build",
-    "test": "jest"
+    "lint": "n8n-node lint",
+    "lint:fix": "n8n-node lint --fix",
+    "release": "n8n-node release",
+    "prepublishOnly": "n8n-node prerelease"
   },
   "files": [
-    "dist",
-    "nodes"
+    "dist"
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
-    "credentials": [],
+    "strict": true,
+    "credentials": [
+      "dist/credentials/S3StorageApi.credentials.js"
+    ],
     "nodes": [
-      "dist/nodes/BinaryBridge/BinaryBridge.node.js"
+      "dist/nodes/BinaryToUrl/BinaryToUrl.node.js"
     ]
   },
   "dependencies": {},
   "devDependencies": {
-    "@types/jest": "^30.0.0",
-    "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.50.0",
+    "@n8n/node-cli": "*",
+    "eslint": "9.32.0",
     "eslint-plugin-n8n-nodes-base": "^1.11.0",
-    "jest": "^30.2.0",
-    "prettier": "^3.0.0",
-    "ts-jest": "^29.4.6",
-    "typescript": "^5.2.0"
+    "prettier": "3.6.2",
+    "typescript": "5.9.2"
   },
   "peerDependencies": {
     "n8n-workflow": "*"

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

@@ -1,370 +0,0 @@
-import {
-  INodeType,
-  INodeTypeDescription,
-  IExecuteFunctions,
-  IWebhookFunctions,
-  IWebhookResponseData,
-  INodeExecutionData,
-  NodeOperationError,
-} from 'n8n-workflow';
-import { createStorageDriver, StorageDriver } from '../../drivers';
-
-const MAX_FILE_SIZE = 100 * 1024 * 1024;
-const ALLOWED_MIME_TYPES = [
-  'image/jpeg',
-  'image/png',
-  'image/gif',
-  'image/webp',
-  'image/svg+xml',
-  'image/bmp',
-  'image/tiff',
-  'image/avif',
-  'video/mp4',
-  'video/webm',
-  'video/quicktime',
-  'video/x-msvideo',
-  'video/x-matroska',
-  'application/pdf',
-  'application/zip',
-  'application/x-rar-compressed',
-  'application/x-7z-compressed',
-  'audio/mpeg',
-  'audio/wav',
-  'audio/ogg',
-  'audio/flac',
-  'text/plain',
-  'text/csv',
-  'application/json',
-  'application/xml',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-];
-
-export class BinaryBridge implements INodeType {
-  description: INodeTypeDescription = {
-    displayName: 'Binary to URL',
-    name: 'binaryToUrl',
-    icon: 'file:BinaryBridge.svg',
-    group: ['transform'],
-    version: 1,
-    subtitle: '={{$parameter["operation"]}}',
-    description: 'Upload binary files to S3 storage and proxy them via public URL',
-    defaults: {
-      name: 'Binary to URL',
-    },
-    inputs: ['main'],
-    outputs: ['main'],
-    credentials: [
-      {
-        name: 'awsS3',
-        required: true,
-      },
-    ],
-    webhooks: [
-      {
-        name: 'default',
-        httpMethod: 'GET',
-        responseMode: 'onReceived',
-        path: 'file/:fileKey',
-        isFullPath: true,
-      },
-    ],
-    properties: [
-      {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options',
-        noDataExpression: true,
-        options: [
-          {
-            name: 'Upload',
-            value: 'upload',
-            description: 'Upload binary file to storage',
-            action: 'Upload file',
-          },
-          {
-            name: 'Delete',
-            value: 'delete',
-            description: 'Delete file from storage',
-            action: 'Delete file',
-          },
-        ],
-        default: 'upload',
-      },
-      {
-        displayName: 'Binary Property',
-        name: 'binaryPropertyName',
-        type: 'string',
-        displayOptions: {
-          show: {
-            operation: ['upload'],
-          },
-        },
-        default: 'data',
-        description: 'Name of binary property containing the file to upload',
-      },
-      {
-        displayName: 'File Key',
-        name: 'fileKey',
-        type: 'string',
-        displayOptions: {
-          show: {
-            operation: ['delete'],
-          },
-        },
-        default: '',
-        description: 'Key of the file to delete from storage',
-      },
-      {
-        displayName: 'Bucket',
-        name: 'bucket',
-        type: 'string',
-        default: '',
-        required: true,
-        description: 'Storage bucket name',
-      },
-      {
-        displayName: 'Region',
-        name: 'region',
-        type: 'string',
-        default: 'us-east-1',
-        required: true,
-        description: 'AWS region (leave empty for some S3-compatible services)',
-      },
-      {
-        displayName: 'Custom Endpoint',
-        name: 'endpoint',
-        type: 'string',
-        default: '',
-        description:
-          'Custom S3 endpoint URL (required for MinIO, DigitalOcean Spaces, Wasabi, etc.)',
-        displayOptions: {
-          show: {
-            operation: ['upload', 'delete'],
-          },
-        },
-      },
-      {
-        displayName: 'Force Path Style',
-        name: 'forcePathStyle',
-        type: 'boolean',
-        default: false,
-        description: 'Use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
-      },
-    ],
-  };
-
-  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-    const items = this.getInputData();
-    const operation = this.getNodeParameter('operation', 0) as string;
-    const bucket = this.getNodeParameter('bucket', 0) as string;
-
-    if (!bucket) {
-      throw new NodeOperationError(this.getNode(), 'Bucket name is required');
-    }
-
-    try {
-      const storage = await createStorageDriver(this, bucket);
-
-      if (operation === 'upload') {
-        return handleUpload(this, items, storage);
-      } else if (operation === 'delete') {
-        return handleDelete(this, items, storage);
-      }
-
-      throw new NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new NodeOperationError(this.getNode(), `Operation failed: ${error.message}`);
-      }
-      throw new NodeOperationError(this.getNode(), `Operation failed: ${String(error)}`);
-    }
-  }
-
-  async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
-    const req = this.getRequestObject();
-    const fileKey = req.params.fileKey as string;
-
-    if (!fileKey) {
-      return {
-        webhookResponse: {
-          status: 400,
-          body: JSON.stringify({ error: 'Missing fileKey' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    if (!isValidFileKey(fileKey)) {
-      return {
-        webhookResponse: {
-          status: 400,
-          body: JSON.stringify({ error: 'Invalid fileKey' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    const bucket = this.getNodeParameter('bucket', 0) as string;
-
-    if (!bucket) {
-      return {
-        webhookResponse: {
-          status: 500,
-          body: JSON.stringify({ error: 'Node configuration is incomplete' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    let storage;
-    try {
-      storage = await createStorageDriver(this, bucket);
-    } catch (error) {
-      return {
-        webhookResponse: {
-          status: 500,
-          body: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    try {
-      const { data, contentType } = await storage.downloadStream(fileKey);
-
-      return {
-        webhookResponse: {
-          status: 200,
-          body: data.toString('base64'),
-          headers: {
-            'Content-Type': contentType,
-            'Cache-Control': 'public, max-age=86400',
-            'Content-Disposition': 'inline',
-          },
-        },
-      };
-    } catch (error) {
-      return {
-        webhookResponse: {
-          status: 404,
-          body: JSON.stringify({ error: 'File not found' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-  }
-}
-
-async function handleUpload(
-  context: IExecuteFunctions,
-  items: INodeExecutionData[],
-  storage: StorageDriver
-): Promise<INodeExecutionData[][]> {
-  const binaryPropertyName = context.getNodeParameter('binaryPropertyName', 0) as string;
-  const webhookBaseUrl = buildWebhookUrl(context, 'default', 'file');
-
-  const returnData: INodeExecutionData[] = [];
-
-  for (const item of items) {
-    const binaryData = item.binary?.[binaryPropertyName];
-
-    if (!binaryData) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `No binary data found in property "${binaryPropertyName}"`
-      );
-    }
-
-    const buffer = Buffer.from(binaryData.data, 'base64');
-
-    // Use provided MIME type or default
-    const contentType = binaryData.mimeType || 'application/octet-stream';
-
-    if (!ALLOWED_MIME_TYPES.includes(contentType)) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `MIME type "${contentType}" is not allowed. Allowed types: ${ALLOWED_MIME_TYPES.join(', ')}`
-      );
-    }
-
-    const fileSize = buffer.length;
-    if (fileSize > MAX_FILE_SIZE) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `File size exceeds maximum limit of ${MAX_FILE_SIZE / 1024 / 1024}MB`
-      );
-    }
-
-    const result = await storage.uploadStream(buffer, contentType);
-
-    const proxyUrl = `${webhookBaseUrl}/${result.fileKey}`;
-
-    returnData.push({
-      json: {
-        fileKey: result.fileKey,
-        proxyUrl,
-        contentType,
-        fileSize,
-      },
-      binary: item.binary,
-    });
-  }
-
-  return [returnData];
-}
-
-async function handleDelete(
-  context: IExecuteFunctions,
-  items: INodeExecutionData[],
-  storage: StorageDriver
-): Promise<INodeExecutionData[][]> {
-  const returnData: INodeExecutionData[] = [];
-
-  for (const item of items) {
-    const fileKey = (item.json.fileKey || context.getNodeParameter('fileKey', 0)) as string;
-
-    if (!fileKey) {
-      throw new NodeOperationError(context.getNode(), 'File key is required for delete operation');
-    }
-
-    await storage.deleteFile(fileKey);
-
-    returnData.push({
-      json: {
-        success: true,
-        deleted: fileKey,
-      },
-    });
-  }
-
-  return [returnData];
-}
-
-function buildWebhookUrl(context: IExecuteFunctions, webhookName: string, path: string): string {
-  const baseUrl = context.getInstanceBaseUrl();
-  const node = context.getNode();
-  const workflow = context.getWorkflow();
-  const workflowId = workflow.id;
-  const nodeName = encodeURIComponent(node.name.toLowerCase());
-  return `${baseUrl}/webhook/${workflowId}/${nodeName}/${path}`;
-}
-
-function isValidFileKey(fileKey: string): boolean {
-  if (!fileKey || typeof fileKey !== 'string') {
-    return false;
-  }
-
-  const fileKeyPattern = /^[0-9]+-[a-z0-9]+\.[a-z0-9]+$/i;
-  return fileKeyPattern.test(fileKey);
-}

package/nodes/BinaryBridge/BinaryBridge.node.ts

@@ -1,370 +0,0 @@
-import {
-  INodeType,
-  INodeTypeDescription,
-  IExecuteFunctions,
-  IWebhookFunctions,
-  IWebhookResponseData,
-  INodeExecutionData,
-  NodeOperationError,
-} from 'n8n-workflow';
-import { createStorageDriver, StorageDriver } from '../../drivers';
-
-const MAX_FILE_SIZE = 100 * 1024 * 1024;
-const ALLOWED_MIME_TYPES = [
-  'image/jpeg',
-  'image/png',
-  'image/gif',
-  'image/webp',
-  'image/svg+xml',
-  'image/bmp',
-  'image/tiff',
-  'image/avif',
-  'video/mp4',
-  'video/webm',
-  'video/quicktime',
-  'video/x-msvideo',
-  'video/x-matroska',
-  'application/pdf',
-  'application/zip',
-  'application/x-rar-compressed',
-  'application/x-7z-compressed',
-  'audio/mpeg',
-  'audio/wav',
-  'audio/ogg',
-  'audio/flac',
-  'text/plain',
-  'text/csv',
-  'application/json',
-  'application/xml',
-  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-];
-
-export class BinaryBridge implements INodeType {
-  description: INodeTypeDescription = {
-    displayName: 'Binary to URL',
-    name: 'binaryToUrl',
-    icon: 'file:BinaryBridge.svg',
-    group: ['transform'],
-    version: 1,
-    subtitle: '={{$parameter["operation"]}}',
-    description: 'Upload binary files to S3 storage and proxy them via public URL',
-    defaults: {
-      name: 'Binary to URL',
-    },
-    inputs: ['main'],
-    outputs: ['main'],
-    credentials: [
-      {
-        name: 'awsS3',
-        required: true,
-      },
-    ],
-    webhooks: [
-      {
-        name: 'default',
-        httpMethod: 'GET',
-        responseMode: 'onReceived',
-        path: 'file/:fileKey',
-        isFullPath: true,
-      },
-    ],
-    properties: [
-      {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options',
-        noDataExpression: true,
-        options: [
-          {
-            name: 'Upload',
-            value: 'upload',
-            description: 'Upload binary file to storage',
-            action: 'Upload file',
-          },
-          {
-            name: 'Delete',
-            value: 'delete',
-            description: 'Delete file from storage',
-            action: 'Delete file',
-          },
-        ],
-        default: 'upload',
-      },
-      {
-        displayName: 'Binary Property',
-        name: 'binaryPropertyName',
-        type: 'string',
-        displayOptions: {
-          show: {
-            operation: ['upload'],
-          },
-        },
-        default: 'data',
-        description: 'Name of binary property containing the file to upload',
-      },
-      {
-        displayName: 'File Key',
-        name: 'fileKey',
-        type: 'string',
-        displayOptions: {
-          show: {
-            operation: ['delete'],
-          },
-        },
-        default: '',
-        description: 'Key of the file to delete from storage',
-      },
-      {
-        displayName: 'Bucket',
-        name: 'bucket',
-        type: 'string',
-        default: '',
-        required: true,
-        description: 'Storage bucket name',
-      },
-      {
-        displayName: 'Region',
-        name: 'region',
-        type: 'string',
-        default: 'us-east-1',
-        required: true,
-        description: 'AWS region (leave empty for some S3-compatible services)',
-      },
-      {
-        displayName: 'Custom Endpoint',
-        name: 'endpoint',
-        type: 'string',
-        default: '',
-        description:
-          'Custom S3 endpoint URL (required for MinIO, DigitalOcean Spaces, Wasabi, etc.)',
-        displayOptions: {
-          show: {
-            operation: ['upload', 'delete'],
-          },
-        },
-      },
-      {
-        displayName: 'Force Path Style',
-        name: 'forcePathStyle',
-        type: 'boolean',
-        default: false,
-        description: 'Use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
-      },
-    ],
-  };
-
-  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-    const items = this.getInputData();
-    const operation = this.getNodeParameter('operation', 0) as string;
-    const bucket = this.getNodeParameter('bucket', 0) as string;
-
-    if (!bucket) {
-      throw new NodeOperationError(this.getNode(), 'Bucket name is required');
-    }
-
-    try {
-      const storage = await createStorageDriver(this, bucket);
-
-      if (operation === 'upload') {
-        return handleUpload(this, items, storage);
-      } else if (operation === 'delete') {
-        return handleDelete(this, items, storage);
-      }
-
-      throw new NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new NodeOperationError(this.getNode(), `Operation failed: ${error.message}`);
-      }
-      throw new NodeOperationError(this.getNode(), `Operation failed: ${String(error)}`);
-    }
-  }
-
-  async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
-    const req = this.getRequestObject();
-    const fileKey = req.params.fileKey as string;
-
-    if (!fileKey) {
-      return {
-        webhookResponse: {
-          status: 400,
-          body: JSON.stringify({ error: 'Missing fileKey' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    if (!isValidFileKey(fileKey)) {
-      return {
-        webhookResponse: {
-          status: 400,
-          body: JSON.stringify({ error: 'Invalid fileKey' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    const bucket = this.getNodeParameter('bucket', 0) as string;
-
-    if (!bucket) {
-      return {
-        webhookResponse: {
-          status: 500,
-          body: JSON.stringify({ error: 'Node configuration is incomplete' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    let storage;
-    try {
-      storage = await createStorageDriver(this, bucket);
-    } catch (error) {
-      return {
-        webhookResponse: {
-          status: 500,
-          body: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-
-    try {
-      const { data, contentType } = await storage.downloadStream(fileKey);
-
-      return {
-        webhookResponse: {
-          status: 200,
-          body: data.toString('base64'),
-          headers: {
-            'Content-Type': contentType,
-            'Cache-Control': 'public, max-age=86400',
-            'Content-Disposition': 'inline',
-          },
-        },
-      };
-    } catch (error) {
-      return {
-        webhookResponse: {
-          status: 404,
-          body: JSON.stringify({ error: 'File not found' }),
-          headers: {
-            'Content-Type': 'application/json',
-          },
-        },
-      };
-    }
-  }
-}
-
-async function handleUpload(
-  context: IExecuteFunctions,
-  items: INodeExecutionData[],
-  storage: StorageDriver
-): Promise<INodeExecutionData[][]> {
-  const binaryPropertyName = context.getNodeParameter('binaryPropertyName', 0) as string;
-  const webhookBaseUrl = buildWebhookUrl(context, 'default', 'file');
-
-  const returnData: INodeExecutionData[] = [];
-
-  for (const item of items) {
-    const binaryData = item.binary?.[binaryPropertyName];
-
-    if (!binaryData) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `No binary data found in property "${binaryPropertyName}"`
-      );
-    }
-
-    const buffer = Buffer.from(binaryData.data, 'base64');
-
-    // Use provided MIME type or default
-    const contentType = binaryData.mimeType || 'application/octet-stream';
-
-    if (!ALLOWED_MIME_TYPES.includes(contentType)) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `MIME type "${contentType}" is not allowed. Allowed types: ${ALLOWED_MIME_TYPES.join(', ')}`
-      );
-    }
-
-    const fileSize = buffer.length;
-    if (fileSize > MAX_FILE_SIZE) {
-      throw new NodeOperationError(
-        context.getNode(),
-        `File size exceeds maximum limit of ${MAX_FILE_SIZE / 1024 / 1024}MB`
-      );
-    }
-
-    const result = await storage.uploadStream(buffer, contentType);
-
-    const proxyUrl = `${webhookBaseUrl}/${result.fileKey}`;
-
-    returnData.push({
-      json: {
-        fileKey: result.fileKey,
-        proxyUrl,
-        contentType,
-        fileSize,
-      },
-      binary: item.binary,
-    });
-  }
-
-  return [returnData];
-}
-
-async function handleDelete(
-  context: IExecuteFunctions,
-  items: INodeExecutionData[],
-  storage: StorageDriver
-): Promise<INodeExecutionData[][]> {
-  const returnData: INodeExecutionData[] = [];
-
-  for (const item of items) {
-    const fileKey = (item.json.fileKey || context.getNodeParameter('fileKey', 0)) as string;
-
-    if (!fileKey) {
-      throw new NodeOperationError(context.getNode(), 'File key is required for delete operation');
-    }
-
-    await storage.deleteFile(fileKey);
-
-    returnData.push({
-      json: {
-        success: true,
-        deleted: fileKey,
-      },
-    });
-  }
-
-  return [returnData];
-}
-
-function buildWebhookUrl(context: IExecuteFunctions, webhookName: string, path: string): string {
-  const baseUrl = context.getInstanceBaseUrl();
-  const node = context.getNode();
-  const workflow = context.getWorkflow();
-  const workflowId = workflow.id;
-  const nodeName = encodeURIComponent(node.name.toLowerCase());
-  return `${baseUrl}/webhook/${workflowId}/${nodeName}/${path}`;
-}
-
-function isValidFileKey(fileKey: string): boolean {
-  if (!fileKey || typeof fileKey !== 'string') {
-    return false;
-  }
-
-  const fileKeyPattern = /^[0-9]+-[a-z0-9]+\.[a-z0-9]+$/i;
-  return fileKeyPattern.test(fileKey);
-}