[#174797437] Use proper parameter name (#202)

Author: balanza

Diff for: README.md

@@ -228,6 +228,7 @@ Generated code is slightly different from `v4` as it implements some bug fixes t
 * The above rule doesn't apply to headers: in case of a security definition or a global parameter which has `in: header`, the definition name is considered, as the `name` attribute refers to the actual header name to be used as for OpenApi specification.
 * Generated decoders now support multiple success codes (i.e. 200 and 202), so we don't need to write custom decoders for such case as [we used to do](https://github.com/pagopa/io-backend/compare/174376802-experiment-with-sdk?expand=1#diff-cf7a83babfaf6e5babe84dffe22f64e4L81). 
 * When using `gen-api-models` command, `--request-types` flag must be used explicitly in order to have `requestTypes` file generated.
+* Parameters that has a schema reference (like [this](https://github.com/pagopa/io-utils/blob/491d927ff263863bda9038fffa26442050b788e7/__mocks__/api.yaml#L87)) now use the `name` attribute as the parameter name. It used to be the lower-cased reference's name instead.
 #### from 4.0.0 to 4.3.0
 * Attributes with `type: string` and `format: date` used to result in a `String` definition, while now produce `Date`. [#184](https://github.com/pagopa/io-utils/pull/184)
 * Allow camel-cased prop names. [#183](https://github.com/pagopa/io-utils/pull/183)

Diff for: __mocks__/api.yaml

@@ -78,6 +78,19 @@ paths:
               type: string
         "500":
           description: "Fatal error"
+  /test-parameter-with-reference:
+    post:
+      operationId: "testParameterWithReference"
+      parameters:
+        - name: createdMessage
+          in: body
+          schema:
+            $ref: "#/definitions/Message"
+      responses:
+        "201":
+          description: "Created"
+        "500":
+          description: "Fatal error"          
 
 definitions:
   AllOfTest:

Diff for: src/commands/gen-api-models/__tests__/__snapshots__/index.test.ts.snap

@@ -665,7 +665,9 @@ import {
   TestFileUploadT,
   testFileUploadDefaultDecoder,
   TestResponseHeaderT,
-  testResponseHeaderDefaultDecoder
+  testResponseHeaderDefaultDecoder,
+  TestParameterWithReferenceT,
+  testParameterWithReferenceDefaultDecoder
 } from \\"./requestTypes\\";
 
 // This is a placeholder for undefined when dealing with object keys
@@ -677,12 +679,14 @@ type __UNDEFINED_KEY = \\"_____\\";
 export type ApiOperation = TypeofApiCall<TestAuthBearerT> &
   TypeofApiCall<TestMultipleSuccessT> &
   TypeofApiCall<TestFileUploadT> &
-  TypeofApiCall<TestResponseHeaderT>;
+  TypeofApiCall<TestResponseHeaderT> &
+  TypeofApiCall<TestParameterWithReferenceT>;
 
 export type ParamKeys = keyof (TypeofApiParams<TestAuthBearerT> &
   TypeofApiParams<TestMultipleSuccessT> &
   TypeofApiParams<TestFileUploadT> &
-  TypeofApiParams<TestResponseHeaderT>);
+  TypeofApiParams<TestResponseHeaderT> &
+  TypeofApiParams<TestParameterWithReferenceT>);
 
 /**
  * Defines an adapter for TypeofApiCall which omit one or more parameters in the signature
@@ -709,7 +713,8 @@ export type WithDefaultsT<
   | TestAuthBearerT
   | TestMultipleSuccessT
   | TestFileUploadT
-  | TestResponseHeaderT,
+  | TestResponseHeaderT
+  | TestParameterWithReferenceT,
   K
 >;
 
@@ -728,6 +733,10 @@ export type Client<
       readonly testFileUpload: TypeofApiCall<TestFileUploadT>;
 
       readonly testResponseHeader: TypeofApiCall<TestResponseHeaderT>;
+
+      readonly testParameterWithReference: TypeofApiCall<
+        TestParameterWithReferenceT
+      >;
     }
   : {
       readonly testAuthBearer: TypeofApiCall<
@@ -757,6 +766,13 @@ export type Client<
           Omit<RequestParams<TestResponseHeaderT>, K>
         >
       >;
+
+      readonly testParameterWithReference: TypeofApiCall<
+        ReplaceRequestParams<
+          TestParameterWithReferenceT,
+          Omit<RequestParams<TestParameterWithReferenceT>, K>
+        >
+      >;
     };
 
 /**
@@ -876,11 +892,35 @@ export function createClient<K extends ParamKeys>({
     options
   );
 
+  const testParameterWithReferenceT: ReplaceRequestParams<
+    TestParameterWithReferenceT,
+    RequestParams<TestParameterWithReferenceT>
+  > = {
+    method: \\"post\\",
+
+    headers: () => ({
+      \\"Content-Type\\": \\"application/json\\"
+    }),
+    response_decoder: testParameterWithReferenceDefaultDecoder(),
+    url: ({}) => \`\${basePath}/test-parameter-with-reference\`,
+
+    body: ({ createdMessage }) => JSON.stringify(createdMessage),
+
+    query: () => ({})
+  };
+  const testParameterWithReference: TypeofApiCall<TestParameterWithReferenceT> = createFetchRequestForApi(
+    testParameterWithReferenceT,
+    options
+  );
+
   return {
     testAuthBearer: (withDefaults || identity)(testAuthBearer),
     testMultipleSuccess: (withDefaults || identity)(testMultipleSuccess),
     testFileUpload: (withDefaults || identity)(testFileUpload),
-    testResponseHeader: (withDefaults || identity)(testResponseHeader)
+    testResponseHeader: (withDefaults || identity)(testResponseHeader),
+    testParameterWithReference: (withDefaults || identity)(
+      testParameterWithReference
+    )
   };
 }
 "

Diff for: src/commands/gen-api-models/__tests__/index.test.ts

@@ -510,7 +510,7 @@ describe("gen-api-models", () => {
 
     const allOperations = parseAllOperations(spec, "undefined", "undefined");
 
-    expect(allOperations).toEqual(expected);
+    expect(allOperations).toEqual(expect.arrayContaining(expected));
   });
 
   it("should render a client", async () => {

Diff for: src/commands/gen-api-models/__tests__/parse.test.ts

@@ -0,0 +1,56 @@
+/* tslint:disable:no-duplicate-string */
+
+import { OpenAPIV2 } from "openapi-types";
+import * as SwaggerParser from "swagger-parser";
+
+import {
+  parseAllOperations,
+  parseOperation,
+} from "../parse";
+
+let spec: OpenAPIV2.Document;
+beforeAll(
+  async () =>
+    (spec = (await SwaggerParser.bundle(
+      `${process.cwd()}/__mocks__/api.yaml`
+    )) as OpenAPIV2.Document)
+);
+
+describe("gen-api-models parse", () => {
+  it("should parse an operation with external parameter", () => {
+    const parsed = parseOperation(spec, "/test-auth-bearer", [], "undefined", "undefined")("get");
+
+    expect(parsed).toEqual(
+      expect.objectContaining({
+        method: "get",
+        path: "/test-auth-bearer",
+        parameters: expect.arrayContaining([
+          { name: "qo?", in: "query", type: "string" },
+          { name: "qr", in: "query", type: "string" },
+          // cursor is defined as external parameter
+          { name: "cursor?", in: "query", type: "string" }
+        ])
+      })
+    );
+  })
+
+  it("should parse an operation which parameter has schema reference", () => {
+    const parsed = parseOperation(
+      spec,
+      "/test-parameter-with-reference",
+      [],
+      "undefined",
+      "undefined"
+    )("post");
+
+    expect(parsed).toEqual(
+      expect.objectContaining({
+        method: "post",
+        path: "/test-parameter-with-reference",
+        parameters: expect.arrayContaining([
+          { name: "createdMessage?", in: "body", type: "Message" }
+        ])
+      })
+    );
+  });
+});

Diff for: src/commands/gen-api-models/parse.ts

@@ -313,7 +313,7 @@ const parseParameter = (
   const paramName = `${uncapitalize(
     specParameters && specParameters[parsedRef.e2]
       ? specParameters[parsedRef.e2].name
-      : parsedRef.e2
+      : param.name
   )}${isParamRequired ? "" : "?"}`;
 
   const paramIn =