Add support to get single nodes from given syntax tree

build-config/spotbugs-exclude.xml

@@ -34,7 +34,15 @@
         <Bug pattern="EI_EXPOSE_REP" />
     </Match>
     <Match>
-        <Class name="io.ballerina.xsd.core.Response" />
+        <Class name="io.ballerina.xsd.core.response.Response" />
+        <Bug pattern="EI_EXPOSE_REP" />
+    </Match>
+    <Match>
+        <Class name="io.ballerina.xsd.core.node.MemberNode" />
+        <Bug pattern="EI_EXPOSE_REP" />
+    </Match>
+    <Match>
+        <Class name="io.ballerina.xsd.core.response.NodeResponse" />
         <Bug pattern="EI_EXPOSE_REP" />
     </Match>
     <Match>
@@ -70,7 +78,15 @@
         <Bug pattern="EI_EXPOSE_REP2" />
     </Match>
     <Match>
-        <Class name="io.ballerina.xsd.core.Response" />
+        <Class name="io.ballerina.xsd.core.response.Response" />
+        <Bug pattern="EI_EXPOSE_REP2" />
+    </Match>
+    <Match>
+        <Class name="io.ballerina.xsd.core.node.MemberNode" />
+        <Bug pattern="EI_EXPOSE_REP2" />
+    </Match>
+    <Match>
+        <Class name="io.ballerina.xsd.core.response.NodeResponse" />
         <Bug pattern="EI_EXPOSE_REP2" />
     </Match>
     <Match>

xsd-cli/src/main/java/io/ballerina/xsd/cli/XsdCmd.java

@@ -19,7 +19,7 @@
 package io.ballerina.xsd.cli;
 
 import io.ballerina.projects.util.ProjectUtils;
-import io.ballerina.xsd.core.Response;
+import io.ballerina.xsd.core.response.Response;
 import io.ballerina.xsd.core.XSDToRecord;
 import org.w3c.dom.Document;
 import org.xml.sax.ErrorHandler;
@@ -145,6 +145,9 @@ public void execute() {
     }
 
     private void handleSingleFile(Path outputDirPath, String fileName) throws Exception {
+        if (Files.notExists(outputDirPath)) {
+            Files.createDirectories(outputDirPath);
+        }
         Path filePath = Path.of(fileName);
         if (!Files.exists(filePath)) {
             outStream.println(fileName + " file does not exist.");

xsd-core/src/main/java/io/ballerina/xsd/core/Utils.java

@@ -26,6 +26,8 @@
 import io.ballerina.compiler.syntax.tree.NodeList;
 import io.ballerina.compiler.syntax.tree.NodeParser;
 import io.ballerina.compiler.syntax.tree.Token;
+import io.ballerina.xsd.core.node.Kind;
+import io.ballerina.xsd.core.node.MemberNode;
 import io.ballerina.xsd.core.visitor.XSDVisitor;
 import io.ballerina.xsd.core.visitor.XSDVisitorImpl;
 import org.ballerinalang.formatter.core.Formatter;
@@ -55,32 +57,36 @@ public class Utils {
     private Utils() {
     }
 
-    public static ModulePartNode generateModulePartNode(Map<String, ModuleMemberDeclarationNode> nodes,
-                                                 XSDVisitor xsdVisitor) throws Exception {
-        NodeList<ModuleMemberDeclarationNode> moduleMembers = AbstractNodeFactory.createNodeList(nodes.values());
+    public static ModulePartNode generateModulePartNode(Map<String, MemberNode> nodes,
+                                                        XSDVisitor xsdVisitor) throws Exception {
+        NodeList<ModuleMemberDeclarationNode> moduleMembers = AbstractNodeFactory
+                .createNodeList(nodes.values().stream().map(MemberNode::node).toList());
         NodeList<ImportDeclarationNode> imports = getImportDeclarations(xsdVisitor);
         Token eofToken = AbstractNodeFactory.createIdentifierToken(XSDToRecord.EOF_TOKEN);
         return NodeFactory.createModulePartNode(imports, moduleMembers, eofToken);
     }
 
-    static void processRecordTypeElements(Map<String, ModuleMemberDeclarationNode> nodes,
+    static void processRecordTypeElements(Map<String, MemberNode> nodes,
                                           String element, String type, String contentField) {
-        String fields = extractSubstring(nodes.get(type).toString(), RECORD_WITH_OPEN_BRACE,
-                               VERTICAL_BAR + CLOSE_BRACES + SEMICOLON, contentField);
-        String extendedValue = nodes.get(element)
-                .toString().replace(type + WHITESPACE + contentField + SEMICOLON, fields);
-        ModuleMemberDeclarationNode moduleNode = NodeParser.parseModuleMemberDeclaration(extendedValue);
-        nodes.put(element, moduleNode);
+        if (nodes.containsKey(type) && nodes.containsKey(element)) {
+            String fields = extractSubstring(nodes.get(type).node().toString(), RECORD_WITH_OPEN_BRACE,
+                    VERTICAL_BAR + CLOSE_BRACES + SEMICOLON, contentField);
+            String extendedValue = nodes.get(element).node()
+                    .toString().replace(type + WHITESPACE + contentField + SEMICOLON, fields);
+            ModuleMemberDeclarationNode moduleNode = NodeParser.parseModuleMemberDeclaration(extendedValue);
+            nodes.put(element, new MemberNode(moduleNode, Kind.ELEMENT));
+        }
     }
 
-    static void processSingleTypeElements(Map<String, ModuleMemberDeclarationNode> nodes,
+    static void processSingleTypeElements(Map<String, MemberNode> nodes,
                                           String element, String type, String[] tokens, String contentField) {
-        String token = (!nodes.containsKey(type)) || nodes.get(type).toString().contains(XSDVisitorImpl.ENUM)
+        String token = (!nodes.containsKey(type) || nodes.get(type).node().toString().contains(XSDVisitorImpl.ENUM))
                 ? STRING : tokens[tokens.length - 2];
-        String rootElement = nodes.get(element).toString().replace(type + WHITESPACE + contentField,
-                token + WHITESPACE + contentField);
-        ModuleMemberDeclarationNode moduleNode = NodeParser.parseModuleMemberDeclaration(rootElement);
-        nodes.put(element, moduleNode);
+        if (nodes.containsKey(element)) {
+            String rootElement = nodes.get(element).node().toString()
+                    .replace(type + WHITESPACE + contentField, token + WHITESPACE + contentField);
+            nodes.put(element, new MemberNode(NodeParser.parseModuleMemberDeclaration(rootElement), Kind.ELEMENT));
+        }
     }
 
     static String extractSubstring(String baseString, String startToken, String endToken, String contentField) {

xsd-core/src/main/java/io/ballerina/xsd/core/XSDNodeContext.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2025, WSO2 LLC. (http://www.wso2.com)
+ *
+ * WSO2 LLC. licenses this file to you 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.
+ */
+
+package io.ballerina.xsd.core;
+
+import io.ballerina.compiler.syntax.tree.ModuleMemberDeclarationNode;
+import io.ballerina.xsd.core.context.NodeContext;
+import io.ballerina.xsd.core.node.Kind;
+import io.ballerina.xsd.core.node.MemberNode;
+import io.ballerina.xsd.core.node.XSDElement;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Represents the nodeContext for processing XSD elements.
+ * This class provides methods to manage and retrieve syntax tree nodes and XSD elements.
+ */
+final class XSDNodeContext implements NodeContext {
+     private final Map<String, MemberNode> nodes = new HashMap<>();
+     private final Map<String, XSDElement> nameResolvers = new HashMap<>();
+
+    public XSDNodeContext(Map<String, MemberNode> nodes, Map<String, XSDElement> nameResolvers) {
+        this.nodes.putAll(nodes);
+        this.nameResolvers.putAll(nameResolvers);
+    }
+
+    static <K, V> K getKeyByValue(Map<K, V> map, V value) {
+        for (Map.Entry<K, V> entry : map.entrySet()) {
+            if (Objects.equals(value, entry.getValue())) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public ModuleMemberDeclarationNode findNode(String element, Kind kind) {
+        List<MemberNode> memberNodeList = new ArrayList<>();
+        if (nodes.containsKey(element)) {
+            memberNodeList.add(nodes.get(element));
+        }
+        Collection<XSDElement> elements = nameResolvers.values();
+        for (XSDElement xsdElement : elements) {
+            if (Objects.equals(xsdElement.type(), element)) {
+                String key = getKeyByValue(nameResolvers, xsdElement);
+                if (key != null && nodes.containsKey(key)) {
+                    memberNodeList.add(nodes.get(key));
+                }
+            }
+        }
+        return memberNodeList.stream()
+                .filter(memberNode -> memberNode.kind() == kind)
+                .findFirst()
+                .map(MemberNode::node)
+                .orElse(null);
+    }
+}