@5minds/node-red-contrib-processcube-tools 1.1.0-feature-6eab97-mg0ov11s → 1.1.0-feature-975857-mg4vqpai

package/swagger/swagger.js

@@ -0,0 +1,277 @@
+/**
+ * Copyright 2015, 2016 IBM Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
+const DEFAULT_TEMPLATE = {
+    openapi: '3.0.0',
+    info: {
+        title: 'My Node-RED API',
+        version: '1.0.0',
+        description: 'A sample API',
+    },
+    servers: [
+        {
+            url: 'http://localhost:1880/',
+            description: 'Local server',
+        },
+    ],
+    paths: {},
+    components: {
+        schemas: {},
+        responses: {},
+        parameters: {},
+        securitySchemes: {},
+    },
+    tags: [],
+};
+
+module.exports = function (RED) {
+    'use strict';
+
+    const path = require('path');
+
+    const convToSwaggerPath = (x) => `/{${x.substring(2)}}`;
+    const trimAll = (ary) => ary.map((x) => x.trim());
+    const csvStrToArray = (csvStr) => (csvStr ? trimAll(csvStr.split(',')) : []);
+    const ensureLeadingSlash = (url) => (url.startsWith('/') ? url : '/' + url);
+    const stripTerminalSlash = (url) => (url.length > 1 && url.endsWith('/') ? url.slice(0, -1) : url);
+    const regexColons = /\/:\w*/g;
+
+    // Helper function to convert collection format to OpenAPI 3.0 style
+    const getStyleFromCollectionFormat = (collectionFormat) => {
+        const formatMap = {
+            csv: 'simple',
+            ssv: 'spaceDelimited',
+            tsv: 'pipeDelimited',
+            pipes: 'pipeDelimited',
+            multi: 'form',
+        };
+        return formatMap[collectionFormat] || 'simple';
+    };
+
+    RED.httpNode.get('/http-api/swagger.json', (req, res) => {
+        try {
+            const { httpNodeRoot, openapi: { template = {}, parameters: additionalParams = [] } = {} } = RED.settings;
+
+            const resp = { ...DEFAULT_TEMPLATE, ...template };
+            resp.paths = {};
+
+            // Update server URL to include the httpNodeRoot
+            if (httpNodeRoot && httpNodeRoot !== '/') {
+                resp.servers = resp.servers.map((server) => ({
+                    ...server,
+                    url: server.url.replace(/\/$/, '') + httpNodeRoot,
+                }));
+            }
+
+            RED.nodes.eachNode((node) => {
+                const { name, type, method, swaggerDoc, url } = node;
+
+                if (type === 'http in' && swaggerDoc) {
+                    const swaggerDocNode = RED.nodes.getNode(swaggerDoc);
+
+                    if (swaggerDocNode) {
+                        // Convert Node-RED path parameters to OpenAPI format
+                        const endPoint = stripTerminalSlash(
+                            ensureLeadingSlash(url.replace(regexColons, convToSwaggerPath)),
+                        );
+
+                        if (!resp.paths[endPoint]) resp.paths[endPoint] = {};
+
+                        const {
+                            summary = name || `${method.toUpperCase()} ${endPoint}`,
+                            description = '',
+                            tags = '',
+                            deprecated = false,
+                            parameters = [],
+                            requestBody = null,
+                            responses = {},
+                        } = swaggerDocNode;
+
+                        const aryTags = csvStrToArray(tags);
+
+                        const operation = {
+                            summary,
+                            description,
+                            tags: aryTags,
+                            deprecated,
+                            parameters: [...parameters, ...additionalParams].map((param) => {
+                                const paramDef = {
+                                    name: param.name,
+                                    in: param.in,
+                                    required: param.required || false,
+                                    description: param.description || '',
+                                };
+
+                                // Handle parameter schema - preserve the original schema structure
+                                if (param.schema) {
+                                    // If there's already a schema object, use it
+                                    paramDef.schema = param.schema;
+                                } else if (param.type) {
+                                    // Build schema from individual type properties
+                                    paramDef.schema = { type: param.type };
+                                    if (param.format) {
+                                        paramDef.schema.format = param.format;
+                                    }
+                                    if (param.type === 'array' && param.items) {
+                                        paramDef.schema.items = param.items;
+                                    }
+                                    if (param.collectionFormat && param.type === 'array') {
+                                        paramDef.style = getStyleFromCollectionFormat(param.collectionFormat);
+                                        paramDef.explode = param.collectionFormat === 'multi';
+                                    }
+                                }
+
+                                return paramDef;
+                            }),
+                            responses: {},
+                        };
+
+                        // Add request body if it exists
+                        if (requestBody && Object.keys(requestBody.content || {}).length > 0) {
+                            const content = requestBody.content;
+                            Object.keys(content).forEach(contentType => {
+                                if (contentType.includes('xml') && content[contentType].example) {
+                                    content['text/plain'] = {
+                                        schema: { type: 'string' },
+                                        example: content[contentType].example.replace(/\\n/g, '\n')
+                                    };
+                                    delete content[contentType];
+                                }
+                            });
+                            operation.requestBody = requestBody;
+                        }
+
+                        // Process responses
+                        if (responses && typeof responses === 'object') {
+                            Object.keys(responses).forEach((status) => {
+                                const responseDetails = responses[status];
+                                operation.responses[status] = {
+                                    description: responseDetails.description || 'No description',
+                                };
+
+                                // Add content if schema exists
+                                if (responseDetails.schema) {
+                                    operation.responses[status].content = {
+                                        'application/json': {
+                                            schema: responseDetails.schema,
+                                        },
+                                    };
+                                }
+                            });
+                        }
+
+                        // Ensure at least one response exists
+                        if (Object.keys(operation.responses).length === 0) {
+                            operation.responses['200'] = {
+                                description: 'Successful response',
+                            };
+                        }
+
+                        resp.paths[endPoint][method.toLowerCase()] = operation;
+                    }
+                }
+            });
+
+            // Clean up empty sections
+            cleanupOpenAPISpec(resp);
+            res.json(resp);
+        } catch (error) {
+            console.error('Error generating Swagger JSON:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+
+    function cleanupOpenAPISpec(spec) {
+        // Clean up components
+        if (spec.components) {
+            ['schemas', 'responses', 'parameters', 'securitySchemes'].forEach((key) => {
+                if (spec.components[key] && Object.keys(spec.components[key]).length === 0) {
+                    delete spec.components[key];
+                }
+            });
+
+            // If all components are empty, remove the components object itself
+            if (Object.keys(spec.components).length === 0) {
+                delete spec.components;
+            }
+        }
+
+        // Clean up empty tags array
+        if (Array.isArray(spec.tags) && spec.tags.length === 0) {
+            delete spec.tags;
+        }
+    }
+
+    function SwaggerDoc(n) {
+        RED.nodes.createNode(this, n);
+        this.summary = n.summary;
+        this.description = n.description;
+        this.tags = n.tags;
+        this.parameters = n.parameters || [];
+        this.responses = n.responses || {};
+        this.requestBody = n.requestBody || null;
+        this.deprecated = n.deprecated || false;
+    }
+    RED.nodes.registerType('swagger-doc', SwaggerDoc);
+
+    // Serve the main Swagger UI HTML file
+    RED.httpAdmin.get('/swagger-ui/swagger-ui.html', (req, res) => {
+        const filename = path.join(__dirname, 'swagger-ui', 'swagger-ui.html');
+        sendFile(res, filename);
+    });
+
+    // Serve Swagger UI assets
+    RED.httpAdmin.get('/swagger-ui/*', (req, res, next) => {
+        let filename = req.params[0];
+
+        // Skip if it's the HTML file (handled by specific route above)
+        if (filename === 'swagger-ui.html') {
+            return next();
+        }
+
+        try {
+            const swaggerUiPath = require('swagger-ui-dist').getAbsoluteFSPath();
+            const filePath = path.join(swaggerUiPath, filename);
+            sendFile(res, filePath);
+        } catch (err) {
+            console.error('Error serving Swagger UI asset:', err);
+            res.status(404).send('File not found');
+        }
+    });
+
+    // Serve localization files
+    RED.httpAdmin.get('/swagger-ui/nls/*', (req, res) => {
+        const filename = path.join(__dirname, 'locales', req.params[0]);
+        sendFile(res, filename);
+    });
+
+    // Generic function to send files
+    function sendFile(res, filePath) {
+        const fs = require('fs');
+
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            return res.status(404).send('File not found');
+        }
+
+        res.sendFile(path.resolve(filePath), (err) => {
+            if (err) {
+                console.error('Error sending file:', err);
+                res.status(err.status || 500).send('Error sending file');
+            }
+        });
+    }
+};

package/file-storage/file-storage.html

@@ -1,97 +0,0 @@
-<script type="text/javascript">
-    RED.nodes.registerType('file-storage', {
-        category: 'ProcessCube Tools',
-        color: '#02AFD6',
-        defaults: {
-            name: { value: '' },
-            provider: { value: 'fs' },
-            baseDir: { value: '' },
-            pgConnectionString: { value: '' },
-            pgSchema: { value: 'public' },
-            pgTable: { value: 'files' },
-            outputAs: { value: 'stream' },
-            defaultAction: { value: 'store' },
-        },
-        inputs: 1,
-        outputs: 1,
-        icon: 'file.png',
-        label: function () {
-            return this.name || 'file-storage';
-        },
-    });
-</script>
-
-<script type="text/html" data-template-name="file-storage">
-    <div class="form-row">
-        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="file-storage" />
-    </div>
-    <div class="form-row">
-        <label for="node-input-provider"><i class="fa fa-database"></i> Provider</label>
-        <select id="node-input-provider">
-            <option value="fs">Filesystem</option>
-            <option value="pg">PostgreSQL</option>
-        </select>
-    </div>
-    <div class="form-row">
-        <label for="node-input-outputAs"><i class="fa fa-share-square-o"></i> Output</label>
-        <select id="node-input-outputAs">
-            <option value="stream">Stream</option>
-            <option value="buffer">Buffer</option>
-            <option value="path">Path (nur FS)</option>
-        </select>
-    </div>
-    <hr />
-    <div class="form-tips">Filesystem</div>
-    <div class="form-row">
-        <label for="node-input-baseDir"><i class="fa fa-folder-open"></i> Base Dir</label>
-        <input type="text" id="node-input-baseDir" placeholder="/data/files" />
-    </div>
-    <hr />
-    <div class="form-tips">PostgreSQL</div>
-    <div class="form-row">
-        <label for="node-input-pgConnectionString"><i class="fa fa-plug"></i> Connection</label>
-        <input type="text" id="node-input-pgConnectionString" placeholder="postgres://user:pass@host:5432/db" />
-    </div>
-    <div class="form-row">
-        <label for="node-input-pgSchema"><i class="fa fa-sitemap"></i> Schema</label>
-        <input type="text" id="node-input-pgSchema" placeholder="public" />
-    </div>
-    <div class="form-row">
-        <label for="node-input-pgTable"><i class="fa fa-table"></i> Tabelle</label>
-        <input type="text" id="node-input-pgTable" placeholder="files" />
-    </div>
-    <hr />
-    <div class="form-row">
-        <label for="node-input-defaultAction"><i class="fa fa-cog"></i> Default Action</label>
-        <select id="node-input-defaultAction">
-            <option value="store">store</option>
-            <option value="get">get</option>
-            <option value="delete">delete</option>
-        </select>
-    </div>
-</script>
-
-<script type="text/html" data-help-name="file-storage">
-    <p>
-        File-Storage-Node zum Speichern/Abrufen/Löschen von Dateien inkl. Metadaten. Provider: Filesystem (Datei + JSON)
-        oder PostgreSQL (Large Objects + Metadaten-Tabelle).
-    </p>
-    <h3>Input</h3>
-    <pre>
-  msg.action = "store" | "get" | "delete"
-  msg.payload = Buffer | Readable | String (bei store)
-  msg.file = {
-    id?: string (bei get/delete),
-    filename?: string,
-    contentType?: string,
-    metadata?: object
-  }
-  </pre
-    >
-    <h3>Output</h3>
-    <p>
-        Bei <code>store</code>: <code>msg.payload</code> enthält Metadaten inkl. <code>id</code>. Bei <code>get</code>:
-        <code>msg.payload</code> ist Stream/Buffer/Pfad (je nach Option), Metadaten in <code>msg.file</code>.
-    </p>
-</script>

package/file-storage/file-storage.js

@@ -1,70 +0,0 @@
-module.exports = function (RED) {
-    const StorageCore = require('../storage/storage-core');
-
-    function FileStorageNode(config) {
-        RED.nodes.createNode(this, config);
-        const node = this;
-
-        // Node-Konfiguration
-        node.provider = config.provider || 'fs';
-        node.baseDir = config.baseDir;
-        node.pg = {
-            connectionString: config.pgConnectionString,
-            schema: config.pgSchema || 'public',
-            table: config.pgTable || 'files',
-        };
-        node.outputAs = config.outputAs || 'stream'; // 'stream' | 'buffer' | 'path' (path nur fs)
-
-        // Storage-Kern
-        const storage = new StorageCore({
-            provider: node.provider,
-            fs: { baseDir: node.baseDir },
-            pg: node.pg,
-        });
-
-        storage.init().catch((err) => node.error(err));
-
-        node.on('input', async function (msg, send, done) {
-            try {
-                const action = msg.action || config.defaultAction || 'store';
-                if (action === 'store') {
-                    const file = msg.file || {};
-                    const result = await storage.store(msg.payload, file);
-                    msg.payload = result;
-                    msg.file = { ...file, ...result };
-                    send(msg);
-                    done();
-                    return;
-                }
-
-                if (action === 'get') {
-                    const id = msg.file && msg.file.id;
-                    if (!id) throw new Error('file.id is required for get');
-                    const { meta, payload } = await storage.get(id, { as: node.outputAs });
-                    msg.file = { ...meta, id: meta.id };
-                    msg.payload = payload;
-                    send(msg);
-                    done();
-                    return;
-                }
-
-                if (action === 'delete') {
-                    const id = msg.file && msg.file.id;
-                    if (!id) throw new Error('file.id is required for delete');
-                    const result = await storage.delete(id);
-                    msg.payload = result;
-                    send(msg);
-                    done();
-                    return;
-                }
-
-                throw new Error(`Unknown action: ${action}`);
-            } catch (err) {
-                node.error(err, msg);
-                if (done) done(err);
-            }
-        });
-    }
-
-    RED.nodes.registerType('file-storage', FileStorageNode);
-};

package/storage/providers/fs.js

@@ -1,117 +0,0 @@
-const fs = require('fs');
-const fsp = require('fs/promises');
-const path = require('path');
-const { pipeline } = require('stream');
-const { createHash } = require('crypto');
-const { promisify } = require('util');
-const pump = promisify(pipeline);
-
-class FsProvider {
-    constructor(opts = {}) {
-        this.baseDir = opts.baseDir || path.resolve(process.cwd(), 'data');
-    }
-
-    async init() {
-        await fsp.mkdir(this.baseDir, { recursive: true });
-    }
-
-    _buildPaths(id) {
-        const d = new Date();
-        const parts = [
-            String(d.getUTCFullYear()),
-            String(d.getUTCMonth() + 1).padStart(2, '0'),
-            String(d.getUTCDate()).padStart(2, '0'),
-        ];
-        const dir = path.join(this.baseDir, ...parts);
-        const filePath = path.join(dir, id);
-        const metaPath = path.join(dir, `${id}.json`);
-        return { dir, filePath, metaPath };
-    }
-
-    async store(readable, info) {
-        const { id, filename, contentType, metadata, createdAt } = info;
-        const { dir, filePath, metaPath } = this._buildPaths(id);
-        await fsp.mkdir(dir, { recursive: true });
-
-        const hash = createHash('sha256');
-        let size = 0;
-
-        const out = fs.createWriteStream(filePath);
-        readable.on('data', (chunk) => {
-            hash.update(chunk);
-            size += chunk.length;
-        });
-
-        await pump(readable, out);
-
-        const sha256 = hash.digest('hex');
-        const meta = { id, filename, contentType, size, sha256, metadata, createdAt };
-        await fsp.writeFile(metaPath, JSON.stringify(meta, null, 2));
-
-        return { size, sha256, path: filePath };
-    }
-
-    async get(id, options = { as: 'stream' }) {
-        // Find meta file by searching dated folders
-        const meta = await this._findMeta(id);
-        if (!meta) throw new Error(`File not found: ${id}`);
-        const filePath = meta.__filePath;
-
-        if (options.as === 'path') {
-            return { meta, payload: filePath };
-        }
-
-        if (options.as === 'buffer') {
-            const buf = await fsp.readFile(filePath);
-            return { meta, payload: buf };
-        }
-
-        // default: stream
-        const stream = fs.createReadStream(filePath);
-        return { meta, payload: stream };
-    }
-
-    async delete(id) {
-        const meta = await this._findMeta(id);
-        if (!meta) return; // idempotent
-        await fsp.unlink(meta.__filePath).catch(() => {});
-        await fsp.unlink(meta.__metaPath).catch(() => {});
-    }
-
-    async _findMeta(id) {
-        // Walk date folders (YYYY/MM/DD). For Performance: keep index/cache in prod.
-        const years = await this._ls(this.baseDir);
-        for (const y of years) {
-            const yearDir = path.join(this.baseDir, y);
-            const months = await this._ls(yearDir);
-            for (const m of months) {
-                const monthDir = path.join(yearDir, m);
-                const days = await this._ls(monthDir);
-                for (const d of days) {
-                    const dir = path.join(monthDir, d);
-                    const metaPath = path.join(dir, `${id}.json`);
-                    try {
-                        const raw = await fsp.readFile(metaPath, 'utf-8');
-                        const meta = JSON.parse(raw);
-                        meta.__metaPath = metaPath;
-                        meta.__filePath = path.join(dir, id);
-                        return meta;
-                    } catch (_) {
-                        /* continue */
-                    }
-                }
-            }
-        }
-        return null;
-    }
-
-    async _ls(dir) {
-        try {
-            return (await fsp.readdir(dir)).filter((n) => !n.startsWith('.'));
-        } catch {
-            return [];
-        }
-    }
-}
-
-module.exports = FsProvider;