Enhance configuration saving with optional XML formatting and improve attribute ordering

Author: stijnpotters1

src/main/frontend/app/routes/studio/canvas/flow.tsx

@@ -165,7 +165,7 @@ function FlowCanvas() {
 
       const updatedConfigXml = replaceAdapterInXml(fullConfigXml, adapterIndex, newAdapterXml.trim())
 
-      await saveConfiguration(currentProject.name, configurationPath, updatedConfigXml)
+      await saveConfiguration(currentProject.name, configurationPath, updatedConfigXml, true)
       clearConfigurationCache(currentProject.name, configurationPath)
       useEditorTabStore.getState().refreshAllTabs()
       if (currentProject.isGitRepository) await refreshOpenDiffs(currentProject.name)

src/main/frontend/app/routes/studio/flow-to-xml-parser.ts

@@ -5,9 +5,6 @@ import { getAdapter } from '~/services/adapter-service'
 import { FlowConfig } from './canvas/flow.config'
 import { isGroupNode, isStickyNote } from '~/stores/flow-store'
 import type { GroupNode } from './canvas/nodetypes/group-node'
-import { fetchFrankConfigXsd } from '~/services/xsd-service'
-import { getMandatoryAttributeNames, parseXsd } from '~/utils/xsd-utils'
-import { sortAttributes } from '~/utils/xml-attribute-sort'
 
 interface ReactFlowJson {
   nodes: FlowNode[]
@@ -45,14 +42,6 @@ export async function exportFlowToXml(
       : existingAdapterXml
   const adapterAttributes = getAdapterAttributes(adapterXml)
 
-  let xsdDoc: Document | null = null
-
-  try {
-    xsdDoc = parseXsd(await fetchFrankConfigXsd())
-  } catch {
-    console.warn('Could not fetch FrankConfig XSD; attribute order may not be optimal.')
-  }
-
   const { nodes, edges } = json
   const validNodes = nodes.filter((node) => hasDataProperty(node))
   const nodeMap = new Map(validNodes.map((n) => [n.id, n]))
@@ -87,13 +76,13 @@ export async function exportFlowToXml(
 
     const type = node.data.type?.toLowerCase()
     if (type === 'receiver') {
-      receivers.push(generateXmlElement(node, edgeMap, exitNodeIds, nodeMap, xsdDoc))
+      receivers.push(generateXmlElement(node, edgeMap, exitNodeIds, nodeMap))
     } else if (type === 'pipe') {
-      pipelineParts.push(generateXmlElement(node, edgeMap, exitNodeIds, nodeMap, xsdDoc))
+      pipelineParts.push(generateXmlElement(node, edgeMap, exitNodeIds, nodeMap))
     }
   }
 
-  const exitsXml = exitNodes.length > 0 ? `      <Exits>\n${generateExitsXml(exitNodes, xsdDoc)}\n      </Exits>` : ''
+  const exitsXml = exitNodes.length > 0 ? `      <Exits>\n${generateExitsXml(exitNodes)}\n      </Exits>` : ''
   const flowXml = generateFlowElementsXml(nodes)
 
   return `
@@ -108,18 +97,17 @@ ${pipelineParts.join('\n')}
 }
 
 export function replaceAdapterInXml(configXml: string, adapterIndex: number, newAdapterXml: string): string {
-  const starts = [...configXml.matchAll(/<[Aa]dapter\b/g)].map((m) => m.index)
+  const matches = [...configXml.matchAll(/<(Adapter|adapter)\b/g)]
 
-  if (adapterIndex >= starts.length) return configXml
+  if (adapterIndex >= matches.length) return configXml
 
-  const start = starts[adapterIndex]
-  const closeRegex = /<\/[Aa]dapter>/g
-  closeRegex.lastIndex = start
+  const match = matches[adapterIndex]
+  const start = match.index
+  const closingTag = `</${match[1]}>`
+  const closeIndex = configXml.indexOf(closingTag, start)
+  if (closeIndex === -1) return configXml
 
-  const closeMatch = closeRegex.exec(configXml)
-  if (!closeMatch) return configXml
-
-  return configXml.slice(0, start) + newAdapterXml + configXml.slice(closeMatch.index + closeMatch[0].length)
+  return configXml.slice(0, start) + newAdapterXml + configXml.slice(closeIndex + closingTag.length)
 }
 
 function buildEdgeMaps(edges: Edge[]) {
@@ -178,7 +166,6 @@ function generateXmlElement(
   edgeMap: Map<string, { targetId: string; label: string }[]>,
   exitNodeIds: Set<string>,
   nodeMap: Map<string, FlowNode>,
-  xsdDoc: Document | null,
 ): string {
   const { subtype, name } = node.data as NodeData
   const { x, y } = node.position
@@ -190,7 +177,7 @@ function generateXmlElement(
     width = node.measured.width
   }
 
-  const height: number | undefined = node.height ?? undefined
+  const height: number | null = node.height ?? null
   const attributes = (node.data as NodeData).attributes || {}
   const children = (node.data as NodeData).children || []
 
@@ -200,14 +187,13 @@ function generateXmlElement(
     'flow:x': String(roundedX),
     'flow:y': String(roundedY),
     'flow:width': String(width),
-    ...(height === undefined ? {} : { 'flow:height': String(height) }),
+    ...(height === null ? {} : { 'flow:height': String(height) }),
   }
-  const mandatory = xsdDoc ? getMandatoryAttributeNames(xsdDoc, subtype) : new Set<string>()
-  const attrStr = sortAttributes(allAttrs, mandatory)
+  const attrStr = Object.entries(allAttrs)
     .map(([k, v]) => `${k}="${escapeXml(v)}"`)
     .join(' ')
 
-  const childXml = children.map((child: ChildNode) => generateChildXml(child, 4, xsdDoc)).join('\n')
+  const childXml = children.map((child: ChildNode) => generateChildXml(child, 4)).join('\n')
 
   const type = (node.data as NodeData).type?.toLowerCase()
 
@@ -232,16 +218,15 @@ function generateXmlElement(
   return content ? `  <${subtype} ${attrStr} >\n${content}\n  </${subtype}>` : `  <${subtype} ${attrStr} />`
 }
 
-function generateChildXml(child: ChildNode, indent: number, xsdDoc: Document | null): string {
+function generateChildXml(child: ChildNode, indent: number): string {
   const spaces = ' '.repeat(indent)
 
   const childAttrs: Record<string, string> = {
     ...(child.name ? { name: child.name } : {}),
     ...child.attributes,
   }
 
-  const mandatory = xsdDoc ? getMandatoryAttributeNames(xsdDoc, child.subtype) : new Set<string>()
-  const attrStr = sortAttributes(childAttrs, mandatory)
+  const attrStr = Object.entries(childAttrs)
     .map(([k, v]) => `${k}="${escapeXml(v)}"`)
     .join(' ')
 
@@ -252,16 +237,14 @@ function generateChildXml(child: ChildNode, indent: number, xsdDoc: Document | n
     return `${spaces}<${child.subtype}${attrs}/>`
   }
 
-  const childXmlStrings = child.children!.map((nested) => generateChildXml(nested, indent + 2, xsdDoc))
+  const childXmlStrings = child.children!.map((nested) => generateChildXml(nested, indent + 2))
 
   return `${spaces}<${child.subtype}${attrs}>
 ${childXmlStrings.join('\n')}
 ${spaces}</${child.subtype}>`
 }
 
-function generateExitsXml(exitNodes: FlowNode[], xsdDoc: Document | null): string {
-  const mandatory = xsdDoc ? getMandatoryAttributeNames(xsdDoc, 'Exit') : new Set<string>()
-
+function generateExitsXml(exitNodes: FlowNode[]): string {
   return exitNodes
     .map((node) => {
       const { name } = node.data as NodeData
@@ -284,7 +267,7 @@ function generateExitsXml(exitNodes: FlowNode[], xsdDoc: Document | null): strin
         'flow:width': String(width),
         'flow:height': String(height),
       }
-      const attrStr = sortAttributes(allAttrs, mandatory)
+      const attrStr = Object.entries(allAttrs)
         .map(([k, v]) => `${k}="${escapeXml(v)}"`)
         .join(' ')
 

src/main/frontend/app/services/configuration-service.ts

@@ -31,8 +31,14 @@ export async function fetchConfiguration(projectName: string, filepath: string,
   return content
 }
 
-export async function saveConfiguration(projectName: string, filepath: string, content: string): Promise<XmlResponse> {
-  return apiFetch<XmlResponse>(`${getBaseUrl(projectName)}?path=${encodeURIComponent(filepath)}`, {
+export async function saveConfiguration(
+  projectName: string,
+  filepath: string,
+  content: string,
+  format = false,
+): Promise<XmlResponse> {
+  const formatParam = format ? '&format=true' : ''
+  return apiFetch<XmlResponse>(`${getBaseUrl(projectName)}?path=${encodeURIComponent(filepath)}${formatParam}`, {
     method: 'PUT',
     body: content,
   })

src/main/frontend/app/utils/xml-attribute-sort.ts

@@ -386,57 +386,6 @@ function getRequiredOnly(requirement: Requirement): Requirement | null {
   return null
 }
 
-/**
- * Returns the set of attribute names that are required (`use="required"`) for the
- * given element name in the XSD. Walks the type hierarchy via `xs:extension` so
- * attributes inherited from base types are included.
- */
-export function getMandatoryAttributeNames(doc: Document, elementName: string): Set<string> {
-  const typeNode = getComplexTypeByName(doc, `${elementName}Type`)
-  if (!typeNode) return new Set()
-  return collectRequiredAttributes(doc, typeNode, new Set())
-}
-
-/**
- * Recursively walks a complex-type node (and any base types it extends) to collect
- * all mandatory attribute names`.
- */
-function collectRequiredAttributes(doc: Document, node: Element, visited: Set<string>): Set<string> {
-  const result = new Set<string>()
-
-  for (const child of node.children) {
-    switch (child.localName) {
-      case 'attribute': {
-        const name = child.getAttribute('name')
-        if (name && child.getAttribute('use') === 'required') result.add(name)
-        break
-      }
-      case 'extension': {
-        const base = child.getAttribute('base')
-        if (base && !visited.has(base)) {
-          visited.add(base)
-          const baseType = getComplexTypeByName(doc, base)
-          if (baseType) {
-            for (const a of collectRequiredAttributes(doc, baseType, visited)) result.add(a)
-          }
-        }
-        for (const a of collectRequiredAttributes(doc, child, visited)) result.add(a)
-        break
-      }
-      case 'complexContent':
-      case 'simpleContent':
-      case 'sequence':
-      case 'all':
-      case 'choice': {
-        for (const a of collectRequiredAttributes(doc, child, visited)) result.add(a)
-        break
-      }
-    }
-  }
-
-  return result
-}
-
 interface RequirementBase {
   kind: 'element' | 'group'
 }

src/main/frontend/app/utils/xsd-utils.ts

@@ -41,9 +41,10 @@ public ResponseEntity<ConfigurationDTO> getConfigurationByPath(
 	public ResponseEntity<XmlDTO> updateConfiguration(
 			@PathVariable String projectName,
 			@RequestParam String path,
+			@RequestParam(defaultValue = "false") boolean format,
 			@RequestBody String content
 	) throws ApiException {
-		String updatedContent = configurationService.updateConfiguration(projectName, path, content);
+		String updatedContent = configurationService.updateConfiguration(projectName, path, content, format);
 		XmlDTO xmlDTO = new XmlDTO(updatedContent);
 		return ResponseEntity.ok(xmlDTO);
 	}

src/main/java/org/frankframework/flow/configuration/ConfigurationController.java

@@ -1,33 +1,76 @@
 package org.frankframework.flow.configuration;
 
 import java.io.IOException;
+import java.io.StringReader;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.TransformerException;
+import lombok.extern.slf4j.Slf4j;
 import org.frankframework.flow.exception.ApiException;
 import org.frankframework.flow.filesystem.FileSystemStorage;
+import org.frankframework.flow.frankconfig.FrankConfigXsdNotFoundException;
+import org.frankframework.flow.frankconfig.FrankConfigXsdService;
 import org.frankframework.flow.project.Project;
 import org.frankframework.flow.project.ProjectService;
 import org.frankframework.flow.utility.XmlConfigurationUtils;
+import org.frankframework.flow.utility.XmlFormatterUtils;
+import org.frankframework.flow.utility.XmlSecurityUtils;
+import org.frankframework.flow.utility.XsdAttributeOrdererUtils;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.http.HttpStatus;
 import org.springframework.stereotype.Service;
 import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
 import org.xml.sax.SAXException;
 
+@Slf4j
 @Service
 public class ConfigurationService {
 
 	private static final String CONFIGURATIONS_DIR = "src/main/configurations";
 
 	private final FileSystemStorage fileSystemStorage;
 	private final ProjectService projectService;
+	private final FrankConfigXsdService frankConfigXsdService;
 
-	public ConfigurationService(FileSystemStorage fileSystemStorage, ProjectService projectService) {
+	private volatile XsdAttributeOrdererUtils xsdOrderer;
+	private volatile boolean xsdLoadAttempted = false;
+
+	public ConfigurationService(
+			FileSystemStorage fileSystemStorage,
+			ProjectService projectService,
+			FrankConfigXsdService frankConfigXsdService) {
 		this.fileSystemStorage = fileSystemStorage;
 		this.projectService = projectService;
+		this.frankConfigXsdService = frankConfigXsdService;
+	}
+
+	private XsdAttributeOrdererUtils getXsdOrderer() {
+		if (!xsdLoadAttempted) {
+			synchronized (this) {
+				if (!xsdLoadAttempted) {
+					xsdLoadAttempted = true;
+					xsdOrderer = loadXsdOrderer();
+				}
+			}
+		}
+		return xsdOrderer;
+	}
+
+	private XsdAttributeOrdererUtils loadXsdOrderer() {
+		try {
+			String xsdContent = frankConfigXsdService.getFrankConfigXsd();
+			Document doc = XmlSecurityUtils.createSecureDocumentBuilder()
+					.parse(new InputSource(new StringReader(xsdContent)));
+			return new XsdAttributeOrdererUtils(doc);
+		} catch (FrankConfigXsdNotFoundException e) {
+			log.warn("FrankConfig XSD unavailable; attribute ordering will be skipped: {}", e.getMessage());
+		} catch (Exception e) {
+			log.warn("Failed to parse FrankConfig XSD; attribute ordering will be skipped: {}", e.getMessage());
+		}
+		return null;
 	}
 
 	public ConfigurationDTO getConfigurationContent(String projectName, String filepath) throws IOException, ApiException {
@@ -41,7 +84,7 @@ public ConfigurationDTO getConfigurationContent(String projectName, String filep
 		return new ConfigurationDTO(filepath, content);
 	}
 
-	public String updateConfiguration(String projectName, String filepath, String content)
+	public String updateConfiguration(String projectName, String filepath, String content, boolean format)
 			throws ApiException {
 		Path absolutePath = fileSystemStorage.toAbsolutePath(filepath);
 
@@ -55,11 +98,15 @@ public String updateConfiguration(String projectName, String filepath, String co
 
 		try {
 			String withNamespace = ensureFlowNamespace(content);
-			String formatted = XmlConfigurationUtils.formatPreservingAttributeOrder(withNamespace);
+			if (!format) {
+				fileSystemStorage.writeFile(absolutePath.toString(), withNamespace);
+				return withNamespace;
+			}
+			String formatted = XmlFormatterUtils.format(withNamespace, getXsdOrderer());
 			fileSystemStorage.writeFile(absolutePath.toString(), formatted);
 			return formatted;
 		} catch (Exception e) {
-			throw new ApiException("Failed to format configuration: " + e.getMessage(), HttpStatus.BAD_REQUEST);
+			throw new ApiException("Failed to save configuration: " + e.getMessage(), HttpStatus.BAD_REQUEST);
 		}
 	}