@fachkraftfreund/n8n-nodes-supabase 1.2.7 → 1.2.8

package/dist/nodes/Supabase/Supabase.node.js

@@ -335,6 +335,23 @@ class Supabase {
                         },
                     },
                 },
+                {
+                    displayName: 'Match Column',
+                    name: 'matchColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Column used to match rows for updating (typically the primary key). Each input item must include this column in its data. Uses upsert internally, so rows will be created if no match is found.',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['update'],
+                        },
+                    },
+                },
                 {
                     displayName: 'Match Columns',
                     name: 'matchColumns',
@@ -431,7 +448,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['read', 'update', 'delete'],
+                            operation: ['read', 'delete'],
                             uiMode: ['simple'],
                         },
                     },
@@ -491,7 +508,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['read', 'update', 'delete'],
+                            operation: ['read', 'delete'],
                             uiMode: ['advanced'],
                         },
                     },
@@ -883,34 +900,51 @@ class Supabase {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid credentials: ${errorMessage}`);
         }
         const supabase = (0, supabaseClient_1.createSupabaseClient)(credentials);
-        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        if (resource === 'database' && ['create', 'upsert', 'update'].includes(operation)) {
             try {
-                const resource = this.getNodeParameter('resource', itemIndex);
-                const operation = this.getNodeParameter('operation', itemIndex);
-                let operationResults = [];
-                if (resource === 'database') {
-                    operationResults = await database_1.executeDatabaseOperation.call(this, supabase, operation, itemIndex);
-                }
-                else if (resource === 'storage') {
-                    operationResults = await storage_1.executeStorageOperation.call(this, supabase, operation, itemIndex);
-                }
-                else {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown resource: ${resource}`);
-                }
-                returnData.push(...operationResults);
+                const results = await database_1.executeBulkDatabaseOperation.call(this, supabase, operation, items.length);
+                returnData.push(...results);
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
                 if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            error: errorMessage,
-                            itemIndex,
-                        },
-                    });
-                    continue;
+                    returnData.push({ json: { error: errorMessage } });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
+                }
+            }
+        }
+        else {
+            for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                try {
+                    let operationResults = [];
+                    if (resource === 'database') {
+                        operationResults = await database_1.executeDatabaseOperation.call(this, supabase, operation, itemIndex);
+                    }
+                    else if (resource === 'storage') {
+                        operationResults = await storage_1.executeStorageOperation.call(this, supabase, operation, itemIndex);
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown resource: ${resource}`);
+                    }
+                    returnData.push(...operationResults);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                    if (this.continueOnFail()) {
+                        returnData.push({
+                            json: {
+                                error: errorMessage,
+                                itemIndex,
+                            },
+                        });
+                        continue;
+                    }
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex });
                 }
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, { itemIndex });
             }
         }
         return [returnData];

package/dist/nodes/Supabase/operations/database/index.d.ts

@@ -2,3 +2,4 @@ import { SupabaseClient } from '@supabase/supabase-js';
 import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
 import { DatabaseOperation } from '../../types';
 export declare function executeDatabaseOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: DatabaseOperation, itemIndex: number): Promise<INodeExecutionData[]>;
+export declare function executeBulkDatabaseOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: DatabaseOperation, itemCount: number): Promise<INodeExecutionData[]>;

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

@@ -1,26 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeDatabaseOperation = void 0;
+exports.executeBulkDatabaseOperation = exports.executeDatabaseOperation = void 0;
 const supabaseClient_1 = require("../../utils/supabaseClient");
 async function executeDatabaseOperation(supabase, operation, itemIndex) {
     const returnData = [];
     try {
         switch (operation) {
-            case 'create':
-                returnData.push(...await handleCreate.call(this, supabase, itemIndex));
-                break;
             case 'read':
                 returnData.push(...await handleRead.call(this, supabase, itemIndex));
                 break;
-            case 'update':
-                returnData.push(...await handleUpdate.call(this, supabase, itemIndex));
-                break;
             case 'delete':
                 returnData.push(...await handleDelete.call(this, supabase, itemIndex));
                 break;
-            case 'upsert':
-                returnData.push(...await handleUpsert.call(this, supabase, itemIndex));
-                break;
             case 'createTable':
                 returnData.push(...await handleCreateTable.call(this, supabase, itemIndex));
                 break;
@@ -55,56 +46,123 @@ async function executeDatabaseOperation(supabase, operation, itemIndex) {
     return returnData;
 }
 exports.executeDatabaseOperation = executeDatabaseOperation;
-async function handleCreate(supabase, itemIndex) {
-    const table = this.getNodeParameter('table', itemIndex);
-    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
-    (0, supabaseClient_1.validateTableName)(table);
-    let dataToInsert;
-    if (uiMode === 'advanced') {
-        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
-        try {
-            dataToInsert = JSON.parse(jsonData);
+function collectRowData(context, itemCount) {
+    const rows = [];
+    for (let i = 0; i < itemCount; i++) {
+        const uiMode = context.getNodeParameter('uiMode', i, 'simple');
+        let row;
+        if (uiMode === 'advanced') {
+            const jsonData = context.getNodeParameter('jsonData', i, '{}');
+            try {
+                row = JSON.parse(jsonData);
+            }
+            catch {
+                throw new Error(`Invalid JSON data at item ${i}`);
+            }
         }
-        catch {
-            throw new Error('Invalid JSON data provided');
+        else {
+            const columns = context.getNodeParameter('columns.column', i, []);
+            row = {};
+            for (const column of columns) {
+                if (column.name && column.value !== undefined) {
+                    row[column.name] = column.value;
+                }
+            }
         }
+        rows.push(row);
     }
-    else {
-        const columns = this.getNodeParameter('columns.column', itemIndex, []);
-        dataToInsert = {};
-        for (const column of columns) {
-            if (column.name && column.value !== undefined) {
-                dataToInsert[column.name] = column.value;
-            }
+    return rows;
+}
+async function executeBulkDatabaseOperation(supabase, operation, itemCount) {
+    try {
+        switch (operation) {
+            case 'create':
+                return await handleBulkCreate.call(this, supabase, itemCount);
+            case 'upsert':
+                return await handleBulkUpsert.call(this, supabase, itemCount);
+            case 'update':
+                return await handleBulkUpdate.call(this, supabase, itemCount);
+            default:
+                throw new Error(`Operation ${operation} does not support bulk mode`);
         }
     }
+    catch (error) {
+        throw new Error(`Database operation failed: ${(0, supabaseClient_1.formatSupabaseError)(error)}`);
+    }
+}
+exports.executeBulkDatabaseOperation = executeBulkDatabaseOperation;
+async function handleBulkCreate(supabase, itemCount) {
+    const table = this.getNodeParameter('table', 0);
+    (0, supabaseClient_1.validateTableName)(table);
+    const rows = collectRowData(this, itemCount);
     const { data, error } = await supabase
         .from(table)
-        .insert(dataToInsert)
+        .insert(rows)
         .select();
-    if (error) {
+    if (error)
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    if (Array.isArray(data)) {
+        return data.map((row) => ({ json: row }));
     }
     return [{ json: { data, operation: 'create', table } }];
 }
-async function handleRead(supabase, itemIndex) {
-    const table = this.getNodeParameter('table', itemIndex);
-    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+async function handleBulkUpsert(supabase, itemCount) {
+    const table = this.getNodeParameter('table', 0);
+    const onConflict = this.getNodeParameter('onConflict', 0, '');
     (0, supabaseClient_1.validateTableName)(table);
-    let query = supabase.from(table).select('*');
-    const returnFields = this.getNodeParameter('returnFields', itemIndex, '*');
-    if (returnFields && returnFields !== '*') {
-        query = supabase.from(table).select(returnFields);
+    const rows = collectRowData(this, itemCount);
+    const options = {};
+    if (onConflict)
+        options.onConflict = onConflict;
+    const { data, error } = await supabase
+        .from(table)
+        .upsert(rows, options)
+        .select();
+    if (error)
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    if (Array.isArray(data)) {
+        return data.map((row) => ({ json: row }));
     }
+    return [{ json: { data, operation: 'upsert', table } }];
+}
+async function handleBulkUpdate(supabase, itemCount) {
+    const table = this.getNodeParameter('table', 0);
+    const matchColumn = this.getNodeParameter('matchColumn', 0);
+    (0, supabaseClient_1.validateTableName)(table);
+    if (!matchColumn) {
+        throw new Error('Match Column is required for update operations');
+    }
+    const rows = collectRowData(this, itemCount);
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        if (!row || row[matchColumn] === undefined) {
+            throw new Error(`Item ${i} is missing the match column "${matchColumn}"`);
+        }
+    }
+    const { data, error } = await supabase
+        .from(table)
+        .upsert(rows, { onConflict: matchColumn })
+        .select();
+    if (error)
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    if (Array.isArray(data)) {
+        return data.map((row) => ({ json: row }));
+    }
+    return [{ json: { data, operation: 'update', table } }];
+}
+function buildReadQuery(context, supabase, table, returnFields, itemIndex, options) {
+    const selectFields = returnFields && returnFields !== '*' ? returnFields : '*';
+    let query = supabase.from(table).select(selectFields, options);
+    const uiMode = context.getNodeParameter('uiMode', itemIndex, 'simple');
     if (uiMode === 'simple') {
-        const filters = this.getNodeParameter('filters.filter', itemIndex, []);
+        const filters = context.getNodeParameter('filters.filter', itemIndex, []);
         for (const filter of filters) {
             const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
             query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
         }
     }
     else {
-        const advancedFilters = this.getNodeParameter('advancedFilters', itemIndex, '');
+        const advancedFilters = context.getNodeParameter('advancedFilters', itemIndex, '');
         if (advancedFilters) {
             try {
                 const filters = JSON.parse(advancedFilters);
@@ -123,10 +181,16 @@ async function handleRead(supabase, itemIndex) {
             }
         }
     }
-    const sort = this.getNodeParameter('sort.sortField', itemIndex, []);
+    const sort = context.getNodeParameter('sort.sortField', itemIndex, []);
     for (const sortField of sort) {
         query = query.order(sortField.column, { ascending: sortField.ascending });
     }
+    return query;
+}
+async function handleRead(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    (0, supabaseClient_1.validateTableName)(table);
+    const returnFields = this.getNodeParameter('returnFields', itemIndex, '*');
     const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
     const returnData = [];
     if (returnAll) {
@@ -134,42 +198,8 @@ async function handleRead(supabase, itemIndex) {
         let offset = 0;
         let hasMore = true;
         while (hasMore) {
-            let batchQuery = supabase.from(table).select(returnFields && returnFields !== '*' ? returnFields : '*', { count: 'exact' });
-            const batchFilterMode = this.getNodeParameter('filterMode', itemIndex, 'simple');
-            if (batchFilterMode === 'simple') {
-                const batchFilters = this.getNodeParameter('filters.conditions', itemIndex, []);
-                for (const filter of batchFilters) {
-                    if (filter.column && filter.value !== undefined) {
-                        batchQuery = batchQuery.eq(filter.column, filter.value);
-                    }
-                }
-            }
-            else {
-                const batchAdvancedFilters = this.getNodeParameter('advancedFilters', itemIndex, '');
-                if (batchAdvancedFilters) {
-                    try {
-                        const parsed = JSON.parse(batchAdvancedFilters);
-                        for (const condition of parsed) {
-                            const { column, operator, value } = condition;
-                            if (operator) {
-                                batchQuery = batchQuery.filter(column, (0, supabaseClient_1.convertFilterOperator)(operator), (0, supabaseClient_1.normalizeFilterValue)(operator, value));
-                            }
-                            else {
-                                batchQuery = batchQuery.eq(column, condition);
-                            }
-                        }
-                    }
-                    catch {
-                        throw new Error('Invalid advanced filters JSON');
-                    }
-                }
-            }
-            const batchSort = this.getNodeParameter('sort.sortField', itemIndex, []);
-            for (const sortField of batchSort) {
-                batchQuery = batchQuery.order(sortField.column, { ascending: sortField.ascending });
-            }
-            batchQuery = batchQuery.range(offset, offset + batchSize - 1);
-            const { data: batchData, error: batchError } = await batchQuery;
+            const batchQuery = buildReadQuery(this, supabase, table, returnFields, itemIndex, { count: 'exact' });
+            const { data: batchData, error: batchError } = await batchQuery.range(offset, offset + batchSize - 1);
             if (batchError) {
                 throw new Error((0, supabaseClient_1.formatSupabaseError)(batchError));
             }
@@ -188,6 +218,7 @@ async function handleRead(supabase, itemIndex) {
     else {
         const limit = this.getNodeParameter('limit', itemIndex, undefined);
         const offset = this.getNodeParameter('offset', itemIndex, undefined);
+        let query = buildReadQuery(this, supabase, table, returnFields, itemIndex);
         if (limit !== undefined) {
             query = query.limit(limit);
         }
@@ -217,41 +248,6 @@ async function handleRead(supabase, itemIndex) {
     }
     return returnData;
 }
-async function handleUpdate(supabase, itemIndex) {
-    const table = this.getNodeParameter('table', itemIndex);
-    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
-    (0, supabaseClient_1.validateTableName)(table);
-    let dataToUpdate;
-    if (uiMode === 'advanced') {
-        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
-        try {
-            dataToUpdate = JSON.parse(jsonData);
-        }
-        catch {
-            throw new Error('Invalid JSON data provided');
-        }
-    }
-    else {
-        const columns = this.getNodeParameter('columns.column', itemIndex, []);
-        dataToUpdate = {};
-        for (const column of columns) {
-            if (column.name && column.value !== undefined) {
-                dataToUpdate[column.name] = column.value;
-            }
-        }
-    }
-    let query = supabase.from(table).update(dataToUpdate);
-    const filters = this.getNodeParameter('filters.filter', itemIndex, []);
-    for (const filter of filters) {
-        const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
-        query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
-    }
-    const { data, error } = await query.select();
-    if (error) {
-        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
-    }
-    return [{ json: { data, operation: 'update', table, updated: (data === null || data === void 0 ? void 0 : data.length) || 0 } }];
-}
 async function handleDelete(supabase, itemIndex) {
     const table = this.getNodeParameter('table', itemIndex);
     (0, supabaseClient_1.validateTableName)(table);
@@ -270,43 +266,6 @@ async function handleDelete(supabase, itemIndex) {
     }
     return [{ json: { data, operation: 'delete', table, deleted: (data === null || data === void 0 ? void 0 : data.length) || 0 } }];
 }
-async function handleUpsert(supabase, itemIndex) {
-    const table = this.getNodeParameter('table', itemIndex);
-    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
-    const onConflict = this.getNodeParameter('onConflict', itemIndex, '');
-    (0, supabaseClient_1.validateTableName)(table);
-    let dataToUpsert;
-    if (uiMode === 'advanced') {
-        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
-        try {
-            dataToUpsert = JSON.parse(jsonData);
-        }
-        catch {
-            throw new Error('Invalid JSON data provided');
-        }
-    }
-    else {
-        const columns = this.getNodeParameter('columns.column', itemIndex, []);
-        dataToUpsert = {};
-        for (const column of columns) {
-            if (column.name && column.value !== undefined) {
-                dataToUpsert[column.name] = column.value;
-            }
-        }
-    }
-    const options = {};
-    if (onConflict) {
-        options.onConflict = onConflict;
-    }
-    const { data, error } = await supabase
-        .from(table)
-        .upsert(dataToUpsert, options)
-        .select();
-    if (error) {
-        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
-    }
-    return [{ json: { data, operation: 'upsert', table } }];
-}
 async function handleCreateTable(supabase, itemIndex) {
     const tableName = this.getNodeParameter('tableName', itemIndex);
     const columns = this.getNodeParameter('columnDefinitions.column', itemIndex, []);
@@ -334,7 +293,7 @@ async function handleCreateTable(supabase, itemIndex) {
         columnDefs.push(columnDef);
     }
     sql += columnDefs.join(', ') + ')';
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }
@@ -345,7 +304,7 @@ async function handleDropTable(supabase, itemIndex) {
     const cascade = this.getNodeParameter('cascade', itemIndex, false);
     (0, supabaseClient_1.validateTableName)(tableName);
     const sql = `DROP TABLE "${tableName}"${cascade ? ' CASCADE' : ''}`;
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }
@@ -363,7 +322,7 @@ async function handleAddColumn(supabase, itemIndex) {
     if (columnDefinition.defaultValue) {
         sql += ` DEFAULT ${columnDefinition.defaultValue}`;
     }
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }
@@ -376,7 +335,7 @@ async function handleDropColumn(supabase, itemIndex) {
     (0, supabaseClient_1.validateTableName)(tableName);
     (0, supabaseClient_1.validateColumnName)(columnName);
     const sql = `ALTER TABLE "${tableName}" DROP COLUMN "${columnName}"${cascade ? ' CASCADE' : ''}`;
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }
@@ -393,7 +352,7 @@ async function handleCreateIndex(supabase, itemIndex) {
     const method = indexDefinition.method ? ` USING ${indexDefinition.method}` : '';
     const columnList = indexDefinition.columns.map(col => `"${col}"`).join(', ');
     const sql = `CREATE ${uniqueKeyword}INDEX "${indexDefinition.name}" ON "${tableName}"${method} (${columnList})`;
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }
@@ -406,7 +365,7 @@ async function handleDropIndex(supabase, itemIndex) {
         throw new Error('Index name is required');
     }
     const sql = `DROP INDEX "${indexName}"${cascade ? ' CASCADE' : ''}`;
-    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    const { error } = await supabase.rpc('exec_sql', { sql });
     if (error) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fachkraftfreund/n8n-nodes-supabase",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "Comprehensive n8n community node for Supabase with database and storage operations",
   "keywords": [
     "n8n-community-node-package",