Feature/add api operation head decorator

README.md

@@ -312,6 +312,7 @@ You can quickly test swagger-express-ts with the project example [example-swagge
 - [@ApiOperationPut](./wiki/api-operation-put.decorator.md)
 - [@ApiOperationPatch](./wiki/api-operation-patch.decorator.md)
 - [@ApiOperationDelete](./wiki/api-operation-delete.decorator.md)
+- [@ApiOperationHead](./wiki/api-operation-head.decorator.md)
 
 ## For any questions, suggestions, or feature requests
 

lib/swagger-express-ts-lib/src/api-operation-head.decorator.ts

@@ -0,0 +1,13 @@
+import { SwaggerService } from './swagger.service';
+import { IApiOperationArgsBase } from './i-api-operation-args.base';
+export interface IApiOperationHeadArgs extends IApiOperationArgsBase {}
+
+export function ApiOperationHead(args: IApiOperationHeadArgs): MethodDecorator {
+    return (
+        target: any,
+        propertyKey: string | symbol,
+        descriptor: PropertyDescriptor
+    ) => {
+        SwaggerService.getInstance().addOperationHead(args, target, propertyKey);
+    };
+}

lib/swagger-express-ts-lib/src/i-swagger.ts

@@ -100,6 +100,7 @@ export interface ISwaggerPath {
     put?: ISwaggerOperation;
     patch?: ISwaggerOperation;
     delete?: ISwaggerOperation;
+    head?: ISwaggerOperation;
 }
 
 export interface ISwaggerDefinitionPropertyItems {

lib/swagger-express-ts-lib/src/index.ts

@@ -21,6 +21,10 @@ export {
     IApiOperationDeleteArgs,
     ApiOperationDelete,
 } from './api-operation-delete.decorator';
+export {
+  IApiOperationHeadArgs,
+  ApiOperationHead,
+} from './api-operation-head.decorator';
 
 export {
     IApiModelPropertyArgs,

lib/swagger-express-ts-lib/src/swagger.service.spec.ts

@@ -15,6 +15,7 @@ import { IApiOperationPatchArgs } from './api-operation-patch.decorator';
 import { IApiOperationDeleteArgs } from './api-operation-delete.decorator';
 import { SwaggerDefinitionConstant } from './swagger-definition.constant';
 import { ISwaggerBuildDefinitionModel } from './swagger.builder';
+import { IApiOperationHeadArgs } from './api-operation-head.decorator';
 const expect = chai.expect;
 
 describe('SwaggerService', () => {
@@ -244,6 +245,69 @@ describe('SwaggerService', () => {
         });
     });
 
+    describe('addOperationHead', () => {
+      const pathArgs: IApiPathArgs = {
+          path: '/versions',
+          name: 'Version',
+      };
+      const pathTarget: any = {
+          name: 'VersionsController',
+      };
+      const operationHeadTarget: any = {
+          constructor: {
+              name: 'VersionsController',
+          },
+      };
+      let propertyKey: string | symbol;
+      let expectedPaths: { [key: string]: ISwaggerPath };
+
+      beforeEach(() => {
+          SwaggerService.getInstance().addPath(pathArgs, pathTarget);
+      });
+
+      describe('expect no content', () => {
+          beforeEach(() => {
+              propertyKey = 'getVersions';
+              expectedPaths = {
+                  '/versions': {
+                      head: {
+                          consumes: [SwaggerDefinitionConstant.Consume.JSON],
+                          operationId: 'getVersions',
+                          produces: [SwaggerDefinitionConstant.Produce.JSON],
+                          responses: {
+                              204: {
+                                  description: 'Success',
+                              },
+                          },
+                          tags: ['Version'],
+                      },
+                  },
+              };
+          });
+
+          it('expect default', () => {
+              const operationHeadArgs: IApiOperationHeadArgs = {
+                  responses: {
+                      204: {
+                        description: 'Success',
+                    },
+                  },
+              };
+
+              SwaggerService.getInstance().addOperationHead(
+                  operationHeadArgs,
+                  operationHeadTarget,
+                  propertyKey
+              );
+
+              SwaggerService.getInstance().buildSwagger();
+              expect(
+                  SwaggerService.getInstance().getData().paths
+              ).to.deep.equal(expectedPaths);
+          });
+      });
+  });
+
     describe('addOperationGet', () => {
         const pathArgs: IApiPathArgs = {
             path: '/versions',

lib/swagger-express-ts-lib/src/swagger.service.ts

@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as _ from 'lodash';
-import { IApiModelArgs } from '.';
+import { IApiModelArgs, IApiOperationHeadArgs } from '.';
 import { IApiModelPropertyArgs } from './api-model-property.decorator';
 import { IApiOperationGetArgs } from './api-operation-get.decorator';
 import { IApiOperationPostArgs } from './api-operation-post.decorator';
@@ -41,6 +41,7 @@ interface IPath {
     put?: ISwaggerOperation;
     patch?: ISwaggerOperation;
     delete?: ISwaggerOperation;
+    head?: ISwaggerOperation;
 }
 
 interface IController {
@@ -190,6 +191,19 @@ export class SwaggerService {
         );
     }
 
+    public addOperationHead(
+      args: IApiOperationHeadArgs,
+      target: any,
+      propertyKey: string | symbol
+  ): void {
+      assert.ok(args, 'Args are required.');
+      assert.ok(args.responses, 'Responses are required.');
+      if (args.parameters) {
+          assert.ok(!args.parameters.body, 'Parameter body is not required.');
+      }
+      this.addOperation('head', args, target, propertyKey);
+  }
+
     public addOperationGet(
         args: IApiOperationGetArgs,
         target: any,
@@ -292,6 +306,12 @@ export class SwaggerService {
                             controller
                         );
                     }
+                    if (path.head) {
+                      swaggerPath.head = this.buildSwaggerOperation(
+                          path.head,
+                          controller
+                      );
+                  }
                     if (path.path && path.path.length > 0) {
                         data.paths[controller.path.concat(path.path)] = {...data.paths[controller.path.concat(path.path)],...swaggerPath};
                     } else {
@@ -404,12 +424,14 @@ export class SwaggerService {
         target: any,
         propertyKey: string | symbol
     ): void {
+        const targetName = target.constructor.name !== 'Function' ? target.constructor.name : target.name;
+
         let currentController: IController = {
             paths: {},
         };
         for (const index in this.controllerMap) {
             const controller = this.controllerMap[index];
-            if (index === target.constructor.name) {
+            if (index === targetName) {
                 currentController = controller;
             }
         }
@@ -448,7 +470,11 @@ export class SwaggerService {
             currentPath.delete = this.buildOperation(args, target, propertyKey);
         }
 
-        this.controllerMap[target.constructor.name] = currentController;
+        if ('head' === operation) {
+          currentPath.head = this.buildOperation(args, target, propertyKey);
+        }
+
+        this.controllerMap[targetName] = currentController;
     }
 
     private buildOperation(