fix: improve generated files quality

Author: mdevils

src/schema-to-typescript/common/core/common-http-client.ts

@@ -219,7 +219,10 @@ async function convertResponseBody(
     throw new Error('Invalid response body type.');
 }
 
-type ResponseByMediaType<T extends CommonHttpClientResponse<unknown>, K extends string> = T extends any
+/**
+ * `extends unknown` is a trick to split the union into individual types.
+ */
+type ResponseByMediaType<T extends CommonHttpClientResponse<unknown>, K extends string> = T extends unknown
     ? ((a: T) => void) extends (a: {
           mediaType: K;
           status: infer _Status;
@@ -387,10 +390,8 @@ export class CommonHttpClient {
         response.headers.forEach((value, key) => {
             headers[key] = value;
         });
-        if (response.headers.has('set-cookie')) {
-            if ('getSetCookie' in response.headers) {
-                headers['set-cookie'] = (response.headers as {getSetCookie(): string[]}).getSetCookie();
-            }
+        if (response.headers.has('set-cookie') && 'getSetCookie' in response.headers) {
+            headers['set-cookie'] = (response.headers as {getSetCookie(): string[]}).getSetCookie();
         }
         return {
             status: response.status,

src/schema-to-typescript/common/core/common-http-service.ts

@@ -5,9 +5,9 @@ export class CommonHttpService {
     constructor(getClientInstance: () => commonHttpClient.CommonHttpClient) {
         this.getClientInstance = () => {
             const classInstance = this.constructor as typeof CommonHttpService;
-            if (!classInstance.initialized) {
+            if (classInstance.initialized !== true) {
                 classInstance.initialized = true;
-                if (classInstance.initialize) {
+                if (classInstance.initialize !== undefined) {
                     classInstance.initialize();
                 }
             }
@@ -16,5 +16,5 @@ export class CommonHttpService {
         };
     }
     protected static initialized: boolean | undefined;
-    protected static initialize: () => void | undefined;
+    protected static initialize: (() => void) | undefined;
 }

src/schema-to-typescript/common/validation-providers/zod-validation-provider/index.ts

@@ -10,10 +10,12 @@ import {
     Expression,
     expressionStatement,
     identifier,
+    IfStatement,
     ifStatement,
     isIdentifier,
     isImportSpecifier,
     isVariableDeclaration,
+    logicalExpression,
     memberExpression,
     newExpression,
     numericLiteral,
@@ -555,16 +557,26 @@ export class ZodValidationProvider extends ValidationProvider {
                 otherwise = undefined;
             }
             caseEntries = Object.entries(cases);
-            let prefIfStatement = ifStatement(
-                buildCondition(caseEntries[0][0]),
-                buildStatement(caseEntries[0][1], caseEntries[0][0])
-            );
+            const ifBlockInfos: {condition: Expression; statement: Statement}[] = caseEntries.map(([key, value]) => ({
+                condition: buildCondition(key),
+                statement: buildStatement(value, key)
+            }));
+            const resultingIfBlocks: IfStatement[] = [];
+            while (ifBlockInfos.length > 0) {
+                const info = ifBlockInfos.shift()!;
+                for (let i = 0; i < ifBlockInfos.length; i++) {
+                    if (R.equals(ifBlockInfos[i].statement, info.statement)) {
+                        info.condition = logicalExpression('||', info.condition, ifBlockInfos[i].condition);
+                        ifBlockInfos.splice(i, 1);
+                        i--;
+                    }
+                }
+                resultingIfBlocks.push(ifStatement(info.condition, info.statement));
+            }
+            let prefIfStatement = resultingIfBlocks.shift()!;
             const result = prefIfStatement;
-            for (let i = 1; i < caseEntries.length; i++) {
-                const newIfStatement = ifStatement(
-                    buildCondition(caseEntries[i][0]),
-                    buildStatement(caseEntries[i][1], caseEntries[i][0])
-                );
+            while (resultingIfBlocks.length > 0) {
+                const newIfStatement = resultingIfBlocks.shift()!;
                 prefIfStatement.alternate = newIfStatement;
                 prefIfStatement = newIfStatement;
             }