feat: improve generate-arazzo commang output

Author: DmitryAnansky

packages/core/src/typings/openapi.ts

@@ -292,12 +292,12 @@ export interface Oas3SecurityRequirement {
 }
 
 export interface Oas3SecurityScheme {
-  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+  type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'mutualTLS';
   description?: string;
   name?: string;
   in?: 'query' | 'header' | 'cookie';
   scheme?: string;
-  bearerFormat: string;
+  bearerFormat?: string;
   flows: {
     implicit?: {
       refreshUrl?: string;

packages/respect-core/src/modules/__tests__/arazzo-description-generator/generate-inputs-arazzo-components.test.ts

@@ -0,0 +1,36 @@
+import { Oas3SecurityScheme } from 'core/src/typings/openapi';
+import { generateSecurityInputsArazzoComponents } from '../../arazzo-description-generator';
+
+describe('generateSecurityInputsArazzoComponents', () => {
+  it('should generate empty inputs for the security schemes if there are no security schemes', () => {
+    const securitySchemes = {};
+    const result = generateSecurityInputsArazzoComponents(securitySchemes);
+    expect(result).toEqual({ inputs: {} });
+  });
+
+  it('should generate the correct inputs for the Basic auth security scheme', () => {
+    const securitySchemes = {
+      basicAuth: {
+        type: 'http' as const,
+        scheme: 'basic',
+      } as Oas3SecurityScheme,
+    };
+    const result = generateSecurityInputsArazzoComponents(securitySchemes);
+    expect(result).toEqual({
+      inputs: {
+        basicAuth: {
+          type: 'object',
+          properties: {
+            username: { type: 'string', description: 'Username for basic authentication' },
+            password: {
+              type: 'string',
+              format: 'password',
+              description: 'Password for basic authentication',
+            },
+          },
+          required: ['username', 'password'],
+        },
+      },
+    });
+  });
+});

packages/respect-core/src/modules/__tests__/arazzo-description-generator/generate-workflow-security-inputs.test.ts

@@ -0,0 +1,44 @@
+import { generateWorkflowSecurityInputs } from '../../arazzo-description-generator';
+
+describe('generateWorkflowSecurityInputs', () => {
+  it('should return undefined if there are no security requirements', () => {
+    const inputsComponents = {};
+    const security = [] as any[];
+    const result = generateWorkflowSecurityInputs(inputsComponents, security);
+    expect(result).toBeUndefined();
+  });
+
+  it('should return the correct workflow security inputs reference', () => {
+    const inputsComponents = {
+      inputs: {
+        basicAuth: {
+          type: 'object',
+        },
+        bearerAuth: {
+          type: 'string',
+        },
+      },
+    };
+    const security = [{ basicAuth: [] }];
+    const result = generateWorkflowSecurityInputs(inputsComponents, security);
+    expect(result).toEqual({
+      $ref: '#/components/inputs/basicAuth',
+    });
+  });
+
+  it('should return undefined if the security requirement is not found in the inputs components', () => {
+    const inputsComponents = {
+      inputs: {
+        basicAuth: {
+          type: 'object',
+        },
+        bearerAuth: {
+          type: 'string',
+        },
+      },
+    };
+    const security = [{ apiKey: [] }];
+    const result = generateWorkflowSecurityInputs(inputsComponents, security);
+    expect(result).toBeUndefined();
+  });
+});

packages/respect-core/src/modules/__tests__/arazzo-description-generator/generate-workflow-security-parameters.test.ts

@@ -0,0 +1,105 @@
+import { generateWorkflowSecurityParameters } from '../../arazzo-description-generator';
+
+describe('generateWorkflowSecurityParameters', () => {
+  it('should return the correct workflow security parameters for Basic authentication', () => {
+    const inputsComponents = {
+      inputs: {
+        basicAuth: {
+          type: 'object',
+          properties: {
+            username: {
+              type: 'string',
+              description: 'Username for basic authentication',
+            },
+            password: {
+              type: 'string',
+              description: 'Password for basic authentication',
+              format: 'password',
+            },
+          },
+        },
+      },
+    };
+
+    const security = [{ basicAuth: [] }];
+
+    const securitySchemes = {
+      basicAuth: {
+        type: 'http',
+        scheme: 'basic',
+      },
+    } as any;
+
+    const result = generateWorkflowSecurityParameters(inputsComponents, security, securitySchemes);
+
+    expect(result).toEqual([
+      {
+        name: 'Authorization',
+        value: `Basic ....`,
+        in: 'header',
+      },
+    ]);
+  });
+
+  it('should return the correct workflow security parameters for Bearer authentication', () => {
+    const inputsComponents = {
+      inputs: {
+        bearerAuth: {
+          type: 'string',
+          description: 'Bearer token',
+          format: 'password',
+        },
+      },
+    };
+
+    const security = [{ bearerAuth: [] }];
+
+    const securitySchemes = {
+      bearerAuth: {
+        type: 'http',
+        scheme: 'bearer',
+      },
+    } as any;
+
+    const result = generateWorkflowSecurityParameters(inputsComponents, security, securitySchemes);
+
+    expect(result).toEqual([
+      {
+        name: 'Authorization',
+        value: `Bearer {$inputs.bearerAuth}`,
+        in: 'header',
+      },
+    ]);
+  });
+
+  it('should return an empty array if there are no security parameters', () => {
+    const inputsComponents = {};
+    const security = [] as any;
+    const securitySchemes = {};
+
+    const result = generateWorkflowSecurityParameters(inputsComponents, security, securitySchemes);
+
+    expect(result).toEqual([]);
+  });
+
+  it('should return an empty array if the security scheme is not supported', () => {
+    const inputsComponents = {
+      inputs: {
+        oauth2Auth: {
+          type: 'string',
+          description: 'OAuth2 token',
+        },
+      },
+    };
+    const security = [{ oauth2Auth: [] }] as any;
+    const securitySchemes = {
+      oauth2Auth: {
+        type: 'oauth2',
+      },
+    } as any;
+
+    const result = generateWorkflowSecurityParameters(inputsComponents, security, securitySchemes);
+
+    expect(result).toEqual([]);
+  });
+});