@fachkraftfreund/n8n-nodes-supabase 1.2.8 → 1.2.9

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fachkraftfreund/n8n-nodes-supabase",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "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": {