@fachkraftfreund/n8n-nodes-supabase 1.2.7 → 1.2.9

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'],
                         },
                     },
@@ -874,6 +891,12 @@ class Supabase {
     async execute() {
         const items = this.getInputData();
         const returnData = [];
+        const firstItem = items[0];
+        if (items.length === 1 &&
+            (firstItem === null || firstItem === void 0 ? void 0 : firstItem.json) &&
+            Object.keys(firstItem.json).length === 0) {
+            return [[{ json: {} }]];
+        }
         const credentials = await this.getCredentials('supabaseExtendedApi');
         try {
             (0, supabaseClient_1.validateCredentials)(credentials);
@@ -883,34 +906,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/SupabaseTrigger.node.d.ts

@@ -0,0 +1,11 @@
+import { ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription, IPollFunctions } from 'n8n-workflow';
+export declare class SupabaseTrigger implements INodeType {
+    description: INodeTypeDescription;
+    poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+    methods: {
+        loadOptions: {
+            getTables(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getColumns(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+}

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

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseTrigger = void 0;
+const supabaseClient_1 = require("./utils/supabaseClient");
+class SupabaseTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Supabase Trigger',
+            name: 'supabaseExtendedTrigger',
+            icon: 'file:icons/supabase.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Triggers when rows are created or updated in a Supabase table',
+            polling: true,
+            defaults: {
+                name: 'Supabase Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'supabaseExtendedApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Table',
+                    name: 'table',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getTables',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Table to watch for changes',
+                },
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Row Created',
+                            value: 'rowCreated',
+                            description: 'Trigger when new rows are inserted',
+                        },
+                        {
+                            name: 'Row Updated',
+                            value: 'rowUpdated',
+                            description: 'Trigger when existing rows are updated',
+                        },
+                        {
+                            name: 'Row Created or Updated',
+                            value: 'rowCreatedOrUpdated',
+                            description: 'Trigger on both inserts and updates',
+                        },
+                    ],
+                    default: 'rowCreated',
+                },
+                {
+                    displayName: 'Timestamp Column',
+                    name: 'timestampColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Column that tracks when the row was created or last updated',
+                    displayOptions: {
+                        show: {
+                            event: ['rowCreated', 'rowUpdated'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Created At Column',
+                    name: 'createdAtColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Column that stores row creation time',
+                    displayOptions: {
+                        show: {
+                            event: ['rowCreatedOrUpdated'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Updated At Column',
+                    name: 'updatedAtColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Column that stores row last-update time',
+                    displayOptions: {
+                        show: {
+                            event: ['rowCreatedOrUpdated'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Key Column',
+                    name: 'keyColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Unique identifier column (e.g. id) used for deduplication and field-change tracking',
+                },
+                {
+                    displayName: 'Watched Fields',
+                    name: 'watchedFields',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    default: [],
+                    description: 'Only trigger when these specific fields change. Leave empty to trigger on any change.',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getTables() {
+                    const credentials = await this.getCredentials('supabaseExtendedApi');
+                    (0, supabaseClient_1.validateCredentials)(credentials);
+                    const host = credentials.host.replace(/\/$/, '');
+                    try {
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${host}/rest/v1/`,
+                            headers: {
+                                apikey: credentials.serviceKey,
+                                Authorization: `Bearer ${credentials.serviceKey}`,
+                            },
+                            json: true,
+                        });
+                        const definitions = response.definitions || {};
+                        const tables = Object.keys(definitions).sort();
+                        if (tables.length === 0) {
+                            return [{ name: 'No tables found', value: '', description: 'No tables are exposed via the REST API' }];
+                        }
+                        return tables.map((t) => ({ name: t, value: t }));
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : 'Unknown error';
+                        return [{ name: `Error: ${msg}`, value: '', description: 'Failed to load tables. Check your credentials.' }];
+                    }
+                },
+                async getColumns() {
+                    const credentials = await this.getCredentials('supabaseExtendedApi');
+                    (0, supabaseClient_1.validateCredentials)(credentials);
+                    const table = this.getCurrentNodeParameter('table');
+                    if (!table) {
+                        return [{ name: 'Select a table first', value: '', description: 'Choose a table to load its columns' }];
+                    }
+                    const host = credentials.host.replace(/\/$/, '');
+                    try {
+                        const response = await this.helpers.request({
+                            method: 'GET',
+                            url: `${host}/rest/v1/`,
+                            headers: {
+                                apikey: credentials.serviceKey,
+                                Authorization: `Bearer ${credentials.serviceKey}`,
+                            },
+                            json: true,
+                        });
+                        const definitions = response.definitions || {};
+                        const tableSchema = definitions[table];
+                        if (!(tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.properties)) {
+                            return [{ name: 'No columns found', value: '', description: `Table "${table}" not found or has no columns` }];
+                        }
+                        return Object.keys(tableSchema.properties).sort().map((col) => {
+                            const colDef = tableSchema.properties[col];
+                            const typeLabel = colDef.format ? `${colDef.type} (${colDef.format})` : colDef.type;
+                            return { name: col, value: col, description: typeLabel };
+                        });
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : 'Unknown error';
+                        return [{ name: `Error: ${msg}`, value: '', description: 'Failed to load columns. Check your credentials.' }];
+                    }
+                },
+            },
+        };
+    }
+    async poll() {
+        const credentials = await this.getCredentials('supabaseExtendedApi');
+        (0, supabaseClient_1.validateCredentials)(credentials);
+        const supabase = (0, supabaseClient_1.createSupabaseClient)(credentials);
+        const table = this.getNodeParameter('table');
+        const event = this.getNodeParameter('event');
+        const keyColumn = this.getNodeParameter('keyColumn');
+        const watchedFields = this.getNodeParameter('watchedFields', []);
+        const staticData = this.getWorkflowStaticData('node');
+        if (!staticData.lastTimestamp) {
+            if (this.getMode() === 'manual') {
+                const lookback = new Date();
+                lookback.setHours(lookback.getHours() - 24);
+                staticData.lastTimestamp = lookback.toISOString();
+            }
+            else {
+                staticData.lastTimestamp = new Date().toISOString();
+                staticData.fieldStates = {};
+                return null;
+            }
+        }
+        const lastTimestamp = staticData.lastTimestamp;
+        let query = supabase.from(table).select('*');
+        if (event === 'rowCreatedOrUpdated') {
+            const createdAtCol = this.getNodeParameter('createdAtColumn');
+            const updatedAtCol = this.getNodeParameter('updatedAtColumn');
+            query = query.or(`${createdAtCol}.gt.${lastTimestamp},${updatedAtCol}.gt.${lastTimestamp}`);
+        }
+        else {
+            const timestampCol = this.getNodeParameter('timestampColumn');
+            query = query.gt(timestampCol, lastTimestamp);
+        }
+        const orderCol = event === 'rowCreatedOrUpdated'
+            ? this.getNodeParameter('updatedAtColumn')
+            : this.getNodeParameter('timestampColumn');
+        query = query.order(orderCol, { ascending: true }).limit(1000);
+        const { data, error } = await query;
+        if (error) {
+            throw new Error(`Supabase trigger error: ${error.message}`);
+        }
+        if (!data || data.length === 0) {
+            return null;
+        }
+        const seen = new Set();
+        const uniqueRows = [];
+        for (const row of data) {
+            const key = String(row[keyColumn]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                uniqueRows.push(row);
+            }
+        }
+        let maxTimestamp = lastTimestamp;
+        for (const row of uniqueRows) {
+            if (event === 'rowCreatedOrUpdated') {
+                const createdAtCol = this.getNodeParameter('createdAtColumn');
+                const updatedAtCol = this.getNodeParameter('updatedAtColumn');
+                const c = row[createdAtCol] || '';
+                const u = row[updatedAtCol] || '';
+                if (c > maxTimestamp)
+                    maxTimestamp = c;
+                if (u > maxTimestamp)
+                    maxTimestamp = u;
+            }
+            else {
+                const timestampCol = this.getNodeParameter('timestampColumn');
+                const ts = row[timestampCol] || '';
+                if (ts > maxTimestamp)
+                    maxTimestamp = ts;
+            }
+        }
+        staticData.lastTimestamp = maxTimestamp;
+        let resultRows = uniqueRows;
+        if (watchedFields.length > 0) {
+            const fieldStates = (staticData.fieldStates || {});
+            const changedRows = [];
+            for (const row of uniqueRows) {
+                const rowKey = String(row[keyColumn]);
+                const prevState = fieldStates[rowKey];
+                const currentState = {};
+                for (const field of watchedFields) {
+                    currentState[field] = row[field];
+                }
+                if (!prevState) {
+                    const changed = { ...row, _changedFields: watchedFields };
+                    changedRows.push(changed);
+                }
+                else {
+                    const changed = watchedFields.filter((f) => JSON.stringify(prevState[f]) !== JSON.stringify(currentState[f]));
+                    if (changed.length > 0) {
+                        changedRows.push({ ...row, _changedFields: changed });
+                    }
+                }
+                fieldStates[rowKey] = currentState;
+            }
+            const keys = Object.keys(fieldStates);
+            if (keys.length > 10000) {
+                const excess = keys.length - 10000;
+                for (let i = 0; i < excess; i++) {
+                    const key = keys[i];
+                    if (key !== undefined) {
+                        delete fieldStates[key];
+                    }
+                }
+            }
+            staticData.fieldStates = fieldStates;
+            resultRows = changedRows;
+        }
+        if (resultRows.length === 0) {
+            return null;
+        }
+        return [resultRows.map((row) => ({ json: row }))];
+    }
+}
+exports.SupabaseTrigger = SupabaseTrigger;

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.9",
   "description": "Comprehensive n8n community node for Supabase with database and storage operations",
   "keywords": [
     "n8n-community-node-package",
@@ -37,7 +37,8 @@
       "dist/credentials/SupabaseExtendedApi.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/Supabase/Supabase.node.js"
+      "dist/nodes/Supabase/Supabase.node.js",
+      "dist/nodes/Supabase/SupabaseTrigger.node.js"
     ]
   },
   "devDependencies": {