Merge pull request #55 from nicolas-chaulet/fix/duplicate-path-params

fix(parser): skip global params if they are duplicates of path params

Author: mrlubos

README.md

@@ -15,6 +15,16 @@ This is an opinionated fork of the [openapi-typescript-codegen](https://github.c
 - can be used with CLI, Node.js, or npx
 - abortable requests through cancellable promise pattern
 
+## Quickstart
+
+The fastest way to use this package is via npx
+
+```sh
+npx @nicolas-chaulet/openapi-typescript-codegen -i path/to/openapi.json -o src/client
+```
+
+Congratulations on generating your first client! 🎉
+
 ## Install
 
 ```
@@ -64,7 +74,7 @@ $ openapi --help
 If you use Prettier, your client will be automatically formatted according to your configuration. To disable automatic formatting, run
 
 ```sh
-openapi --input path/to/openapi.json --output src/client --no-autoformat
+openapi -i path/to/openapi.json -o src/client --no-autoformat
 ```
 
 To prevent your client from being processed by linters and similar tools, you should add your output path to the tool's ignore file (e.g. `.eslintignore`).

src/openApi/v3/index.ts

@@ -4,7 +4,7 @@ import type { OpenApi } from './interfaces/OpenApi';
 import { getModels } from './parser/getModels';
 import { getServer } from './parser/getServer';
 import { getServices } from './parser/getServices';
-import { getServiceVersion } from './parser/getServiceVersion';
+import { getServiceVersion } from './parser/service';
 
 /**
  * Parse the OpenAPI specification to a Client model that contains

src/openApi/v3/interfaces/OpenApiPath.d.ts

@@ -6,16 +6,16 @@ import type { OpenApiServer } from './OpenApiServer';
  * https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#pathItemObject
  */
 export interface OpenApiPath {
-    summary?: string;
+    delete?: OpenApiOperation;
     description?: string;
     get?: OpenApiOperation;
-    put?: OpenApiOperation;
-    post?: OpenApiOperation;
-    delete?: OpenApiOperation;
-    options?: OpenApiOperation;
     head?: OpenApiOperation;
+    options?: OpenApiOperation;
+    parameters?: OpenApiParameter[];
     patch?: OpenApiOperation;
-    trace?: OpenApiOperation;
+    post?: OpenApiOperation;
+    put?: OpenApiOperation;
     servers?: OpenApiServer[];
-    parameters?: OpenApiParameter[];
+    summary?: string;
+    trace?: OpenApiOperation;
 }

src/openApi/v3/parser/getServices.spec.ts renamed to src/openApi/v3/parser/__tests__/getServices.spec.ts

@@ -1,5 +1,5 @@
-import type { Options } from '../../../client/interfaces/Options';
-import { getServices } from './getServices';
+import type { Options } from '../../../../client/interfaces/Options';
+import { getServices } from '../getServices';
 
 describe('getServices', () => {
     it('should create a unnamed service if tags are empty', () => {

src/openApi/v3/parser/getServiceName.spec.ts renamed to src/openApi/v3/parser/__tests__/service.spec.ts

@@ -1,4 +1,4 @@
-import { getServiceName } from './getServiceName';
+import { getServiceName, getServiceVersion } from '../service';
 
 describe('getServiceName', () => {
     it('should produce correct result', () => {
@@ -12,3 +12,11 @@ describe('getServiceName', () => {
         expect(getServiceName('non-ascii-æøåÆØÅöôêÊ字符串')).toEqual('NonAsciiÆøåÆøÅöôêÊ字符串');
     });
 });
+
+describe('getServiceVersion', () => {
+    it('should produce correct result', () => {
+        expect(getServiceVersion('1.0')).toEqual('1.0');
+        expect(getServiceVersion('v1.0')).toEqual('1.0');
+        expect(getServiceVersion('V1.0')).toEqual('1.0');
+    });
+});

src/openApi/v3/parser/getOperation.ts

@@ -4,6 +4,8 @@ import type { OpenApiParameter } from '../interfaces/OpenApiParameter';
 import { getOperationParameter } from './getOperationParameter';
 import { getRef } from './getRef';
 
+const allowedIn = ['cookie', 'formData', 'header', 'path', 'query'] as const;
+
 export const getOperationParameters = (openApi: OpenApi, parameters: OpenApiParameter[]): OperationParameters => {
     const operationParameters: OperationParameters = {
         $refs: [],
@@ -14,54 +16,43 @@ export const getOperationParameters = (openApi: OpenApi, parameters: OpenApiPara
         parametersForm: [],
         parametersCookie: [],
         parametersHeader: [],
-        parametersBody: null, // Not used in V3 -> @see requestBody
+        parametersBody: null, // Not used in v3 -> @see requestBody
     };
 
-    // Iterate over the parameters
     parameters.forEach(parameterOrReference => {
         const parameterDef = getRef<OpenApiParameter>(openApi, parameterOrReference);
         const parameter = getOperationParameter(openApi, parameterDef);
 
-        // We ignore the "api-version" param, since we do not want to add this
-        // as the first / default parameter for each of the service calls.
-        if (parameter.prop !== 'api-version') {
-            switch (parameterDef.in) {
-                case 'path':
-                    operationParameters.parametersPath.push(parameter);
-                    operationParameters.parameters.push(parameter);
-                    operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
-                    operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
-                    break;
-
-                case 'query':
-                    operationParameters.parametersQuery.push(parameter);
-                    operationParameters.parameters.push(parameter);
-                    operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
-                    operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
-                    break;
-
-                case 'formData':
-                    operationParameters.parametersForm.push(parameter);
-                    operationParameters.parameters.push(parameter);
-                    operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
-                    operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
-                    break;
+        const defIn = parameterDef.in as (typeof allowedIn)[number];
 
-                case 'cookie':
-                    operationParameters.parametersCookie.push(parameter);
-                    operationParameters.parameters.push(parameter);
-                    operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
-                    operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
-                    break;
+        // ignore the "api-version" param since we do not want to add it
+        // as the first/default parameter for each of the service calls
+        if (parameter.prop === 'api-version' || !allowedIn.includes(defIn)) {
+            return;
+        }
 
-                case 'header':
-                    operationParameters.parametersHeader.push(parameter);
-                    operationParameters.parameters.push(parameter);
-                    operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
-                    operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
-                    break;
-            }
+        switch (defIn) {
+            case 'cookie':
+                operationParameters.parametersCookie = [...operationParameters.parametersCookie, parameter];
+                break;
+            case 'formData':
+                operationParameters.parametersForm = [...operationParameters.parametersForm, parameter];
+                break;
+            case 'header':
+                operationParameters.parametersHeader = [...operationParameters.parametersHeader, parameter];
+                break;
+            case 'path':
+                operationParameters.parametersPath = [...operationParameters.parametersPath, parameter];
+                break;
+            case 'query':
+                operationParameters.parametersQuery = [...operationParameters.parametersQuery, parameter];
+                break;
         }
+
+        operationParameters.$refs = [...operationParameters.$refs, ...parameter.$refs];
+        operationParameters.imports = [...operationParameters.imports, ...parameter.imports];
+        operationParameters.parameters = [...operationParameters.parameters, parameter];
     });
+
     return operationParameters;
 };

src/openApi/v3/parser/getOperationParameters.ts

@@ -3,8 +3,9 @@ import type { Options } from '../../../client/interfaces/Options';
 import type { Service } from '../../../client/interfaces/Service';
 import { unique } from '../../../utils/unique';
 import type { OpenApi } from '../interfaces/OpenApi';
-import { getOperation } from './getOperation';
 import { getOperationParameters } from './getOperationParameters';
+import { getOperation } from './operation';
+import { allowedServiceMethods } from './service';
 
 const getNewService = (operation: Operation): Service => ({
     $refs: [],
@@ -13,44 +14,35 @@ const getNewService = (operation: Operation): Service => ({
     operations: [],
 });
 
-/**
- * Get the OpenAPI services
- */
 export const getServices = (openApi: OpenApi, options: Options): Service[] => {
     const services = new Map<string, Service>();
+
     for (const url in openApi.paths) {
-        if (openApi.paths.hasOwnProperty(url)) {
-            // Grab path and parse any global path parameters
-            const path = openApi.paths[url];
-            const pathParams = getOperationParameters(openApi, path.parameters || []);
+        const path = openApi.paths[url];
+        const pathParams = getOperationParameters(openApi, path.parameters ?? []);
 
-            // Parse all the methods for this path
-            for (const method in path) {
-                if (path.hasOwnProperty(method)) {
-                    switch (method) {
-                        case 'delete':
-                        case 'get':
-                        case 'head':
-                        case 'options':
-                        case 'patch':
-                        case 'post':
-                        case 'put':
-                            // Each method contains an OpenAPI operation, we parse the operation
-                            const op = path[method]!;
-                            const tags = op.tags?.length ? op.tags.filter(unique) : ['Default'];
-                            tags.forEach(tag => {
-                                const operation = getOperation(openApi, url, method, tag, op, pathParams, options);
-                                const service = services.get(operation.service) || getNewService(operation);
-                                service.$refs = [...service.$refs, ...operation.$refs];
-                                service.imports = [...service.imports, ...operation.imports];
-                                service.operations = [...service.operations, operation];
-                                services.set(operation.service, service);
-                            });
-                            break;
-                    }
-                }
+        for (const key in path) {
+            const method = key as (typeof allowedServiceMethods)[number];
+            if (allowedServiceMethods.includes(method)) {
+                const op = path[method]!;
+                const tags = op.tags?.length ? op.tags.filter(unique) : ['Default'];
+                tags.forEach(tag => {
+                    const operation = getOperation(openApi, options, {
+                        method,
+                        op,
+                        pathParams,
+                        tag,
+                        url,
+                    });
+                    const service = services.get(operation.service) || getNewService(operation);
+                    service.$refs = [...service.$refs, ...operation.$refs];
+                    service.imports = [...service.imports, ...operation.imports];
+                    service.operations = [...service.operations, operation];
+                    services.set(operation.service, service);
+                });
             }
         }
     }
+
     return Array.from(services.values());
 };