@fachkraftfreund/n8n-nodes-supabase 1.2.8 → 1.2.10

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

@@ -891,6 +891,12 @@ class Supabase {
     async execute() {
         const items = this.getInputData();
         const returnData = [];
+        const firstItem = items[0];
+        if (items.length === 1 &&
+            (firstItem === null || firstItem === void 0 ? void 0 : firstItem.json) &&
+            Object.keys(firstItem.json).length === 0) {
+            return [[{ json: {} }]];
+        }
         const credentials = await this.getCredentials('supabaseExtendedApi');
         try {
             (0, supabaseClient_1.validateCredentials)(credentials);

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

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

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

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

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

@@ -150,38 +150,39 @@ async function handleBulkUpdate(supabase, itemCount) {
     }
     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);
+function getFilters(context, itemIndex) {
     const uiMode = context.getNodeParameter('uiMode', itemIndex, 'simple');
     if (uiMode === 'simple') {
-        const filters = context.getNodeParameter('filters.filter', itemIndex, []);
-        for (const filter of filters) {
-            const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
-            query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
-        }
+        return context.getNodeParameter('filters.filter', itemIndex, []);
     }
-    else {
-        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), (0, supabaseClient_1.normalizeFilterValue)(operator, value));
-                    }
-                    else {
-                        query = query.eq(column, condition);
-                    }
-                }
+    const advancedFilters = context.getNodeParameter('advancedFilters', itemIndex, '');
+    if (!advancedFilters)
+        return [];
+    try {
+        const parsed = JSON.parse(advancedFilters);
+        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 });
             }
-            catch {
-                throw new Error('Invalid advanced filters JSON');
+            else {
+                filters.push({ column, operator: 'eq', value: condition });
             }
         }
+        return filters;
+    }
+    catch {
+        throw new Error('Invalid advanced filters JSON');
+    }
+}
+function buildReadQuery(supabase, table, returnFields, filters, sort, options) {
+    const selectFields = returnFields && returnFields !== '*' ? returnFields : '*';
+    let query = supabase.from(table).select(selectFields, options);
+    for (const filter of filters) {
+        const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
+        query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
     }
-    const sort = context.getNodeParameter('sort.sortField', itemIndex, []);
     for (const sortField of sort) {
         query = query.order(sortField.column, { ascending: sortField.ascending });
     }
@@ -192,46 +193,51 @@ async function handleRead(supabase, itemIndex) {
     (0, supabaseClient_1.validateTableName)(table);
     const returnFields = this.getNodeParameter('returnFields', itemIndex, '*');
     const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
+    const filters = getFilters(this, itemIndex);
+    const sort = this.getNodeParameter('sort.sortField', itemIndex, []);
+    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters);
     const returnData = [];
-    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 });
+    for (const chunkFilters of filterChunks) {
+        if (returnAll) {
+            const batchSize = 1000;
+            let offset = 0;
+            let hasMore = true;
+            while (hasMore) {
+                const batchQuery = buildReadQuery(supabase, table, returnFields, chunkFilters, sort, { count: 'exact' });
+                const { data: batchData, error: batchError } = await batchQuery.range(offset, offset + batchSize - 1);
+                if (batchError) {
+                    throw new Error((0, supabaseClient_1.formatSupabaseError)(batchError));
                 }
-                hasMore = batchData.length === batchSize;
-            }
-            else {
-                hasMore = false;
+                if (Array.isArray(batchData)) {
+                    for (const row of batchData) {
+                        returnData.push({ json: row });
+                    }
+                    hasMore = batchData.length === batchSize;
+                }
+                else {
+                    hasMore = false;
+                }
+                offset += batchSize;
             }
-            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 });
+        else {
+            const limit = this.getNodeParameter('limit', itemIndex, undefined);
+            const offset = this.getNodeParameter('offset', itemIndex, undefined);
+            let query = buildReadQuery(supabase, table, returnFields, chunkFilters, sort);
+            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 });
+                }
             }
         }
     }
@@ -251,20 +257,27 @@ async function handleRead(supabase, itemIndex) {
 async function handleDelete(supabase, itemIndex) {
     const table = this.getNodeParameter('table', itemIndex);
     (0, supabaseClient_1.validateTableName)(table);
-    let query = supabase.from(table).delete();
     const filters = this.getNodeParameter('filters.filter', itemIndex, []);
     if (filters.length === 0) {
         throw new Error('At least one filter is required for delete operations to prevent accidental data loss');
     }
-    for (const filter of filters) {
-        const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
-        query = query.filter(filter.column, operator, (0, supabaseClient_1.normalizeFilterValue)(filter.operator, filter.value));
-    }
-    const { data, error } = await query.select();
-    if (error) {
-        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters);
+    const allDeleted = [];
+    for (const chunkFilters of filterChunks) {
+        let query = supabase.from(table).delete();
+        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));
+        }
+        if (Array.isArray(data)) {
+            allDeleted.push(...data);
+        }
     }
-    return [{ json: { data, operation: 'delete', table, deleted: (data === null || data === void 0 ? void 0 : data.length) || 0 } }];
+    return [{ json: { data: allDeleted, operation: 'delete', table, deleted: allDeleted.length } }];
 }
 async function handleCreateTable(supabase, itemIndex) {
     const tableName = this.getNodeParameter('tableName', itemIndex);

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

@@ -8,7 +8,7 @@ export interface ISupabaseCredentials {
 export interface IRowFilter {
     column: string;
     operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd';
-    value: string | number | boolean | null;
+    value: string | number | boolean | null | unknown[];
 }
 export interface IRowSort {
     column: string;

package/dist/nodes/Supabase/utils/supabaseClient.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-import { ISupabaseCredentials } from '../types';
+import { ISupabaseCredentials, IRowFilter } from '../types';
 export declare function createSupabaseClient(credentials: ISupabaseCredentials): SupabaseClient;
 export declare function validateCredentials(credentials: ISupabaseCredentials): void;
 export declare function getStorageUrl(projectUrl: string): string;
@@ -11,4 +11,7 @@ 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;
+export declare function normalizeFilterValue(operator: string, value: string | number | boolean | null | unknown[]): string | number | boolean | null;
+export declare const IN_FILTER_CHUNK_SIZE = 200;
+export declare function chunkArray<T>(arr: T[], size: number): T[][];
+export declare function expandChunkedFilters(filters: IRowFilter[]): IRowFilter[][];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.expandChunkedFilters = exports.chunkArray = exports.IN_FILTER_CHUNK_SIZE = 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, {
@@ -137,13 +137,60 @@ function convertFilterOperator(operator) {
 }
 exports.convertFilterOperator = convertFilterOperator;
 function normalizeFilterValue(operator, value) {
-    if (operator === 'in' && typeof value === 'string') {
-        const trimmed = value.trim();
-        if (!trimmed.startsWith('(')) {
-            return `(${trimmed})`;
+    if (operator === 'in') {
+        if (Array.isArray(value)) {
+            return `(${value.join(',')})`;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed.startsWith('(')) {
+                return `(${trimmed})`;
+            }
+            return trimmed;
         }
-        return trimmed;
     }
     return value;
 }
 exports.normalizeFilterValue = normalizeFilterValue;
+exports.IN_FILTER_CHUNK_SIZE = 200;
+function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size) {
+        chunks.push(arr.slice(i, i + size));
+    }
+    return chunks;
+}
+exports.chunkArray = chunkArray;
+function expandChunkedFilters(filters) {
+    const staticFilters = [];
+    const chunkedEntries = [];
+    for (const filter of filters) {
+        if (filter.operator === 'in' && Array.isArray(filter.value) && filter.value.length > exports.IN_FILTER_CHUNK_SIZE) {
+            chunkedEntries.push({
+                filter,
+                chunks: chunkArray(filter.value, exports.IN_FILTER_CHUNK_SIZE),
+            });
+        }
+        else {
+            staticFilters.push(filter);
+        }
+    }
+    if (chunkedEntries.length === 0) {
+        return [filters];
+    }
+    let combinations = [staticFilters];
+    for (const { filter, chunks } of chunkedEntries) {
+        const newCombinations = [];
+        for (const existing of combinations) {
+            for (const chunk of chunks) {
+                newCombinations.push([
+                    ...existing,
+                    { ...filter, value: chunk },
+                ]);
+            }
+        }
+        combinations = newCombinations;
+    }
+    return combinations;
+}
+exports.expandChunkedFilters = expandChunkedFilters;

package/package.json

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