Simplify extracted functions

Author: bodograumann

modules/openapi-generator/src/main/resources/typescript/configuration.mustache

@@ -105,65 +105,53 @@ export function createConfiguration(conf: ConfigurationParameters = {}): Configu
  */
 {{#useInversify}}
 export function mergeConfiguration(conf: Configuration, options?: Configuration): Configuration {
-    if (options) {
-        conf = options;
-    }
-    return conf;
+    return options || conf;
 }
 {{/useInversify}}
 {{^useInversify}}
 export function mergeConfiguration(conf: Configuration, options?: ConfigurationOptions): Configuration {
-    let allMiddleware: Middleware[] = mergeMiddleware(conf.middleware, options?.middleware, options?.middlewareMergeStrategy);
-    if (options) {
-        conf = {
-          baseServer: options.baseServer || conf.baseServer,
-          httpApi: options.httpApi || conf.httpApi,
-          authMethods: options.authMethods || conf.authMethods,
-          middleware: allMiddleware,
-        };
+    if (!options) {
+        return conf;
     }
-    return conf;
+    return {
+        baseServer: options.baseServer || conf.baseServer,
+        httpApi: options.httpApi || conf.httpApi,
+        authMethods: options.authMethods || conf.authMethods,
+        middleware: mergeMiddleware(conf.middleware, options?.middleware, options?.middlewareMergeStrategy),
+    };
 }
 
 function mergeMiddleware(staticMiddleware: Middleware[], calltimeMiddleware?: Middleware[], strategy?: "append" | "prepend" | "replace") {
-    let allMiddleware: Middleware[] = staticMiddleware;
-    if (calltimeMiddleware) {
-        const middlewareMergeStrategy = strategy || "replace" // default to replace behavior
-        // call-time middleware provided
-        const calltimeMiddleware: Middleware[] = calltimeMiddleware;
-
-        switch(middlewareMergeStrategy) {
+    if (!calltimeMiddleware) {
+        return staticMiddleware;
+    }
+    // default to replace behavior
+    switch(strategy ?? "replace") {
         case "append":
-            allMiddleware = staticMiddleware.concat(calltimeMiddleware);
-            break;
+            return staticMiddleware.concat(calltimeMiddleware);
         case "prepend":
-            allMiddleware = calltimeMiddleware.concat(staticMiddleware)
-            break;
+            return calltimeMiddleware.concat(staticMiddleware)
         case "replace":
-            allMiddleware = calltimeMiddleware
-            break;
-        default:
-            throw new Error(`unrecognized middleware merge strategy '${middlewareMergeStrategy}'`);
-        }
+            return calltimeMiddleware
     }
-    return allMiddleware;
+    throw new Error(`Unrecognized middleware merge strategy '${strategy}'`)
 }
 {{/useInversify}}
 
 /**
  * Convert Promise-based configuration options to Observable-based configuration options.
  */
 export function wrapOptions(options?: PromiseConfigurationOptions): StandardConfigurationOptions | undefined {
-    if (options) {
-        return {
-            baseServer: options.baseServer,
-            httpApi: options.httpApi,
-            middleware: options.middleware?.map(
-              m => new PromiseMiddlewareWrapper(m)
-            ),
-            middlewareMergeStrategy: options.middlewareMergeStrategy,
-            authMethods: options.authMethods,
-        }
+    if (!options) {
+        return;
+    }
+    return {
+        baseServer: options.baseServer,
+        httpApi: options.httpApi,
+        middleware: options.middleware?.map(
+          m => new PromiseMiddlewareWrapper(m)
+        ),
+        middlewareMergeStrategy: options.middlewareMergeStrategy,
+        authMethods: options.authMethods,
     }
-    return;
 }