[typescript] Use static middleware when calltime options exist but specify no middleware (#20985)

* Keep static middleware when options contain no middleware field

* Regenerate samples

* Fix indentation and quotes

* Extract middleware merge logic into function

* Regenerate samples

* Simplify extracted functions

* Regenerate samples

* Fix: Pass static config when no options are given for inversify

* Fix: Allow overriding http api with options

* Regenerate samples

* Use default parameter for default middlware merge strategy

* Throw exception for failed match within switch block

Author: bodograumann

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

@@ -12,16 +12,16 @@ import { BaseServerConfiguration, server1 } from "./servers{{importFileExtension
 import { configureAuthMethods, AuthMethods, AuthMethodsConfiguration } from "./auth/auth{{importFileExtension}}";
 
 export interface Configuration<M = Middleware> {
-  readonly baseServer: BaseServerConfiguration;
-  readonly httpApi: HttpLibrary;
-  readonly middleware: M[];
-  readonly authMethods: AuthMethods;
+    readonly baseServer: BaseServerConfiguration;
+    readonly httpApi: HttpLibrary;
+    readonly middleware: M[];
+    readonly authMethods: AuthMethods;
 }
 
 // Additional option specific to middleware merge strategy
 export interface MiddlewareMergeOptions {
-  // default is `'replace'` for backwards compatibility
-  middlewareMergeStrategy?: 'replace' | 'append' | 'prepend';
+    // default is `"replace"` for backwards compatibility
+    middlewareMergeStrategy?: "replace" | "append" | "prepend";
 }
 
 // Unify configuration options using Partial plus extra merge strategy
@@ -105,43 +105,36 @@ 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[] = [];
-    if (options && options.middleware) {
-        const middlewareMergeStrategy = options.middlewareMergeStrategy || "replace" // default to replace behavior
-        // call-time middleware provided
-        const calltimeMiddleware: Middleware[] = options.middleware;
+    if (!options) {
+        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),
+    };
+}
 
-        switch(middlewareMergeStrategy) {
+function mergeMiddleware(staticMiddleware: Middleware[], calltimeMiddleware?: Middleware[], strategy: "append" | "prepend" | "replace" = "replace") {
+    if (!calltimeMiddleware) {
+        return staticMiddleware;
+    }
+    switch(strategy) {
         case "append":
-            allMiddleware = conf.middleware.concat(calltimeMiddleware);
-            break;
+            return staticMiddleware.concat(calltimeMiddleware);
         case "prepend":
-            allMiddleware = calltimeMiddleware.concat(conf.middleware)
-            break;
+            return calltimeMiddleware.concat(staticMiddleware)
         case "replace":
-            allMiddleware = calltimeMiddleware
-            break;
+            return calltimeMiddleware
         default:
-            throw new Error(`unrecognized middleware merge strategy '${middlewareMergeStrategy}'`);
-        }
-    }
-    if (options) {
-        conf = {
-          baseServer: options.baseServer || conf.baseServer,
-          httpApi: options.httpApi || conf.httpApi,
-          authMethods: options.authMethods || conf.authMethods,
-          middleware: allMiddleware || conf.middleware
-        };
+            throw new Error(`Unrecognized middleware merge strategy '${strategy}'`)
     }
-    return conf;
 }
 {{/useInversify}}
 

modules/openapi-generator/src/main/resources/typescript/types/ObservableAPI.mustache

@@ -65,14 +65,14 @@ export class Observable{{classname}} {
     public {{nickname}}WithHttpInfo({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}_options?: Configuration{{^useInversify}}Options{{/useInversify}}): Observable<HttpInfo<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
         const _config = mergeConfiguration(this.configuration, _options);
 
-        const requestContextPromise = this.requestFactory.{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}{{#useInversify}}_options{{/useInversify}}{{^useInversify}}_config{{/useInversify}});
+        const requestContextPromise = this.requestFactory.{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}_config);
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
         for (const middleware of _config.middleware) {
             middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
         }
 
-        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
+        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => _config.httpApi.send(ctx))).
             pipe(mergeMap((response: ResponseContext) => {
                 let middlewarePostObservable = of(response);
                 for (const middleware of _config.middleware.reverse()) {