@fachkraftfreund/n8n-nodes-supabase 1.2.9 → 1.2.11

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_MAX_CHAR_LENGTH = 4000;
+export declare function chunkInFilterValues(values: unknown[]): unknown[][];
+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.chunkInFilterValues = exports.IN_FILTER_MAX_CHAR_LENGTH = 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,77 @@ 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_MAX_CHAR_LENGTH = 4000;
+function chunkInFilterValues(values) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentLength = 0;
+    for (const value of values) {
+        const valueStr = String(value);
+        const addedLength = currentChunk.length === 0 ? valueStr.length : valueStr.length + 1;
+        if (currentLength + addedLength > exports.IN_FILTER_MAX_CHAR_LENGTH && currentChunk.length > 0) {
+            chunks.push(currentChunk);
+            currentChunk = [value];
+            currentLength = valueStr.length;
+        }
+        else {
+            currentChunk.push(value);
+            currentLength += addedLength;
+        }
+    }
+    if (currentChunk.length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+exports.chunkInFilterValues = chunkInFilterValues;
+function expandChunkedFilters(filters) {
+    const staticFilters = [];
+    const chunkedEntries = [];
+    for (const filter of filters) {
+        if (filter.operator === 'in' && Array.isArray(filter.value)) {
+            const serialized = filter.value.map(String).join(',');
+            if (serialized.length > exports.IN_FILTER_MAX_CHAR_LENGTH) {
+                chunkedEntries.push({
+                    filter,
+                    chunks: chunkInFilterValues(filter.value),
+                });
+                continue;
+            }
+        }
+        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.9",
+  "version": "1.2.11",
   "description": "Comprehensive n8n community node for Supabase with database and storage operations",
   "keywords": [
     "n8n-community-node-package",