@fachkraftfreund/n8n-nodes-supabase 1.2.6 → 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'],
                         },
                     },
@@ -551,6 +568,19 @@ class Supabase {
                         },
                     ],
                 },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to return all results or limit the number of results',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['read'],
+                        },
+                    },
+                },
                 {
                     displayName: 'Limit',
                     name: 'limit',
@@ -561,6 +591,7 @@ class Supabase {
                         show: {
                             resource: ['database'],
                             operation: ['read'],
+                            returnAll: [false],
                         },
                     },
                 },
@@ -574,6 +605,7 @@ class Supabase {
                         show: {
                             resource: ['database'],
                             operation: ['read'],
+                            returnAll: [false],
                         },
                     },
                 },
@@ -868,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,63 +46,130 @@ 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, filter.value);
+            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);
                 for (const [column, condition] of Object.entries(filters)) {
                     if (typeof condition === 'object' && condition !== null) {
                         const [operator, value] = Object.entries(condition)[0];
-                        query = query.filter(column, (0, supabaseClient_1.convertFilterOperator)(operator), value);
+                        query = query.filter(column, (0, supabaseClient_1.convertFilterOperator)(operator), (0, supabaseClient_1.normalizeFilterValue)(operator, value));
                     }
                     else {
                         query = query.eq(column, condition);
@@ -123,33 +181,65 @@ 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 });
     }
-    const limit = this.getNodeParameter('limit', itemIndex, undefined);
-    const offset = this.getNodeParameter('offset', itemIndex, undefined);
-    if (limit !== undefined) {
-        query = query.limit(limit);
-    }
-    if (offset !== undefined) {
-        query = query.range(offset, offset + (limit || 1000) - 1);
-    }
-    const { data, error, count } = await query;
-    if (error) {
-        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
-    }
+    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 (Array.isArray(data)) {
-        for (const row of data) {
-            returnData.push({ json: row });
+    if (returnAll) {
+        const batchSize = 1000;
+        let offset = 0;
+        let hasMore = true;
+        while (hasMore) {
+            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));
+            }
+            if (Array.isArray(batchData)) {
+                for (const row of batchData) {
+                    returnData.push({ json: row });
+                }
+                hasMore = batchData.length === batchSize;
+            }
+            else {
+                hasMore = false;
+            }
+            offset += batchSize;
+        }
+    }
+    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);
+        }
+        if (offset !== undefined) {
+            query = query.range(offset, offset + (limit || 1000) - 1);
+        }
+        const { data, error } = await query;
+        if (error) {
+            throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+        }
+        if (Array.isArray(data)) {
+            for (const row of data) {
+                returnData.push({ json: row });
+            }
         }
     }
     if (returnData.length === 0) {
         returnData.push({
             json: {
                 data: [],
-                count: count || 0,
+                count: 0,
                 operation: 'read',
                 table,
                 message: 'No records found',
@@ -158,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, 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);
@@ -203,7 +258,7 @@ async function handleDelete(supabase, itemIndex) {
     }
     for (const filter of filters) {
         const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
-        query = query.filter(filter.column, operator, filter.value);
+        query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
     }
     const { data, error } = await query.select();
     if (error) {
@@ -211,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, []);
@@ -275,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));
     }
@@ -286,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));
     }
@@ -304,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));
     }
@@ -317,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));
     }
@@ -334,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));
     }
@@ -347,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/dist/nodes/Supabase/utils/supabaseClient.d.ts

@@ -11,3 +11,4 @@ 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;
+export declare function normalizeFilterValue(operator: string, value: string | number | boolean | null): string | number | boolean | null;

package/dist/nodes/Supabase/utils/supabaseClient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertFilterOperator = exports.validateColumnName = exports.validateTableName = exports.sanitizeColumnName = exports.isNetworkError = exports.isAuthError = exports.formatSupabaseError = exports.getDatabaseUrl = exports.getStorageUrl = exports.validateCredentials = exports.createSupabaseClient = void 0;
+exports.normalizeFilterValue = exports.convertFilterOperator = exports.validateColumnName = exports.validateTableName = exports.sanitizeColumnName = exports.isNetworkError = exports.isAuthError = exports.formatSupabaseError = exports.getDatabaseUrl = exports.getStorageUrl = exports.validateCredentials = exports.createSupabaseClient = void 0;
 const supabase_js_1 = require("@supabase/supabase-js");
 function createSupabaseClient(credentials) {
     const client = (0, supabase_js_1.createClient)(credentials.host, credentials.serviceKey, {
@@ -136,3 +136,14 @@ function convertFilterOperator(operator) {
     return operatorMap[operator] || 'eq';
 }
 exports.convertFilterOperator = convertFilterOperator;
+function normalizeFilterValue(operator, value) {
+    if (operator === 'in' && typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed.startsWith('(')) {
+            return `(${trimmed})`;
+        }
+        return trimmed;
+    }
+    return value;
+}
+exports.normalizeFilterValue = normalizeFilterValue;

package/package.json

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