n8n-nodes-binary-to-url 0.0.8 → 0.0.10

package/dist/drivers/MemoryStorage.d.ts

@@ -0,0 +1,21 @@
+export declare class MemoryStorage {
+    private static cache;
+    private static readonly DEFAULT_TTL;
+    private static readonly MAX_CACHE_SIZE;
+    private static currentCacheSize;
+    static generateFileKey(): string;
+    static upload(data: Buffer, contentType: string, ttl?: number): Promise<{
+        fileKey: string;
+        contentType: string;
+    }>;
+    static download(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;
+}

package/dist/drivers/MemoryStorage.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+// Simple in-memory storage with TTL
+class MemoryStorage {
+    static generateFileKey() {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 15);
+        return `${timestamp}-${random}`;
+    }
+    static async upload(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);
+            }
+        }
+        const file = {
+            data,
+            contentType,
+            uploadedAt: now,
+            expiresAt,
+        };
+        this.cache.set(fileKey, file);
+        this.currentCacheSize += fileSize;
+        return { fileKey, contentType };
+    }
+    static async download(fileKey) {
+        const file = this.cache.get(fileKey);
+        if (!file) {
+            return null;
+        }
+        // Check if expired
+        if (Date.now() > file.expiresAt) {
+            this.delete(fileKey);
+            return null;
+        }
+        return {
+            data: file.data,
+            contentType: file.contentType,
+        };
+    }
+    static async delete(fileKey) {
+        const file = this.cache.get(fileKey);
+        if (!file)
+            return false;
+        this.currentCacheSize -= file.data.length;
+        return this.cache.delete(fileKey);
+    }
+    static cleanupExpired() {
+        const now = Date.now();
+        for (const [key, file] of this.cache.entries()) {
+            if (now > file.expiresAt) {
+                this.delete(key);
+            }
+        }
+    }
+    static cleanupOldest(requiredSpace) {
+        const entries = Array.from(this.cache.entries());
+        // Sort by upload time (oldest first)
+        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);
+        }
+    }
+    static getCacheSize() {
+        return this.currentCacheSize;
+    }
+    static getCacheCount() {
+        return this.cache.size;
+    }
+    static clear() {
+        this.cache.clear();
+        this.currentCacheSize = 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;

package/dist/drivers/index.d.ts

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

package/dist/drivers/index.js

@@ -1,48 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Storage = void 0;
-exports.createStorageDriver = createStorageDriver;
-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('s3Api');
-    if (!credentials) {
-        throw new Error('No S3 credentials found. Please configure S3 credentials.');
-    }
-    const region = context.getNodeParameter('region', 0);
-    const endpoint = context.getNodeParameter('endpoint', 0);
-    const forcePathStyle = context.getNodeParameter('forcePathStyle', 0);
-    // Extract credentials from S3 API credential
-    const creds = credentials;
-    const accessKeyId = creds.accessKeyId || '';
-    const secretAccessKey = creds.secretAccessKey || '';
-    const credentialEndpoint = creds.endpoint;
-    const credentialRegion = creds.region;
-    // Convert forcePathStyle from credential (could be string or boolean)
-    const credentialForcePathStyle = String(creds.forcePathStyle) === 'true';
-    // Use credential values if node parameters are empty
-    const finalEndpoint = endpoint || credentialEndpoint;
-    const finalRegion = region || credentialRegion || 'us-east-1';
-    // Use boolean OR to combine forcePathStyle from node and credential
-    const finalForcePathStyle = forcePathStyle || credentialForcePathStyle || false;
-    if (!accessKeyId || !secretAccessKey) {
-        throw new Error('Invalid credentials. Missing access key or secret key.');
-    }
-    // Auto-determine if path style should be forced
-    let shouldForcePathStyle = finalForcePathStyle;
-    // Force path style by default if custom endpoint is provided
-    // This is needed for MinIO, Wasabi, DigitalOcean Spaces, Alibaba OSS, Tencent COS, etc.
-    if (finalEndpoint && finalEndpoint !== '' && !finalForcePathStyle) {
-        shouldForcePathStyle = true;
-    }
-    const config = {
-        accessKeyId: accessKeyId,
-        secretAccessKey: secretAccessKey,
-        region: finalRegion,
-        bucket,
-        endpoint: finalEndpoint || undefined,
-        forcePathStyle: shouldForcePathStyle,
-    };
-    return new S3Storage_1.S3Storage(config);
-}
+exports.MemoryStorage = void 0;
+var MemoryStorage_1 = require("./MemoryStorage");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return MemoryStorage_1.MemoryStorage; } });

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 drivers_1 = require("../../drivers");
+const MemoryStorage_1 = require("../../drivers/MemoryStorage");
 const MAX_FILE_SIZE = 100 * 1024 * 1024;
 const ALLOWED_MIME_TYPES = [
     'image/jpeg',
@@ -42,18 +42,12 @@ class BinaryToUrl {
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"]}}',
-            description: 'Upload binary files to S3 storage and proxy them via public URL',
+            description: 'Upload binary files to memory storage and proxy them via public URL',
             defaults: {
                 name: 'Binary to URL',
             },
             inputs: ['main'],
             outputs: ['main'],
-            credentials: [
-                {
-                    name: 's3Api',
-                    required: true,
-                },
-            ],
             webhooks: [
                 {
                     name: 'default',
@@ -73,13 +67,13 @@ class BinaryToUrl {
                         {
                             name: 'Upload',
                             value: 'upload',
-                            description: 'Upload binary file to storage',
+                            description: 'Upload binary file to memory storage',
                             action: 'Upload file',
                         },
                         {
                             name: 'Delete',
                             value: 'delete',
-                            description: 'Delete file from storage',
+                            description: 'Delete file from memory storage',
                             action: 'Delete file',
                         },
                     ],
@@ -98,51 +92,29 @@ class BinaryToUrl {
                     description: 'Name of binary property containing the file to upload',
                 },
                 {
-                    displayName: 'File Key',
-                    name: 'fileKey',
-                    type: 'string',
+                    displayName: 'File Expiration Time (Seconds)',
+                    name: 'ttl',
+                    type: 'number',
                     displayOptions: {
                         show: {
-                            operation: ['delete'],
+                            operation: ['upload'],
                         },
                     },
-                    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)',
+                    default: 3600,
+                    description: 'How long to keep the file in memory (default: 3600 seconds = 1 hour)',
+                    hint: 'Files are automatically deleted after this time',
                 },
                 {
-                    displayName: 'Custom Endpoint',
-                    name: 'endpoint',
+                    displayName: 'File Key',
+                    name: 'fileKey',
                     type: 'string',
-                    default: '',
-                    description: 'Custom S3 endpoint URL (required for MinIO, DigitalOcean Spaces, Wasabi, etc.)',
                     displayOptions: {
                         show: {
-                            operation: ['upload', 'delete'],
+                            operation: ['delete'],
                         },
                     },
-                },
-                {
-                    displayName: 'Force Path Style',
-                    name: 'forcePathStyle',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
+                    default: '',
+                    description: 'Key of the file to delete from storage',
                 },
             ],
             usableAsTool: true,
@@ -151,26 +123,13 @@ class BinaryToUrl {
     async execute() {
         const items = this.getInputData();
         const operation = this.getNodeParameter('operation', 0);
-        const bucket = this.getNodeParameter('bucket', 0);
-        if (!bucket) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Bucket name is required');
-        }
-        try {
-            const storage = await (0, drivers_1.createStorageDriver)(this, bucket);
-            if (operation === 'upload') {
-                return handleUpload(this, items, storage);
-            }
-            else if (operation === 'delete') {
-                return handleDelete(this, items, storage);
-            }
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
+        if (operation === 'upload') {
+            return handleUpload(this, items);
         }
-        catch (error) {
-            if (error instanceof Error) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation failed: ${error.message}`);
-            }
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation failed: ${String(error)}`);
+        else if (operation === 'delete') {
+            return handleDelete(this, items);
         }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`);
     }
     async webhook() {
         const req = this.getRequestObject();
@@ -197,52 +156,36 @@ class BinaryToUrl {
                 },
             };
         }
-        const bucket = this.getNodeParameter('bucket', 0);
-        if (!bucket) {
-            return {
-                webhookResponse: {
-                    status: 500,
-                    body: JSON.stringify({ error: 'Node configuration is incomplete' }),
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                },
-            };
-        }
-        let storage;
         try {
-            storage = await (0, drivers_1.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',
+            const result = await MemoryStorage_1.MemoryStorage.download(fileKey);
+            if (!result) {
+                return {
+                    webhookResponse: {
+                        status: 404,
+                        body: JSON.stringify({ error: 'File not found or expired' }),
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
                     },
-                },
-            };
-        }
-        try {
-            const { data, contentType } = await storage.downloadStream(fileKey);
+                };
+            }
             return {
                 webhookResponse: {
                     status: 200,
-                    body: data.toString('base64'),
+                    body: result.data.toString('base64'),
                     headers: {
-                        'Content-Type': contentType,
+                        'Content-Type': result.contentType,
                         'Cache-Control': 'public, max-age=86400',
                         'Content-Disposition': 'inline',
                     },
                 },
             };
         }
-        catch {
+        catch (error) {
             return {
                 webhookResponse: {
-                    status: 404,
-                    body: JSON.stringify({ error: 'File not found' }),
+                    status: 500,
+                    body: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
                     headers: {
                         'Content-Type': 'application/json',
                     },
@@ -252,9 +195,15 @@ class BinaryToUrl {
     }
 }
 exports.BinaryToUrl = BinaryToUrl;
-async function handleUpload(context, items, storage) {
+async function handleUpload(context, items) {
     const binaryPropertyName = context.getNodeParameter('binaryPropertyName', 0);
-    const webhookBaseUrl = buildWebhookUrl(context, 'default', 'file');
+    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 workflow = context.getWorkflow();
+    const workflowId = workflow.id;
+    const webhookUrl = `${baseUrl}/webhook/${workflowId}/file/:fileKey`;
     const returnData = [];
     for (const item of items) {
         const binaryData = item.binary?.[binaryPropertyName];
@@ -271,8 +220,9 @@ async function handleUpload(context, items, storage) {
         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 storage.uploadStream(buffer, contentType);
-        const proxyUrl = `${webhookBaseUrl}/${result.fileKey}`;
+        const result = await MemoryStorage_1.MemoryStorage.upload(buffer, contentType, ttl);
+        // Replace the :fileKey placeholder with the actual file key
+        const proxyUrl = webhookUrl.replace(':fileKey', result.fileKey);
         returnData.push({
             json: {
                 fileKey: result.fileKey,
@@ -285,14 +235,14 @@ async function handleUpload(context, items, storage) {
     }
     return [returnData];
 }
-async function handleDelete(context, items, storage) {
+async function handleDelete(context, items) {
     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 storage.deleteFile(fileKey);
+        await MemoryStorage_1.MemoryStorage.delete(fileKey);
         returnData.push({
             json: {
                 success: true,
@@ -302,14 +252,6 @@ async function handleDelete(context, items, storage) {
     }
     return [returnData];
 }
-function buildWebhookUrl(context, webhookName, path) {
-    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) {
     if (!fileKey || typeof fileKey !== 'string') {
         return false;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "n8n-nodes-binary-to-url",
-  "version": "0.0.8",
-  "description": "n8n community node for binary file to public URL bridge with S3 storage",
+  "version": "0.0.10",
+  "description": "n8n community node for binary file to public URL bridge with in-memory storage",
   "keywords": [
     "n8n-community-node-package",
     "n8n",
     "binary",
     "file",
     "storage",
-    "s3",
+    "memory",
     "proxy",
     "webhook",
     "to-url"
@@ -39,9 +39,6 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "strict": true,
-    "credentials": [
-      "dist/credentials/S3Api.credentials.js"
-    ],
     "nodes": [
       "dist/nodes/BinaryToUrl/BinaryToUrl.node.js"
     ]

package/dist/credentials/S3Api.credentials.d.ts

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

package/dist/credentials/S3Api.credentials.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Api = void 0;
-class S3Api {
-    constructor() {
-        this.name = 's3Api';
-        this.displayName = 'S3';
-        this.icon = 'file:../icons/BinaryToUrl.svg';
-        this.documentationUrl = 'https://docs.aws.amazon.com/AmazonS3/latest/userguide/AccessCredentials.html';
-        this.properties = [
-            {
-                displayName: 'S3 Endpoint',
-                name: 'endpoint',
-                type: 'string',
-                default: '',
-                description: 'S3-compatible service endpoint (e.g., https://s3.amazonaws.com, https://minio.example.com)',
-            },
-            {
-                displayName: 'Region',
-                name: 'region',
-                type: 'string',
-                default: 'us-east-1',
-                description: 'AWS region or custom region for S3-compatible service',
-            },
-            {
-                displayName: 'Access Key ID',
-                name: 'accessKeyId',
-                type: 'string',
-                default: '',
-            },
-            {
-                displayName: 'Secret Access Key',
-                name: 'secretAccessKey',
-                type: 'string',
-                default: '',
-                typeOptions: {
-                    password: true,
-                },
-            },
-            {
-                displayName: 'Force Path Style',
-                name: 'forcePathStyle',
-                type: 'boolean',
-                default: false,
-                description: 'Use path-style addressing (required for MinIO, DigitalOcean Spaces, etc.)',
-            },
-        ];
-        this.test = {
-            request: {
-                baseURL: '={{$credentials.endpoint}}',
-                url: '=/',
-                method: 'GET',
-            },
-        };
-    }
-}
-exports.S3Api = S3Api;

package/dist/drivers/S3Storage.d.ts

@@ -1,35 +0,0 @@
-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 {
-    data: Buffer;
-    contentType: string;
-}
-export declare class S3Storage {
-    private config;
-    constructor(config: StorageConfig);
-    uploadStream(data: Buffer, contentType: string, metadata?: Record<string, string>): Promise<UploadResult>;
-    downloadStream(fileKey: string): Promise<DownloadResult>;
-    deleteFile(fileKey: string): Promise<void>;
-    private getEndpoint;
-    private generateAuthorization;
-    private getAmzDate;
-    private getDateStamp;
-    private getCanonicalHeaders;
-    private getSignedHeaders;
-    private sha256;
-    private hmac;
-    private getSigningKey;
-    private hmacSha256;
-    private generateFileKey;
-    private getExtensionFromMimeType;
-}

package/dist/drivers/S3Storage.js

@@ -1,298 +0,0 @@
-"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;
-    }
-    async uploadStream(data, contentType, metadata) {
-        const fileKey = this.generateFileKey(contentType);
-        const endpoint = this.getEndpoint();
-        const url = `${endpoint}/${this.config.bucket}/${fileKey}`;
-        const headers = {
-            'Content-Type': contentType,
-            'x-amz-content-sha256': 'UNSIGNED-PAYLOAD',
-        };
-        if (metadata) {
-            Object.entries(metadata).forEach(([key, value]) => {
-                headers[`x-amz-meta-${key}`] = value;
-            });
-        }
-        const authorization = await this.generateAuthorization('PUT', `/${this.config.bucket}/${fileKey}`, headers);
-        try {
-            const response = await fetch(url, {
-                method: 'PUT',
-                headers: {
-                    ...headers,
-                    Authorization: authorization,
-                },
-                body: data,
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`S3 upload failed: ${response.status} ${response.statusText} - ${errorText}`);
-            }
-            return {
-                fileKey,
-                contentType,
-            };
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw error;
-            }
-            throw new Error(`S3 upload failed: ${String(error)}`);
-        }
-    }
-    async downloadStream(fileKey) {
-        const endpoint = this.getEndpoint();
-        const url = `${endpoint}/${this.config.bucket}/${fileKey}`;
-        const authorization = await this.generateAuthorization('GET', `/${this.config.bucket}/${fileKey}`, {});
-        try {
-            const response = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    Authorization: authorization,
-                },
-            });
-            if (!response.ok) {
-                if (response.status === 404) {
-                    throw new Error(`File not found: ${fileKey}`);
-                }
-                if (response.status === 403) {
-                    throw new Error(`Access denied to bucket "${this.config.bucket}". Check your credentials`);
-                }
-                throw new Error(`S3 download failed: ${response.status} ${response.statusText}`);
-            }
-            const contentType = response.headers.get('content-type') || 'application/octet-stream';
-            const arrayBuffer = await response.arrayBuffer();
-            const data = Buffer.from(arrayBuffer);
-            return {
-                data,
-                contentType,
-            };
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw error;
-            }
-            throw new Error(`S3 download failed: ${String(error)}`);
-        }
-    }
-    async deleteFile(fileKey) {
-        const endpoint = this.getEndpoint();
-        const url = `${endpoint}/${this.config.bucket}/${fileKey}`;
-        const authorization = await this.generateAuthorization('DELETE', `/${this.config.bucket}/${fileKey}`, {});
-        try {
-            const response = await fetch(url, {
-                method: 'DELETE',
-                headers: {
-                    Authorization: authorization,
-                },
-            });
-            if (!response.ok && response.status !== 204) {
-                throw new Error(`S3 delete failed: ${response.status} ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                throw error;
-            }
-            throw new Error(`S3 delete failed: ${String(error)}`);
-        }
-    }
-    getEndpoint() {
-        if (this.config.endpoint) {
-            return this.config.endpoint;
-        }
-        if (this.config.forcePathStyle) {
-            return `https://s3.${this.config.region}.amazonaws.com`;
-        }
-        return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com`;
-    }
-    async generateAuthorization(method, path, headers) {
-        const now = new Date();
-        const amzDate = this.getAmzDate(now);
-        const dateStamp = this.getDateStamp(now);
-        // Canonical request
-        const canonicalHeaders = this.getCanonicalHeaders(headers);
-        const signedHeaders = this.getSignedHeaders(headers);
-        const payloadHash = 'UNSIGNED-PAYLOAD';
-        const canonicalRequest = [
-            method,
-            path,
-            '', // Query string
-            canonicalHeaders,
-            signedHeaders,
-            payloadHash,
-        ].join('\n');
-        const canonicalRequestHash = await this.sha256(canonicalRequest);
-        // String to sign
-        const credentialScope = `${dateStamp}/${this.config.region}/s3/aws4_request`;
-        const stringToSign = ['AWS4-HMAC-SHA256', amzDate, credentialScope, canonicalRequestHash].join('\n');
-        // Calculate signature
-        const signingKey = await this.getSigningKey(dateStamp);
-        const signature = await this.hmac(signingKey, stringToSign);
-        // Authorization header
-        return `AWS4-HMAC-SHA256 Credential=${this.config.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-    }
-    getAmzDate(date) {
-        return date
-            .toISOString()
-            .replace(/[:-]|.\d{3}/g, '')
-            .replace(/T/, 'T');
-    }
-    getDateStamp(date) {
-        return date.toISOString().substring(0, 10).replace(/-/g, '');
-    }
-    getCanonicalHeaders(headers) {
-        const canonicalHeaders = [];
-        const lowerCaseHeaders = {};
-        for (const [key, value] of Object.entries(headers)) {
-            lowerCaseHeaders[key.toLowerCase()] = value.trim();
-        }
-        for (const [key, value] of Object.entries(lowerCaseHeaders).sort()) {
-            canonicalHeaders.push(`${key}:${value}\n`);
-        }
-        return canonicalHeaders.join('');
-    }
-    getSignedHeaders(headers) {
-        const lowerCaseHeaders = Object.keys(headers).map((h) => h.toLowerCase());
-        return lowerCaseHeaders.sort().join(';');
-    }
-    async sha256(message) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(message);
-        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 cryptoInstance.subtle.importKey('raw', key, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-        const encoder = new TextEncoder();
-        const data = encoder.encode(message);
-        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('');
-    }
-    async getSigningKey(dateStamp) {
-        const kDate = await this.hmacSha256(`AWS4${this.config.secretAccessKey}`, dateStamp);
-        const kRegion = await this.hmacSha256(kDate, this.config.region);
-        const kService = await this.hmacSha256(kRegion, 's3');
-        const kSigning = await this.hmacSha256(kService, 'aws4_request');
-        return kSigning;
-    }
-    async hmacSha256(key, message) {
-        const keyBuffer = typeof key === 'string' ? Buffer.from(key) : key;
-        const encoder = new TextEncoder();
-        const data = encoder.encode(message);
-        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) {
-        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/index.d.ts

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

package/dist/index.js

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