@fachkraftfreund/n8n-nodes-supabase 1.2.4 → 1.2.6

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

@@ -129,6 +129,12 @@ class Supabase {
                             description: 'Execute custom SQL query',
                             action: 'Execute custom query',
                         },
+                        {
+                            name: 'Find or Create',
+                            value: 'findOrCreate',
+                            description: 'Return existing row matching criteria, or create it if not found',
+                            action: 'Find or create row',
+                        },
                     ],
                     default: 'read',
                 },
@@ -255,7 +261,7 @@ class Supabase {
                     displayOptions: {
                         show: {
                             resource: ['database'],
-                            operation: ['create', 'read', 'update', 'delete', 'upsert'],
+                            operation: ['create', 'read', 'update', 'delete', 'upsert', 'findOrCreate'],
                         },
                     },
                 },
@@ -316,14 +322,12 @@ class Supabase {
                     },
                 },
                 {
-                    displayName: 'On Conflict Column',
+                    displayName: 'On Conflict Columns',
                     name: 'onConflict',
-                    type: 'options',
-                    typeOptions: {
-                        loadOptionsMethod: 'getColumns',
-                    },
+                    type: 'string',
                     default: '',
-                    description: 'Column to use for conflict resolution (usually the primary key). Leave empty to use the default.',
+                    placeholder: 'id or company_id,name',
+                    description: 'Comma-separated column(s) to use for conflict resolution. Required for composite unique constraints (e.g. company_id,name).',
                     displayOptions: {
                         show: {
                             resource: ['database'],
@@ -331,6 +335,90 @@ class Supabase {
                         },
                     },
                 },
+                {
+                    displayName: 'Match Columns',
+                    name: 'matchColumns',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    placeholder: 'Add Match Column',
+                    description: 'Columns used to look up an existing row. If a row matches all values, it is returned; otherwise a new row is created.',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['findOrCreate'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Column',
+                            name: 'column',
+                            values: [
+                                {
+                                    displayName: 'Column',
+                                    name: 'name',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getColumns',
+                                    },
+                                    default: '',
+                                    description: 'Column to match on',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Value to match',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Additional Columns',
+                    name: 'additionalColumns',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    placeholder: 'Add Column',
+                    description: 'Extra columns to set when creating a new row (not used when a match is found)',
+                    displayOptions: {
+                        show: {
+                            resource: ['database'],
+                            operation: ['findOrCreate'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Column',
+                            name: 'column',
+                            values: [
+                                {
+                                    displayName: 'Column',
+                                    name: 'name',
+                                    type: 'options',
+                                    typeOptions: {
+                                        loadOptionsMethod: 'getColumns',
+                                    },
+                                    default: '',
+                                    description: 'Column name',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Value to set',
+                                },
+                            ],
+                        },
+                    ],
+                },
                 {
                     displayName: 'Filters',
                     name: 'filters',

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

@@ -42,6 +42,9 @@ async function executeDatabaseOperation(supabase, operation, itemIndex) {
             case 'customQuery':
                 returnData.push(...await handleCustomQuery.call(this, supabase, itemIndex));
                 break;
+            case 'findOrCreate':
+                returnData.push(...await handleFindOrCreate.call(this, supabase, itemIndex));
+                break;
             default:
                 throw new Error(`Unknown database operation: ${operation}`);
         }
@@ -355,7 +358,8 @@ async function handleCustomQuery(supabase, itemIndex) {
     if (!(customSql === null || customSql === void 0 ? void 0 : customSql.trim())) {
         throw new Error('SQL query is required');
     }
-    if (customSql.trim().toLowerCase().startsWith('select')) {
+    const returnsRows = /^\s*(select|with|explain|table)\b/i.test(customSql);
+    if (returnsRows) {
         const { data, error } = await supabase.rpc('exec_sql_select', { sql: customSql });
         if (error) {
             throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
@@ -386,3 +390,39 @@ async function handleCustomQuery(supabase, itemIndex) {
         return [{ json: { operation: 'customQuery', sql: customSql, result: data, success: true } }];
     }
 }
+async function handleFindOrCreate(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    (0, supabaseClient_1.validateTableName)(table);
+    const matchCols = this.getNodeParameter('matchColumns.column', itemIndex, []);
+    if (matchCols.length === 0) {
+        throw new Error('At least one Match Column is required for Find or Create');
+    }
+    let query = supabase.from(table).select('*');
+    for (const col of matchCols) {
+        if (!col.name)
+            continue;
+        (0, supabaseClient_1.validateColumnName)(col.name);
+        query = query.eq(col.name, col.value);
+    }
+    query = query.limit(1);
+    const { data: existing, error: readError } = await query;
+    if (readError)
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(readError));
+    if (existing && existing.length > 0) {
+        return [{ json: { ...existing[0], _found: true, _created: false } }];
+    }
+    const additionalCols = this.getNodeParameter('additionalColumns.column', itemIndex, []);
+    const dataToInsert = {};
+    for (const col of [...matchCols, ...additionalCols]) {
+        if (col.name)
+            dataToInsert[col.name] = col.value;
+    }
+    const { data: created, error: insertError } = await supabase
+        .from(table)
+        .insert(dataToInsert)
+        .select()
+        .single();
+    if (insertError)
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(insertError));
+    return [{ json: { ...created, _found: false, _created: true } }];
+}

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';
+export type DatabaseOperation = 'create' | 'read' | 'update' | 'delete' | 'upsert' | 'createTable' | 'dropTable' | 'addColumn' | 'dropColumn' | 'createIndex' | 'dropIndex' | 'customQuery' | 'findOrCreate';
 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.4",
+  "version": "1.2.6",
   "description": "Comprehensive n8n community node for Supabase with database and storage operations",
   "keywords": [
     "n8n-community-node-package",