@5minds/node-red-contrib-processcube-tools 1.2.0-feature-37541f-mg92jkdw → 1.2.0-feature-8f3d72-mg9cplxi

package/src/html-to-text/html-to-text.ts

@@ -1,53 +0,0 @@
-import { NodeInitializer, Node, NodeDef, NodeMessage } from 'node-red';
-const { compile } = require('html-to-text');
-
-interface HtmlToTextNodeProperties extends NodeDef {
-    // Add your custom properties here if needed
-}
-
-interface HtmlToTextNodeMessage extends NodeMessage {
-    payload: string;
-}
-
-const HtmlToTextNode: NodeInitializer = function (RED) {
-    function HtmlToText(this: Node, config: HtmlToTextNodeProperties) {
-        RED.nodes.createNode(this, config);
-        const node = this;
-
-        const options = {
-            wordwrap: 130,
-        };
-
-        const compiledConvert = compile(options);
-
-        (node as any).on('input', (msg: HtmlToTextNodeMessage, send?: Function, done?: Function) => {
-            // Provide default functions if not available (for older Node-RED versions)
-            send =
-                send ||
-                function (m: NodeMessage | NodeMessage[]) {
-                    node.send(m);
-                };
-            done =
-                done ||
-                function (err?: Error) {
-                    if (err) node.error(err, msg);
-                };
-
-            try {
-                if (typeof msg.payload !== 'string') {
-                    throw new Error('Payload is not a string!');
-                }
-
-                msg.payload = compiledConvert(msg.payload);
-                send(msg);
-                done();
-            } catch (error) {
-                done(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
-    }
-
-    RED.nodes.registerType('html-to-text', HtmlToText);
-};
-
-export = HtmlToTextNode;

package/src/index.ts

@@ -1,12 +0,0 @@
-// Importiere die Registrierungsfunktion für deine Nodes.
-import registerEmailReceiverNode from './email-receiver/email-receiver';
-import registerEmailSenderNode from './email-sender/email-sender';
-import registerHtmlToTextNode from './html-to-text/html-to-text';
-
-// Exportiere eine Funktion, die alle Nodes registriert.
-export = function (RED: any) {
-    // Rufe die Registrierungsfunktionen für jede Node auf.
-    registerEmailReceiverNode(RED);
-    registerEmailSenderNode(RED);
-    registerHtmlToTextNode(RED);
-};

package/src/interfaces/EmailReceiverMessage.ts

@@ -1,22 +0,0 @@
-import type { ParsedMail } from 'mailparser';
-
-// Custom type for the output message
-export interface EmailReceiverMessage {
-    topic: string | undefined;
-    payload: string | undefined;
-    html: string | boolean | undefined;
-    from: string | undefined;
-    date: Date | undefined;
-    folder: string;
-    header: ParsedMail['headers'];
-    attachments: Array<{
-        contentType: string;
-        fileName: string | undefined;
-        contentDisposition: string;
-        generatedFileName: string | undefined;
-        contentId: string | undefined;
-        checksum: string;
-        length: number;
-        content: Buffer;
-    }>;
-}

package/src/interfaces/EmailSenderNodeProperties.ts

@@ -1,37 +0,0 @@
-import { NodeDef } from 'node-red';
-
-export interface EmailSenderNodeProperties extends NodeDef {
-    // Mail configuration properties
-    sender: string;
-    senderType: string;
-    address: string;
-    addressType: string;
-    to: string;
-    toType: string;
-    cc: string;
-    ccType: string;
-    bcc: string;
-    bccType: string;
-    replyTo: string;
-    replyToType: string;
-    subject: string;
-    subjectType: string;
-    htmlContent: string;
-    htmlContentType: string;
-    attachments: string;
-    attachmentsType: string;
-
-    // SMTP configuration properties
-    host: string;
-    hostType: string;
-    port: string;
-    portType: string;
-    user: string;
-    userType: string;
-    password: string;
-    passwordType: string;
-    secure: string;
-    secureType: string;
-    rejectUnauthorized: string;
-    rejectUnauthorizedType: string;
-}

package/src/interfaces/FetchState.ts

@@ -1,9 +0,0 @@
-export interface FetchState {
-    totalFolders: number;
-    processedFolders: number;
-    successes: number;
-    failures: number;
-    totalMails: number;
-    errors: Error[];
-    folderCount: { [folder: string]: number };
-}

package/src/interfaces/ImapConnectionConfig.ts

@@ -1,14 +0,0 @@
-export interface ImapConnectionConfig {
-    host: string;
-    port: number;
-    tls: boolean;
-    user: string;
-    password: string;
-    folders: string[];
-    markSeen: boolean;
-    connTimeout: number;
-    authTimeout: number;
-    keepalive: boolean;
-    autotls: string;
-    tlsOptions: { rejectUnauthorized: boolean };
-}

package/src/test/framework/advanced-test-patterns.ts

@@ -1,224 +0,0 @@
-// ============================================================================
-// ADVANCED TEST PATTERNS FOR NODE-RED CUSTOM NODES
-// ============================================================================
-
-import type { TestScenario } from './types';
-
-// ============================================================================
-// ERROR RESILIENCE PATTERNS
-// ============================================================================
-
-export class ErrorResilienceTestBuilder {
-    private scenarios: TestScenario[] = [];
-
-    addNetworkErrorScenario(name: string, config: any): this {
-        return this.addScenario({
-            name: `${name} - network error`,
-            config: { ...config, host: 'unreachable.invalid.test' },
-            input: { payload: 'test' },
-            expectedError: /network|connection|timeout/i,
-            timeout: 3000,
-        });
-    }
-
-    addMalformedInputScenario(name: string, config: any): this {
-        const malformedInputs = [
-            null,
-            undefined,
-            { payload: null },
-            { payload: '' },
-            { payload: { malformed: true, circular: null } },
-            'not-an-object',
-        ];
-
-        malformedInputs.forEach((input, index) => {
-            this.addScenario({
-                name: `${name} - malformed input ${index + 1}`,
-                config,
-                input,
-                timeout: 2000,
-            });
-        });
-
-        return this;
-    }
-
-    addResourceExhaustionScenario(name: string, config: any): this {
-        return this.addScenario({
-            name: `${name} - resource exhaustion`,
-            config,
-            input: {
-                payload: 'x'.repeat(10 * 1024 * 1024), // 10MB payload
-                largeArray: Array.from({ length: 100000 }, (_, i) => ({ id: i, data: 'test' })),
-            },
-            timeout: 5000,
-        });
-    }
-
-    addRapidFireScenario(name: string, config: any, messageCount: number = 1000): this {
-        return this.addScenario({
-            name: `${name} - rapid fire messages`,
-            config,
-            input: Array.from({ length: messageCount }, (_, i) => ({
-                payload: `rapid-message-${i}`,
-                sequence: i,
-            })),
-            timeout: Math.max(5000, messageCount * 5),
-        });
-    }
-
-    private addScenario(scenario: TestScenario): this {
-        this.scenarios.push(scenario);
-        return this;
-    }
-
-    getScenarios(): TestScenario[] {
-        return [...this.scenarios];
-    }
-}
-// ============================================================================
-// EDGE CASE PATTERNS
-// ============================================================================
-
-export class EdgeCaseTestBuilder {
-    private scenarios: TestScenario[] = [];
-
-    addEmptyDataScenarios(name: string, config: any): this {
-        const emptyDataCases = [
-            { name: 'empty object', data: {} },
-            { name: 'empty array', data: [] },
-            { name: 'empty string', data: '' },
-            { name: 'null payload', data: null },
-            { name: 'undefined payload', data: undefined },
-            { name: 'zero value', data: 0 },
-            { name: 'false value', data: false },
-        ];
-
-        emptyDataCases.forEach((testCase) => {
-            this.scenarios.push({
-                name: `${name} - ${testCase.name}`,
-                config,
-                input: { payload: testCase.data },
-                timeout: 2000,
-            });
-        });
-
-        return this;
-    }
-
-    addSpecialCharacterScenarios(name: string, config: any): this {
-        const specialCases = [
-            { name: 'unicode characters', data: '🚀💡🌟' },
-            { name: 'newlines and tabs', data: 'line1\nline2\tindented' },
-            { name: 'special symbols', data: '!@#$%^&*()_+-=[]{}|;:,.<>?' },
-            { name: 'very long string', data: 'a'.repeat(10000) },
-            { name: 'mixed encoding', data: 'Ñiño café résumé 北京' },
-        ];
-
-        specialCases.forEach((testCase) => {
-            this.scenarios.push({
-                name: `${name} - ${testCase.name}`,
-                config,
-                input: { payload: testCase.data },
-                timeout: 3000,
-            });
-        });
-
-        return this;
-    }
-
-    addLargeDataScenarios(name: string, config: any): this {
-        const largeCases = [
-            {
-                name: 'large object',
-                data: Object.fromEntries(Array.from({ length: 1000 }, (_, i) => [`key${i}`, `value${i}`])),
-            },
-            {
-                name: 'deeply nested object',
-                data: Array.from({ length: 100 }, () => ({})).reduce((acc, _, i) => ({ [`level${i}`]: acc }), {
-                    deepest: true,
-                }),
-            },
-            {
-                name: 'large array',
-                data: Array.from({ length: 10000 }, (_, i) => ({ id: i, data: `item${i}` })),
-            },
-        ];
-
-        largeCases.forEach((testCase) => {
-            this.scenarios.push({
-                name: `${name} - ${testCase.name}`,
-                config,
-                input: { payload: testCase.data },
-                timeout: 5000,
-            });
-        });
-
-        return this;
-    }
-
-    getScenarios(): TestScenario[] {
-        return [...this.scenarios];
-    }
-}
-
-// ============================================================================
-// SECURITY TESTING PATTERNS
-// ============================================================================
-
-export class SecurityTestBuilder {
-    private scenarios: TestScenario[] = [];
-
-    addInjectionTestScenarios(name: string, config: any): this {
-        const injectionPayloads = [
-            { name: 'SQL injection', payload: "'; DROP TABLE users; --" },
-            { name: 'XSS attempt', payload: '<script>alert("xss")</script>' },
-            { name: 'Command injection', payload: '; rm -rf / ;' },
-            { name: 'Path traversal', payload: '../../../etc/passwd' },
-            { name: 'JSON injection', payload: '{"__proto__":{"isAdmin":true}}' },
-        ];
-
-        injectionPayloads.forEach((attack) => {
-            this.scenarios.push({
-                name: `${name} - ${attack.name}`,
-                config,
-                input: { payload: attack.payload },
-                timeout: 2000,
-            });
-        });
-
-        return this;
-    }
-
-    addOversizedPayloadScenarios(name: string, config: any): this {
-        const oversizedCases = [
-            { name: '1MB payload', size: 1024 * 1024 },
-            { name: '10MB payload', size: 10 * 1024 * 1024 },
-            { name: 'deeply nested payload', depth: 1000 },
-        ];
-
-        oversizedCases.forEach((testCase) => {
-            let payload;
-            if (testCase.size) {
-                payload = 'x'.repeat(testCase.size);
-            } else if (testCase.depth) {
-                payload = Array.from({ length: testCase.depth }, () => ({})).reduce((acc) => ({ nested: acc }), {
-                    bottom: true,
-                });
-            }
-
-            this.scenarios.push({
-                name: `${name} - ${testCase.name}`,
-                config,
-                input: { payload },
-                timeout: 10000,
-            });
-        });
-
-        return this;
-    }
-
-    getScenarios(): TestScenario[] {
-        return [...this.scenarios];
-    }
-}

package/src/test/framework/generic-node-test-suite.ts

@@ -1,58 +0,0 @@
-import { expect } from 'chai';
-import { TestScenarioBuilder } from './test-scenario-builder';
-import { NodeTestRunner } from './node-test-runner';
-import { NodeAssertions } from './node-assertions';
-import type { TestScenario } from './types';
-
-/**
- * Generic test suite generator for Node-RED custom nodes
- */
-export function createNodeTestSuite(nodeName: string, nodeConstructor: Function, testConfigs: Record<string, any>) {
-    describe(`${nodeName} - Generic Test Suite`, function () {
-        this.timeout(10000);
-
-        describe('Node Registration', function () {
-            it('should register without errors', async function () {
-                const scenario: TestScenario = {
-                    name: 'registration',
-                    config: testConfigs.valid || testConfigs.minimal || {},
-                };
-
-                const context = await NodeTestRunner.runScenario(nodeConstructor, scenario);
-                expect(context.nodeInstance).to.exist;
-                expect(context.mockRED.nodes.lastRegisteredType).to.exist;
-                expect(context.mockRED.nodes.lastRegisteredConstructor).to.be.a('function');
-            });
-        });
-
-        describe('Configuration Validation', function () {
-            const validationTests = new TestScenarioBuilder();
-
-            if (testConfigs.valid) {
-                validationTests.addValidScenario('valid config', testConfigs.valid);
-            }
-
-            if (testConfigs.minimal) {
-                validationTests.addValidScenario('minimal config', testConfigs.minimal);
-            }
-
-            if (testConfigs.invalid) {
-                validationTests.addErrorScenario('invalid config', testConfigs.invalid, /error|invalid|missing/i);
-            }
-
-            validationTests.getScenarios().forEach((scenario) => {
-                it(`should handle ${scenario.name}`, async function () {
-                    const context = await NodeTestRunner.runScenario(nodeConstructor, scenario);
-
-                    expect(context.nodeInstance).to.exist;
-
-                    if (scenario.expectedError) {
-                        NodeAssertions.expectError(context, scenario.expectedError);
-                    } else {
-                        NodeAssertions.expectNoErrors(context);
-                    }
-                });
-            });
-        });
-    });
-}

package/src/test/framework/index.ts

@@ -1,17 +0,0 @@
-// Main exports for the Node-RED test framework
-
-// Unit Testing Framework
-export { TestScenarioBuilder } from './test-scenario-builder';
-export { NodeTestRunner } from './node-test-runner';
-export { NodeAssertions } from './node-assertions';
-export { createNodeTestSuite } from './generic-node-test-suite';
-
-// Integration Testing Framework
-export { IntegrationTestRunner } from './integration-test-runner';
-export { IntegrationAssertions } from './integration-assertions';
-export { IntegrationScenarioBuilder } from './integration-scenario-builder';
-
-export { ErrorResilienceTestBuilder, EdgeCaseTestBuilder, SecurityTestBuilder } from './advanced-test-patterns';
-
-// Types
-export * from './types';

package/src/test/framework/integration-assertions.ts

@@ -1,67 +0,0 @@
-import { expect } from 'chai';
-import type { IntegrationTestContext } from './integration-test-runner';
-
-export class IntegrationAssertions {
-    static expectNodeExists(context: IntegrationTestContext, nodeId: string): void {
-        expect(context.nodes[nodeId], `Node ${nodeId} should exist`).to.exist;
-    }
-
-    static expectNodeProperty(context: IntegrationTestContext, nodeId: string, property: string, value: any): void {
-        this.expectNodeExists(context, nodeId);
-        expect(context.nodes[nodeId], `Node ${nodeId} should have property ${property}`).to.have.property(
-            property,
-            value,
-        );
-    }
-
-    static expectMessageReceived(context: IntegrationTestContext, nodeId: string): void {
-        const messages = context.messages.filter((m) => m.nodeId === nodeId);
-        expect(messages, `Node ${nodeId} should have received at least one message`).to.have.length.greaterThan(0);
-    }
-
-    static expectMessageCount(context: IntegrationTestContext, nodeId: string, count: number): void {
-        const messages = context.messages.filter((m) => m.nodeId === nodeId);
-        expect(messages, `Node ${nodeId} should have received ${count} messages`).to.have.length(count);
-    }
-
-    static expectMessageContent(context: IntegrationTestContext, nodeId: string, expectedContent: any): void {
-        const messages = context.messages.filter((m) => m.nodeId === nodeId);
-        expect(messages, `Node ${nodeId} should have received messages`).to.have.length.greaterThan(0);
-
-        const lastMessage = messages[messages.length - 1].message;
-        if (typeof expectedContent === 'object') {
-            Object.keys(expectedContent).forEach((key) => {
-                expect(lastMessage, `Message should have property ${key}`).to.have.property(key);
-                if (expectedContent[key] !== undefined) {
-                    expect(lastMessage[key], `Message property ${key} should match`).to.deep.equal(
-                        expectedContent[key],
-                    );
-                }
-            });
-        } else {
-            expect(lastMessage.payload).to.equal(expectedContent);
-        }
-    }
-
-    static expectNoMessages(context: IntegrationTestContext, nodeId: string): void {
-        const messages = context.messages.filter((m) => m.nodeId === nodeId);
-        expect(messages, `Node ${nodeId} should not have received any messages`).to.have.length(0);
-    }
-
-    static expectAllNodesExist(context: IntegrationTestContext, nodeIds: string[]): void {
-        nodeIds.forEach((nodeId) => {
-            this.expectNodeExists(context, nodeId);
-        });
-    }
-
-    static expectMessageOrder(context: IntegrationTestContext, nodeIds: string[]): void {
-        const sortedMessages = [...context.messages].sort((a, b) => a.timestamp - b.timestamp);
-
-        nodeIds.forEach((expectedNodeId, index) => {
-            expect(sortedMessages[index], `Message ${index} should be from node ${expectedNodeId}`).to.have.property(
-                'nodeId',
-                expectedNodeId,
-            );
-        });
-    }
-}

package/src/test/framework/integration-scenario-builder.ts

@@ -1,77 +0,0 @@
-import { expect } from 'chai';
-import type { IntegrationTestScenario } from './integration-test-runner';
-import type { Node } from 'node-red';
-
-export class IntegrationScenarioBuilder {
-    private scenarios: IntegrationTestScenario[] = [];
-
-    addScenario(scenario: IntegrationTestScenario): this {
-        this.scenarios.push(scenario);
-        return this;
-    }
-
-    addLoadingScenario(name: string, flow: any[], nodeId: string): this {
-        return this.addScenario({
-            name,
-            flow,
-            nodeId,
-            timeout: 2000,
-        });
-    }
-
-    addMessageFlowScenario(
-        name: string,
-        flow: any[],
-        sourceNodeId: string,
-        input: any,
-        expectedMessages: Array<{ nodeId: string; expectedMsg: any }>,
-    ): this {
-        return this.addScenario({
-            name,
-            flow,
-            nodeId: sourceNodeId,
-            input,
-            expectedMessages,
-            timeout: 3000,
-        });
-    }
-
-    addConnectionScenario(name: string, flow: any[], nodeIds: string[]): this {
-        return this.addScenario({
-            name,
-            flow,
-            nodeId: nodeIds[0], // Primary node
-            setup: (nodes) => {
-                // Verify all nodes are connected
-                nodeIds.forEach((nodeId) => {
-                    expect(nodes[nodeId], `Node ${nodeId} should exist in connection test`).to.exist;
-                });
-            },
-        });
-    }
-
-    addLifecycleScenario(
-        name: string,
-        flow: any[],
-        nodeId: string,
-        operations: Array<(nodes: Record<string, Node>) => void>,
-    ): this {
-        return this.addScenario({
-            name,
-            flow,
-            nodeId,
-            setup: (nodes) => {
-                operations.forEach((operation) => operation(nodes));
-            },
-        });
-    }
-
-    getScenarios(): IntegrationTestScenario[] {
-        return [...this.scenarios];
-    }
-
-    clear(): this {
-        this.scenarios = [];
-        return this;
-    }
-}