n8n-nodes-mat-framework 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+LICENSE
+Copyright © 2026 Iquall Networks.
+All rights reserved.
+
+This software and associated documentation files (the “Software”) are proprietary to Iquall Networks. Permission is granted solely to install and use the Software for integration with a valid and properly licensed MAT platform instance. Any use beyond the scope expressly permitted herein is strictly prohibited.
+
+The following actions are strictly prohibited:
+Modify, adapt, translate, reverse engineer, decompile, or disassemble the Software.
+
+Create derivative works based on the Software.
+
+Redistribute, sublicense, rent, lease, sell, or otherwise transfer the Software.
+
+Publish the Software or make it publicly available without explicit written authorization from Iquall Networks.
+
+Remove, alter, or obscure any proprietary notices.
+The Software is licensed, not sold. All intellectual property rights in and to the Software remain the exclusive property of Iquall Networks. Any unauthorized use automatically terminates this license.
+
+The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to merchantability, fitness for a particular purpose, and non-infringement. In no event shall Iquall Networks be liable for any claim, damages, or other liability arising from or in connection with the Software or its use.

package/README.md

@@ -0,0 +1,86 @@
+
+# MAT Framework n8n Community Node
+This repository provides the official community node that integrates MAT Framework with n8n. The node enables n8n workflows to securely trigger and monitor network-impacting automations executed inside MAT Framework.
+
+All execution logic, governance, policy enforcement, and auditing are handled entirely within MAT.
+
+## Documentation
+Full documentation, configuration guides, compatibility notes, and release information are available at:
+
+https://iquall.net/mat-n8n/
+
+For production deployments, always refer to the official documentation page above. This repository does not duplicate or maintain detailed usage documentation.
+
+## Overview
+
+The node acts as a thin client over MAT’s northbound API layer. It does not execute automation logic itself. All execution, governance, policy enforcement, and auditing are handled by MAT.
+
+High-level flow:
+n8n Workflow
+  ↓
+MAT Community Node
+  ↓
+MAT Framework API
+  ↓
+Network / OSS / BSS Domains
+
+**What this Node does:** 
+- Triggers MAT automations or Bricks
+- Pass structured input parameters
+- Retrieves execution results
+- Integrates MAT job outputs into n8n workflows
+
+The node acts strictly as a thin client over MAT’s REST API. All authorization and validation are enforced server-side by MAT.
+
+## Prerequisites
+- A running MAT Framework instance (SaaS or On-Prem)
+- A valid API token
+- Network connectivity between n8n and your MAT tenant
+- A valid commercial MAT license
+
+## Security & Governance
+
+This node does not execute automation logic locally and does not bypass MAT controls. All RBAC, CI/CD validation, approval gates, maintenance windows, and audit logging are enforced server-side within MAT.
+
+When triggering a workflow:
+1. n8n sends a request to MAT API.
+2. MAT validates authentication and permissions.
+3. MAT registers a Job internally.
+4. Execution is performed within the MAT Engine.
+5. Job status and output can be polled asynchronously.
+
+The node does not bypass:
+- Role-based access control
+- Approval gates
+- CI/CD enforcement
+- Closed-loop policies
+- Audit logging
+
+## Error Handling
+Errors returned by the node fall into two categories:
+- Transport errors (network, timeout, TLS)
+- Execution errors (returned by MAT API)
+
+MAT-side execution errors include:
+- Authorization failure
+- Invalid workflow ID
+- Parameter validation error
+- Policy restriction
+
+All execution logs remain traceable inside MAT.
+
+## Security Notes
+- The node stores credentials in n8n’s encrypted credential store.
+- API tokens should be scoped according to least privilege.
+- All sensitive execution logic remains server-side in MAT.
+- No network configuration logic resides in this repository.
+
+## Development
+This node is implemented in TypeScript and follows n8n community node structure.
+
+## Scope
+This repository does not include the MAT Engine, automation workflows or SLA/support services, nor does it expose proprietary Bricks. Use of MAT APIs requires a valid commercial license.
+
+## License
+Proprietary License.
+See [LICENSE](./LICENSE) for details.

package/dist/credentials/MatApi.credentials.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatApi = void 0;
+class MatApi {
+    name = 'matApi';
+    displayName = 'MAT API';
+    documentationUrl = 'https://iquall.net/mat-n8n/';
+    properties = [
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: {
+                password: true,
+            },
+            default: '',
+            required: true,
+            description: 'The API key for authenticating with the MAT platform',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: {
+                apikey: '={{$credentials.apiKey}}',
+            },
+        },
+    };
+}
+exports.MatApi = MatApi;

package/dist/nodes/MAT_Framework/Read/MATFrameworkRead.node.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATFrameworkRead = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class MATFrameworkRead {
+    description = {
+        displayName: 'MAT Framework Read',
+        name: 'matFrameworkRead',
+        icon: 'file:mat-framework-icon.png',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["readOperation"]}}',
+        description: 'Read job data and reports from MAT platform',
+        documentationUrl: 'https://iquall.net/mat-n8n/',
+        defaults: {
+            name: 'MAT Framework Read',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'matApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'MAT REST API URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://your-domain.com/namespace/api/v2',
+                required: true,
+                description: 'The base URL for your MAT platform API (must end with /api/v2). Protocol (https://) will be added automatically if not provided.',
+            },
+            {
+                displayName: 'Environment',
+                name: 'environment',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Production',
+                        value: 'production',
+                    },
+                    {
+                        name: 'Preproduction',
+                        value: 'preproduction',
+                    },
+                    {
+                        name: 'Sandbox',
+                        value: 'sandbox',
+                    },
+                ],
+                default: 'production',
+                required: true,
+                description: 'The environment to read data from',
+            },
+            {
+                displayName: 'Automation Type',
+                name: 'automationType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Network Task',
+                        value: 'networktask',
+                    },
+                    {
+                        name: 'Network Workflow',
+                        value: 'networkworkflow',
+                    },
+                    {
+                        name: 'Orchestration Workflow',
+                        value: 'orchestrationworkflow',
+                    },
+                    // {
+                    // 	name: 'Serverless Function',
+                    // 	value: 'serverlessfunctions',
+                    // },
+                ],
+                default: 'networktask',
+                required: true,
+                description: 'The type of automation',
+            },
+            {
+                displayName: 'Operation',
+                name: 'readOperation',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Get Job Information',
+                        value: 'jobDetails',
+                    },
+                    {
+                        name: 'View Job Logs',
+                        value: 'logs',
+                    },
+                    {
+                        name: 'Get Network Elements',
+                        value: 'networkelements',
+                    },
+                    {
+                        name: 'Get Job Result',
+                        value: 'result',
+                    },
+                    {
+                        name: 'Get Job Report',
+                        value: 'report',
+                    },
+                    {
+                        name: 'Download Report File',
+                        value: 'reportFile',
+                    },
+                    {
+                        name: 'Get Alarms',
+                        value: 'alarms',
+                    },
+                ],
+                default: 'jobDetails',
+                required: true,
+                description: 'The type of data to retrieve',
+            },
+            {
+                displayName: 'Automation ID',
+                name: 'automationId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: {
+                    hide: {
+                        automationType: ['serverlessfunctions'],
+                    },
+                },
+                description: 'The ID of the automation',
+            },
+            // {
+            // 	displayName: 'SLF Namespace ID',
+            // 	name: 'slfNamespace',
+            // 	type: 'string',
+            // 	default: '',
+            // 	required: true,
+            // 	displayOptions: {
+            // 		show: {
+            // 			automationType: ['serverlessfunctions'],
+            // 			readOperation: ['alarms'],
+            // 		},
+            // 	},
+            // 	description: 'The namespace for the serverless function',
+            // },
+            // {
+            // 	displayName: 'Function Name',
+            // 	name: 'functionName',
+            // 	type: 'string',
+            // 	default: '',
+            // 	required: true,
+            // 	displayOptions: {
+            // 		show: {
+            // 			automationType: ['serverlessfunctions'],
+            // 			readOperation: ['alarms'],
+            // 		},
+            // 	},
+            // 	description: 'The name of the serverless function',
+            // },
+            {
+                displayName: 'Job ID',
+                name: 'jobId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: {
+                    show: {
+                        readOperation: ['jobDetails', 'logs', 'networkelements', 'result', 'report', 'reportFile'],
+                    },
+                    hide: {
+                        automationType: ['serverlessfunctions'],
+                    },
+                },
+                description: 'The ID of the job to retrieve data from',
+            },
+            {
+                displayName: 'Report Name',
+                name: 'reportName',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: {
+                    show: {
+                        readOperation: ['report', 'reportFile'],
+                    },
+                },
+                description: 'The name of the report to retrieve',
+            },
+            {
+                displayName: 'File ID',
+                name: 'fileId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: {
+                    show: {
+                        readOperation: ['reportFile'],
+                    },
+                },
+                description: 'The ID of the file to download from the report',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // 1. Get parameters
+                let baseUrl = this.getNodeParameter('baseUrl', i);
+                const environment = this.getNodeParameter('environment', i);
+                const automationType = this.getNodeParameter('automationType', i);
+                const readOperation = this.getNodeParameter('readOperation', i);
+                // 2. Get credentials
+                const credentials = await this.getCredentials('matApi', i);
+                const apiKey = credentials.apiKey;
+                // 3. Normalize and validate base URL
+                // Trim whitespace
+                baseUrl = baseUrl.trim();
+                // Add https:// if no protocol present
+                if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
+                    baseUrl = 'https://' + baseUrl;
+                }
+                // Remove trailing slashes
+                baseUrl = baseUrl.replace(/\/+$/, '');
+                // Validate base URL ends with /api/v2 (case-insensitive)
+                if (!baseUrl.toLowerCase().endsWith('/api/v2')) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `MAT REST API URL must end with /api/v2\nProvided: ${baseUrl}\nExpected format: https://your-domain.com/namespace/api/v2`, { itemIndex: i });
+                }
+                // Ensure /api/v2 is lowercase for consistency
+                if (!baseUrl.endsWith('/api/v2')) {
+                    baseUrl = baseUrl.substring(0, baseUrl.length - 7) + '/api/v2';
+                }
+                // 4. Validate operation compatibility
+                if (automationType === 'serverlessfunctions' && readOperation !== 'alarms') {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Serverless Functions only support the "Get Alarms" operation', { itemIndex: i });
+                }
+                // 5. Build URL based on automation type and operation
+                let url;
+                if (readOperation === 'alarms') {
+                    if (automationType === 'serverlessfunctions') {
+                        const slfNamespace = this.getNodeParameter('slfNamespace', i);
+                        const functionName = this.getNodeParameter('functionName', i);
+                        url = `${baseUrl}/serverlessfunctions/namespace/${slfNamespace}/function/${functionName}/env/${environment}/alarms`;
+                    }
+                    else {
+                        const automationId = this.getNodeParameter('automationId', i);
+                        url = `${baseUrl}/${automationType}/${automationId}/env/${environment}/alarms`;
+                    }
+                }
+                else {
+                    // All other operations require automation_id and job_id
+                    const automationId = this.getNodeParameter('automationId', i);
+                    const jobId = this.getNodeParameter('jobId', i);
+                    const baseJobUrl = `${baseUrl}/${automationType}/${automationId}/env/${environment}/jobs/${jobId}`;
+                    switch (readOperation) {
+                        case 'jobDetails':
+                            url = baseJobUrl;
+                            break;
+                        case 'logs':
+                            url = `${baseJobUrl}/logs`;
+                            break;
+                        case 'networkelements':
+                            url = `${baseJobUrl}/networkelements`;
+                            break;
+                        case 'result':
+                            url = `${baseJobUrl}/result`;
+                            break;
+                        case 'report':
+                            const reportName = this.getNodeParameter('reportName', i);
+                            url = `${baseJobUrl}/report/${reportName}`;
+                            break;
+                        case 'reportFile':
+                            const reportNameForFile = this.getNodeParameter('reportName', i);
+                            const fileId = this.getNodeParameter('fileId', i);
+                            url = `${baseJobUrl}/report/${reportNameForFile}/file/${fileId}`;
+                            break;
+                        default:
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${readOperation}`, { itemIndex: i });
+                    }
+                }
+                // 6. Make HTTP GET request
+                if (readOperation === 'reportFile') {
+                    // Handle binary file download
+                    const fileId = this.getNodeParameter('fileId', i);
+                    const response = await this.helpers.request({
+                        method: 'GET',
+                        url: url,
+                        headers: {
+                            'apikey': apiKey,
+                        },
+                        encoding: null, // Important: don't encode binary data
+                        resolveWithFullResponse: true,
+                    });
+                    // Extract filename from fileId or Content-Disposition header
+                    let fileName = fileId;
+                    const contentDisposition = response.headers['content-disposition'];
+                    if (contentDisposition) {
+                        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
+                        if (matches != null && matches[1]) {
+                            fileName = matches[1].replace(/['"]/g, '');
+                        }
+                    }
+                    // Prepare binary data
+                    const binaryData = await this.helpers.prepareBinaryData(response.body, fileName, response.headers['content-type'] || 'application/octet-stream');
+                    // 7. Return as binary
+                    returnData.push({
+                        json: {
+                            fileId: fileId,
+                            fileName: fileName,
+                            mimeType: response.headers['content-type'] || 'application/octet-stream',
+                        },
+                        binary: {
+                            data: binaryData,
+                        },
+                    });
+                }
+                else {
+                    // Handle JSON responses (all other operations)
+                    const options = {
+                        method: 'GET',
+                        url: url,
+                        headers: {
+                            'apikey': apiKey,
+                            'Accept': 'application/json',
+                            'Content-Type': 'application/json',
+                        },
+                        json: true,
+                    };
+                    const response = await this.helpers.request(options);
+                    // 7. Return response
+                    returnData.push({ json: response });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    const statusCode = error.statusCode || 'unknown';
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            statusCode: statusCode,
+                        },
+                    });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.MATFrameworkRead = MATFrameworkRead;

package/dist/nodes/MAT_Framework/Trigger/MATFrameworkTrigger.node.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATFrameworkTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class MATFrameworkTrigger {
+    description = {
+        displayName: 'MAT Framework Trigger',
+        name: 'matFrameworkTrigger',
+        icon: 'file:mat-framework-icon.png',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["automationType"]}}',
+        description: 'Trigger MAT platform automations via simplified API',
+        documentationUrl: 'https://iquall.net/mat-n8n/',
+        defaults: {
+            name: 'MAT Framework Trigger',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'matApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'MAT REST API URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: '',
+                placeholder: 'https://your-domain.com/namespace/api/v2',
+                required: true,
+                description: 'The base URL for your MAT platform API (must end with /api/v2). Protocol (https://) will be added automatically if not provided.',
+            },
+            {
+                displayName: 'Environment',
+                name: 'environment',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Production',
+                        value: 'production',
+                    },
+                    {
+                        name: 'Preproduction',
+                        value: 'preproduction',
+                    },
+                    {
+                        name: 'Sandbox',
+                        value: 'sandbox',
+                    },
+                ],
+                default: 'production',
+                required: true,
+                description: 'The environment to trigger the automation in',
+            },
+            {
+                displayName: 'Automation Type',
+                name: 'automationType',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Network Task',
+                        value: 'networktask',
+                    },
+                    {
+                        name: 'Network Workflow',
+                        value: 'networkworkflow',
+                    },
+                    {
+                        name: 'Orchestration Workflow',
+                        value: 'orchestrationworkflow',
+                    },
+                    // {
+                    // 	name: 'Serverless Function',
+                    // 	value: 'serverlessfunctions',
+                    // },
+                ],
+                default: 'networktask',
+                required: true,
+                description: 'The type of automation to trigger',
+            },
+            {
+                displayName: 'Execution Mode',
+                name: 'syncMode',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Async',
+                        value: 'async',
+                    },
+                    {
+                        name: 'Sync',
+                        value: 'sync',
+                    },
+                ],
+                default: 'async',
+                displayOptions: {
+                    show: {
+                        automationType: ['networktask'],
+                    },
+                },
+                description: 'Whether to execute synchronously or asynchronously',
+            },
+            {
+                displayName: 'Automation ID',
+                name: 'automationId',
+                type: 'string',
+                default: '',
+                required: true,
+                displayOptions: {
+                    hide: {
+                        automationType: ['serverlessfunctions'],
+                    },
+                },
+                description: 'The ID of the automation to trigger',
+            },
+            // {
+            // 	displayName: 'SLF Namespace ID',
+            // 	name: 'slfNamespace',
+            // 	type: 'string',
+            // 	default: '',
+            // 	required: true,
+            // 	displayOptions: {
+            // 		show: {
+            // 			automationType: ['serverlessfunctions'],
+            // 		},
+            // 	},
+            // 	description: 'The namespace for the serverless function',
+            // },
+            // {
+            // 	displayName: 'Function Name',
+            // 	name: 'functionName',
+            // 	type: 'string',
+            // 	default: '',
+            // 	required: true,
+            // 	displayOptions: {
+            // 		show: {
+            // 			automationType: ['serverlessfunctions'],
+            // 		},
+            // 	},
+            // 	description: 'The name of the serverless function to invoke',
+            // },
+            // {
+            // 	displayName: 'Request Body',
+            // 	name: 'requestBodyServerless',
+            // 	type: 'json',
+            // 	default: '{}',
+            // 	displayOptions: {
+            // 		show: {
+            // 			automationType: ['serverlessfunctions'],
+            // 		},
+            // 	},
+            // 	description: 'JSON body for Serverless Function requests.',
+            // },
+            {
+                displayName: 'Request Body',
+                name: 'requestBodyStandard',
+                type: 'json',
+                default: '{\n  "form_data": {}\n}',
+                displayOptions: {
+                    hide: {
+                        automationType: ['serverlessfunctions'],
+                    },
+                },
+                description: 'JSON body for non-serverless requests. Keep payload under form_data.',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // 1. Get all parameters
+                let baseUrl = this.getNodeParameter('baseUrl', i);
+                const environment = this.getNodeParameter('environment', i);
+                const automationType = this.getNodeParameter('automationType', i);
+                // 2. Get credentials
+                const credentials = await this.getCredentials('matApi', i);
+                const apiKey = credentials.apiKey;
+                // 3. Normalize and validate base URL
+                // Trim whitespace
+                baseUrl = baseUrl.trim();
+                // Add https:// if no protocol present
+                if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
+                    baseUrl = 'https://' + baseUrl;
+                }
+                // Remove trailing slashes
+                baseUrl = baseUrl.replace(/\/+$/, '');
+                // Validate base URL ends with /api/v2 (case-insensitive)
+                if (!baseUrl.toLowerCase().endsWith('/api/v2')) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `MAT REST API URL must end with /api/v2\nProvided: ${baseUrl}\nExpected format: https://your-domain.com/namespace/api/v2`, { itemIndex: i });
+                }
+                // Ensure /api/v2 is lowercase for consistency
+                if (!baseUrl.endsWith('/api/v2')) {
+                    baseUrl = baseUrl.substring(0, baseUrl.length - 7) + '/api/v2';
+                }
+                // 4. Build URL based on automation type
+                let url;
+                if (automationType === 'serverlessfunctions') {
+                    const slfNamespace = this.getNodeParameter('slfNamespace', i);
+                    const functionName = this.getNodeParameter('functionName', i);
+                    url = `${baseUrl}/serverlessfunctions/namespace/${slfNamespace}/function/${functionName}/env/${environment}`;
+                }
+                else {
+                    const automationId = this.getNodeParameter('automationId', i);
+                    url = `${baseUrl}/${automationType}/${automationId}/env/${environment}/jobs`;
+                    // Add /sync suffix for Network Task + Sync mode
+                    if (automationType === 'networktask') {
+                        const syncMode = this.getNodeParameter('syncMode', i);
+                        if (syncMode === 'sync') {
+                            url += '/sync';
+                        }
+                    }
+                }
+                // 5. Process request body
+                let requestBody;
+                const bodyParam = this.getNodeParameter(automationType === 'serverlessfunctions' ? 'requestBodyServerless' : 'requestBodyStandard', i);
+                // Parse JSON string if it's a string
+                if (typeof bodyParam === 'string') {
+                    try {
+                        requestBody = JSON.parse(bodyParam);
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON in Request Body: ${errorMessage}`, { itemIndex: i });
+                    }
+                }
+                else {
+                    requestBody = bodyParam;
+                }
+                // Only wrap in form_data for automation types that require it
+                // Serverless Functions expect plain JSON bodies
+                if (automationType !== 'serverlessfunctions') {
+                    if (!Object.prototype.hasOwnProperty.call(requestBody ?? {}, 'form_data')) {
+                        requestBody = { form_data: requestBody };
+                    }
+                }
+                // 6. Make HTTP request
+                const options = {
+                    method: 'POST',
+                    url: url,
+                    headers: {
+                        'apikey': apiKey,
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                    json: true,
+                };
+                const response = await this.helpers.request(options);
+                // 7. Return response
+                returnData.push({ json: response });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    const statusCode = error.statusCode || 'unknown';
+                    returnData.push({
+                        json: {
+                            error: errorMessage,
+                            statusCode: statusCode,
+                        },
+                    });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.MATFrameworkTrigger = MATFrameworkTrigger;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "n8n-nodes-mat-framework",
+  "version": "1.0.0",
+  "description": "Official community nodes that integrate MAT Framework with n8n",
+  "keywords": [
+    "n8n-community-node-package",
+    "mat-framework"
+  ],
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://iquall.net/",
+  "author": {
+    "name": "Iquall Networks",
+    "email": "marketing@iquall.net"
+  },
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "prepack": "npm run build",
+    "dev": "tsc --watch",
+    "start": "npm run build && PKG_NAME=$(node -p \"require('./package.json').name\") && CUSTOM_DIR=\"$HOME/.n8n/custom\" && mkdir -p \"$CUSTOM_DIR\" && ln -sfn \"$(pwd)\" \"$CUSTOM_DIR/$PKG_NAME\" && N8N_CUSTOM_EXTENSIONS=\"$CUSTOM_DIR\" npx n8n",
+    "lint": "eslint nodes credentials --ext .ts",
+    "lintfix": "eslint nodes credentials --ext .ts --fix",
+    "format": "prettier nodes credentials --write"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/MatApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/MAT_Framework/Trigger/MATFrameworkTrigger.node.js",
+      "dist/nodes/MAT_Framework/Read/MATFrameworkRead.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.56.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.1",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}