@fachkraftfreund/n8n-nodes-supabase 1.2.25 → 1.3.1

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,659 @@
+"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 escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+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')) {
+        const escaped = quoteChar + str.replace(new RegExp(escapeRegExp(quoteChar), 'g'), quoteChar + quoteChar) + quoteChar;
+        return escaped;
+    }
+    return str;
+}
+function discoverHeaders(rows) {
+    const set = new Set();
+    for (const row of rows) {
+        for (const key of Object.keys(row))
+            set.add(key);
+    }
+    return [...set];
+}
+function batchToCsvBuffer(rows, headers, delimiter, quoteChar) {
+    const lines = new Array(rows.length);
+    for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        lines[i] = headers
+            .map((h) => escapeCsvField(row[h], delimiter, quoteChar))
+            .join(delimiter);
+    }
+    return Buffer.from(lines.join('\n'), 'utf-8');
+}
+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');
+    }
+}
+const BATCH_SIZE = 1000;
+async function* fetchBatches(supabase, table, selectFields, filters, sort, hostUrl, returnAll, limit, preferOffset) {
+    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);
+    let totalYielded = 0;
+    const maxRows = returnAll ? Infinity : limit;
+    for (const chunkFilters of filterChunks) {
+        if (totalYielded >= maxRows)
+            break;
+        if (returnAll) {
+            const useKeyset = !preferOffset &&
+                (selectFields === '*' || selectFields.split(',').some((f) => f.trim() === 'id'));
+            let hasMore = true;
+            if (useKeyset) {
+                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(BATCH_SIZE);
+                    const { data, error } = await query;
+                    if (error)
+                        throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+                    if (Array.isArray(data) && data.length > 0) {
+                        yield data;
+                        totalYielded += data.length;
+                        lastId = data[data.length - 1].id;
+                        hasMore = data.length === BATCH_SIZE;
+                    }
+                    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 + BATCH_SIZE - 1);
+                    if (error)
+                        throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+                    if (Array.isArray(data) && data.length > 0) {
+                        yield data;
+                        totalYielded += data.length;
+                        hasMore = data.length === BATCH_SIZE;
+                    }
+                    else {
+                        hasMore = false;
+                    }
+                    offset += BATCH_SIZE;
+                }
+            }
+        }
+        else {
+            const remaining = maxRows - totalYielded;
+            if (remaining <= 0)
+                break;
+            const query = buildSelectQuery(supabase, table, selectFields, chunkFilters, sort);
+            const { data, error } = await query.limit(remaining);
+            if (error)
+                throw new Error((0, supabaseClient_2.formatSupabaseError)(error));
+            if (Array.isArray(data) && data.length > 0) {
+                yield data;
+                totalYielded += data.length;
+            }
+        }
+    }
+}
+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. ' +
+                        'The transform runs per batch (~1000 rows) so it stays memory-efficient ' +
+                        'even for very large exports. Use .filter() and .map() to shape your data.',
+                },
+                {
+                    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 enableTransform = this.getNodeParameter('enableTransform', 0, false);
+        const idColumn = this.getNodeParameter('idColumn', 0, 'id');
+        const csvOpts = this.getNodeParameter('csvOptions', 0, {});
+        const csvOptions = {
+            delimiter: csvOpts.delimiter || ',',
+            quoteChar: csvOpts.quoteChar || '"',
+            includeHeaders: csvOpts.includeHeaders !== false,
+            fileName: csvOpts.fileName || 'export.csv',
+        };
+        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})`;
+        }
+        const { delimiter, quoteChar } = csvOptions;
+        const csvChunks = [];
+        const ids = [];
+        let rowCount = 0;
+        let headers = null;
+        try {
+            let transformFn = null;
+            let params = {};
+            if (enableTransform) {
+                const paramEntries = this.getNodeParameter('transformParams.param', 0, []);
+                for (const entry of paramEntries) {
+                    if (entry.name)
+                        params[entry.name] = entry.value;
+                }
+                const code = this.getNodeParameter('transformCode', 0, 'return rows;');
+                try {
+                    transformFn = new Function('rows', 'params', code);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : 'Unknown error';
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Transform code syntax error: ${msg}`);
+                }
+            }
+            const preferOffset = sort.length > 0;
+            for await (const batch of fetchBatches(supabase, table, selectWithJoins, filters, sort, credentials.host, returnAll, limit, preferOffset)) {
+                let rows = batch;
+                if (transformFn) {
+                    try {
+                        const result = transformFn(batch, params);
+                        if (!Array.isArray(result)) {
+                            throw new Error('Transform code must return an array. Got: ' + typeof result);
+                        }
+                        rows = result;
+                    }
+                    catch (error) {
+                        if (error instanceof n8n_workflow_1.NodeOperationError)
+                            throw error;
+                        const msg = error instanceof Error ? error.message : 'Unknown error';
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Transform code error: ${msg}`);
+                    }
+                }
+                if (rows.length === 0)
+                    continue;
+                if (headers === null) {
+                    headers = discoverHeaders(rows);
+                    if (csvOptions.includeHeaders) {
+                        const headerLine = headers
+                            .map((h) => escapeCsvField(h, delimiter, quoteChar))
+                            .join(delimiter);
+                        csvChunks.push(Buffer.from(headerLine + '\n', 'utf-8'));
+                    }
+                }
+                for (const row of rows) {
+                    if (row[idColumn] != null)
+                        ids.push(row[idColumn]);
+                }
+                const buf = batchToCsvBuffer(rows, headers, delimiter, quoteChar);
+                csvChunks.push(buf);
+                csvChunks.push(Buffer.from('\n', 'utf-8'));
+                rowCount += rows.length;
+            }
+            if (csvChunks.length > 0) {
+                const last = csvChunks[csvChunks.length - 1];
+                if (last.length === 1 && last[0] === 0x0a) {
+                    csvChunks.pop();
+                }
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            if (error instanceof n8n_workflow_1.NodeOperationError)
+                throw error;
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Export failed: ${msg}`);
+        }
+        const csvBuffer = Buffer.concat(csvChunks);
+        csvChunks.length = 0;
+        const binaryData = await this.helpers.prepareBinaryData(csvBuffer, csvOptions.fileName, 'text/csv');
+        return [[
+                {
+                    json: {
+                        table,
+                        rowCount,
+                        ids,
+                        fileName: csvOptions.fileName,
+                    },
+                    binary: {
+                        data: binaryData,
+                    },
+                },
+            ]];
+    }
+}
+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}`);
         }
@@ -662,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.25",
+  "version": "1.3.1",
   "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": {