@fachkraftfreund/n8n-nodes-supabase 1.2.12 → 1.2.14

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

@@ -928,7 +928,7 @@ class Supabase {
                 try {
                     let operationResults = [];
                     if (resource === 'database') {
-                        operationResults = await database_1.executeDatabaseOperation.call(this, supabase, operation, itemIndex);
+                        operationResults = await database_1.executeDatabaseOperation.call(this, supabase, operation, itemIndex, credentials.host);
                     }
                     else if (resource === 'storage') {
                         operationResults = await storage_1.executeStorageOperation.call(this, supabase, operation, itemIndex);

package/dist/nodes/Supabase/operations/database/index.d.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
 import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
 import { DatabaseOperation } from '../../types';
-export declare function executeDatabaseOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: DatabaseOperation, itemIndex: number): Promise<INodeExecutionData[]>;
+export declare function executeDatabaseOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: DatabaseOperation, itemIndex: number, hostUrl: string): Promise<INodeExecutionData[]>;
 export declare function executeBulkDatabaseOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: DatabaseOperation, itemCount: number): Promise<INodeExecutionData[]>;

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

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeBulkDatabaseOperation = exports.executeDatabaseOperation = void 0;
 const supabaseClient_1 = require("../../utils/supabaseClient");
-async function executeDatabaseOperation(supabase, operation, itemIndex) {
+async function executeDatabaseOperation(supabase, operation, itemIndex, hostUrl) {
     const returnData = [];
     try {
         switch (operation) {
             case 'read':
-                returnData.push(...await handleRead.call(this, supabase, itemIndex));
+                returnData.push(...await handleRead.call(this, supabase, itemIndex, hostUrl));
                 break;
             case 'delete':
-                returnData.push(...await handleDelete.call(this, supabase, itemIndex));
+                returnData.push(...await handleDelete.call(this, supabase, itemIndex, hostUrl));
                 break;
             case 'createTable':
                 returnData.push(...await handleCreateTable.call(this, supabase, itemIndex));
@@ -188,23 +188,25 @@ function buildReadQuery(supabase, table, returnFields, filters, sort, options) {
     }
     return query;
 }
-async function handleRead(supabase, itemIndex) {
+async function handleRead(supabase, itemIndex, hostUrl) {
     const table = this.getNodeParameter('table', itemIndex);
     (0, supabaseClient_1.validateTableName)(table);
     const returnFields = this.getNodeParameter('returnFields', itemIndex, '*');
     const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
     const filters = getFilters(this, itemIndex);
     const sort = this.getNodeParameter('sort.sortField', itemIndex, []);
-    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters);
+    const overhead = (0, supabaseClient_1.estimateUrlOverhead)(hostUrl, table, returnFields, filters, sort);
+    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) {
-        if (returnAll) {
+    if (returnAll) {
+        for (const chunkFilters of filterChunks) {
             const batchSize = 1000;
-            let offset = 0;
+            let batchOffset = 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);
+                const { data: batchData, error: batchError } = await batchQuery.range(batchOffset, batchOffset + batchSize - 1);
                 if (batchError) {
                     throw new Error((0, supabaseClient_1.formatSupabaseError)(batchError));
                 }
@@ -217,18 +219,26 @@ async function handleRead(supabase, itemIndex) {
                 else {
                     hasMore = false;
                 }
-                offset += batchSize;
+                batchOffset += batchSize;
             }
         }
-        else {
-            const limit = this.getNodeParameter('limit', itemIndex, undefined);
-            const offset = this.getNodeParameter('offset', itemIndex, undefined);
+    }
+    else {
+        const limit = this.getNodeParameter('limit', itemIndex, 100);
+        const userOffset = this.getNodeParameter('offset', itemIndex, 0);
+        const isMultiChunk = filterChunks.length > 1;
+        for (const chunkFilters of filterChunks) {
             let query = buildReadQuery(supabase, table, returnFields, chunkFilters, sort);
-            if (limit !== undefined) {
-                query = query.limit(limit);
+            if (isMultiChunk) {
+                query = query.limit(userOffset + limit);
             }
-            if (offset !== undefined) {
-                query = query.range(offset, offset + (limit || 1000) - 1);
+            else {
+                if (userOffset > 0) {
+                    query = query.range(userOffset, userOffset + limit - 1);
+                }
+                else {
+                    query = query.limit(limit);
+                }
             }
             const { data, error } = await query;
             if (error) {
@@ -240,6 +250,11 @@ async function handleRead(supabase, itemIndex) {
                 }
             }
         }
+        if (isMultiChunk && (userOffset > 0 || returnData.length > limit)) {
+            const sliced = returnData.slice(userOffset, userOffset + limit);
+            returnData.length = 0;
+            returnData.push(...sliced);
+        }
     }
     if (returnData.length === 0) {
         returnData.push({
@@ -254,14 +269,16 @@ async function handleRead(supabase, itemIndex) {
     }
     return returnData;
 }
-async function handleDelete(supabase, itemIndex) {
+async function handleDelete(supabase, itemIndex, hostUrl) {
     const table = this.getNodeParameter('table', itemIndex);
     (0, supabaseClient_1.validateTableName)(table);
     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');
     }
-    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters);
+    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 allDeleted = [];
     for (const chunkFilters of filterChunks) {
         let query = supabase.from(table).delete();

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

@@ -1,5 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-import { ISupabaseCredentials, IRowFilter } from '../types';
+import { ISupabaseCredentials, IRowFilter, IRowSort } from '../types';
 export declare function createSupabaseClient(credentials: ISupabaseCredentials): SupabaseClient;
 export declare function validateCredentials(credentials: ISupabaseCredentials): void;
 export declare function getStorageUrl(projectUrl: string): string;
@@ -12,6 +12,7 @@ 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 | 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[][];
+export declare const MAX_SAFE_URL_LENGTH = 7500;
+export declare function estimateUrlOverhead(hostUrl: string, table: string, selectFields?: string, filters?: IRowFilter[], sort?: IRowSort[]): number;
+export declare function chunkInFilterValues(values: unknown[], maxChars: number): unknown[][];
+export declare function expandChunkedFilters(filters: IRowFilter[], maxInChars?: number): IRowFilter[][];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.expandChunkedFilters = exports.chunkInFilterValues = exports.estimateUrlOverhead = exports.MAX_SAFE_URL_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, {
@@ -152,15 +152,41 @@ function normalizeFilterValue(operator, value) {
     return value;
 }
 exports.normalizeFilterValue = normalizeFilterValue;
-exports.IN_FILTER_MAX_CHAR_LENGTH = 4000;
-function chunkInFilterValues(values) {
+exports.MAX_SAFE_URL_LENGTH = 7500;
+const MIN_IN_CHUNK_CHARS = 500;
+function estimateUrlOverhead(hostUrl, table, selectFields, filters, sort) {
+    let overhead = hostUrl.length + '/rest/v1/'.length + table.length + 1;
+    if (selectFields) {
+        overhead += 'select='.length + selectFields.length + 1;
+    }
+    if (filters) {
+        for (const f of filters) {
+            if (f.operator === 'in') {
+                overhead += f.column.length + '=in.()&'.length;
+            }
+            else {
+                const val = normalizeFilterValue(f.operator, f.value);
+                overhead += f.column.length + 1 + f.operator.length + 1 + String(val).length + 1;
+            }
+        }
+    }
+    if (sort) {
+        for (const s of sort) {
+            overhead += 'order='.length + s.column.length + 1 + (s.ascending ? 3 : 4) + 1;
+        }
+    }
+    overhead += 230;
+    return overhead;
+}
+exports.estimateUrlOverhead = estimateUrlOverhead;
+function chunkInFilterValues(values, maxChars) {
     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) {
+        if (currentLength + addedLength > maxChars && currentChunk.length > 0) {
             chunks.push(currentChunk);
             currentChunk = [value];
             currentLength = valueStr.length;
@@ -176,25 +202,57 @@ function chunkInFilterValues(values) {
     return chunks;
 }
 exports.chunkInFilterValues = chunkInFilterValues;
-function expandChunkedFilters(filters) {
+function expandChunkedFilters(filters, maxInChars) {
     const staticFilters = [];
-    const chunkedEntries = [];
+    const inEntries = [];
     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),
-                });
+        if (filter.operator === 'in') {
+            let values;
+            if (Array.isArray(filter.value)) {
+                values = filter.value;
+            }
+            else if (typeof filter.value === 'string') {
+                let str = filter.value.trim();
+                if (str.startsWith('(') && str.endsWith(')'))
+                    str = str.slice(1, -1);
+                if (str.startsWith('[') && str.endsWith(']'))
+                    str = str.slice(1, -1);
+                values = str.split(',').map(v => v.trim()).filter(v => v.length > 0);
+            }
+            else {
+                staticFilters.push(filter);
                 continue;
             }
+            const serializedLength = values.map(String).join(',').length;
+            inEntries.push({ filter: { ...filter, value: values }, values, serializedLength });
+            continue;
         }
         staticFilters.push(filter);
     }
-    if (chunkedEntries.length === 0) {
+    if (inEntries.length === 0) {
         return [filters];
     }
+    const defaultBudget = exports.MAX_SAFE_URL_LENGTH - 500;
+    const totalBudget = maxInChars !== null && maxInChars !== void 0 ? maxInChars : defaultBudget;
+    const perFilterBudget = Math.max(MIN_IN_CHUNK_CHARS, Math.floor(totalBudget / inEntries.length));
+    const chunkedEntries = [];
+    for (const entry of inEntries) {
+        if (entry.serializedLength > perFilterBudget) {
+            chunkedEntries.push({
+                filter: entry.filter,
+                chunks: chunkInFilterValues(entry.values, perFilterBudget),
+            });
+        }
+        else {
+            staticFilters.push(entry.filter);
+        }
+    }
+    if (chunkedEntries.length === 0) {
+        return [filters.map(f => {
+                const inEntry = inEntries.find(e => e.filter.column === f.column && f.operator === 'in');
+                return inEntry ? inEntry.filter : f;
+            })];
+    }
     let combinations = [staticFilters];
     for (const { filter, chunks } of chunkedEntries) {
         const newCombinations = [];

package/package.json

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