@fachkraftfreund/n8n-nodes-supabase 1.3.14 → 1.4.1

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

@@ -565,7 +565,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['read'],
+                            operation: ['read', 'count'],
                         },
                     },
                     options: [
@@ -729,6 +729,37 @@ class Supabase {
                         },
                     },
                 },
+                {
+                    displayName: 'Batch Counts',
+                    name: 'batchCounts',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to combine all input items into a single GROUP BY query instead of one count per item. Requires the exec_sql_select RPC function.',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['count'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Group By Column',
+                    name: 'groupByColumn',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getColumns',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'Column to group counts by (e.g. sector). Each unique value produces one output item with its count.',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['count'],
+                            batchCounts: [true],
+                        },
+                    },
+                },
                 {
                     displayName: 'Bucket',
                     name: 'bucket',
@@ -1023,7 +1054,23 @@ class Supabase {
         const supabase = (0, supabaseClient_1.createSupabaseClient)(credentials);
         const resource = this.getNodeParameter('resource', 0);
         const operation = this.getNodeParameter('operation', 0);
-        if (resource === 'database' && ['create', 'upsert', 'update'].includes(operation)) {
+        if (resource === 'database' && operation === 'count' && this.getNodeParameter('batchCounts', 0, false)) {
+            try {
+                const results = await database_1.executeBulkDatabaseOperation.call(this, supabase, operation, items.length);
+                for (const r of results)
+                    returnData.push(r);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: errorMessage } });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
+                }
+            }
+        }
+        else if (resource === 'database' && ['create', 'upsert', 'update'].includes(operation)) {
             const firstItem = items[0];
             if (items.length === 1 &&
                 (firstItem === null || firstItem === void 0 ? void 0 : firstItem.json) &&
@@ -1045,7 +1092,7 @@ class Supabase {
                 }
             }
         }
-        else if (resource === 'database' && (operation === 'read' || operation === 'count')) {
+        else if (resource === 'database' && operation === 'read') {
             try {
                 const operationResults = await database_1.executeDatabaseOperation.call(this, supabase, operation, 0, credentials.host);
                 for (const r of operationResults)

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

@@ -178,6 +178,8 @@ async function executeBulkDatabaseOperation(supabase, operation, itemCount) {
                 return await handleBulkUpsert.call(this, supabase, itemCount);
             case 'update':
                 return await handleBulkUpdate.call(this, supabase, itemCount);
+            case 'count':
+                return await handleBatchCount.call(this, supabase, itemCount);
             default:
                 throw new Error(`Operation ${operation} does not support bulk mode`);
         }
@@ -786,12 +788,22 @@ async function handleCount(supabase, itemIndex, hostUrl) {
     const table = this.getNodeParameter('table', itemIndex);
     (0, supabaseClient_1.validateTableName)(table);
     const filters = getFilters(this, itemIndex);
-    const overhead = (0, supabaseClient_1.estimateUrlOverhead)(hostUrl, table, undefined, filters);
+    const joins = this.getNodeParameter('joins.join', itemIndex, []);
+    let selectWithJoins = '*';
+    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 overhead = (0, supabaseClient_1.estimateUrlOverhead)(hostUrl, table, selectWithJoins, filters);
     const maxInChars = Math.max(500, supabaseClient_1.MAX_SAFE_URL_LENGTH - overhead);
-    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters, maxInChars);
+    const maxItems = (0, supabaseClient_1.computeMaxIdsPerChunk)(selectWithJoins);
+    const filterChunks = (0, supabaseClient_1.expandChunkedFilters)(filters, maxInChars, maxItems);
     let totalCount = 0;
     for (const chunkFilters of filterChunks) {
-        let query = supabase.from(table).select('*', { count: 'exact', head: true });
+        let query = supabase.from(table).select(selectWithJoins, { count: 'exact', head: true });
         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));
@@ -803,3 +815,90 @@ async function handleCount(supabase, itemIndex, hostUrl) {
     }
     return [{ json: { count: totalCount, table } }];
 }
+async function handleBatchCount(supabase, itemCount) {
+    const table = this.getNodeParameter('table', 0);
+    const groupByColumn = this.getNodeParameter('groupByColumn', 0);
+    (0, supabaseClient_1.validateTableName)(table);
+    (0, supabaseClient_1.validateColumnName)(groupByColumn);
+    const baseFilters = getFilters(this, 0);
+    const groupValues = new Set();
+    for (let i = 0; i < itemCount; i++) {
+        const itemFilters = getFilters(this, i);
+        for (const f of itemFilters) {
+            if (f.column === groupByColumn) {
+                groupValues.add(String(f.value));
+            }
+        }
+    }
+    const whereClauses = [];
+    const staticFilters = baseFilters.filter(f => f.column !== groupByColumn);
+    for (const f of staticFilters) {
+        const col = `"${f.column}"`;
+        switch (f.operator) {
+            case 'eq':
+                whereClauses.push(`${col} = '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'neq':
+                whereClauses.push(`${col} != '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'gt':
+                whereClauses.push(`${col} > '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'gte':
+                whereClauses.push(`${col} >= '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'lt':
+                whereClauses.push(`${col} < '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'lte':
+                whereClauses.push(`${col} <= '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'is':
+                whereClauses.push(`${col} IS ${f.value}`);
+                break;
+            case 'like':
+                whereClauses.push(`${col} LIKE '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'ilike':
+                whereClauses.push(`${col} ILIKE '${String(f.value).replace(/'/g, "''")}'`);
+                break;
+            case 'in': {
+                const vals = Array.isArray(f.value) ? f.value : String(f.value).split(',');
+                const escaped = vals.map(v => `'${String(v).trim().replace(/'/g, "''")}'`).join(',');
+                whereClauses.push(`${col} IN (${escaped})`);
+                break;
+            }
+            default: whereClauses.push(`${col} = '${String(f.value).replace(/'/g, "''")}'`);
+        }
+    }
+    if (groupValues.size > 0) {
+        const escaped = Array.from(groupValues).map(v => `'${v.replace(/'/g, "''")}'`).join(',');
+        whereClauses.push(`"${groupByColumn}" IN (${escaped})`);
+    }
+    const joins = this.getNodeParameter('joins.join', 0, []);
+    const joinClauses = [];
+    for (const j of joins) {
+        if (!j.table)
+            continue;
+        (0, supabaseClient_1.validateTableName)(j.table);
+        const joinType = j.joinType === 'inner' ? 'INNER JOIN' : 'LEFT JOIN';
+        joinClauses.push(`${joinType} "${j.table}" ON "${j.table}"."${table.replace(/s$/, '')}_id" = "${table}"."id"`);
+    }
+    const whereStr = whereClauses.length > 0 ? ` WHERE ${whereClauses.join(' AND ')}` : '';
+    const joinStr = joinClauses.length > 0 ? ` ${joinClauses.join(' ')}` : '';
+    const sql = `SELECT "${groupByColumn}", COUNT(*) as count FROM "${table}"${joinStr}${whereStr} GROUP BY "${groupByColumn}" ORDER BY count DESC`;
+    console.log(`[Supabase BATCH COUNT] sql: ${sql}`);
+    const { data, error } = await supabase.rpc('exec_sql_select', { sql });
+    if (error)
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    if (!Array.isArray(data) || data.length === 0) {
+        return [{ json: { table, groupByColumn, counts: [], message: 'No rows matched' } }];
+    }
+    return data.map((row) => ({
+        json: {
+            [groupByColumn]: row[groupByColumn],
+            count: Number(row.count),
+            table,
+        },
+    }));
+}

package/package.json

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