@rudsys/n8n-nodes-sqlite3 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 RudSys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# n8n-nodes-sqlite3
+
+This is an n8n community node to perform CRUD operations on a **Remote SQLite Database** via **SSH**.
+
+It allows you to manage SQLite databases hosted on remote servers (e.g., VPS, Shared Hosting) without downloading the file.
+
+## Prerequisites
+
+1.  **SSH Access** to the remote server.
+2.  **`sqlite3`** binary must be installed and available in the PATH on the remote server.
+    - Test it by running `ssh user@host "sqlite3 --version"`
+    - If it's not in PATH, you might need to symlink it or use the full path (currently not configurable, defaults to `sqlite3`).
+
+## Operations
+
+### 1. Execute Query
+
+Run any raw SQL query. Useful for complex `JOIN`s, `GROUP BY`, or subqueries.
+
+- **Query:** Type your SQL (e.g., `SELECT * FROM users JOIN orders ON users.id = orders.user_id`).
+
+### 2. Insert
+
+Insert data from n8n items into a table.
+
+- **Conflict Mode:**
+  - **Abort:** Fail if a constraint is violated (default).
+  - **Ignore:** Skip row on conflict (`INSERT OR IGNORE`).
+  - **Replace:** Overwrite existing row (`INSERT OR REPLACE`).
+
+### 3. Select
+
+Read data from a table with advanced options.
+
+- **Columns:** Specify columns (e.g., `id, name, email`) or use `*`. Support for aggregates (e.g., `COUNT(*)`).
+- **Distinct:** Toggle `SELECT DISTINCT` to remove duplicates.
+- **Filters:** Add multiple conditions (AND logic):
+  - Operators: `=`, `!=`, `<`, `<=`, `>`, `>=`, `LIKE`, `NOT LIKE`, `GLOB`, `IN`, `NOT IN`, `BETWEEN`, `IS NULL`, `IS NOT NULL`.
+- **Sort:** Order results by one or more columns (ASC/DESC).
+- **Limit & Offset:** Control pagination.
+
+### 4. Update
+
+Update rows in a table based on conditions.
+
+- **Filters:** Specify which rows to update (WHERE clause).
+- **Data:** The fields in your input JSON will be set in the database.
+
+### 5. Delete
+
+Delete data or tables.
+
+- **Mode:**
+  - **Delete Rows:** Remove specific rows based on Filters.
+  - **Drop Table:** Remove the entire table and its structure.
+
+### 6. Vacuum
+
+- Run `VACUUM` command to rebuild the database file and reclaim space.
+
+## Credentials
+
+Requires **SQLite SSH Credentials**:
+
+- Host
+- Port
+- Username
+- Password OR Private Key
+
+## Output Format
+
+The node attempts to use `sqlite3 -json` for parsing results.
+
+- **JSON (Preferred):** Requires SQLite 3.33.0+ on the remote server.
+- **CSV (Fallback):** Can be selected in "Options" if your remote SQLite version is older. Note: CSV parsing is basic.
+
+## License
+
+MIT

package/dist/credentials/SqliteSsh.credentials.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSsh = void 0;
+class SqliteSsh {
+    constructor() {
+        this.name = 'sqliteSsh';
+        this.displayName = 'SQLite SSH Credentials';
+        this.documentationUrl = 'https://github.com/rudsys/n8n-nodes-sqlite3';
+        this.properties = [
+            {
+                displayName: 'Host',
+                name: 'host',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Port',
+                name: 'port',
+                type: 'number',
+                default: 22,
+                required: true,
+            },
+            {
+                displayName: 'Username',
+                name: 'username',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Authentication Method',
+                name: 'authMethod',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Password',
+                        value: 'password',
+                    },
+                    {
+                        name: 'Private Key',
+                        value: 'privateKey',
+                    },
+                ],
+                default: 'password',
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                displayOptions: {
+                    show: {
+                        authMethod: ['password'],
+                    },
+                },
+                default: '',
+            },
+            {
+                displayName: 'Private Key',
+                name: 'privateKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                    rows: 4,
+                },
+                displayOptions: {
+                    show: {
+                        authMethod: ['privateKey'],
+                    },
+                },
+                default: '',
+                description: 'The private key content (PEM format)',
+            },
+            {
+                displayName: 'Passphrase',
+                name: 'passphrase',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                displayOptions: {
+                    show: {
+                        authMethod: ['privateKey'],
+                    },
+                },
+                default: '',
+                description: 'Passphrase for the private key',
+            },
+        ];
+    }
+}
+exports.SqliteSsh = SqliteSsh;

package/dist/nodes/SqliteSsh/SqliteSsh.node.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSsh = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const node_ssh_1 = require("node-ssh");
+class SqliteSsh {
+    constructor() {
+        this.description = {
+            displayName: 'SQLite SSH',
+            name: 'sqliteSsh',
+            icon: 'fa:database',
+            group: ['transform'],
+            version: 1,
+            description: 'Execute SQLite operations on a remote server via SSH',
+            defaults: {
+                name: 'SQLite SSH',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'sqliteSsh',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Database Path',
+                    name: 'databasePath',
+                    type: 'string',
+                    default: '',
+                    placeholder: '/var/www/html/data/database.db',
+                    required: true,
+                    description: 'Absolute path to the SQLite database file on the remote server',
+                },
+                {
+                    displayName: 'SQLite Binary Path',
+                    name: 'binaryPath',
+                    type: 'string',
+                    default: 'sqlite3',
+                    placeholder: '/usr/bin/sqlite3',
+                    description: 'Path to the sqlite3 binary on the remote server',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Execute Query', value: 'executeQuery', description: 'Execute a raw SQL query' },
+                        { name: 'Insert', value: 'insert', description: 'Insert data from input items' },
+                        { name: 'Select', value: 'select', description: 'Select data from a table' },
+                        { name: 'Update', value: 'update', description: 'Update data in a table' },
+                        { name: 'Delete', value: 'delete', description: 'Delete data from a table' },
+                        { name: 'Vacuum', value: 'vacuum', description: 'Rebuild the database file' },
+                    ],
+                    default: 'executeQuery',
+                },
+                // ------------------ Execute Query ------------------
+                {
+                    displayName: 'Query',
+                    name: 'query',
+                    type: 'string',
+                    typeOptions: { rows: 5 },
+                    displayOptions: { show: { operation: ['executeQuery'] } },
+                    default: '',
+                    placeholder: 'SELECT * FROM users;',
+                    required: true,
+                },
+                // ------------------ Table Field ------------------
+                {
+                    displayName: 'Table',
+                    name: 'table',
+                    type: 'string',
+                    displayOptions: { show: { operation: ['insert', 'select', 'update', 'delete'] } },
+                    default: '',
+                    required: true,
+                },
+                // ------------------ Insert Options ------------------
+                {
+                    displayName: 'Conflict Mode',
+                    name: 'conflictMode',
+                    type: 'options',
+                    displayOptions: { show: { operation: ['insert'] } },
+                    options: [
+                        { name: 'Abort (Fail)', value: 'abort' },
+                        { name: 'Ignore', value: 'ignore' },
+                        { name: 'Replace', value: 'replace' },
+                    ],
+                    default: 'abort',
+                },
+                {
+                    displayName: 'Data Processing Mode',
+                    name: 'dataMode',
+                    type: 'options',
+                    options: [
+                        { name: 'Auto-Map Input Data to Columns', value: 'autoMap', description: 'Use all input items fields as column names' },
+                        { name: 'Map Specific Columns', value: 'define', description: 'Only use specific fields from input items' },
+                    ],
+                    displayOptions: { show: { operation: ['insert', 'update'] } },
+                    default: 'autoMap',
+                    description: 'Choose whether to map all input fields to columns or select specific ones',
+                },
+                {
+                    displayName: 'Columns to Map',
+                    name: 'specificColumns',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['insert', 'update'],
+                            dataMode: ['define'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'id, name, email',
+                    description: 'Comma-separated list of column names to map from input',
+                },
+                // ------------------ Select Options ------------------
+                {
+                    displayName: 'Columns',
+                    name: 'columns',
+                    type: 'string',
+                    displayOptions: { show: { operation: ['select'] } },
+                    default: '*',
+                    description: 'Comma-separated list of columns',
+                },
+                // ------------------ Filters ------------------
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'fixedCollection',
+                    typeOptions: { multipleValues: true },
+                    displayOptions: {
+                        show: { operation: ['select', 'update', 'delete'] },
+                        hide: { deleteMode: ['dropTable'] },
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'filter',
+                            displayName: 'Filter',
+                            values: [
+                                { displayName: 'Column', name: 'column', type: 'string', default: '' },
+                                {
+                                    displayName: 'Operator',
+                                    name: 'operator',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Equal (=)', value: 'equal' },
+                                        { name: 'Not Equal (!=)', value: 'notEqual' },
+                                        { name: 'Like', value: 'like' },
+                                        { name: 'Greater Than (>)', value: 'greater' },
+                                        { name: 'Less Than (<)', value: 'less' },
+                                        { name: 'Is Null', value: 'isNull' },
+                                        { name: 'Is Not Null', value: 'isNotNull' },
+                                    ],
+                                    default: 'equal',
+                                },
+                                {
+                                    displayName: 'Value',
+                                    name: 'value',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: { hide: { operator: ['isNull', 'isNotNull'] } },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('sqliteSsh');
+        const operation = this.getNodeParameter('operation', 0);
+        const databasePath = this.getNodeParameter('databasePath', 0);
+        const binaryPath = this.getNodeParameter('binaryPath', 0, 'sqlite3');
+        const ssh = new node_ssh_1.NodeSSH();
+        // Helpers for SQL Escaping
+        const escapeIdentifier = (id) => `"${id.replace(/"/g, '""')}"`;
+        const escapeValue = (v) => {
+            if (v === null || v === undefined)
+                return 'NULL';
+            if (typeof v === 'number')
+                return String(v);
+            if (typeof v === 'boolean')
+                return v ? '1' : '0';
+            return `'${String(v).replace(/'/g, "''")}'`;
+        };
+        const buildWhereClause = (i) => {
+            const filters = this.getNodeParameter('filters', i, {});
+            if (!filters.filter || filters.filter.length === 0)
+                return '';
+            const clauses = filters.filter.map((f) => {
+                const col = escapeIdentifier(f.column);
+                switch (f.operator) {
+                    case 'equal': return `${col} = ${escapeValue(f.value)}`;
+                    case 'notEqual': return `${col} != ${escapeValue(f.value)}`;
+                    case 'like': return `${col} LIKE ${escapeValue(f.value)}`;
+                    case 'greater': return `${col} > ${escapeValue(f.value)}`;
+                    case 'less': return `${col} < ${escapeValue(f.value)}`;
+                    case 'isNull': return `${col} IS NULL`;
+                    case 'isNotNull': return `${col} IS NOT NULL`;
+                    default: return '';
+                }
+            });
+            return ` WHERE ${clauses.join(' AND ')}`;
+        };
+        try {
+            // 1. Establish SSH Connection
+            await ssh.connect({
+                host: credentials.host,
+                port: credentials.port,
+                username: credentials.username,
+                password: credentials.password,
+                privateKey: credentials.privateKey,
+                passphrase: credentials.passphrase,
+                readyTimeout: 20000,
+            });
+            // 2. Handle Operations
+            if (operation === 'insert') {
+                // BULK INSERT (Efficiency)
+                const table = escapeIdentifier(this.getNodeParameter('table', 0));
+                const conflictMode = this.getNodeParameter('conflictMode', 0, 'abort');
+                const verb = conflictMode === 'replace' ? 'INSERT OR REPLACE' : (conflictMode === 'ignore' ? 'INSERT OR IGNORE' : 'INSERT');
+                if (items.length > 0) {
+                    const dataMode = this.getNodeParameter('dataMode', 0, 'autoMap');
+                    let columnsList = Object.keys(items[0].json);
+                    if (dataMode === 'define') {
+                        const specificColumns = this.getNodeParameter('specificColumns', 0, '')
+                            .split(',')
+                            .map(c => c.trim())
+                            .filter(c => c);
+                        if (specificColumns.length > 0) {
+                            columnsList = specificColumns;
+                        }
+                    }
+                    const columnsSql = columnsList.map(escapeIdentifier).join(', ');
+                    const valuesSql = items.map(item => {
+                        return `(${columnsList.map(k => escapeValue(item.json[k])).join(', ')})`;
+                    }).join(', ');
+                    const sql = `${verb} INTO ${table} (${columnsSql}) VALUES ${valuesSql};`;
+                    const result = await ssh.execCommand(`${binaryPath} -json "${databasePath}" '${sql.replace(/'/g, "'\\''")}'`);
+                    if (result.code !== 0)
+                        throw new Error(result.stderr || 'SQLite Execution Error');
+                    items.forEach((_, i) => returnData.push({ json: { success: true }, pairedItem: { item: i } }));
+                }
+            }
+            else {
+                // ITERATIVE OPERATIONS (Select, Update, Delete, Raw Query)
+                for (let i = 0; i < items.length; i++) {
+                    let sql = '';
+                    const table = this.getNodeParameter('table', i, '') ? escapeIdentifier(this.getNodeParameter('table', i, '')) : '';
+                    if (operation === 'select') {
+                        const columns = this.getNodeParameter('columns', i, '*');
+                        const where = buildWhereClause(i);
+                        sql = `SELECT ${columns} FROM ${table}${where};`;
+                    }
+                    else if (operation === 'update') {
+                        const where = buildWhereClause(i);
+                        const dataMode = this.getNodeParameter('dataMode', i, 'autoMap');
+                        let updateEntries = Object.entries(items[i].json);
+                        if (dataMode === 'define') {
+                            const specificColumns = this.getNodeParameter('specificColumns', i, '')
+                                .split(',')
+                                .map(c => c.trim())
+                                .filter(c => c);
+                            if (specificColumns.length > 0) {
+                                updateEntries = updateEntries.filter(([k]) => specificColumns.includes(k));
+                            }
+                        }
+                        const updateFields = updateEntries
+                            .map(([k, v]) => `${escapeIdentifier(k)} = ${escapeValue(v)}`)
+                            .join(', ');
+                        sql = `UPDATE ${table} SET ${updateFields}${where};`;
+                    }
+                    else if (operation === 'delete') {
+                        const where = buildWhereClause(i);
+                        sql = `DELETE FROM ${table}${where};`;
+                    }
+                    else if (operation === 'executeQuery') {
+                        sql = this.getNodeParameter('query', i);
+                    }
+                    else if (operation === 'vacuum') {
+                        sql = 'VACUUM;';
+                    }
+                    const result = await ssh.execCommand(`${binaryPath} -json "${databasePath}" '${sql.replace(/'/g, "'\\''")}'`);
+                    if (result.code !== 0)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), result.stderr || 'SQLite Error', { itemIndex: i });
+                    if (result.stdout) {
+                        try {
+                            const parsed = JSON.parse(result.stdout);
+                            if (Array.isArray(parsed)) {
+                                parsed.forEach(row => returnData.push({ json: row, pairedItem: { item: i } }));
+                            }
+                            else {
+                                returnData.push({ json: parsed, pairedItem: { item: i } });
+                            }
+                        }
+                        catch {
+                            returnData.push({ json: { output: result.stdout }, pairedItem: { item: i } });
+                        }
+                    }
+                    else {
+                        returnData.push({ json: { success: true }, pairedItem: { item: i } });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            ssh.dispose();
+        }
+        return [returnData];
+    }
+}
+exports.SqliteSsh = SqliteSsh;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@rudsys/n8n-nodes-sqlite3",
+  "version": "0.1.0",
+  "description": "n8n node for Remote SQLite operations via SSH",
+  "license": "MIT",
+  "keywords": [
+    "n8n-community-node-package"
+  ],
+  "scripts": {
+    "build": "n8n-node build",
+    "dev": "n8n-node dev",
+    "lint": "n8n-node lint",
+    "lint:fix": "n8n-node lint --fix"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/SqliteSsh/SqliteSsh.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/SqliteSsh.credentials.js"
+    ]
+  },
+  "devDependencies": {
+    "@n8n/node-cli": "^0.17.0",
+    "@types/node": "^22.0.0",
+    "n8n-workflow": "*",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "node-ssh": "^13.2.1"
+  }
+}