@vdwpsmt/node-red-contrib-flow-splitter-extended 1.0.0 → 1.0.2

package/README.md

@@ -22,13 +22,18 @@ It will make the diffs of your version control much more controlled and readable
 - Supports both YAML and JSON formats
 - Maintains tab order through configuration
 
-### Function & Template Extraction (NEW)
-- Automatically extracts code from `function` nodes into `.js` files
-- Extracts `ui-template` (Dashboard 2.0) content into `.vue` files
-- Supports function `initialize` and `finalize` code in separate files
-- Extracts node `info` documentation into `.md` files
+### Optional Function & Template Extraction and Restore (NEW)
+- Automatically extracts into seperate files per function/ui-template
+  - Extracts code from `function` nodes into `.js` files
+  - Extracts `ui-template` (Dashboard 2.0) content into `.vue` files
+  - Supports function `initialize` and `finalize` code in separate files
+  - Extracts node `info` documentation into `.md` files
 - Organizes extracted files in subdirectories alongside their parent tab/subflow
-- Automatically syncs changes back to Node-RED on startup
+- Restores changes back to Node-RED
+  - Automatically on startup
+  - Manually reload using endpoint
+- Both extraction (default true) and restoring (default false) can be changed in `.config.flow-splitter.json`
+
 
 ## Functioning
 
@@ -81,7 +86,7 @@ fetch('http://localhost:1880/flow-splitter/reload', {method: 'POST'})
 ```
 
 This allows you to:
-1. Edit function/template files in VS Code
+1. Edit function/template files in VS Code or any other IDE
 2. Save changes
 3. Run the reload command
 4. See changes immediately in Node-RED (without deploy/restart)
@@ -124,7 +129,9 @@ Default configuration file =
   "fileFormat": "yaml",
   "destinationFolder": "src",
   "tabsOrder": [],
-  "extractFunctionsTemplates": true
+  "extractFunctionsTemplates": true,
+  "restoreFunctionsTemplates": false,
+  "enableArtifact": false
 }
 ```
 
@@ -134,6 +141,7 @@ You can freely edit the config file, the changes are taken into account at the n
 - `destinationFolder`: path where to create the `tabs`, `subflows` and `config-nodes` sub-directories
 - `tabsOrder`: position of each tab (ordered array of the Ids of each tab node)
 - `extractFunctionsTemplates`: additional extraction of function and ui-template nodes
+- `enableArtifact`: when `true`, writes a deployable monolith artifact to `artifact/flows.json` on reload/start events
 ## Installation
 
 ```bash

package/functions-templates-handler.js

@@ -4,7 +4,7 @@ const fs = require('fs-extra')
 /**
  * Functions and Templates nodes Handler
  * Extracts function and ui-template node code into separate files
- * and collects them back when rebuilding flows
+ * and restores them back when rebuilding flows
  */
 
 /**
@@ -18,6 +18,12 @@ function extractFunctionsAndTemplates(flowNodes, flowName, flowDir, RED) {
     if (!flowNodes || flowNodes.length === 0) return
 
     const extractedDir = path.join(flowDir, flowName)
+    
+    // Delete entire extracted directory to ensure fresh state
+    if (fs.existsSync(extractedDir)) {
+        fs.removeSync(extractedDir)
+    }
+    
     const manifest = {}
     const fileNames = []
     let count = 0
@@ -124,20 +130,17 @@ function extractFunctionsAndTemplates(flowNodes, flowName, flowDir, RED) {
         
         RED.log.info(`[node-red-contrib-flow-splitter] Extracted ${count} functions/templates for "${flowName}"`)
     }
-
-    // Clean up unused files
-    cleanupUnusedFiles(extractedDir, manifest, RED)
 }
 
 /**
- * Collect functions and templates from separate files back into flow nodes
+ * Restore functions and templates from separate files back into flow nodes
  * @param {Array} flowNodes - Array of nodes from a tab or subflow
  * @param {string} flowName - Name of the tab or subflow
  * @param {string} flowDir - Directory where the flow file is stored
  * @param {object} RED - Node-RED runtime
  * @returns {Array} - Updated flow nodes
  */
-function collectFunctionsAndTemplates(flowNodes, flowName, flowDir, RED) {
+function restoreFunctionsAndTemplates(flowNodes, flowName, flowDir, RED) {
     if (!flowNodes || flowNodes.length === 0) return flowNodes
 
     const extractedDir = path.join(flowDir, flowName)
@@ -225,77 +228,13 @@ function collectFunctionsAndTemplates(flowNodes, flowName, flowDir, RED) {
     })
 
     if (updatedCount > 0) {
-        RED.log.info(`[node-red-contrib-flow-splitter] Collected ${updatedCount} functions/templates for "${flowName}"`)
+        RED.log.info(`[node-red-contrib-flow-splitter] Restored ${updatedCount} functions/templates for "${flowName}"`)
     }
 
     return flowNodes
 }
 
-/**
- * Clean up files that are no longer in the manifest
- * @param {string} extractedDir - Directory containing extracted files
- * @param {object} manifest - Manifest object
- * @param {object} RED - Node-RED runtime
- */
-function cleanupUnusedFiles(extractedDir, manifest, RED) {
-    if (!fs.existsSync(extractedDir)) return
-
-    const validExtensions = ['.vue', '.js', '.md']
-    const files = getAllFiles(extractedDir, validExtensions)
-
-    files.forEach(file => {
-        // Skip manifest file
-        if (file.endsWith('.manifest.json')) return
-
-        let found = false
-        Object.keys(manifest).forEach((id) => {
-            const item = manifest[id]
-            if (file.indexOf(item.fileName) > -1) {
-                found = true
-            }
-        })
-
-        if (!found) {
-            const filePath = path.join(extractedDir, file)
-            try {
-                fs.removeSync(filePath)
-                RED.log.info(`[node-red-contrib-flow-splitter] Removed unused file: ${file}`)
-            } catch (error) {
-                RED.log.warn(`[node-red-contrib-flow-splitter] Could not remove file ${file}: ${error.message}`)
-            }
-        }
-    })
-}
-
-/**
- * Get all files with specified extensions from a directory
- * @param {string} dir - Directory to search
- * @param {Array<string>} exts - Array of extensions to match
- * @param {Array<string>} fileList - Accumulated file list
- * @param {string} relDir - Relative directory path
- * @returns {Array<string>} - List of file paths
- */
-function getAllFiles(dir, exts, fileList = [], relDir = '') {
-    if (!fs.existsSync(dir)) return fileList
-
-    const files = fs.readdirSync(dir)
-
-    files.forEach(file => {
-        const filePath = path.join(dir, file)
-        const relPath = path.join(relDir, file)
-        const stat = fs.statSync(filePath)
-
-        if (stat.isDirectory()) {
-            getAllFiles(filePath, exts, fileList, relPath)
-        } else if (exts.some(ext => file.endsWith(ext))) {
-            fileList.push(relPath)
-        }
-    })
-
-    return fileList
-}
-
 module.exports = {
     extractFunctionsAndTemplates,
-    collectFunctionsAndTemplates
+    restoreFunctionsAndTemplates
 }

package/index.js

@@ -25,12 +25,16 @@ const functionsTemplatesHandler = require('./functions-templates-handler')
 let RED
 
 const splitCfgFilename = '.config.flow-splitter.json'
+const artifactsDirname = 'artifact'
+const artifactsFilename = 'flows.json'
 const DEFAULT_CFG = {
     fileFormat: 'yaml',
     destinationFolder: 'src',
     tabsOrder: [],
     monolithFilename: "flows.json",
-    extractFunctionsTemplates: true
+    extractFunctionsTemplates: true,
+    restoreFunctionsTemplates: false,
+    enableArtifact: false
 }
 
 /**
@@ -113,6 +117,142 @@ function extractFunctionsTemplatesFromSplitFiles(cfg, projectPath) {
 
     processFlowDirectory(tabsDir, cfg.fileFormat, 'tab')
     processFlowDirectory(subflowsDir, cfg.fileFormat, 'subflow')
+    
+    // Clean up orphaned directories from renamed/deleted flows
+    cleanupOrphanedDirectories(tabsDir, cfg.fileFormat)
+    cleanupOrphanedDirectories(subflowsDir, cfg.fileFormat)
+}
+
+/**
+ * Remove subdirectories that don't have a corresponding flow file
+ * @param {string} dir - Directory to clean (tabs or subflows)
+ * @param {string} fileFormat - File format (yaml or json)
+ */
+function cleanupOrphanedDirectories(dir, fileFormat) {
+    if (!fs.existsSync(dir)) {
+        return
+    }
+
+    const extension = fileFormat === 'yaml' ? '.yaml' : '.json'
+    
+    // Get all flow files
+    const flowFiles = fs.readdirSync(dir)
+        .filter(f => f.endsWith(extension))
+        .map(f => path.basename(f, extension))
+    
+    // Get all subdirectories
+    const subdirs = fs.readdirSync(dir)
+        .filter(f => {
+            const fullPath = path.join(dir, f)
+            return fs.statSync(fullPath).isDirectory()
+        })
+    
+    // Remove orphaned subdirectories
+    subdirs.forEach(subdir => {
+        if (!flowFiles.includes(subdir)) {
+            const subdirPath = path.join(dir, subdir)
+            try {
+                fs.rmSync(subdirPath, { recursive: true, force: true })
+                RED.log.info(`[node-red-contrib-flow-splitter-extended] Removed orphaned directory: ${subdir}`)
+            } catch (error) {
+                RED.log.warn(`[node-red-contrib-flow-splitter-extended] Could not remove orphaned directory ${subdir}: ${error.message}`)
+            }
+        }
+    })
+}
+
+/**
+ * Clean up old flow files when a tab or subflow has been renamed.
+ * Scans existing files and removes those with IDs that match current flows but have different filenames.
+ * @param {Array} flowNodes - Array of all flow nodes from Node-RED
+ * @param {object} cfg - Splitter configuration
+ * @param {string} projectPath - Path to the project
+ */
+function cleanupRenamedFlows(flowNodes, cfg, projectPath) {
+    const srcDir = path.join(projectPath, cfg.destinationFolder || 'src')
+    const tabsDir = path.join(srcDir, 'tabs')
+    const subflowsDir = path.join(srcDir, 'subflows')
+    const extension = cfg.fileFormat === 'yaml' ? '.yaml' : '.json'
+
+    // Build maps of ID -> expected filename from the current flow nodes
+    const tabsIdToFilename = new Map()
+    const subflowsIdToFilename = new Map()
+
+    flowNodes.forEach(node => {
+        if (node.type === 'tab' && node.id) {
+            // Use normalizedLabel if available, otherwise compute from label
+            const label = node.label || node.id
+            const expectedFilename = node.normalizedLabel || 
+                label.replace(/[\/\\:*?"<>|]/g, '-').toLowerCase().replace(/\s+/g, '-')
+            tabsIdToFilename.set(node.id, expectedFilename)
+        } else if (node.type === 'subflow' && node.id) {
+            const name = node.name || node.id
+            const expectedFilename = name.replace(/[\/\\:*?"<>|]/g, '-').toLowerCase().replace(/\s+/g, '-')
+            subflowsIdToFilename.set(node.id, expectedFilename)
+        }
+    })
+
+    // Clean up tabs directory
+    cleanupRenamedFlowsInDir(tabsDir, tabsIdToFilename, extension, 'tab')
+    
+    // Clean up subflows directory
+    cleanupRenamedFlowsInDir(subflowsDir, subflowsIdToFilename, extension, 'subflow')
+}
+
+/**
+ * Clean up renamed flows in a specific directory.
+ * Removes old files when the same ID exists but with a different filename.
+ * @param {string} dir - Directory to scan
+ * @param {Map} idToFilename - Map of ID to expected filename
+ * @param {string} extension - File extension (.yaml or .json)
+ * @param {string} flowType - Type of flow (tab or subflow)
+ */
+function cleanupRenamedFlowsInDir(dir, idToFilename, extension, flowType) {
+    if (!fs.existsSync(dir)) {
+        return
+    }
+
+    const files = fs.readdirSync(dir).filter(f => f.endsWith(extension))
+
+    files.forEach(file => {
+        const filePath = path.join(dir, file)
+        const filename = path.basename(file, extension)
+
+        try {
+            let flowData
+            const fileContent = fs.readFileSync(filePath, 'utf8')
+
+            if (extension === '.yaml') {
+                flowData = yaml.load(fileContent)
+            } else {
+                flowData = JSON.parse(fileContent)
+            }
+
+            const flowDataArray = Array.isArray(flowData) ? flowData : [flowData]
+            const flowNode = flowDataArray.find(n => n.type === flowType)
+
+            if (flowNode && flowNode.id) {
+                const expectedFilename = idToFilename.get(flowNode.id)
+                
+                // If this ID exists in current flows but with a different filename, this is an old renamed file
+                if (expectedFilename && expectedFilename !== filename) {
+                    RED.log.info(`[node-red-contrib-flow-splitter-extended] Removing old ${flowType} file "${file}" (renamed to "${expectedFilename}${extension}")`)
+                    
+                    // Remove the old flow file
+                    fs.unlinkSync(filePath)
+                    
+                    // Remove the corresponding subdirectory if it exists
+                    const subdirPath = path.join(dir, filename)
+                    if (fs.existsSync(subdirPath) && fs.statSync(subdirPath).isDirectory()) {
+                        fs.rmSync(subdirPath, { recursive: true, force: true })
+                        RED.log.info(`[node-red-contrib-flow-splitter-extended] Removed old ${flowType} directory "${filename}"`)
+                    }
+                }
+            }
+        } catch (error) {
+            RED.log.warn(`[node-red-contrib-flow-splitter-extended] Error checking ${flowType} file ${file}: ${error.message}`)
+        }
+    })
 }
 
 /**
@@ -153,12 +293,12 @@ function processFlowDirectory(dir, fileFormat, flowType) {
 }
 
 /**
- * Collect functions and templates back into split flow files before rebuilding monolith
+ * Restore functions and templates back into split flow files before rebuilding single flows.json file
  * @param {object} cfg - Splitter configuration
  * @param {string} projectPath - Path to the project
  */
-function collectFunctionsTemplatesIntoSplitFiles(cfg, projectPath) {
-    if (cfg.extractFunctionsTemplates === false) {
+function restoreFunctionsTemplatesIntoSplitFiles(cfg, projectPath) {
+    if (cfg.restoreFunctionsTemplates === false) {
         return
     }
 
@@ -166,19 +306,19 @@ function collectFunctionsTemplatesIntoSplitFiles(cfg, projectPath) {
     const tabsDir = path.join(srcDir, 'tabs')
     const subflowsDir = path.join(srcDir, 'subflows')
 
-    RED.log.info("[node-red-contrib-flow-splitter-extended] Collecting functions and templates...")
+    RED.log.info("[node-red-contrib-flow-splitter-extended] Restoring functions and templates...")
 
-    collectFromFlowDirectory(tabsDir, cfg.fileFormat, 'tab')
-    collectFromFlowDirectory(subflowsDir, cfg.fileFormat, 'subflow')
+    restoreIntoFlowDirectory(tabsDir, cfg.fileFormat, 'tab')
+    restoreIntoFlowDirectory(subflowsDir, cfg.fileFormat, 'subflow')
 }
 
 /**
- * Process a directory of flow files to collect functions/templates
+ * Process a directory of flow files to restore functions/templates
  * @param {string} dir - Directory to process
  * @param {string} fileFormat - File format (yaml or json)
  * @param {string} flowType - Type of flow (tab or subflow)
  */
-function collectFromFlowDirectory(dir, fileFormat, flowType) {
+function restoreIntoFlowDirectory(dir, fileFormat, flowType) {
     if (!fs.existsSync(dir)) {
         return
     }
@@ -201,7 +341,7 @@ function collectFromFlowDirectory(dir, fileFormat, flowType) {
             }
 
             let flowNodes = Array.isArray(flowData) ? flowData : [flowData]
-            flowNodes = functionsTemplatesHandler.collectFunctionsAndTemplates(flowNodes, flowName, dir, RED)
+            flowNodes = functionsTemplatesHandler.restoreFunctionsAndTemplates(flowNodes, flowName, dir, RED)
 
             if (fileFormat === 'yaml') {
                 const yamlContent = yaml.dump(flowNodes, {
@@ -216,14 +356,50 @@ function collectFromFlowDirectory(dir, fileFormat, flowType) {
             }
 
         } catch (error) {
-            RED.log.warn(`[node-red-contrib-flow-splitter-extended] Error collecting ${flowType} ${flowName}: ${error.message}`)
+            RED.log.warn(`[node-red-contrib-flow-splitter-extended] Error restoring ${flowType} ${flowName}: ${error.message}`)
         }
     })
 }
 
+/**
+ * Write a monolith artifact file to artifact/flows.json when enabled.
+ * @param {object} cfg - Splitter configuration
+ * @param {string} projectPath - Path to the project
+ * @param {Array} [flowNodes] - Optional flow nodes to serialize directly
+ */
+function writeMonolithArtifact(cfg, projectPath, flowNodes) {
+    if (cfg.enableArtifact !== true) {
+        return
+    }
+
+    const artifactDir = path.join(projectPath, artifactsDirname)
+    const artifactPath = path.join(artifactDir, artifactsFilename)
+
+    try {
+        fs.mkdirSync(artifactDir, { recursive: true })
+
+        if (Array.isArray(flowNodes)) {
+            fs.writeFileSync(artifactPath, eol.auto(JSON.stringify(flowNodes, null, 2)), 'utf8')
+        } else {
+            const monolithPath = path.join(projectPath, cfg.monolithFilename || RED.settings.flowFile || 'flows.json')
+
+            if (!fs.existsSync(monolithPath)) {
+                RED.log.warn(`[node-red-contrib-flow-splitter-extended] Could not write artifact: monolith file not found at '${monolithPath}'`)
+                return
+            }
+
+            fs.copyFileSync(monolithPath, artifactPath)
+        }
+
+        RED.log.info(`[node-red-contrib-flow-splitter-extended] Wrote monolith artifact at '${artifactPath}'`)
+    } catch (error) {
+        RED.log.warn(`[node-red-contrib-flow-splitter-extended] Could not write monolith artifact: ${error.message}`)
+    }
+}
+
 /**
  * Manual reload endpoint handler
- * Collects functions/templates from files and reloads flows
+ * Restores functions/templates from files and reloads flows
  */
 async function manualReload(req, res) {
     try {
@@ -232,7 +408,7 @@ async function manualReload(req, res) {
         const projectPath = getProjectPath()
         const cfg = loadSplitterConfig(projectPath)
 
-        collectFunctionsTemplatesIntoSplitFiles(cfg, projectPath)
+        restoreFunctionsTemplatesIntoSplitFiles(cfg, projectPath)
 
         const flowSet = manager.constructFlowSetFromTreeFiles(cfg, projectPath)
 
@@ -245,6 +421,7 @@ async function manualReload(req, res) {
         }
 
         manager.constructMonolithFileFromFlowSet(flowSet, cfg, projectPath, false)
+        writeMonolithArtifact(cfg, projectPath)
 
         const PRIVATE_RED = getPrivateRED()
         await PRIVATE_RED.nodes.loadFlows(true)
@@ -278,9 +455,9 @@ async function onFlowReload(flowEventData) {
 
     if (flowEventData.config.flows.length === 0) {
         // The flow file does not exist or is empty - rebuild from split files
-        RED.log.info("[node-red-contrib-flow-splitter-extended] Rebuilding monolith file from source files")
+        RED.log.info("[node-red-contrib-flow-splitter-extended] Rebuilding single flows.json file from source files")
         
-        collectFunctionsTemplatesIntoSplitFiles(cfg, projectPath)
+        restoreFunctionsTemplatesIntoSplitFiles(cfg, projectPath)
         
         const flowSet = manager.constructFlowSetFromTreeFiles(cfg, projectPath)
 
@@ -291,6 +468,7 @@ async function onFlowReload(flowEventData) {
 
         const updatedCfg = manager.constructMonolithFileFromFlowSet(flowSet, cfg, projectPath, false)
         writeSplitterConfig(updatedCfg, projectPath)
+        writeMonolithArtifact(updatedCfg, projectPath)
 
         const PRIVATE_RED = getPrivateRED()
 
@@ -303,10 +481,14 @@ async function onFlowReload(flowEventData) {
     }
 
     // Flows exist - split into source files
+    // First, clean up any old files from renamed tabs/subflows
+    cleanupRenamedFlows(flowEventData.config.flows, cfg, projectPath)
+
     const flowSet = manager.constructFlowSetFromMonolithObject(flowEventData.config.flows)
 
     const updatedCfg = manager.constructTreeFilesFromFlowSet(flowSet, cfg, projectPath)
     writeSplitterConfig(updatedCfg, projectPath)
+    writeMonolithArtifact(updatedCfg, projectPath, flowEventData.config.flows)
 
     extractFunctionsTemplatesFromSplitFiles(updatedCfg, projectPath)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vdwpsmt/node-red-contrib-flow-splitter-extended",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Split your flows.json file in individual YAML or JSON files (per tab, subflow and config-node) with optional function and ui-template node code extraction.",
   "main": "index.js",
   "keywords": [