@fachkraftfreund/n8n-nodes-supabase 1.2.0

package/dist/nodes/Supabase/operations/storage/index.js

@@ -0,0 +1,474 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeStorageOperation = void 0;
+const supabaseClient_1 = require("../../utils/supabaseClient");
+const path = __importStar(require("path"));
+const mime_types_1 = require("mime-types");
+async function executeStorageOperation(supabase, operation, itemIndex) {
+    const returnData = [];
+    try {
+        switch (operation) {
+            case 'uploadFile':
+                returnData.push(...await handleUploadFile.call(this, supabase, itemIndex));
+                break;
+            case 'downloadFile':
+                returnData.push(...await handleDownloadFile.call(this, supabase, itemIndex));
+                break;
+            case 'listFiles':
+                returnData.push(...await handleListFiles.call(this, supabase, itemIndex));
+                break;
+            case 'deleteFile':
+                returnData.push(...await handleDeleteFile.call(this, supabase, itemIndex));
+                break;
+            case 'moveFile':
+                returnData.push(...await handleMoveFile.call(this, supabase, itemIndex));
+                break;
+            case 'copyFile':
+                returnData.push(...await handleCopyFile.call(this, supabase, itemIndex));
+                break;
+            case 'createBucket':
+                returnData.push(...await handleCreateBucket.call(this, supabase, itemIndex));
+                break;
+            case 'deleteBucket':
+                returnData.push(...await handleDeleteBucket.call(this, supabase, itemIndex));
+                break;
+            case 'listBuckets':
+                returnData.push(...await handleListBuckets.call(this, supabase, itemIndex));
+                break;
+            case 'getBucketDetails':
+                returnData.push(...await handleGetBucketDetails.call(this, supabase, itemIndex));
+                break;
+            case 'getFileInfo':
+                returnData.push(...await handleGetFileInfo.call(this, supabase, itemIndex));
+                break;
+            case 'generateSignedUrl':
+                returnData.push(...await handleGenerateSignedUrl.call(this, supabase, itemIndex));
+                break;
+            default:
+                throw new Error(`Unknown storage operation: ${operation}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Storage operation failed: ${(0, supabaseClient_1.formatSupabaseError)(error)}`);
+    }
+    return returnData;
+}
+exports.executeStorageOperation = executeStorageOperation;
+async function handleUploadFile(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const fileName = this.getNodeParameter('fileName', itemIndex);
+    const inputType = this.getNodeParameter('inputType', itemIndex, 'binary');
+    if (!bucket || !fileName) {
+        throw new Error('Bucket name and file name are required');
+    }
+    let fileData;
+    let contentType;
+    if (inputType === 'binary') {
+        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex, 'data');
+        const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+        fileData = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+        contentType = binaryData.mimeType;
+    }
+    else if (inputType === 'url') {
+        const fileUrl = this.getNodeParameter('fileUrl', itemIndex);
+        const response = await this.helpers.httpRequest({
+            method: 'GET',
+            url: fileUrl,
+            encoding: 'arraybuffer',
+        });
+        fileData = response.body;
+        contentType = response.headers['content-type'] || (0, mime_types_1.lookup)(fileName) || 'application/octet-stream';
+    }
+    else {
+        const textContent = this.getNodeParameter('textContent', itemIndex);
+        fileData = Buffer.from(textContent, 'utf-8');
+        contentType = 'text/plain';
+    }
+    const options = {};
+    const cacheControl = this.getNodeParameter('cacheControl', itemIndex, '');
+    const upsert = this.getNodeParameter('upsert', itemIndex, false);
+    const customContentType = this.getNodeParameter('contentType', itemIndex, '');
+    if (cacheControl)
+        options.cacheControl = cacheControl;
+    if (upsert)
+        options.upsert = upsert;
+    if (customContentType)
+        options.contentType = customContentType;
+    else if (contentType)
+        options.contentType = contentType;
+    const metadata = this.getNodeParameter('metadata', itemIndex, '');
+    if (metadata) {
+        try {
+            options.metadata = JSON.parse(metadata);
+        }
+        catch {
+            throw new Error('Invalid metadata JSON');
+        }
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .upload(fileName, fileData, options);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'uploadFile',
+                bucket,
+                fileName,
+                path: data === null || data === void 0 ? void 0 : data.path,
+                id: data === null || data === void 0 ? void 0 : data.id,
+                fullPath: data === null || data === void 0 ? void 0 : data.fullPath,
+                success: true,
+            },
+        }];
+}
+async function handleDownloadFile(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const filePath = this.getNodeParameter('filePath', itemIndex);
+    const outputFormat = this.getNodeParameter('outputFormat', itemIndex, 'binary');
+    if (!bucket || !filePath) {
+        throw new Error('Bucket name and file path are required');
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .download(filePath);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    if (!data) {
+        throw new Error('No file data received');
+    }
+    if (outputFormat === 'binary') {
+        const buffer = Buffer.from(await data.arrayBuffer());
+        const fileName = path.basename(filePath);
+        const mimeType = data.type || (0, mime_types_1.lookup)(fileName) || 'application/octet-stream';
+        const binaryData = {
+            data: buffer.toString('base64'),
+            mimeType,
+            fileName,
+        };
+        return [{
+                json: {
+                    operation: 'downloadFile',
+                    bucket,
+                    filePath,
+                    fileName,
+                    size: buffer.length,
+                    mimeType,
+                },
+                binary: {
+                    data: binaryData,
+                },
+            }];
+    }
+    else {
+        const text = await data.text();
+        return [{
+                json: {
+                    operation: 'downloadFile',
+                    bucket,
+                    filePath,
+                    content: text,
+                    size: data.size,
+                    type: data.type,
+                },
+            }];
+    }
+}
+async function handleListFiles(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const folderPath = this.getNodeParameter('folderPath', itemIndex, '');
+    if (!bucket) {
+        throw new Error('Bucket name is required');
+    }
+    const limit = this.getNodeParameter('limit', itemIndex, undefined);
+    const offset = this.getNodeParameter('offset', itemIndex, undefined);
+    const search = this.getNodeParameter('search', itemIndex, '');
+    const sortColumn = this.getNodeParameter('sortColumn', itemIndex, 'name');
+    const sortOrder = this.getNodeParameter('sortOrder', itemIndex, 'asc');
+    const options = {};
+    if (limit !== undefined)
+        options.limit = limit;
+    if (offset !== undefined)
+        options.offset = offset;
+    if (search)
+        options.search = search;
+    if (sortColumn && sortOrder) {
+        options.sortBy = { column: sortColumn, order: sortOrder };
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .list(folderPath, options);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    const returnData = [];
+    if (Array.isArray(data)) {
+        for (const file of data) {
+            returnData.push({
+                json: {
+                    ...file,
+                    bucket,
+                    folderPath,
+                },
+            });
+        }
+    }
+    if (returnData.length === 0) {
+        returnData.push({
+            json: {
+                operation: 'listFiles',
+                bucket,
+                folderPath,
+                files: [],
+                count: 0,
+                message: 'No files found',
+            },
+        });
+    }
+    return returnData;
+}
+async function handleDeleteFile(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const filePaths = this.getNodeParameter('filePaths', itemIndex);
+    if (!bucket || !filePaths) {
+        throw new Error('Bucket name and file path(s) are required');
+    }
+    const pathsArray = Array.isArray(filePaths) ? filePaths : [filePaths];
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .remove(pathsArray);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'deleteFile',
+                bucket,
+                deletedFiles: pathsArray,
+                result: data,
+                success: true,
+            },
+        }];
+}
+async function handleMoveFile(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const fromPath = this.getNodeParameter('fromPath', itemIndex);
+    const toPath = this.getNodeParameter('toPath', itemIndex);
+    if (!bucket || !fromPath || !toPath) {
+        throw new Error('Bucket name, source path, and destination path are required');
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .move(fromPath, toPath);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'moveFile',
+                bucket,
+                fromPath,
+                toPath,
+                result: data,
+                success: true,
+            },
+        }];
+}
+async function handleCopyFile(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const fromPath = this.getNodeParameter('fromPath', itemIndex);
+    const toPath = this.getNodeParameter('toPath', itemIndex);
+    if (!bucket || !fromPath || !toPath) {
+        throw new Error('Bucket name, source path, and destination path are required');
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .copy(fromPath, toPath);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'copyFile',
+                bucket,
+                fromPath,
+                toPath,
+                result: data,
+                success: true,
+            },
+        }];
+}
+async function handleCreateBucket(supabase, itemIndex) {
+    const bucketName = this.getNodeParameter('bucketName', itemIndex);
+    const isPublic = this.getNodeParameter('isPublic', itemIndex, false);
+    const fileSizeLimit = this.getNodeParameter('fileSizeLimit', itemIndex, undefined);
+    const allowedMimeTypes = this.getNodeParameter('allowedMimeTypes', itemIndex, '');
+    if (!bucketName) {
+        throw new Error('Bucket name is required');
+    }
+    const options = {
+        public: isPublic,
+    };
+    if (fileSizeLimit !== undefined) {
+        options.fileSizeLimit = fileSizeLimit;
+    }
+    if (allowedMimeTypes) {
+        try {
+            options.allowedMimeTypes = allowedMimeTypes.split(',').map(type => type.trim());
+        }
+        catch {
+            throw new Error('Invalid allowed MIME types format');
+        }
+    }
+    const { data, error } = await supabase.storage.createBucket(bucketName, options);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'createBucket',
+                bucketName,
+                options,
+                result: data,
+                success: true,
+            },
+        }];
+}
+async function handleDeleteBucket(supabase, itemIndex) {
+    const bucketName = this.getNodeParameter('bucketName', itemIndex);
+    if (!bucketName) {
+        throw new Error('Bucket name is required');
+    }
+    const { data, error } = await supabase.storage.deleteBucket(bucketName);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'deleteBucket',
+                bucketName,
+                result: data,
+                success: true,
+            },
+        }];
+}
+async function handleListBuckets(supabase, itemIndex) {
+    const { data, error } = await supabase.storage.listBuckets();
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    const returnData = [];
+    if (Array.isArray(data)) {
+        for (const bucket of data) {
+            returnData.push({ json: bucket });
+        }
+    }
+    if (returnData.length === 0) {
+        returnData.push({
+            json: {
+                operation: 'listBuckets',
+                buckets: [],
+                count: 0,
+                message: 'No buckets found',
+            },
+        });
+    }
+    return returnData;
+}
+async function handleGetBucketDetails(supabase, itemIndex) {
+    const bucketName = this.getNodeParameter('bucketName', itemIndex);
+    if (!bucketName) {
+        throw new Error('Bucket name is required');
+    }
+    const { data, error } = await supabase.storage.getBucket(bucketName);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'getBucketDetails',
+                bucketName,
+                ...data,
+            },
+        }];
+}
+async function handleGetFileInfo(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const filePath = this.getNodeParameter('filePath', itemIndex);
+    if (!bucket || !filePath) {
+        throw new Error('Bucket name and file path are required');
+    }
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .list(path.dirname(filePath), {
+        search: path.basename(filePath),
+    });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    const fileInfo = data === null || data === void 0 ? void 0 : data.find(file => file.name === path.basename(filePath));
+    if (!fileInfo) {
+        throw new Error('File not found');
+    }
+    return [{
+            json: {
+                operation: 'getFileInfo',
+                bucket,
+                filePath,
+                ...fileInfo,
+            },
+        }];
+}
+async function handleGenerateSignedUrl(supabase, itemIndex) {
+    const bucket = this.getNodeParameter('bucket', itemIndex);
+    const filePath = this.getNodeParameter('filePath', itemIndex);
+    const expiresIn = this.getNodeParameter('expiresIn', itemIndex, 3600);
+    const download = this.getNodeParameter('download', itemIndex, false);
+    if (!bucket || !filePath) {
+        throw new Error('Bucket name and file path are required');
+    }
+    const options = { download };
+    const { data, error } = await supabase.storage
+        .from(bucket)
+        .createSignedUrl(filePath, expiresIn, options);
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{
+            json: {
+                operation: 'generateSignedUrl',
+                bucket,
+                filePath,
+                expiresIn,
+                download,
+                signedUrl: data === null || data === void 0 ? void 0 : data.signedUrl,
+                ...(data && 'path' in data ? { path: data.path } : {}),
+                ...(data && 'token' in data ? { token: data.token } : {}),
+            },
+        }];
+}

package/dist/nodes/Supabase/types/index.d.ts

@@ -0,0 +1,107 @@
+export interface ISupabaseCredentials {
+    host: string;
+    serviceKey: string;
+    additionalOptions?: {
+        schema?: string;
+    };
+}
+export interface IRowFilter {
+    column: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd';
+    value: string | number | boolean | null;
+}
+export interface IRowSort {
+    column: string;
+    ascending: boolean;
+}
+export interface IColumnDefinition {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    defaultValue?: string;
+    primaryKey?: boolean;
+    unique?: boolean;
+}
+export interface IIndexDefinition {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+    method?: 'btree' | 'hash' | 'gist' | 'gin';
+}
+export interface IStorageFile {
+    name: string;
+    id?: string;
+    updated_at?: string;
+    created_at?: string;
+    last_accessed_at?: string;
+    metadata?: Record<string, any>;
+}
+export interface IStorageBucket {
+    id: string;
+    name: string;
+    owner?: string;
+    public?: boolean;
+    file_size_limit?: number;
+    allowed_mime_types?: string[];
+    created_at?: string;
+    updated_at?: string;
+}
+export interface IFileUploadOptions {
+    cacheControl?: string;
+    contentType?: string;
+    upsert?: boolean;
+    metadata?: Record<string, any>;
+}
+export interface IFileListOptions {
+    limit?: number;
+    offset?: number;
+    sortBy?: {
+        column: 'name' | 'id' | 'updated_at' | 'created_at' | 'last_accessed_at';
+        order: 'asc' | 'desc';
+    };
+    search?: string;
+}
+export interface ISupabaseResponse<T = any> {
+    data: T | null;
+    error: any;
+    count?: number;
+    status?: number;
+    statusText?: string;
+}
+export interface ISupabaseStorageResponse<T = any> {
+    data: T | null;
+    error: {
+        message: string;
+        statusCode?: string;
+    } | null;
+}
+export type DatabaseOperation = 'create' | 'read' | 'update' | 'delete' | 'upsert' | 'createTable' | 'dropTable' | 'addColumn' | 'dropColumn' | 'createIndex' | 'dropIndex' | 'customQuery';
+export type StorageOperation = 'uploadFile' | 'downloadFile' | 'listFiles' | 'deleteFile' | 'moveFile' | 'copyFile' | 'createBucket' | 'deleteBucket' | 'listBuckets' | 'getBucketDetails' | 'getFileInfo' | 'generateSignedUrl';
+export type SupabaseResource = 'database' | 'storage';
+export interface ISupabaseNodeParameters {
+    resource: SupabaseResource;
+    operation: DatabaseOperation | StorageOperation;
+    table?: string;
+    columns?: string;
+    filters?: IRowFilter[];
+    sort?: IRowSort[];
+    limit?: number;
+    offset?: number;
+    returnFields?: string;
+    tableName?: string;
+    columnDefinitions?: IColumnDefinition[];
+    indexDefinition?: IIndexDefinition;
+    customSql?: string;
+    bucket?: string;
+    fileName?: string;
+    filePath?: string;
+    fileContent?: string;
+    fileOptions?: IFileUploadOptions;
+    listOptions?: IFileListOptions;
+    signedUrlOptions?: {
+        expiresIn: number;
+        download?: boolean;
+    };
+    uiMode?: 'simple' | 'advanced';
+    additionalOptions?: Record<string, any>;
+}

package/dist/nodes/Supabase/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/Supabase/utils/supabaseClient.d.ts

@@ -0,0 +1,13 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { ISupabaseCredentials } from '../types';
+export declare function createSupabaseClient(credentials: ISupabaseCredentials): SupabaseClient;
+export declare function validateCredentials(credentials: ISupabaseCredentials): void;
+export declare function getStorageUrl(projectUrl: string): string;
+export declare function getDatabaseUrl(projectUrl: string): string;
+export declare function formatSupabaseError(error: any): string;
+export declare function isAuthError(error: any): boolean;
+export declare function isNetworkError(error: any): boolean;
+export declare function sanitizeColumnName(columnName: string): string;
+export declare function validateTableName(tableName: string): void;
+export declare function validateColumnName(columnName: string): void;
+export declare function convertFilterOperator(operator: string): string;