@fachkraftfreund/n8n-nodes-supabase 1.2.24 → 1.3.0

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

@@ -135,6 +135,12 @@ class Supabase {
                             description: 'Return existing row matching criteria, or create it if not found',
                             action: 'Find or create row',
                         },
+                        {
+                            name: 'Update by Query',
+                            value: 'updateByQuery',
+                            description: 'Update all rows matching filter conditions (e.g. update where id IN list)',
+                            action: 'Update rows by query',
+                        },
                     ],
                     default: 'read',
                 },
@@ -244,7 +250,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['create', 'read', 'update', 'delete', 'upsert'],
+                            operation: ['create', 'read', 'update', 'delete', 'upsert', 'updateByQuery'],
                         },
                     },
                 },
@@ -261,7 +267,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['create', 'read', 'update', 'delete', 'upsert', 'findOrCreate'],
+                            operation: ['create', 'read', 'update', 'delete', 'upsert', 'findOrCreate', 'updateByQuery'],
                         },
                     },
                 },
@@ -277,7 +283,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['create', 'update', 'upsert'],
+                            operation: ['create', 'update', 'upsert', 'updateByQuery'],
                             uiMode: ['simple'],
                         },
                     },
@@ -316,7 +322,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['create', 'update', 'upsert'],
+                            operation: ['create', 'update', 'upsert', 'updateByQuery'],
                             uiMode: ['advanced'],
                         },
                     },
@@ -448,7 +454,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['read', 'delete'],
+                            operation: ['read', 'delete', 'updateByQuery'],
                             uiMode: ['simple'],
                         },
                     },
@@ -508,7 +514,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['read', 'delete'],
+                            operation: ['read', 'delete', 'updateByQuery'],
                             uiMode: ['advanced'],
                         },
                     },

package/dist/nodes/Supabase/SupabaseCsvExport.node.d.ts

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

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

@@ -0,0 +1,638 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseCsvExport = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const supabaseClient_1 = require("./utils/supabaseClient");
+const supabaseClient_2 = require("./utils/supabaseClient");
+function escapeCsvField(value, delimiter, quoteChar) {
+    if (value === null || value === undefined)
+        return '';
+    const str = typeof value === 'object' ? JSON.stringify(value) : String(value);
+    if (str.includes(delimiter) ||
+        str.includes(quoteChar) ||
+        str.includes('\n') ||
+        str.includes('\r')) {
+        return quoteChar + str.replace(new RegExp(escapeRegExp(quoteChar), 'g'), quoteChar + quoteChar) + quoteChar;
+    }
+    return str;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function generateCsv(rows, options) {
+    if (rows.length === 0)
+        return '';
+    const { delimiter, quoteChar, includeHeaders } = options;
+    const headerSet = new Set();
+    for (const row of rows) {
+        for (const key of Object.keys(row))
+            headerSet.add(key);
+    }
+    const headers = [...headerSet];
+    const lines = [];
+    if (includeHeaders) {
+        lines.push(headers.map((h) => escapeCsvField(h, delimiter, quoteChar)).join(delimiter));
+    }
+    for (const row of rows) {
+        lines.push(headers.map((h) => escapeCsvField(row[h], delimiter, quoteChar)).join(delimiter));
+    }
+    return lines.join('\n');
+}
+function buildSelectQuery(supabase, table, selectFields, filters, sort) {
+    let query = supabase.from(table).select(selectFields);
+    for (const filter of filters) {
+        const operator = (0, supabaseClient_2.convertFilterOperator)(filter.operator);
+        query = query.filter(filter.column, operator, (0, supabaseClient_2.normalizeFilterValue)(filter.operator, filter.value));
+    }
+    for (const s of sort) {
+        query = query.order(s.column, { ascending: s.ascending });
+    }
+    return query;
+}
+function parseFilters(context, itemIndex) {
+    const uiMode = context.getNodeParameter('uiMode', itemIndex, 'simple');
+    if (uiMode === 'simple') {
+        return context.getNodeParameter('filters.filter', itemIndex, []);
+    }
+    const raw = context.getNodeParameter('advancedFilters', itemIndex, '');
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        const filters = [];
+        for (const [column, condition] of Object.entries(parsed)) {
+            if (typeof condition === 'object' && condition !== null) {
+                const [operator, value] = Object.entries(condition)[0];
+                filters.push({ column, operator: operator, value: value });
+            }
+            else {
+                filters.push({ column, operator: 'eq', value: condition });
+            }
+        }
+        return filters;
+    }
+    catch {
+        throw new Error('Invalid advanced filters JSON');
+    }
+}
+async function fetchAllRows(supabase, table, selectFields, filters, sort, hostUrl, returnAll, limit) {
+    const overhead = (0, supabaseClient_2.estimateUrlOverhead)(hostUrl, table, selectFields, filters, sort);
+    const maxInChars = Math.max(500, supabaseClient_2.MAX_SAFE_URL_LENGTH - overhead);
+    const maxItems = (0, supabaseClient_2.computeMaxIdsPerChunk)(selectFields);
+    const filterChunks = (0, supabaseClient_2.expandChunkedFilters)(filters, maxInChars, maxItems);
+    const allRows = [];
+    if (returnAll) {
+        const batchSize = 1000;
+        const hasIdColumn = selectFields === '*' || selectFields.split(',').some((f) => f.trim() === 'id');
+        for (const chunkFilters of filterChunks) {
+            let hasMore = true;
+            if (hasIdColumn) {
+                let lastId = null;
+                while (hasMore) {
+                    let query = buildSelectQuery(supabase, table, selectFields, chunkFilters, []);
+                    if (lastId !== null) {
+                        query = query.gt('id', lastId);
+                    }
+                    query = query.order('id', { ascending: true }).limit(batchSize);
+                    const { data, error } = await query;
+                    if (error)
+                        throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+                    if (Array.isArray(data) && data.length > 0) {
+                        for (const row of data)
+                            allRows.push(row);
+                        lastId = data[data.length - 1].id;
+                        hasMore = data.length === batchSize;
+                    }
+                    else {
+                        hasMore = false;
+                    }
+                }
+            }
+            else {
+                let offset = 0;
+                while (hasMore) {
+                    const query = buildSelectQuery(supabase, table, selectFields, chunkFilters, sort);
+                    const { data, error } = await query.range(offset, offset + batchSize - 1);
+                    if (error)
+                        throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+                    if (Array.isArray(data) && data.length > 0) {
+                        for (const row of data)
+                            allRows.push(row);
+                        hasMore = data.length === batchSize;
+                    }
+                    else {
+                        hasMore = false;
+                    }
+                    offset += batchSize;
+                }
+            }
+        }
+        if (hasIdColumn && sort.length > 0) {
+            allRows.sort((a, b) => {
+                var _a, _b;
+                for (const s of sort) {
+                    const aVal = ((_a = a[s.column]) !== null && _a !== void 0 ? _a : null);
+                    const bVal = ((_b = b[s.column]) !== null && _b !== void 0 ? _b : null);
+                    if (aVal === bVal)
+                        continue;
+                    if (aVal === null)
+                        return 1;
+                    if (bVal === null)
+                        return -1;
+                    if (aVal < bVal)
+                        return s.ascending ? -1 : 1;
+                    if (aVal > bVal)
+                        return s.ascending ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+    }
+    else {
+        for (const chunkFilters of filterChunks) {
+            const query = buildSelectQuery(supabase, table, selectFields, chunkFilters, sort);
+            const { data, error } = await query.limit(limit);
+            if (error)
+                throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+            if (Array.isArray(data)) {
+                for (const row of data)
+                    allRows.push(row);
+            }
+        }
+        if (allRows.length > limit) {
+            allRows.length = limit;
+        }
+    }
+    return allRows;
+}
+class SupabaseCsvExport {
+    constructor() {
+        this.description = {
+            displayName: 'Supabase CSV Export',
+            name: 'supabaseCsvExport',
+            icon: 'file:icons/supabase.svg',
+            group: ['output'],
+            version: 1,
+            subtitle: '={{$parameter["table"]}}',
+            description: 'Fetch data from Supabase, transform with JavaScript, and export as CSV file',
+            defaults: {
+                name: 'Supabase CSV Export',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'supabaseExtendedApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Table',
+                    name: 'table',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getTables',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Table to export data from',
+                },
+                {
+                    displayName: 'Return Fields',
+                    name: 'returnFields',
+                    type: 'string',
+                    default: '*',
+                    placeholder: 'id,name,email',
+                    description: 'Comma-separated list of columns to fetch (* for all)',
+                },
+                {
+                    displayName: 'Joins',
+                    name: 'joins',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    default: {},
+                    placeholder: 'Add Join',
+                    description: 'Join related tables via foreign keys (PostgREST resource embedding)',
+                    options: [
+                        {
+                            displayName: 'Join',
+                            name: 'join',
+                            values: [
+                                {
+                                    displayName: 'Table',
+                                    name: 'table',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'related_table',
+                                    description: 'Related table to join',
+                                },
+                                {
+                                    displayName: 'Columns',
+                                    name: 'columns',
+                                    type: 'string',
+                                    default: '*',
+                                    placeholder: 'col1,col2',
+                                    description: 'Comma-separated columns from the joined table (* for all)',
+                                },
+                                {
+                                    displayName: 'Join Type',
+                                    name: 'joinType',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Left Join', value: 'left' },
+                                        { name: 'Inner Join', value: 'inner' },
+                                    ],
+                                    default: 'left',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'UI Mode',
+                    name: 'uiMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Simple', value: 'simple', description: 'Use form fields' },
+                        { name: 'Advanced', value: 'advanced', description: 'Use JSON filters' },
+                    ],
+                    default: 'simple',
+                },
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    default: {},
+                    placeholder: 'Add Filter',
+                    displayOptions: { show: { uiMode: ['simple'] } },
+                    options: [
+                        {
+                            displayName: 'Filter',
+                            name: 'filter',
+                            values: [
+                                {
+                                    displayName: 'Column',
+                                    name: 'column',
+                                    type: 'options',
+                                    typeOptions: { loadOptionsMethod: 'getColumns' },
+                                    default: '',
+                                },
+                                {
+                                    displayName: 'Operator',
+                                    name: 'operator',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Equals', value: 'eq' },
+                                        { name: 'Not Equals', value: 'neq' },
+                                        { name: 'Greater Than', value: 'gt' },
+                                        { name: 'Greater Than or Equal', value: 'gte' },
+                                        { name: 'Less Than', value: 'lt' },
+                                        { name: 'Less Than or Equal', value: 'lte' },
+                                        { name: 'Like', value: 'like' },
+                                        { name: 'Case Insensitive Like', value: 'ilike' },
+                                        { name: 'Is', value: 'is' },
+                                        { name: 'In', value: 'in' },
+                                        { name: 'Contains', value: 'cs' },
+                                        { name: 'Contained By', value: 'cd' },
+                                    ],
+                                    default: 'eq',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Advanced Filters',
+                    name: 'advancedFilters',
+                    type: 'json',
+                    default: '{}',
+                    description: 'JSON object with filter conditions',
+                    displayOptions: { show: { uiMode: ['advanced'] } },
+                },
+                {
+                    displayName: 'Sort',
+                    name: 'sort',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    default: {},
+                    placeholder: 'Add Sort Field',
+                    options: [
+                        {
+                            displayName: 'Sort Field',
+                            name: 'sortField',
+                            values: [
+                                {
+                                    displayName: 'Column',
+                                    name: 'column',
+                                    type: 'options',
+                                    typeOptions: { loadOptionsMethod: 'getColumns' },
+                                    default: '',
+                                },
+                                {
+                                    displayName: 'Ascending',
+                                    name: 'ascending',
+                                    type: 'boolean',
+                                    default: true,
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to fetch all matching rows',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    default: 100,
+                    description: 'Maximum number of rows to fetch',
+                    displayOptions: { show: { returnAll: [false] } },
+                },
+                {
+                    displayName: 'Transform Data',
+                    name: 'enableTransform',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to apply a JavaScript transform before generating the CSV',
+                },
+                {
+                    displayName: 'Transform Parameters',
+                    name: 'transformParams',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    default: {},
+                    placeholder: 'Add Parameter',
+                    displayOptions: { show: { enableTransform: [true] } },
+                    description: 'Key-value pairs passed into the transform code as a "params" object. ' +
+                        'Values support n8n expressions, so you can reference previous nodes ' +
+                        '(e.g. {{ $json.threshold }} or {{ $(\'My Node\').item.json.value }}).',
+                    options: [
+                        {
+                            displayName: 'Parameter',
+                            name: 'param',
+                            values: [
+                                {
+                                    displayName: 'Name',
+                                    name: 'name',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: 'threshold',
+                                    description: 'Name used in transform code as params.<name>',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    placeholder: '={{ $json.minScore }}',
+                                    description: 'Value (supports n8n expressions to reference previous nodes)',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Transform Code',
+                    name: 'transformCode',
+                    type: 'string',
+                    typeOptions: {
+                        editor: 'codeNodeEditor',
+                        editorLanguage: 'javaScript',
+                    },
+                    displayOptions: { show: { enableTransform: [true] } },
+                    default: '// "rows"   — array of objects from the database\n' +
+                        '// "params" — values passed in from Transform Parameters above\n' +
+                        '//            (use n8n expressions there to reference previous nodes)\n' +
+                        '\n' +
+                        'return rows\n' +
+                        '  .filter(row => row.score >= (params.threshold || 0))\n' +
+                        '  .map(row => ({\n' +
+                        '    id: row.id,\n' +
+                        '    name: row.name,\n' +
+                        '    email: row.email,\n' +
+                        '  }));\n',
+                    description: 'JavaScript code that receives "rows" (array) and "params" (object). ' +
+                        'Must return an array of objects. Each object becomes a CSV row.',
+                },
+                {
+                    displayName: 'ID Column',
+                    name: 'idColumn',
+                    type: 'string',
+                    default: 'id',
+                    description: 'Column to extract row IDs from (returned alongside the CSV). ' +
+                        'Uses the final (post-transform) data — make sure your transform preserves this column.',
+                },
+                {
+                    displayName: 'CSV Options',
+                    name: 'csvOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Delimiter',
+                            name: 'delimiter',
+                            type: 'string',
+                            default: ',',
+                            description: 'Column separator character',
+                        },
+                        {
+                            displayName: 'Include Headers',
+                            name: 'includeHeaders',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to include a header row',
+                        },
+                        {
+                            displayName: 'File Name',
+                            name: 'fileName',
+                            type: 'string',
+                            default: 'export.csv',
+                            description: 'Name of the generated CSV file',
+                        },
+                        {
+                            displayName: 'Quote Character',
+                            name: 'quoteChar',
+                            type: 'string',
+                            default: '"',
+                            description: 'Character used to quote fields containing special characters',
+                        },
+                    ],
+                },
+            ],
+        };
+        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: '' }];
+                    }
+                },
+                async getColumns() {
+                    var _a;
+                    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: '' }];
+                    }
+                    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 tableSchema = (_a = response.definitions) === null || _a === void 0 ? void 0 : _a[table];
+                        if (!(tableSchema === null || tableSchema === void 0 ? void 0 : tableSchema.properties)) {
+                            return [{ name: 'No columns found', value: '' }];
+                        }
+                        return Object.keys(tableSchema.properties)
+                            .sort()
+                            .map((col) => {
+                            const def = tableSchema.properties[col];
+                            const typeLabel = def.format ? `${def.type} (${def.format})` : def.type;
+                            return { name: col, value: col, description: typeLabel };
+                        });
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : 'Unknown error';
+                        return [{ name: `Error: ${msg}`, value: '' }];
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        const credentials = (await this.getCredentials('supabaseExtendedApi'));
+        try {
+            (0, supabaseClient_1.validateCredentials)(credentials);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid credentials: ${msg}`);
+        }
+        const supabase = (0, supabaseClient_1.createSupabaseClient)(credentials);
+        const table = this.getNodeParameter('table', 0);
+        (0, supabaseClient_2.validateTableName)(table);
+        const returnFields = this.getNodeParameter('returnFields', 0, '*');
+        const returnAll = this.getNodeParameter('returnAll', 0, true);
+        const limit = returnAll ? 0 : this.getNodeParameter('limit', 0, 100);
+        const filters = parseFilters(this, 0);
+        const sort = this.getNodeParameter('sort.sortField', 0, []);
+        const joins = this.getNodeParameter('joins.join', 0, []);
+        let selectWithJoins = returnFields;
+        for (const j of joins) {
+            if (!j.table)
+                continue;
+            const cols = j.columns || '*';
+            const hint = j.joinType === 'inner' ? `${j.table}!inner` : j.table;
+            selectWithJoins += `,${hint}(${cols})`;
+        }
+        let rows;
+        try {
+            rows = await fetchAllRows(supabase, table, selectWithJoins, filters, sort, credentials.host, returnAll, limit);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to fetch data: ${msg}`);
+        }
+        const enableTransform = this.getNodeParameter('enableTransform', 0, false);
+        if (enableTransform) {
+            const paramEntries = this.getNodeParameter('transformParams.param', 0, []);
+            const params = {};
+            for (const entry of paramEntries) {
+                if (entry.name) {
+                    params[entry.name] = entry.value;
+                }
+            }
+            const code = this.getNodeParameter('transformCode', 0, 'return rows;');
+            try {
+                const transformFn = new Function('rows', 'params', code);
+                const result = transformFn(rows, params);
+                if (!Array.isArray(result)) {
+                    throw new Error('Transform code must return an array. Got: ' + typeof result);
+                }
+                rows = result;
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : 'Unknown error';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Transform code error: ${msg}`);
+            }
+        }
+        const idColumn = this.getNodeParameter('idColumn', 0, 'id');
+        const ids = [];
+        for (const row of rows) {
+            if (row[idColumn] !== undefined && row[idColumn] !== null) {
+                ids.push(row[idColumn]);
+            }
+        }
+        const csvOpts = this.getNodeParameter('csvOptions', 0, {});
+        const csvOptions = {
+            delimiter: csvOpts.delimiter || ',',
+            quoteChar: csvOpts.quoteChar || '"',
+            includeHeaders: csvOpts.includeHeaders !== false,
+            fileName: csvOpts.fileName || 'export.csv',
+        };
+        const csvContent = generateCsv(rows, csvOptions);
+        const csvBuffer = Buffer.from(csvContent, 'utf-8');
+        const binaryData = await this.helpers.prepareBinaryData(csvBuffer, csvOptions.fileName, 'text/csv');
+        const returnItem = {
+            json: {
+                table,
+                rowCount: rows.length,
+                ids,
+                fileName: csvOptions.fileName,
+            },
+            binary: {
+                data: binaryData,
+            },
+        };
+        return [[returnItem]];
+    }
+}
+exports.SupabaseCsvExport = SupabaseCsvExport;

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

@@ -39,6 +39,9 @@ async function executeDatabaseOperation(supabase, operation, itemIndex, hostUrl)
             case 'findOrCreate':
                 returnData.push(...await handleFindOrCreate.call(this, supabase, itemIndex));
                 break;
+            case 'updateByQuery':
+                returnData.push(...await handleUpdateByQuery.call(this, supabase, itemIndex, hostUrl));
+                break;
             default:
                 throw new Error(`Unknown database operation: ${operation}`);
         }
@@ -49,6 +52,44 @@ async function executeDatabaseOperation(supabase, operation, itemIndex, hostUrl)
     return returnData;
 }
 exports.executeDatabaseOperation = executeDatabaseOperation;
+const BULK_BATCH_SIZE = 500;
+const MAX_RETRIES = 3;
+const RETRY_BASE_DELAY_MS = 1000;
+function isRetryableError(msg) {
+    const lower = msg.toLowerCase();
+    return (lower.includes('lock timeout') ||
+        lower.includes('canceling statement due to lock') ||
+        lower.includes('deadlock') ||
+        lower.includes('too many connections') ||
+        lower.includes('rate limit') ||
+        lower.includes('could not serialize access') ||
+        lower.includes('connection terminated') ||
+        lower.includes('connection reset') ||
+        lower.includes('econnreset') ||
+        lower.includes('timeout'));
+}
+async function withRetry(fn, label) {
+    var _a;
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const msg = (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(err);
+            if (attempt < MAX_RETRIES && isRetryableError(msg)) {
+                const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+                console.log(`[Supabase ${label}] transient error (attempt ${attempt + 1}/${MAX_RETRIES + 1}), retrying in ${delay}ms: ${msg}`);
+                await new Promise((r) => setTimeout(r, delay));
+                lastError = err instanceof Error ? err : new Error(msg);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    throw lastError;
+}
 function sanitizeString(value) {
     return value
         .replace(/\x00/g, '')
@@ -126,16 +167,26 @@ 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(rows)
-        .select();
-    if (error)
-        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
-    if (Array.isArray(data)) {
-        return data.map((row) => ({ json: row }));
+    const returnData = [];
+    for (let offset = 0; offset < rows.length; offset += BULK_BATCH_SIZE) {
+        const batch = rows.slice(offset, offset + BULK_BATCH_SIZE);
+        const data = await withRetry(async () => {
+            const { data, error } = await supabase
+                .from(table)
+                .insert(batch)
+                .select();
+            if (error)
+                throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+            return data;
+        }, `CREATE ${table} batch ${Math.floor(offset / BULK_BATCH_SIZE) + 1}`);
+        if (Array.isArray(data)) {
+            for (const row of data)
+                returnData.push({ json: row });
+        }
     }
-    return [{ json: { data, operation: 'create', table } }];
+    return returnData.length > 0
+        ? returnData
+        : [{ json: { data: [], operation: 'create', table } }];
 }
 async function handleBulkUpsert(supabase, itemCount) {
     const table = this.getNodeParameter('table', 0);
@@ -145,16 +196,26 @@ async function handleBulkUpsert(supabase, 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 }));
+    const returnData = [];
+    for (let offset = 0; offset < rows.length; offset += BULK_BATCH_SIZE) {
+        const batch = rows.slice(offset, offset + BULK_BATCH_SIZE);
+        const data = await withRetry(async () => {
+            const { data, error } = await supabase
+                .from(table)
+                .upsert(batch, options)
+                .select();
+            if (error)
+                throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+            return data;
+        }, `UPSERT ${table} batch ${Math.floor(offset / BULK_BATCH_SIZE) + 1}`);
+        if (Array.isArray(data)) {
+            for (const row of data)
+                returnData.push({ json: row });
+        }
     }
-    return [{ json: { data, operation: 'upsert', table } }];
+    return returnData.length > 0
+        ? returnData
+        : [{ json: { data: [], operation: 'upsert', table } }];
 }
 async function handleBulkUpdate(supabase, itemCount) {
     const table = this.getNodeParameter('table', 0);
@@ -170,16 +231,26 @@ async function handleBulkUpdate(supabase, itemCount) {
             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 }));
+    const returnData = [];
+    for (let offset = 0; offset < rows.length; offset += BULK_BATCH_SIZE) {
+        const batch = rows.slice(offset, offset + BULK_BATCH_SIZE);
+        const data = await withRetry(async () => {
+            const { data, error } = await supabase
+                .from(table)
+                .upsert(batch, { onConflict: matchColumn })
+                .select();
+            if (error)
+                throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+            return data;
+        }, `UPDATE ${table} batch ${Math.floor(offset / BULK_BATCH_SIZE) + 1}`);
+        if (Array.isArray(data)) {
+            for (const row of data)
+                returnData.push({ json: row });
+        }
     }
-    return [{ json: { data, operation: 'update', table } }];
+    return returnData.length > 0
+        ? returnData
+        : [{ json: { data: [], operation: 'update', table } }];
 }
 function getFilters(context, itemIndex) {
     const uiMode = context.getNodeParameter('uiMode', itemIndex, 'simple');
@@ -594,3 +665,60 @@ async function handleFindOrCreate(supabase, itemIndex) {
         throw new Error((0, supabaseClient_1.formatSupabaseError)(insertError));
     return [{ json: { ...created, _found: false, _created: true } }];
 }
+async function handleUpdateByQuery(supabase, itemIndex, hostUrl) {
+    const table = this.getNodeParameter('table', itemIndex);
+    (0, supabaseClient_1.validateTableName)(table);
+    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+    let updateData;
+    if (uiMode === 'advanced') {
+        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
+        try {
+            updateData = JSON.parse(jsonData);
+        }
+        catch {
+            throw new Error('Invalid JSON data for update values');
+        }
+    }
+    else {
+        const columns = this.getNodeParameter('columns.column', itemIndex, []);
+        updateData = {};
+        for (const column of columns) {
+            if (column.name && column.value !== undefined) {
+                updateData[column.name] = column.value;
+            }
+        }
+    }
+    if (Object.keys(updateData).length === 0) {
+        throw new Error('At least one column value is required for update');
+    }
+    sanitizeRow(updateData);
+    const filters = getFilters(this, itemIndex);
+    if (filters.length === 0) {
+        throw new Error('At least one filter is required for Update by Query to prevent accidental full-table updates');
+    }
+    const overhead = (0, supabaseClient_1.estimateUrlOverhead)(hostUrl, table, undefined, filters);
+    const maxInChars = Math.max(500, supabaseClient_1.MAX_SAFE_URL_LENGTH - overhead);
+    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters, maxInChars);
+    const returnData = [];
+    for (const chunkFilters of filterChunks) {
+        const data = await withRetry(async () => {
+            let query = supabase.from(table).update(updateData);
+            for (const filter of chunkFilters) {
+                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 data;
+        }, `UPDATE_BY_QUERY ${table}`);
+        if (Array.isArray(data)) {
+            for (const row of data)
+                returnData.push({ json: row });
+        }
+    }
+    if (returnData.length === 0) {
+        return [{ json: { data: [], count: 0, operation: 'updateByQuery', table, message: 'No rows matched the filter conditions' } }];
+    }
+    return returnData;
+}

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

@@ -75,7 +75,7 @@ export interface ISupabaseStorageResponse<T = any> {
         statusCode?: string;
     } | null;
 }
-export type DatabaseOperation = 'create' | 'read' | 'update' | 'delete' | 'upsert' | 'createTable' | 'dropTable' | 'addColumn' | 'dropColumn' | 'createIndex' | 'dropIndex' | 'customQuery' | 'findOrCreate';
+export type DatabaseOperation = 'create' | 'read' | 'update' | 'delete' | 'upsert' | 'createTable' | 'dropTable' | 'addColumn' | 'dropColumn' | 'createIndex' | 'dropIndex' | 'customQuery' | 'findOrCreate' | 'updateByQuery';
 export type StorageOperation = 'uploadFile' | 'downloadFile' | 'listFiles' | 'deleteFile' | 'moveFile' | 'copyFile' | 'createBucket' | 'deleteBucket' | 'listBuckets' | 'getBucketDetails' | 'getFileInfo' | 'generateSignedUrl';
 export type SupabaseResource = 'database' | 'storage';
 export interface ISupabaseNodeParameters {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fachkraftfreund/n8n-nodes-supabase",
-  "version": "1.2.24",
+  "version": "1.3.0",
   "description": "Comprehensive n8n community node for Supabase with database and storage operations",
   "keywords": [
     "n8n-community-node-package",
@@ -38,7 +38,8 @@
     ],
     "nodes": [
       "dist/nodes/Supabase/Supabase.node.js",
-      "dist/nodes/Supabase/SupabaseTrigger.node.js"
+      "dist/nodes/Supabase/SupabaseTrigger.node.js",
+      "dist/nodes/Supabase/SupabaseCsvExport.node.js"
     ]
   },
   "devDependencies": {