Extract reusable logic into central functions

bodograumann · bodograumann · commit 1a1057808c56 · 2025-03-26T19:07:47.000+01:00
diff --git a/modules/openapi-generator/src/main/resources/typescript/configuration.mustache b/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';
+  middlewareMergeStrategy?: "replace" | "append" | "prepend";
 }
 
 // Unify configuration options using Partial plus extra merge strategy
@@ -36,44 +36,44 @@ export type PromiseConfigurationOptions = ConfigurationOptions<PromiseMiddleware
  */
 export interface ConfigurationParameters {
     /**
-     * Default server to use - a list of available servers (according to the 
+     * Default server to use - a list of available servers (according to the
      * OpenAPI yaml definition) is included in the `servers` const in `./servers`. You can also
-     * create your own server with the `ServerConfiguration` class from the same 
+     * create your own server with the `ServerConfiguration` class from the same
      * file.
      */
     baseServer?: BaseServerConfiguration;
     /**
-     * HTTP library to use e.g. IsomorphicFetch. This can usually be skipped as 
+     * HTTP library to use e.g. IsomorphicFetch. This can usually be skipped as
      * all generators come with a default library.
      * If available, additional libraries can be imported from `./http/*`
      */
     httpApi?: HttpLibrary;
 
     /**
-     * The middlewares which will be applied to requests and responses. You can 
-     * add any number of middleware components to modify requests before they 
+     * The middlewares which will be applied to requests and responses. You can
+     * add any number of middleware components to modify requests before they
      * are sent or before they are deserialized by implementing the `Middleware`
      * interface defined in `./middleware`
      */
     middleware?: Middleware[];
     /**
-     * Configures middleware functions that return promises instead of 
-     * Observables (which are used by `middleware`). Otherwise allows for the 
-     * same functionality as `middleware`, i.e., modifying requests before they 
+     * Configures middleware functions that return promises instead of
+     * Observables (which are used by `middleware`). Otherwise allows for the
+     * same functionality as `middleware`, i.e., modifying requests before they
      * are sent and before they are deserialized.
      */
     promiseMiddleware?: PromiseMiddleware[];
     /**
-     * Configuration for the available authentication methods (e.g., api keys) 
-     * according to the OpenAPI yaml definition. For the definition, please refer to 
+     * Configuration for the available authentication methods (e.g., api keys)
+     * according to the OpenAPI yaml definition. For the definition, please refer to
      * `./auth/auth`
      */
     authMethods?: AuthMethodsConfiguration
 }
 
 /**
  * Provide your `ConfigurationParameters` to this function to get a `Configuration`
- * object that can be used to configure your APIs (in the constructor or 
+ * object that can be used to configure your APIs (in the constructor or
  * for each request individually).
  *
  * If a property is not included in conf, a default is used:
@@ -99,3 +99,60 @@ export function createConfiguration(conf: ConfigurationParameters = {}): Configu
     }
     return configuration;
 }
+
+/**
+ * Merge configuration options into a configuration.
+ */
+{{#useInversify}}
+export function mergeConfiguration(conf: Configuration, options?: Configuration): Configuration {
+  return options || conf;
+}
+{{/useInversify}}
+{{^useInversify}}
+export function mergeConfiguration(conf: Configuration, options?: ConfigurationOptions): Configuration {
+    if (!options) {
+        return conf;
+    }
+    let allMiddleware: Middleware[] = [];
+    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") {
+    if (!calltimeMiddleware) {
+        return staticMiddleware;
+    }
+    // default to replace behavior
+    switch(strategy ?? "replace") {
+        case "append":
+            return staticMiddleware.concat(calltimeMiddleware);
+        case "prepend":
+            return calltimeMiddleware.concat(staticMiddleware)
+        case "replace":
+            return calltimeMiddleware
+    }
+    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;
+    }
+    return {
+        baseServer: options.baseServer,
+        httpApi: options.httpApi,
+        middleware: options.middleware?.map(
+            m => new PromiseMiddlewareWrapper(m)
+        ),
+        middlewareMergeStrategy: options.middlewareMergeStrategy,
+        authMethods: options.authMethods
+    }
+}
diff --git a/modules/openapi-generator/src/main/resources/typescript/types/ObservableAPI.mustache b/modules/openapi-generator/src/main/resources/typescript/types/ObservableAPI.mustache
@@ -1,5 +1,5 @@
 import { ResponseContext, RequestContext, HttpFile, HttpInfo } from '../http/http{{importFileExtension}}';
-import { Configuration{{^useInversify}}, ConfigurationOptions{{/useInversify}} } from '../configuration{{importFileExtension}}'
+import { Configuration{{^useInversify}}, ConfigurationOptions{{/useInversify}}, mergeConfiguration } from '../configuration{{importFileExtension}}'
 import type { Middleware } from '../middleware{{importFileExtension}}';
 import { Observable, of, from } from {{#useRxJS}}'rxjs'{{/useRxJS}}{{^useRxJS}}'../rxjsStub{{importFileExtension}}'{{/useRxJS}};
 import {mergeMap, map} from  {{#useRxJS}}'rxjs/operators'{{/useRxJS}}{{^useRxJS}}'../rxjsStub{{importFileExtension}}'{{/useRxJS}};
@@ -63,55 +63,18 @@ export class Observable{{classname}} {
      {{/allParams}}
      */
     public {{nickname}}WithHttpInfo({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}_options?: Configuration{{^useInversify}}Options{{/useInversify}}): Observable<HttpInfo<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
-    let _config = this.configuration;
-    let allMiddleware: Middleware[] = [];
-    {{#useInversify}}
-    if (_options){
-      _config = _options;
-    }
-    allMiddleware = _config?.middleware;
-    {{/useInversify}}
-    {{^useInversify}}
-    if (_options && _options.middleware){
-      const middlewareMergeStrategy = _options.middlewareMergeStrategy || 'replace' // default to replace behavior
-      // call-time middleware provided
-      const calltimeMiddleware: Middleware[] = _options.middleware;
-
-      switch(middlewareMergeStrategy){
-      case 'append':
-        allMiddleware = this.configuration.middleware.concat(calltimeMiddleware);
-        break;
-      case 'prepend':
-        allMiddleware = calltimeMiddleware.concat(this.configuration.middleware)
-        break;
-      case 'replace':
-        allMiddleware = calltimeMiddleware
-        break;
-      default: 
-        throw new Error(`unrecognized middleware merge strategy '${middlewareMergeStrategy}'`)
-      }
-	}
-	if (_options){
-    _config = {
-      baseServer: _options.baseServer || this.configuration.baseServer,
-      httpApi: _options.httpApi || this.configuration.httpApi,
-      authMethods: _options.authMethods || this.configuration.authMethods,
-      middleware: allMiddleware || this.configuration.middleware
-		};
-	}
-	{{/useInversify}}
-
+        const _config = mergeConfiguration(this.configuration, _options);
         const requestContextPromise = this.requestFactory.{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}{{#useInversify}}_options{{/useInversify}}{{^useInversify}}_config{{/useInversify}});
         // build promise chain
         let middlewarePreObservable = from<RequestContext>(requestContextPromise);
-        for (const middleware of allMiddleware) {
+        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 allMiddleware.reverse()) {
+                for (const middleware of _config.middleware.reverse()) {
                     middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                 }
                 return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.{{nickname}}WithHttpInfo(rsp)));
diff --git a/modules/openapi-generator/src/main/resources/typescript/types/PromiseAPI.mustache b/modules/openapi-generator/src/main/resources/typescript/types/PromiseAPI.mustache
@@ -1,5 +1,5 @@
 import { ResponseContext, RequestContext, HttpFile, HttpInfo } from '../http/http{{importFileExtension}}';
-import { Configuration{{^useInversify}}, ConfigurationOptions, PromiseConfigurationOptions{{/useInversify}} } from '../configuration{{importFileExtension}}'
+import { Configuration{{^useInversify}}, ConfigurationOptions, PromiseConfigurationOptions, wrapOptions{{/useInversify}} } from '../configuration{{importFileExtension}}'
 {{^useInversify}}
 import { PromiseMiddleware, Middleware, PromiseMiddlewareWrapper } from '../middleware{{importFileExtension}}';
 {{/useInversify}}
@@ -55,21 +55,7 @@ export class Promise{{classname}} {
      {{/allParams}}
      */
     public {{nickname}}WithHttpInfo({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}_options?: {{#useInversify}}Configuration{{/useInversify}}{{^useInversify}}PromiseConfigurationOptions{{/useInversify}}): Promise<HttpInfo<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
-        let observableOptions: undefined | Configuration{{^useInversify}}Options{{/useInversify}}{{#useInversify}} = _options{{/useInversify}}
-        {{^useInversify}}
-        if (_options){
-	    observableOptions = {
-                baseServer: _options.baseServer,
-                httpApi: _options.httpApi,
-                middleware: _options.middleware?.map(
-                    m => new PromiseMiddlewareWrapper(m)
-		),
-		middlewareMergeStrategy: _options.middlewareMergeStrategy,
-                authMethods: _options.authMethods
-	    }
-	}
-        {{/useInversify}}
-        const result = this.api.{{nickname}}WithHttpInfo({{#allParams}}{{paramName}}, {{/allParams}}observableOptions);
+        const result = this.api.{{nickname}}WithHttpInfo({{#allParams}}{{paramName}}, {{/allParams}}{{#useInversify}}_options{{/useInversify}}{{^useInversify}}wrapOptions(_options){{/useInversify}});
         return result.toPromise();
     }
 
@@ -85,21 +71,7 @@ export class Promise{{classname}} {
      {{/allParams}}
      */
     public {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}_options?: {{#useInversify}}Configuration{{/useInversify}}{{^useInversify}}PromiseConfigurationOptions{{/useInversify}}): Promise<{{{returnType}}}{{^returnType}}void{{/returnType}}> {
-        let observableOptions: undefined | Configuration{{^useInversify}}Options{{/useInversify}}{{#useInversify}} = _options{{/useInversify}}
-        {{^useInversify}}
-        if (_options){
-	    observableOptions = {
-                baseServer: _options.baseServer,
-                httpApi: _options.httpApi,
-                middleware: _options.middleware?.map(
-                    m => new PromiseMiddlewareWrapper(m)
-		),
-		middlewareMergeStrategy: _options.middlewareMergeStrategy,
-                authMethods: _options.authMethods
-	    }
-	}
-        {{/useInversify}}
-        const result = this.api.{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}observableOptions);
+        const result = this.api.{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}{{#useInversify}}_options{{/useInversify}}{{^useInversify}}wrapOptions(_options){{/useInversify}});
         return result.toPromise();
     }
 
