n8n-nodes-datatable-manager 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+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,186 @@
+# n8n-nodes-datatable-manager
+
+[![npm version](https://badge.fury.io/js/n8n-nodes-datatable-manager.svg)](https://badge.fury.io/js/n8n-nodes-datatable-manager)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![n8n Community Node](https://img.shields.io/badge/n8n-Community%20Node-ff6d5a)](https://n8n.io)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org)
+
+**[Deutsch](#deutsch) | [English](#english)**
+
+---
+
+## Deutsch
+
+Ein n8n Community Node zur Verwaltung von internen n8n Data Tables direkt aus Workflows heraus.
+
+### Screenshots
+
+<!-- Screenshots hier einfuegen -->
+![Data Table Manager Node](./screenshots/node-overview.png)
+*Node-Uebersicht im n8n Editor*
+
+![Table Operations](./screenshots/table-operations.png)
+*Tabellen-Operationen*
+
+### Features
+
+#### Table Operations (Tabellen-Operationen)
+- **Create** - Neue Tabelle mit Spalten erstellen
+- **Get All** - Alle Tabellen auflisten
+- **Update** - Tabelle umbenennen
+- **Delete** - Tabelle loeschen
+
+#### Column Operations (Spalten-Operationen)
+- **Add** - Spalte zu einer Tabelle hinzufuegen
+- **Get All** - Alle Spalten einer Tabelle auflisten
+- **Delete** - Spalte loeschen
+- **Rename** - Spalte umbenennen
+
+#### Unterstuetzte Spaltentypen
+- `string` - Text
+- `number` - Zahlen
+- `boolean` - Wahr/Falsch
+- `date` - Datum
+
+### Schnellstart
+
+1. Node installieren (siehe [Installationsanleitung](#installation))
+2. n8n neu starten
+3. "Data Table Manager" Node zum Workflow hinzufuegen
+4. Verbindungsdaten konfigurieren (Base URL, Email, Passwort)
+5. Gewuenschte Operation auswaehlen
+
+### Installation
+
+#### Via npm (empfohlen)
+
+```bash
+npm install n8n-nodes-datatable-manager
+```
+
+#### Via n8n Community Nodes
+
+1. In n8n zu **Settings** > **Community Nodes** navigieren
+2. **Install** klicken
+3. `n8n-nodes-datatable-manager` eingeben
+4. **Install** bestaetigen
+
+#### Manuelle Installation
+
+Siehe [DOCS_DE.md](./DOCS_DE.md) fuer detaillierte Installationsanweisungen.
+
+### Dokumentation
+
+Die vollstaendige deutsche Dokumentation finden Sie in [DOCS_DE.md](./DOCS_DE.md).
+
+---
+
+## English
+
+An n8n Community Node for managing internal n8n Data Tables directly from your workflows.
+
+### Screenshots
+
+<!-- Add screenshots here -->
+![Data Table Manager Node](./screenshots/node-overview.png)
+*Node overview in n8n Editor*
+
+![Table Operations](./screenshots/table-operations.png)
+*Table operations*
+
+### Features
+
+#### Table Operations
+- **Create** - Create a new table with columns
+- **Get All** - List all tables
+- **Update** - Rename a table
+- **Delete** - Delete a table
+
+#### Column Operations
+- **Add** - Add a column to a table
+- **Get All** - List all columns of a table
+- **Delete** - Delete a column
+- **Rename** - Rename a column
+
+#### Supported Column Types
+- `string` - Text
+- `number` - Numbers
+- `boolean` - True/False
+- `date` - Date
+
+### Quick Start
+
+1. Install the node (see [Installation](#installation-1))
+2. Restart n8n
+3. Add "Data Table Manager" node to your workflow
+4. Configure connection settings (Base URL, Email, Password)
+5. Select the desired operation
+
+### Installation
+
+#### Via npm (recommended)
+
+```bash
+npm install n8n-nodes-datatable-manager
+```
+
+#### Via n8n Community Nodes
+
+1. Navigate to **Settings** > **Community Nodes** in n8n
+2. Click **Install**
+3. Enter `n8n-nodes-datatable-manager`
+4. Confirm **Install**
+
+#### Manual Installation
+
+See [DOCS_EN.md](./DOCS_EN.md) for detailed installation instructions.
+
+### Documentation
+
+Complete English documentation is available in [DOCS_EN.md](./DOCS_EN.md).
+
+---
+
+## Requirements
+
+- n8n version 1.0.0 or higher
+- Node.js 18.0.0 or higher
+- Data Tables feature enabled (`N8N_ENABLED_MODULES=data-table`)
+
+## Important Notes
+
+- This node uses the **internal n8n API** which is not officially documented
+- Breaking changes may occur with n8n updates
+- Tested with n8n v1.113+
+- Requires valid n8n login credentials
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for a list of changes.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+## Support
+
+- [GitHub Issues](https://github.com/your-username/n8n-nodes-datatable-manager/issues)
+- [n8n Community Forum](https://community.n8n.io/)
+
+## Author
+
+Your Name - your-email@example.com
+
+---
+
+Made with love for the n8n community

package/dist/credentials/N8nInternalApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class N8nInternalApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/N8nInternalApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nInternalApi = void 0;
+class N8nInternalApi {
+    name = 'n8nInternalApi';
+    displayName = 'n8n Internal API';
+    documentationUrl = 'https://docs.n8n.io/api/';
+    properties = [
+        {
+            displayName: 'Base URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: 'http://localhost:5678',
+            placeholder: 'http://localhost:5678',
+            description: 'The base URL of your n8n instance',
+        },
+        {
+            displayName: 'Email',
+            name: 'email',
+            type: 'string',
+            default: '',
+            placeholder: 'admin@example.com',
+            description: 'Your n8n login email',
+        },
+        {
+            displayName: 'Password',
+            name: 'password',
+            type: 'string',
+            typeOptions: {
+                password: true,
+            },
+            default: '',
+            description: 'Your n8n login password',
+        },
+    ];
+}
+exports.N8nInternalApi = N8nInternalApi;

package/dist/nodes/DataTableManager/DataTableManager.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class DataTableManager implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/DataTableManager/DataTableManager.node.js

@@ -0,0 +1,511 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTableManager = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class DataTableManager {
+    description = {
+        displayName: 'Data Table Manager',
+        name: 'dataTableManager',
+        icon: 'file:datatable.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Manage n8n internal Data Tables (Create, List, Update, Delete)',
+        defaults: {
+            name: 'Data Table Manager',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        properties: [
+            // ========== CONNECTION SETTINGS ==========
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:5678',
+                placeholder: 'http://localhost:5678',
+                description: 'The base URL of your n8n instance',
+                required: true,
+            },
+            {
+                displayName: 'Email',
+                name: 'email',
+                type: 'string',
+                default: '',
+                placeholder: 'admin@example.com',
+                description: 'Your n8n login email',
+                required: true,
+            },
+            {
+                displayName: 'Password',
+                name: 'password',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                description: 'Your n8n login password',
+                required: true,
+            },
+            // Resource
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    {
+                        name: 'Table',
+                        value: 'table',
+                    },
+                    {
+                        name: 'Column',
+                        value: 'column',
+                    },
+                ],
+                default: 'table',
+            },
+            // ========== TABLE OPERATIONS ==========
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        resource: ['table'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Create',
+                        value: 'create',
+                        description: 'Create a new data table with columns',
+                        action: 'Create a table',
+                    },
+                    {
+                        name: 'Delete',
+                        value: 'delete',
+                        description: 'Delete a data table',
+                        action: 'Delete a table',
+                    },
+                    {
+                        name: 'Get All',
+                        value: 'getAll',
+                        description: 'Get all data tables',
+                        action: 'Get all tables',
+                    },
+                    {
+                        name: 'Update',
+                        value: 'update',
+                        description: 'Update/rename a data table',
+                        action: 'Update a table',
+                    },
+                ],
+                default: 'create',
+            },
+            // Table Create - Name
+            {
+                displayName: 'Table Name',
+                name: 'tableName',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['table'],
+                        operation: ['create'],
+                    },
+                },
+                description: 'The name of the new data table',
+            },
+            // Table Create - Columns
+            {
+                displayName: 'Columns',
+                name: 'columns',
+                type: 'fixedCollection',
+                typeOptions: {
+                    multipleValues: true,
+                },
+                default: {},
+                displayOptions: {
+                    show: {
+                        resource: ['table'],
+                        operation: ['create'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'columnValues',
+                        displayName: 'Column',
+                        values: [
+                            {
+                                displayName: 'Column Name',
+                                name: 'name',
+                                type: 'string',
+                                default: '',
+                                description: 'Name of the column',
+                            },
+                            {
+                                displayName: 'Column Type',
+                                name: 'type',
+                                type: 'options',
+                                options: [
+                                    {
+                                        name: 'String',
+                                        value: 'string',
+                                    },
+                                    {
+                                        name: 'Number',
+                                        value: 'number',
+                                    },
+                                    {
+                                        name: 'Boolean',
+                                        value: 'boolean',
+                                    },
+                                    {
+                                        name: 'Date',
+                                        value: 'date',
+                                    },
+                                ],
+                                default: 'string',
+                                description: 'Data type of the column',
+                            },
+                        ],
+                    },
+                ],
+                description: 'Columns to create in the table',
+            },
+            // Table ID (for update/delete)
+            {
+                displayName: 'Table ID',
+                name: 'tableId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['table'],
+                        operation: ['update', 'delete'],
+                    },
+                },
+                description: 'The ID of the data table',
+            },
+            // Table Update - New Name
+            {
+                displayName: 'New Table Name',
+                name: 'newTableName',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['table'],
+                        operation: ['update'],
+                    },
+                },
+                description: 'The new name for the data table',
+            },
+            // ========== COLUMN OPERATIONS ==========
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Add',
+                        value: 'add',
+                        description: 'Add a column to a table',
+                        action: 'Add a column',
+                    },
+                    {
+                        name: 'Delete',
+                        value: 'delete',
+                        description: 'Delete a column from a table',
+                        action: 'Delete a column',
+                    },
+                    {
+                        name: 'Get All',
+                        value: 'getAll',
+                        description: 'Get all columns of a table',
+                        action: 'Get all columns',
+                    },
+                    {
+                        name: 'Rename',
+                        value: 'rename',
+                        description: 'Rename a column',
+                        action: 'Rename a column',
+                    },
+                ],
+                default: 'add',
+            },
+            // Column - Table ID
+            {
+                displayName: 'Table ID',
+                name: 'tableId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                    },
+                },
+                description: 'The ID of the data table',
+            },
+            // Column Add - Name
+            {
+                displayName: 'Column Name',
+                name: 'columnName',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                        operation: ['add'],
+                    },
+                },
+                description: 'Name of the new column',
+            },
+            // Column Add - Type
+            {
+                displayName: 'Column Type',
+                name: 'columnType',
+                type: 'options',
+                required: true,
+                options: [
+                    {
+                        name: 'String',
+                        value: 'string',
+                    },
+                    {
+                        name: 'Number',
+                        value: 'number',
+                    },
+                    {
+                        name: 'Boolean',
+                        value: 'boolean',
+                    },
+                    {
+                        name: 'Date',
+                        value: 'date',
+                    },
+                ],
+                default: 'string',
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                        operation: ['add'],
+                    },
+                },
+                description: 'Data type of the column',
+            },
+            // Column ID (for delete/rename)
+            {
+                displayName: 'Column ID',
+                name: 'columnId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                        operation: ['delete', 'rename'],
+                    },
+                },
+                description: 'The ID of the column',
+            },
+            // Column Rename - New Name
+            {
+                displayName: 'New Column Name',
+                name: 'newColumnName',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['column'],
+                        operation: ['rename'],
+                    },
+                },
+                description: 'The new name for the column',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        // Get connection settings
+        const baseUrl = this.getNodeParameter('baseUrl', 0).replace(/\/$/, '');
+        const email = this.getNodeParameter('email', 0);
+        const password = this.getNodeParameter('password', 0);
+        // Login to n8n and get session cookie
+        let sessionCookie = '';
+        try {
+            const loginResponse = await this.helpers.httpRequest({
+                method: 'POST',
+                url: `${baseUrl}/rest/login`,
+                body: { emailOrLdapLoginId: email, password },
+                json: true,
+                skipSslCertificateValidation: true,
+                returnFullResponse: true,
+            });
+            // Extract session cookie from response headers
+            const setCookieHeader = loginResponse.headers?.['set-cookie'];
+            if (setCookieHeader) {
+                const cookies = Array.isArray(setCookieHeader) ? setCookieHeader : [setCookieHeader];
+                sessionCookie = cookies
+                    .map((c) => c.split(';')[0])
+                    .join('; ');
+            }
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to login to n8n: ${error.message}. Please check your credentials.`);
+        }
+        // Get Project ID from API (required for data-tables endpoint)
+        let projectId = '';
+        try {
+            const projectsResponse = await this.helpers.httpRequest({
+                method: 'GET',
+                url: `${baseUrl}/rest/projects`,
+                json: true,
+                skipSslCertificateValidation: true,
+                headers: {
+                    Cookie: sessionCookie,
+                },
+            });
+            // Find personal project or use first available
+            let projects = projectsResponse;
+            if (projectsResponse?.data) {
+                projects = projectsResponse.data;
+            }
+            if (Array.isArray(projects) && projects.length > 0) {
+                const personalProject = projects.find((p) => p.type === 'personal' || p.name?.toLowerCase().includes('personal'));
+                projectId = personalProject?.id || projects[0]?.id;
+            }
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to get projects: ${error.message}`);
+        }
+        if (!projectId) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No project found. Please create a project in n8n first.');
+        }
+        // Build the API URL - n8n uses /rest/projects/:projectId/data-tables
+        const apiBaseUrl = `${baseUrl}/rest/projects/${projectId}/data-tables`;
+        // Helper function to make internal API requests with session cookie
+        const makeInternalRequest = async (method, url, body) => {
+            const requestOptions = {
+                method,
+                url,
+                json: true,
+                skipSslCertificateValidation: true,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Cookie: sessionCookie,
+                },
+            };
+            if (body) {
+                requestOptions.body = body;
+            }
+            try {
+                return await this.helpers.httpRequest(requestOptions);
+            }
+            catch (error) {
+                const errorMessage = error?.message || String(error);
+                throw new Error(`Data Tables API request failed. ` +
+                    `URL: ${url}. ` +
+                    `Error: ${errorMessage}.`);
+            }
+        };
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let responseData;
+                if (resource === 'table') {
+                    if (operation === 'create') {
+                        const tableName = this.getNodeParameter('tableName', i);
+                        const columnsData = this.getNodeParameter('columns', i);
+                        const columns = columnsData.columnValues || [];
+                        responseData = await makeInternalRequest('POST', apiBaseUrl, {
+                            name: tableName,
+                            columns: columns.map((col, index) => ({
+                                name: col.name,
+                                type: col.type,
+                                index,
+                            })),
+                        });
+                    }
+                    else if (operation === 'getAll') {
+                        responseData = await makeInternalRequest('GET', apiBaseUrl);
+                    }
+                    else if (operation === 'update') {
+                        const tableId = this.getNodeParameter('tableId', i);
+                        const newTableName = this.getNodeParameter('newTableName', i);
+                        responseData = await makeInternalRequest('PATCH', `${apiBaseUrl}/${tableId}`, {
+                            name: newTableName,
+                        });
+                    }
+                    else if (operation === 'delete') {
+                        const tableId = this.getNodeParameter('tableId', i);
+                        await makeInternalRequest('DELETE', `${apiBaseUrl}/${tableId}`);
+                        responseData = { success: true, deletedTableId: tableId };
+                    }
+                }
+                else if (resource === 'column') {
+                    const tableId = this.getNodeParameter('tableId', i);
+                    if (operation === 'add') {
+                        const columnName = this.getNodeParameter('columnName', i);
+                        const columnType = this.getNodeParameter('columnType', i);
+                        responseData = await makeInternalRequest('POST', `${apiBaseUrl}/${tableId}/columns`, {
+                            name: columnName,
+                            type: columnType,
+                        });
+                    }
+                    else if (operation === 'getAll') {
+                        responseData = await makeInternalRequest('GET', `${apiBaseUrl}/${tableId}/columns`);
+                    }
+                    else if (operation === 'delete') {
+                        const columnId = this.getNodeParameter('columnId', i);
+                        await makeInternalRequest('DELETE', `${apiBaseUrl}/${tableId}/columns/${columnId}`);
+                        responseData = { success: true, deletedColumnId: columnId };
+                    }
+                    else if (operation === 'rename') {
+                        const columnId = this.getNodeParameter('columnId', i);
+                        const newColumnName = this.getNodeParameter('newColumnName', i);
+                        responseData = await makeInternalRequest('PATCH', `${apiBaseUrl}/${tableId}/columns/${columnId}/rename`, {
+                            name: newColumnName,
+                        });
+                    }
+                }
+                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
+                returnData.push(...executionData);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage, {
+                    itemIndex: i,
+                    description: `Error during ${resource} ${operation}: ${errorMessage}`,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DataTableManager = DataTableManager;

package/dist/nodes/DataTableManager/datatable.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <rect x="3" y="3" width="18" height="18" rx="2" ry="2" fill="#ff6d5a" stroke="#ff6d5a"/>
+  <line x1="3" y1="9" x2="21" y2="9" stroke="white"/>
+  <line x1="3" y1="15" x2="21" y2="15" stroke="white"/>
+  <line x1="9" y1="3" x2="9" y2="21" stroke="white"/>
+  <line x1="15" y1="3" x2="15" y2="21" stroke="white"/>
+</svg>

package/index.js

@@ -0,0 +1,5 @@
+const { DataTableManager } = require('./dist/nodes/DataTableManager/DataTableManager.node');
+
+module.exports = {
+    DataTableManager,
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "n8n-nodes-datatable-manager",
+  "version": "1.0.0",
+  "description": "n8n Community Node to manage internal Data Tables - Create, List, Update, Delete tables and columns",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "n8n-node",
+    "datatable",
+    "data-table",
+    "database",
+    "table-management",
+    "automation",
+    "workflow"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/your-username/n8n-nodes-datatable-manager#readme",
+  "author": {
+    "name": "Thomas Braun",
+    "email": "thomas.braun.web@googlemail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thomasbraun2014/n8n-nodes-datatable-manager.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thomasbraun2014/n8n-nodes-datatable-manager/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes --write",
+    "lint": "eslint nodes --ext .ts",
+    "lintfix": "eslint nodes --ext .ts --fix",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/DataTableManager/DataTableManager.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "eslint": "^8.56.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^3.1.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}