From d3157095df18d98a83df7739ec1d4c748199353d Mon Sep 17 00:00:00 2001
From: Sander van Driel <sander.vandriel@gmail.com>
Date: Tue, 7 May 2024 16:49:44 +0200
Subject: [PATCH 1/4] refactor: extract getInputDefinition

---
 src/parser.ts | 98 ++++++++++++++++++++++++++++++---------------------
 1 file changed, 58 insertions(+), 40 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index dadc95b..966d859 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,6 +1,6 @@
 import * as path from "path";
 import { ComplexTypeElement } from "soap/lib/wsdl/elements";
-import { open_wsdl } from "soap/lib/wsdl/index";
+import { WSDL, open_wsdl } from "soap/lib/wsdl/index";
 import { Definition, Method, ParsedWsdl, Port, Service } from "./models/parsed-wsdl";
 import { changeCase } from "./utils/change-case";
 import { stripExtension } from "./utils/file";
@@ -287,54 +287,38 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
                             Logger.debug(`Parsing Method ${methodName}`);
 
                             // TODO: Deduplicate code below by refactoring it to external function. Is it even possible ?
-                            let requestParamName = "request";
                             let inputDefinition: Definition = null; // default type
+
                             if (method.input) {
-                                if (method.input.$name) {
-                                    requestParamName = method.input.$name;
-                                }
-                                const inputMessage = wsdl.definitions.messages[method.input.$name];
-                                if (inputMessage.element) {
-                                    // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
-                                    const typeName = inputMessage.element.$type ?? inputMessage.element.$name;
-                                    const type = parsedWsdl.findDefinition(
-                                        inputMessage.element.$type ?? inputMessage.element.$name
+                                const inputName = method.input.$name;
+                                if (!inputName) {
+                                    throw new Error(
+                                        `Method '${serviceName}.${portName}.${methodName}' doesn't have input name`
                                     );
-                                    inputDefinition =
-                                        type ??
-                                        parseDefinition(
-                                            parsedWsdl,
-                                            mergedOptions,
-                                            typeName,
-                                            inputMessage.parts,
-                                            [typeName],
-                                            visitedDefinitions
-                                        );
-                                } else if (inputMessage.parts) {
-                                    const type = parsedWsdl.findDefinition(requestParamName);
-                                    inputDefinition =
-                                        type ??
-                                        parseDefinition(
-                                            parsedWsdl,
-                                            mergedOptions,
-                                            requestParamName,
-                                            inputMessage.parts,
-                                            [requestParamName],
-                                            visitedDefinitions
-                                        );
-                                } else {
+                                }
+                                inputDefinition = getInputDefinition(
+                                    inputName,
+                                    wsdl,
+                                    parsedWsdl,
+                                    mergedOptions,
+                                    visitedDefinitions
+                                );
+                                if (!inputDefinition) {
                                     Logger.debug(
                                         `Method '${serviceName}.${portName}.${methodName}' doesn't have any input defined`
                                     );
                                 }
                             }
 
-                            let responseParamName = "response";
                             let outputDefinition: Definition = null; // default type, `{}` or `unknown` ?
                             if (method.output) {
-                                if (method.output.$name) {
-                                    responseParamName = method.output.$name;
+                                if (!method.output.$name) {
+                                    throw new Error(
+                                        `Method '${serviceName}.${portName}.${methodName}' doesn't have output name`
+                                    );
                                 }
+
+                                const methodOutputName = method.output.$name;
                                 const outputMessage = wsdl.definitions.messages[method.output.$name];
                                 if (outputMessage.element) {
                                     // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
@@ -351,20 +335,21 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
                                             visitedDefinitions
                                         );
                                 } else {
-                                    const type = parsedWsdl.findDefinition(responseParamName);
+                                    const type = parsedWsdl.findDefinition(methodOutputName);
                                     outputDefinition =
                                         type ??
                                         parseDefinition(
                                             parsedWsdl,
                                             mergedOptions,
-                                            responseParamName,
+                                            methodOutputName,
                                             outputMessage.parts,
-                                            [responseParamName],
+                                            [methodOutputName],
                                             visitedDefinitions
                                         );
                                 }
                             }
 
+                            const requestParamName = method.input?.$name ?? "request";
                             const camelParamName = changeCase(requestParamName);
                             const portMethod: Method = {
                                 name: methodName,
@@ -401,3 +386,36 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
         );
     });
 }
+
+function getInputDefinition(
+    methodInputName: string,
+    wsdl: WSDL,
+    parsedWsdl: ParsedWsdl,
+    mergedOptions: ParserOptions,
+    visitedDefinitions: VisitedDefinition[]
+): Definition {
+    const inputMessage = wsdl.definitions.messages[methodInputName];
+    if (inputMessage.element) {
+        // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
+        const typeName = inputMessage.element.$type ?? inputMessage.element.$name;
+        const type = parsedWsdl.findDefinition(inputMessage.element.$type ?? inputMessage.element.$name);
+        return (
+            type ??
+            parseDefinition(parsedWsdl, mergedOptions, typeName, inputMessage.parts, [typeName], visitedDefinitions)
+        );
+    } else if (inputMessage.parts) {
+        const type = parsedWsdl.findDefinition(methodInputName);
+        return (
+            type ??
+            parseDefinition(
+                parsedWsdl,
+                mergedOptions,
+                methodInputName,
+                inputMessage.parts,
+                [methodInputName],
+                visitedDefinitions
+            )
+        );
+    }
+    return null;
+}

From 12a7a19838c28db096926042e96f1bc915614863 Mon Sep 17 00:00:00 2001
From: Sander van Driel <sander.vandriel@gmail.com>
Date: Tue, 7 May 2024 18:19:42 +0200
Subject: [PATCH 2/4] refactor: extract output definitions

---
 src/parser.ts | 96 +++++++++++++++++++++++++++------------------------
 1 file changed, 51 insertions(+), 45 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 966d859..53280b7 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,5 +1,5 @@
 import * as path from "path";
-import { ComplexTypeElement } from "soap/lib/wsdl/elements";
+import { ComplexTypeElement, OperationElement } from "soap/lib/wsdl/elements";
 import { WSDL, open_wsdl } from "soap/lib/wsdl/index";
 import { Definition, Method, ParsedWsdl, Port, Service } from "./models/parsed-wsdl";
 import { changeCase } from "./utils/change-case";
@@ -285,16 +285,14 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
 
                         for (const [methodName, method] of Object.entries(port.binding.methods)) {
                             Logger.debug(`Parsing Method ${methodName}`);
+                            const methodPath = `${serviceName}.${portName}.${methodName}`;
 
-                            // TODO: Deduplicate code below by refactoring it to external function. Is it even possible ?
-                            let inputDefinition: Definition = null; // default type
+                            let inputDefinition: Definition | null = null; // default type
 
                             if (method.input) {
                                 const inputName = method.input.$name;
                                 if (!inputName) {
-                                    throw new Error(
-                                        `Method '${serviceName}.${portName}.${methodName}' doesn't have input name`
-                                    );
+                                    throw new Error(`Method '${methodPath}' doesn't have input name`);
                                 }
                                 inputDefinition = getInputDefinition(
                                     inputName,
@@ -304,49 +302,24 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
                                     visitedDefinitions
                                 );
                                 if (!inputDefinition) {
-                                    Logger.debug(
-                                        `Method '${serviceName}.${portName}.${methodName}' doesn't have any input defined`
-                                    );
+                                    Logger.debug(`Method '${methodPath}' doesn't have any input defined`);
                                 }
                             }
 
-                            let outputDefinition: Definition = null; // default type, `{}` or `unknown` ?
-                            if (method.output) {
-                                if (!method.output.$name) {
-                                    throw new Error(
-                                        `Method '${serviceName}.${portName}.${methodName}' doesn't have output name`
-                                    );
-                                }
+                            let outputDefinition: Definition | null = null;
 
+                            if (method.output) {
                                 const methodOutputName = method.output.$name;
-                                const outputMessage = wsdl.definitions.messages[method.output.$name];
-                                if (outputMessage.element) {
-                                    // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
-                                    const typeName = outputMessage.element.$type ?? outputMessage.element.$name;
-                                    const type = parsedWsdl.findDefinition(typeName);
-                                    outputDefinition =
-                                        type ??
-                                        parseDefinition(
-                                            parsedWsdl,
-                                            mergedOptions,
-                                            typeName,
-                                            outputMessage.parts,
-                                            [typeName],
-                                            visitedDefinitions
-                                        );
-                                } else {
-                                    const type = parsedWsdl.findDefinition(methodOutputName);
-                                    outputDefinition =
-                                        type ??
-                                        parseDefinition(
-                                            parsedWsdl,
-                                            mergedOptions,
-                                            methodOutputName,
-                                            outputMessage.parts,
-                                            [methodOutputName],
-                                            visitedDefinitions
-                                        );
+                                if (!methodOutputName) {
+                                    throw new Error(`Method '${methodPath}' doesn't have output name`);
                                 }
+                                outputDefinition = getOutputDefinition(
+                                    methodOutputName,
+                                    wsdl,
+                                    parsedWsdl,
+                                    mergedOptions,
+                                    visitedDefinitions
+                                );
                             }
 
                             const requestParamName = method.input?.$name ?? "request";
@@ -393,7 +366,7 @@ function getInputDefinition(
     parsedWsdl: ParsedWsdl,
     mergedOptions: ParserOptions,
     visitedDefinitions: VisitedDefinition[]
-): Definition {
+): Definition | null {
     const inputMessage = wsdl.definitions.messages[methodInputName];
     if (inputMessage.element) {
         // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
@@ -416,6 +389,39 @@ function getInputDefinition(
                 visitedDefinitions
             )
         );
+    } else {
+        return null;
+    }
+}
+
+function getOutputDefinition(
+    methodOutputName: string,
+    wsdl: WSDL,
+    parsedWsdl: ParsedWsdl,
+    mergedOptions: ParserOptions,
+    visitedDefinitions: VisitedDefinition[]
+): Definition | null {
+    const outputMessage = wsdl.definitions.messages[methodOutputName];
+    if (outputMessage.element) {
+        // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
+        const typeName = outputMessage.element.$type ?? outputMessage.element.$name;
+        const type = parsedWsdl.findDefinition(typeName);
+        return (
+            type ??
+            parseDefinition(parsedWsdl, mergedOptions, typeName, outputMessage.parts, [typeName], visitedDefinitions)
+        );
+    } else {
+        const type = parsedWsdl.findDefinition(methodOutputName);
+        return (
+            type ??
+            parseDefinition(
+                parsedWsdl,
+                mergedOptions,
+                methodOutputName,
+                outputMessage.parts,
+                [methodOutputName],
+                visitedDefinitions
+            )
+        );
     }
-    return null;
 }

From d7da06efe32c3727f6f78ebc3df8fc391097db21 Mon Sep 17 00:00:00 2001
From: Sander van Driel <sander.vandriel@gmail.com>
Date: Tue, 7 May 2024 19:44:12 +0200
Subject: [PATCH 3/4] feat: better naming, use object parameters

---
 src/parser.ts | 50 ++++++++++++++++++++++++++------------------------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/src/parser.ts b/src/parser.ts
index 53280b7..5de96b1 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -290,17 +290,17 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
                             let inputDefinition: Definition | null = null; // default type
 
                             if (method.input) {
-                                const inputName = method.input.$name;
-                                if (!inputName) {
-                                    throw new Error(`Method '${methodPath}' doesn't have input name`);
+                                const methodInputName = method.input.$name;
+                                if (!methodInputName) {
+                                    throw new Error(`Method '${methodPath}' doesn't have an input name`);
                                 }
-                                inputDefinition = getInputDefinition(
-                                    inputName,
+                                inputDefinition = createMethodInputDefinition({
+                                    methodInputName,
                                     wsdl,
                                     parsedWsdl,
                                     mergedOptions,
-                                    visitedDefinitions
-                                );
+                                    visitedDefinitions,
+                                });
                                 if (!inputDefinition) {
                                     Logger.debug(`Method '${methodPath}' doesn't have any input defined`);
                                 }
@@ -313,13 +313,13 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
                                 if (!methodOutputName) {
                                     throw new Error(`Method '${methodPath}' doesn't have output name`);
                                 }
-                                outputDefinition = getOutputDefinition(
+                                outputDefinition = createMethodOutputDefinition({
                                     methodOutputName,
                                     wsdl,
                                     parsedWsdl,
                                     mergedOptions,
-                                    visitedDefinitions
-                                );
+                                    visitedDefinitions,
+                                });
                             }
 
                             const requestParamName = method.input?.$name ?? "request";
@@ -360,13 +360,14 @@ export async function parseWsdl(wsdlPath: string, options: Partial<ParserOptions
     });
 }
 
-function getInputDefinition(
-    methodInputName: string,
-    wsdl: WSDL,
-    parsedWsdl: ParsedWsdl,
-    mergedOptions: ParserOptions,
-    visitedDefinitions: VisitedDefinition[]
-): Definition | null {
+function createMethodInputDefinition(opts: {
+    methodInputName: string;
+    wsdl: WSDL;
+    parsedWsdl: ParsedWsdl;
+    mergedOptions: ParserOptions;
+    visitedDefinitions: VisitedDefinition[];
+}): Definition | null {
+    const { methodInputName, wsdl, parsedWsdl, mergedOptions, visitedDefinitions } = opts;
     const inputMessage = wsdl.definitions.messages[methodInputName];
     if (inputMessage.element) {
         // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport
@@ -394,13 +395,14 @@ function getInputDefinition(
     }
 }
 
-function getOutputDefinition(
-    methodOutputName: string,
-    wsdl: WSDL,
-    parsedWsdl: ParsedWsdl,
-    mergedOptions: ParserOptions,
-    visitedDefinitions: VisitedDefinition[]
-): Definition | null {
+function createMethodOutputDefinition(opts: {
+    methodOutputName: string;
+    wsdl: WSDL;
+    parsedWsdl: ParsedWsdl;
+    mergedOptions: ParserOptions;
+    visitedDefinitions: VisitedDefinition[];
+}): Definition | null {
+    const { methodOutputName, wsdl, parsedWsdl, mergedOptions, visitedDefinitions } = opts;
     const outputMessage = wsdl.definitions.messages[methodOutputName];
     if (outputMessage.element) {
         // TODO: if `$type` not defined, inline type into function declartion (do not create definition file) - wsimport

From 3ee81149d33518f7da0cc87fd87eaebfff3ecb1a Mon Sep 17 00:00:00 2001
From: Sander van Driel <sander.vandriel@gmail.com>
Date: Tue, 7 May 2024 20:16:52 +0200
Subject: [PATCH 4/4] chore: remove nullability of output definition

---
 src/parser.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/parser.ts b/src/parser.ts
index 5de96b1..eb0c8b2 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -401,7 +401,7 @@ function createMethodOutputDefinition(opts: {
     parsedWsdl: ParsedWsdl;
     mergedOptions: ParserOptions;
     visitedDefinitions: VisitedDefinition[];
-}): Definition | null {
+}): Definition {
     const { methodOutputName, wsdl, parsedWsdl, mergedOptions, visitedDefinitions } = opts;
     const outputMessage = wsdl.definitions.messages[methodOutputName];
     if (outputMessage.element) {