fix(execute): explode array parameters for combined schemas (#3826)

Author: glowcloud

src/execute/index.js

@@ -20,11 +20,16 @@ import { serialize as serializeCookie } from '../helpers/cookie.js';
 
 const arrayOrEmpty = (ar) => (Array.isArray(ar) ? ar : []);
 
-const findObjectSchema = (schema, { recurse = true, depth = 1 } = {}) => {
+const findObjectOrArraySchema = (schema, { recurse = true, depth = 1 } = {}) => {
   if (!isPlainObject(schema)) return undefined;
 
-  // check if the schema is an object type
-  if (schema.type === 'object' || (Array.isArray(schema.type) && schema.type.includes('object'))) {
+  // check if the schema is an object or array type
+  if (
+    schema.type === 'object' ||
+    schema.type === 'array' ||
+    (Array.isArray(schema.type) &&
+      (schema.type.includes('object') || schema.type.includes('array')))
+  ) {
     return schema;
   }
 
@@ -33,14 +38,18 @@ const findObjectSchema = (schema, { recurse = true, depth = 1 } = {}) => {
   if (recurse) {
     // traverse oneOf keyword first
     const oneOfResult = Array.isArray(schema.oneOf)
-      ? schema.oneOf.find((subschema) => findObjectSchema(subschema, { recurse, depth: depth + 1 }))
+      ? schema.oneOf.find((subschema) =>
+          findObjectOrArraySchema(subschema, { recurse, depth: depth + 1 })
+        )
       : undefined;
 
     if (oneOfResult) return oneOfResult;
 
     // traverse anyOf keyword second
     const anyOfResult = Array.isArray(schema.anyOf)
-      ? schema.anyOf.find((subschema) => findObjectSchema(subschema, { recurse, depth: depth + 1 }))
+      ? schema.anyOf.find((subschema) =>
+          findObjectOrArraySchema(subschema, { recurse, depth: depth + 1 })
+        )
       : undefined;
 
     if (anyOfResult) return anyOfResult;
@@ -49,18 +58,18 @@ const findObjectSchema = (schema, { recurse = true, depth = 1 } = {}) => {
   return undefined;
 };
 
-const parseJsonObject = ({ value, silentFail = false }) => {
+const parseJsonObjectOrArray = ({ value, silentFail = false }) => {
   try {
     const parsedValue = JSON.parse(value);
-    if (typeof parsedValue === 'object') {
+    if (isPlainObject(parsedValue) || Array.isArray(parsedValue)) {
       return parsedValue;
     }
     if (!silentFail) {
-      throw new Error('Expected JSON serialized object');
+      throw new Error('Expected JSON serialized object or array');
     }
   } catch {
     if (!silentFail) {
-      throw new Error('Could not parse object parameter value string as JSON Object');
+      throw new Error('Could not parse parameter value string as JSON Object or JSON Array');
     }
   }
   return value;
@@ -303,10 +312,23 @@ export function buildRequest(options) {
     }
 
     if (specIsOAS3 && typeof value === 'string') {
-      if (has('type', parameter.schema) && findObjectSchema(parameter.schema, { recurse: false })) {
-        value = parseJsonObject({ value, silentFail: false });
-      } else if (findObjectSchema(parameter.schema, { recurse: true })) {
-        value = parseJsonObject({ value, silentFail: true });
+      if (
+        has('type', parameter.schema) &&
+        typeof parameter.schema.type === 'string' &&
+        findObjectOrArraySchema(parameter.schema, { recurse: false })
+      ) {
+        value = parseJsonObjectOrArray({ value, silentFail: false });
+      } else if (
+        has('type', parameter.schema) &&
+        Array.isArray(parameter.schema.type) &&
+        findObjectOrArraySchema(parameter.schema, { recurse: false })
+      ) {
+        value = parseJsonObjectOrArray({ value, silentFail: true });
+      } else if (
+        !has('type', parameter.schema) &&
+        findObjectOrArraySchema(parameter.schema, { recurse: true })
+      ) {
+        value = parseJsonObjectOrArray({ value, silentFail: true });
       }
     }
 

test/execute/openapi-3-1.js

@@ -138,7 +138,7 @@ describe('given OpenAPI 3.1.0 definition', () => {
     const response = await SwaggerClient.execute({
       spec,
       operationId: 'getUserList',
-      parameters: { q: 'search string' },
+      parameters: { q: ['search string'] },
       securities: { authorized: { BearerAuth: '3492342948239482398' } },
     });
 
@@ -150,7 +150,7 @@ describe('given OpenAPI 3.1.0 definition', () => {
       spec,
       pathName: '/users',
       method: 'get',
-      parameters: { q: 'search string' },
+      parameters: { q: ['search string'] },
       securities: { authorized: { BearerAuth: '3492342948239482398' } },
     });
 
@@ -164,7 +164,7 @@ describe('given OpenAPI 3.1.0 definition', () => {
     });
     const response = await client.execute({
       operationId: 'getUserList',
-      parameters: { q: 'search string' },
+      parameters: { q: ['search string'] },
     });
 
     expect(response.body).toEqual([{ id: 'value' }]);
@@ -174,7 +174,7 @@ describe('given OpenAPI 3.1.0 definition', () => {
     const request = SwaggerClient.buildRequest({
       spec,
       operationId: 'getUserList',
-      parameters: { q: 'search string' },
+      parameters: { q: ['search string'] },
       securities: { authorized: { BearerAuth: '3492342948239482398' } },
       responseContentType: 'application/json',
     });
@@ -195,7 +195,7 @@ describe('given OpenAPI 3.1.0 definition', () => {
     const request = SwaggerClient.buildRequest({
       spec,
       operationId: 'getUserList',
-      parameters: { q: 'search string' },
+      parameters: { q: ['search string'] },
       securities: { authorized: { BearerAuth: '3492342948239482398' } },
       responseContentType: 'application/json',
       baseURL,

test/oas3/execute/main.js

@@ -573,6 +573,82 @@ describe('buildRequest - OpenAPI Specification 3.0', () => {
   });
 
   describe('`schema` parameters', () => {
+    test('should build a request when parameter type is `string` and value is not a stringified object', () => {
+      // Given
+      const spec = {
+        openapi: '3.1.0',
+        paths: {
+          '/users': {
+            get: {
+              operationId: 'myOperation',
+              parameters: [
+                {
+                  in: 'query',
+                  name: 'parameters',
+                  schema: {
+                    type: 'string',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      };
+      // when
+      const req = buildRequest({
+        spec,
+        operationId: 'myOperation',
+        parameters: {
+          parameters: 'test',
+        },
+      });
+
+      expect(req).toEqual({
+        method: 'GET',
+        url: `/users?parameters=test`,
+        credentials: 'same-origin',
+        headers: {},
+      });
+    });
+
+    it('should build a request when parameter type is `string` and value is a stringified object', () => {
+      // Given
+      const spec = {
+        openapi: '3.1.0',
+        paths: {
+          '/users': {
+            get: {
+              operationId: 'myOperation',
+              parameters: [
+                {
+                  in: 'query',
+                  name: 'parameters',
+                  schema: {
+                    type: 'string',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      };
+      // when
+      const req = buildRequest({
+        spec,
+        operationId: 'myOperation',
+        parameters: {
+          parameters: '{"bar":{"baz":"qux"}}',
+        },
+      });
+
+      expect(req).toEqual({
+        method: 'GET',
+        url: `/users?parameters=${escape('{"bar":{"baz":"qux"}}')}`,
+        credentials: 'same-origin',
+        headers: {},
+      });
+    });
+
     it('should encode JSON values provided as objects', () => {
       const req = buildRequest({
         spec: {