@fachkraftfreund/n8n-nodes-supabase 1.2.0

package/dist/nodes/Supabase/icons/supabase.svg

@@ -0,0 +1,15 @@
+<svg width="109" height="113" viewBox="0 0 109 113" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M63.7076 110.284C60.8481 113.885 55.0502 111.912 54.9813 107.314L53.9738 40.0627L99.1935 40.0627C107.384 40.0627 111.952 49.5228 106.859 55.9374L63.7076 110.284Z" fill="url(#paint0_linear)"/>
+<path d="M63.7076 110.284C60.8481 113.885 55.0502 111.912 54.9813 107.314L53.9738 40.0627L99.1935 40.0627C107.384 40.0627 111.952 49.5228 106.859 55.9374L63.7076 110.284Z" fill="url(#paint1_linear)" fill-opacity="0.2"/>
+<path d="M45.317 2.07103C48.1765 -1.53037 53.9745 0.442937 54.0434 5.041L54.4849 72.2922H9.83113C1.64038 72.2922 -2.92775 62.8321 2.1655 56.4175L45.317 2.07103Z" fill="#3ECF8E"/>
+<defs>
+<linearGradient id="paint0_linear" x1="53.9738" y1="54.974" x2="94.1635" y2="71.8295" gradientUnits="userSpaceOnUse">
+<stop stop-color="#249361"/>
+<stop offset="1" stop-color="#3ECF8E"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="36.1558" y1="30.578" x2="54.4844" y2="65.0806" gradientUnits="userSpaceOnUse">
+<stop/>
+<stop offset="1" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>

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

@@ -0,0 +1,4 @@
+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[]>;

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

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeDatabaseOperation = void 0;
+const supabaseClient_1 = require("../../utils/supabaseClient");
+async function executeDatabaseOperation(supabase, operation, itemIndex) {
+    const returnData = [];
+    try {
+        switch (operation) {
+            case 'create':
+                returnData.push(...await handleCreate.call(this, supabase, itemIndex));
+                break;
+            case 'read':
+                returnData.push(...await handleRead.call(this, supabase, itemIndex));
+                break;
+            case 'update':
+                returnData.push(...await handleUpdate.call(this, supabase, itemIndex));
+                break;
+            case 'delete':
+                returnData.push(...await handleDelete.call(this, supabase, itemIndex));
+                break;
+            case 'upsert':
+                returnData.push(...await handleUpsert.call(this, supabase, itemIndex));
+                break;
+            case 'createTable':
+                returnData.push(...await handleCreateTable.call(this, supabase, itemIndex));
+                break;
+            case 'dropTable':
+                returnData.push(...await handleDropTable.call(this, supabase, itemIndex));
+                break;
+            case 'addColumn':
+                returnData.push(...await handleAddColumn.call(this, supabase, itemIndex));
+                break;
+            case 'dropColumn':
+                returnData.push(...await handleDropColumn.call(this, supabase, itemIndex));
+                break;
+            case 'createIndex':
+                returnData.push(...await handleCreateIndex.call(this, supabase, itemIndex));
+                break;
+            case 'dropIndex':
+                returnData.push(...await handleDropIndex.call(this, supabase, itemIndex));
+                break;
+            case 'customQuery':
+                returnData.push(...await handleCustomQuery.call(this, supabase, itemIndex));
+                break;
+            default:
+                throw new Error(`Unknown database operation: ${operation}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Database operation failed: ${(0, supabaseClient_1.formatSupabaseError)(error)}`);
+    }
+    return returnData;
+}
+exports.executeDatabaseOperation = executeDatabaseOperation;
+async function handleCreate(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+    (0, supabaseClient_1.validateTableName)(table);
+    let dataToInsert;
+    if (uiMode === 'advanced') {
+        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
+        try {
+            dataToInsert = JSON.parse(jsonData);
+        }
+        catch {
+            throw new Error('Invalid JSON data provided');
+        }
+    }
+    else {
+        const columns = this.getNodeParameter('columns.column', itemIndex, []);
+        dataToInsert = {};
+        for (const column of columns) {
+            if (column.name && column.value !== undefined) {
+                dataToInsert[column.name] = column.value;
+            }
+        }
+    }
+    const { data, error } = await supabase
+        .from(table)
+        .insert(dataToInsert)
+        .select();
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { data, operation: 'create', table } }];
+}
+async function handleRead(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+    (0, supabaseClient_1.validateTableName)(table);
+    let query = supabase.from(table).select('*');
+    const returnFields = this.getNodeParameter('returnFields', itemIndex, '*');
+    if (returnFields && returnFields !== '*') {
+        query = supabase.from(table).select(returnFields);
+    }
+    if (uiMode === 'simple') {
+        const filters = this.getNodeParameter('filters.filter', itemIndex, []);
+        for (const filter of filters) {
+            const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
+            query = query.filter(filter.column, operator, filter.value);
+        }
+    }
+    else {
+        const advancedFilters = this.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), value);
+                    }
+                    else {
+                        query = query.eq(column, condition);
+                    }
+                }
+            }
+            catch {
+                throw new Error('Invalid advanced filters JSON');
+            }
+        }
+    }
+    const sort = this.getNodeParameter('sort.sortField', itemIndex, []);
+    for (const sortField of sort) {
+        query = query.order(sortField.column, { ascending: sortField.ascending });
+    }
+    const limit = this.getNodeParameter('limit', itemIndex, undefined);
+    const offset = this.getNodeParameter('offset', itemIndex, undefined);
+    if (limit !== undefined) {
+        query = query.limit(limit);
+    }
+    if (offset !== undefined) {
+        query = query.range(offset, offset + (limit || 1000) - 1);
+    }
+    const { data, error, count } = await query;
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    const returnData = [];
+    if (Array.isArray(data)) {
+        for (const row of data) {
+            returnData.push({ json: row });
+        }
+    }
+    if (returnData.length === 0) {
+        returnData.push({
+            json: {
+                data: [],
+                count: count || 0,
+                operation: 'read',
+                table,
+                message: 'No records found',
+            },
+        });
+    }
+    return returnData;
+}
+async function handleUpdate(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+    (0, supabaseClient_1.validateTableName)(table);
+    let dataToUpdate;
+    if (uiMode === 'advanced') {
+        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
+        try {
+            dataToUpdate = JSON.parse(jsonData);
+        }
+        catch {
+            throw new Error('Invalid JSON data provided');
+        }
+    }
+    else {
+        const columns = this.getNodeParameter('columns.column', itemIndex, []);
+        dataToUpdate = {};
+        for (const column of columns) {
+            if (column.name && column.value !== undefined) {
+                dataToUpdate[column.name] = column.value;
+            }
+        }
+    }
+    let query = supabase.from(table).update(dataToUpdate);
+    const filters = this.getNodeParameter('filters.filter', itemIndex, []);
+    for (const filter of filters) {
+        const operator = (0, supabaseClient_1.convertFilterOperator)(filter.operator);
+        query = query.filter(filter.column, operator, filter.value);
+    }
+    const { data, error } = await query.select();
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { data, operation: 'update', table, updated: (data === null || data === void 0 ? void 0 : data.length) || 0 } }];
+}
+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, filter.value);
+    }
+    const { data, error } = await query.select();
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { data, operation: 'delete', table, deleted: (data === null || data === void 0 ? void 0 : data.length) || 0 } }];
+}
+async function handleUpsert(supabase, itemIndex) {
+    const table = this.getNodeParameter('table', itemIndex);
+    const uiMode = this.getNodeParameter('uiMode', itemIndex, 'simple');
+    const onConflict = this.getNodeParameter('onConflict', itemIndex, '');
+    (0, supabaseClient_1.validateTableName)(table);
+    let dataToUpsert;
+    if (uiMode === 'advanced') {
+        const jsonData = this.getNodeParameter('jsonData', itemIndex, '{}');
+        try {
+            dataToUpsert = JSON.parse(jsonData);
+        }
+        catch {
+            throw new Error('Invalid JSON data provided');
+        }
+    }
+    else {
+        const columns = this.getNodeParameter('columns.column', itemIndex, []);
+        dataToUpsert = {};
+        for (const column of columns) {
+            if (column.name && column.value !== undefined) {
+                dataToUpsert[column.name] = column.value;
+            }
+        }
+    }
+    const options = {};
+    if (onConflict) {
+        options.onConflict = onConflict;
+    }
+    const { data, error } = await supabase
+        .from(table)
+        .upsert(dataToUpsert, options)
+        .select();
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { data, operation: 'upsert', table } }];
+}
+async function handleCreateTable(supabase, itemIndex) {
+    const tableName = this.getNodeParameter('tableName', itemIndex);
+    const columns = this.getNodeParameter('columnDefinitions.column', itemIndex, []);
+    (0, supabaseClient_1.validateTableName)(tableName);
+    if (columns.length === 0) {
+        throw new Error('At least one column definition is required');
+    }
+    let sql = `CREATE TABLE "${tableName}" (`;
+    const columnDefs = [];
+    for (const column of columns) {
+        (0, supabaseClient_1.validateColumnName)(column.name);
+        let columnDef = `"${column.name}" ${column.type}`;
+        if (!column.nullable) {
+            columnDef += ' NOT NULL';
+        }
+        if (column.defaultValue) {
+            columnDef += ` DEFAULT ${column.defaultValue}`;
+        }
+        if (column.primaryKey) {
+            columnDef += ' PRIMARY KEY';
+        }
+        if (column.unique && !column.primaryKey) {
+            columnDef += ' UNIQUE';
+        }
+        columnDefs.push(columnDef);
+    }
+    sql += columnDefs.join(', ') + ')';
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'createTable', tableName, sql, success: true } }];
+}
+async function handleDropTable(supabase, itemIndex) {
+    const tableName = this.getNodeParameter('tableName', itemIndex);
+    const cascade = this.getNodeParameter('cascade', itemIndex, false);
+    (0, supabaseClient_1.validateTableName)(tableName);
+    const sql = `DROP TABLE "${tableName}"${cascade ? ' CASCADE' : ''}`;
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'dropTable', tableName, sql, success: true } }];
+}
+async function handleAddColumn(supabase, itemIndex) {
+    const tableName = this.getNodeParameter('tableName', itemIndex);
+    const columnDefinition = this.getNodeParameter('columnDefinition', itemIndex);
+    (0, supabaseClient_1.validateTableName)(tableName);
+    (0, supabaseClient_1.validateColumnName)(columnDefinition.name);
+    let sql = `ALTER TABLE "${tableName}" ADD COLUMN "${columnDefinition.name}" ${columnDefinition.type}`;
+    if (!columnDefinition.nullable) {
+        sql += ' NOT NULL';
+    }
+    if (columnDefinition.defaultValue) {
+        sql += ` DEFAULT ${columnDefinition.defaultValue}`;
+    }
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'addColumn', tableName, columnName: columnDefinition.name, sql, success: true } }];
+}
+async function handleDropColumn(supabase, itemIndex) {
+    const tableName = this.getNodeParameter('tableName', itemIndex);
+    const columnName = this.getNodeParameter('columnName', itemIndex);
+    const cascade = this.getNodeParameter('cascade', itemIndex, false);
+    (0, supabaseClient_1.validateTableName)(tableName);
+    (0, supabaseClient_1.validateColumnName)(columnName);
+    const sql = `ALTER TABLE "${tableName}" DROP COLUMN "${columnName}"${cascade ? ' CASCADE' : ''}`;
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'dropColumn', tableName, columnName, sql, success: true } }];
+}
+async function handleCreateIndex(supabase, itemIndex) {
+    const tableName = this.getNodeParameter('tableName', itemIndex);
+    const indexDefinition = this.getNodeParameter('indexDefinition', itemIndex);
+    (0, supabaseClient_1.validateTableName)(tableName);
+    if (!indexDefinition.name || indexDefinition.columns.length === 0) {
+        throw new Error('Index name and columns are required');
+    }
+    const uniqueKeyword = indexDefinition.unique ? 'UNIQUE ' : '';
+    const method = indexDefinition.method ? ` USING ${indexDefinition.method}` : '';
+    const columnList = indexDefinition.columns.map(col => `"${col}"`).join(', ');
+    const sql = `CREATE ${uniqueKeyword}INDEX "${indexDefinition.name}" ON "${tableName}"${method} (${columnList})`;
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'createIndex', tableName, indexName: indexDefinition.name, sql, success: true } }];
+}
+async function handleDropIndex(supabase, itemIndex) {
+    const indexName = this.getNodeParameter('indexName', itemIndex);
+    const cascade = this.getNodeParameter('cascade', itemIndex, false);
+    if (!indexName) {
+        throw new Error('Index name is required');
+    }
+    const sql = `DROP INDEX "${indexName}"${cascade ? ' CASCADE' : ''}`;
+    const { data, error } = await supabase.rpc('exec_sql', { sql });
+    if (error) {
+        throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+    }
+    return [{ json: { operation: 'dropIndex', indexName, sql, success: true } }];
+}
+async function handleCustomQuery(supabase, itemIndex) {
+    const customSql = this.getNodeParameter('customSql', 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 { data, error } = await supabase.rpc('exec_sql_select', { sql: customSql });
+        if (error) {
+            throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+        }
+        const returnData = [];
+        if (Array.isArray(data)) {
+            for (const row of data) {
+                returnData.push({ json: row });
+            }
+        }
+        if (returnData.length === 0) {
+            returnData.push({
+                json: {
+                    data: [],
+                    operation: 'customQuery',
+                    sql: customSql,
+                    message: 'Query executed successfully, no results returned',
+                },
+            });
+        }
+        return returnData;
+    }
+    else {
+        const { data, error } = await supabase.rpc('exec_sql', { sql: customSql });
+        if (error) {
+            throw new Error((0, supabaseClient_1.formatSupabaseError)(error));
+        }
+        return [{ json: { operation: 'customQuery', sql: customSql, result: data, success: true } }];
+    }
+}

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

@@ -0,0 +1,4 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+import { StorageOperation } from '../../types';
+export declare function executeStorageOperation(this: IExecuteFunctions, supabase: SupabaseClient, operation: StorageOperation, itemIndex: number): Promise<INodeExecutionData[]>;