n8n-nodes-binary-to-url 0.0.1 → 0.0.3

package/dist/drivers/SupabaseStorage.js

@@ -1,206 +0,0 @@
-"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;