fix(swagger): Query Enums with isArray and enumName have type 'array' in schema

lib/services/schema-object-factory.ts

@@ -167,14 +167,24 @@ export class SchemaObjectFactory {
 
       const schemaCombinators = ['oneOf', 'anyOf', 'allOf'];
       let keyOfCombinators = '';
-      if (schemaCombinators.some((_key) => { keyOfCombinators = _key; return _key in property; })) {
-          if (((property as SchemaObjectMetadata)?.type === 'array' || (property as SchemaObjectMetadata).isArray) && keyOfCombinators) {
-              (property as SchemaObjectMetadata).items = {};
-              (property as SchemaObjectMetadata).items[keyOfCombinators] = property[keyOfCombinators];
-              delete property[keyOfCombinators];
-          } else {
-              delete (property as SchemaObjectMetadata).type;
-          }
+      if (
+        schemaCombinators.some((_key) => {
+          keyOfCombinators = _key;
+          return _key in property;
+        })
+      ) {
+        if (
+          ((property as SchemaObjectMetadata)?.type === 'array' ||
+            (property as SchemaObjectMetadata).isArray) &&
+          keyOfCombinators
+        ) {
+          (property as SchemaObjectMetadata).items = {};
+          (property as SchemaObjectMetadata).items[keyOfCombinators] =
+            property[keyOfCombinators];
+          delete property[keyOfCombinators];
+        } else {
+          delete (property as SchemaObjectMetadata).type;
+        }
       }
       return property as ParameterObject;
     });
@@ -203,7 +213,8 @@ export class SchemaObjectFactory {
     if (!propertiesWithType) {
       return '';
     }
-    const extensionProperties = Reflect.getMetadata(DECORATORS.API_EXTENSION, type) || {};
+    const extensionProperties =
+      Reflect.getMetadata(DECORATORS.API_EXTENSION, type) || {};
     const typeDefinition: SchemaObject = {
       type: 'object',
       properties: mapValues(keyBy(propertiesWithType, 'name'), (property) =>
@@ -273,7 +284,10 @@ export class SchemaObjectFactory {
         : undefined;
 
       schemas[enumName] = {
-        type: param.schema?.['type'] ?? 'string',
+        type:
+          (param.isArray
+            ? param.schema?.['items']?.['type']
+            : param.schema?.['type']) ?? 'string',
         enum: _enum
       };
     }
@@ -301,15 +315,17 @@ export class SchemaObjectFactory {
     const $ref = getSchemaPath(enumName);
 
     // Allow given fields to be part of the referenced enum schema
-    const additionalParams = ['description', 'deprecated', 'default']
-    const additionalFields = additionalParams.reduce((acc, param) =>
-      ({...acc, ...(metadata[param] && { [param]: metadata[param] })}), {});
-
-    const enumType: string = (
-      metadata.isArray
-      ? metadata.items['type']
-      : metadata.type
-    ) ?? 'string';
+    const additionalParams = ['description', 'deprecated', 'default'];
+    const additionalFields = additionalParams.reduce(
+      (acc, param) => ({
+        ...acc,
+        ...(metadata[param] && { [param]: metadata[param] })
+      }),
+      {}
+    );
+
+    const enumType: string =
+      (metadata.isArray ? metadata.items['type'] : metadata.type) ?? 'string';
 
     schemas[enumName] = {
       type: enumType,

test/explorer/swagger-explorer.spec.ts

@@ -938,7 +938,7 @@ describe('SwaggerExplorer', () => {
       })
       @ApiQuery({ name: 'order', enum: QueryEnum })
       @ApiQuery({ name: 'page', enum: ['d', 'e', 'f'], isArray: true })
-      find(): Promise<Foo[]> {
+      find(@Param('objectId') objectId: ParamEnum): Promise<Foo[]> {
         return Promise.resolve([]);
       }
     }
@@ -952,7 +952,7 @@ describe('SwaggerExplorer', () => {
       })
       @ApiQuery({ name: 'order', enum: QueryEnum })
       @ApiQuery({ name: 'page', enum: ['d', 'e', 'f'] })
-      find(): Promise<Foo[]> {
+      find(@Param('objectId') objectId: ParamEnum, @Query('order') order: QueryEnum, @Query('page') page: 'd' | 'e' | 'f'): Promise<Foo[]> {
         return Promise.resolve([]);
       }
     }
@@ -972,7 +972,7 @@ describe('SwaggerExplorer', () => {
         enumName: 'QueryEnum',
         isArray: true
       })
-      findBar(): Promise<Foo> {
+      findBar(@Param('objectId') objectId: ParamEnum, @Query('order') order: QueryEnum, @Query('page') page: QueryEnum[]): Promise<Foo> {
         return Promise.resolve(null);
       }
     }
@@ -985,7 +985,7 @@ describe('SwaggerExplorer', () => {
         enum: [1, 2, 3],
         enumName: 'NumberEnum'
       })
-      findBar(): Promise<Foo> {
+      findBar(@Param('objectId') objectId: number): Promise<Foo> {
         return Promise.resolve(null);
       }
     }
@@ -1010,6 +1010,15 @@ describe('SwaggerExplorer', () => {
         '/globalPrefix/v3/modulePath/foos/{objectId}'
       );
       expect(routes[0].root!.parameters).toEqual([
+        {
+          in: 'path',
+          name: 'objectId',
+          required: true,
+          schema: {
+            type: 'string',
+            enum: ['a', 'b', 'c']
+          }
+        },
         {
           in: 'query',
           name: 'page',
@@ -1030,15 +1039,6 @@ describe('SwaggerExplorer', () => {
             type: 'number',
             enum: [1, 2, 3]
           }
-        },
-        {
-          in: 'path',
-          name: 'objectId',
-          required: true,
-          schema: {
-            type: 'string',
-            enum: ['a', 'b', 'c']
-          }
         }
       ]);
     });
@@ -1056,12 +1056,12 @@ describe('SwaggerExplorer', () => {
 
       expect(routes[0].root!.parameters).toEqual([
         {
-          in: 'query',
-          name: 'page',
+          in: 'path',
+          name: 'objectId',
           required: true,
           schema: {
             type: 'string',
-            enum: ['d', 'e', 'f']
+            enum: ['a', 'b', 'c']
           }
         },
         {
@@ -1074,12 +1074,12 @@ describe('SwaggerExplorer', () => {
           }
         },
         {
-          in: 'path',
-          name: 'objectId',
+          in: 'query',
+          name: 'page',
           required: true,
           schema: {
             type: 'string',
-            enum: ['a', 'b', 'c']
+            enum: ['d', 'e', 'f']
           }
         }
       ]);
@@ -1099,14 +1099,11 @@ describe('SwaggerExplorer', () => {
 
       expect(routes[0].root!.parameters).toEqual([
         {
-          in: 'query',
-          name: 'page',
+          in: 'path',
+          name: 'objectId',
           required: true,
           schema: {
-            type: 'array',
-            items: {
-              $ref: '#/components/schemas/QueryEnum'
-            }
+            $ref: '#/components/schemas/ParamEnum'
           }
         },
         {
@@ -1118,11 +1115,14 @@ describe('SwaggerExplorer', () => {
           }
         },
         {
-          in: 'path',
-          name: 'objectId',
+          in: 'query',
+          name: 'page',
           required: true,
           schema: {
-            $ref: '#/components/schemas/ParamEnum'
+            type: 'array',
+            items: {
+              $ref: '#/components/schemas/QueryEnum'
+            }
           }
         }
       ]);

test/services/schema-object-factory.spec.ts

@@ -1,9 +1,13 @@
 import { ApiExtension, ApiProperty } from '../../lib/decorators';
-import { SchemasObject } from '../../lib/interfaces/open-api-spec.interface';
+import {
+  BaseParameterObject,
+  SchemasObject
+} from '../../lib/interfaces/open-api-spec.interface';
 import { ModelPropertiesAccessor } from '../../lib/services/model-properties-accessor';
 import { SchemaObjectFactory } from '../../lib/services/schema-object-factory';
 import { SwaggerTypesMapper } from '../../lib/services/swagger-types-mapper';
 import { CreateUserDto } from './fixtures/create-user.dto';
+import { ParamWithTypeMetadata } from '../../lib/services/parameter-metadata-accessor';
 
 describe('SchemaObjectFactory', () => {
   let modelPropertiesAccessor: ModelPropertiesAccessor;
@@ -328,4 +332,44 @@ describe('SchemaObjectFactory', () => {
       expect(schemas).toEqual({ MyEnum: { enum: [1, 2, 3], type: 'number' } });
     });
   });
+
+  describe('createEnumParam', () => {
+    it('should create an enum schema definition', () => {
+      const params: ParamWithTypeMetadata & BaseParameterObject = {
+        required: true,
+        isArray: false,
+        enumName: 'MyEnum',
+        enum: ['a', 'b', 'c']
+      };
+      const schemas = {};
+      schemaObjectFactory.createEnumParam(params, schemas);
+
+      expect(schemas['MyEnum']).toEqual({
+        enum: ['a', 'b', 'c'],
+        type: 'string'
+      });
+    });
+
+    it('should create an enum schema definition for an array', () => {
+      const params: ParamWithTypeMetadata & BaseParameterObject = {
+        required: true,
+        isArray: true,
+        enumName: 'MyEnum',
+        schema: {
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: ['a', 'b', 'c']
+          }
+        }
+      };
+      const schemas = {};
+      schemaObjectFactory.createEnumParam(params, schemas);
+
+      expect(schemas['MyEnum']).toEqual({
+        enum: ['a', 'b', 'c'],
+        type: 'string'
+      });
+    });
+  });
 });