decorators.ts - Stryker report

'use strict';

import * as _ from 'lodash';
import 'reflect-metadata';
import * as metadata from './metadata';
import { InternalServer } from './server-container';
import { HttpMethod, ServicePreProcessor } from './server-types';

/**
 * A decorator to tell the [[Server]] that a class or a method
 * should be bound to a given path.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ PUT
 *   @ Path(':id')
 *   savePerson(person:Person) {
 *      // ...
 *   }
 *
 *   @ GET
 *   @ Path(':id')
 *   getPerson():Person {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create services that listen for requests like:
 *
 * ```
 * PUT http://mydomain/people/123 or
 * GET http://mydomain/people/123
 * ```
 */
export function Path(path: string) 0{
    return function (...args: Array<any>) 1{
        args = _.without(args, undefined);
        if (23args.length 4=== 1) 5{
            return PathTypeDecorator.apply(this, 6[args[0], path]);
        } else if (78args.length 9=== 3 10&& typeof args[2] 11=== 12'object') 13{
            return PathMethodDecorator.apply(this, 14[args[0], args[1], args[2], path]);
        }

        throw new Error(15'Invalid @Path Decorator declaration.');
    };
}

/**
 * A decorator to tell the [[Server]] that a class or a method
 * should include a determined role
 * or all authorized users (token) using passport
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * @ Security()
 * class PeopleService {
 *   @ PUT
 *   @ Path(':id', true)
 *   @ Security(['ROLE_ADMIN'])
 *   savePerson(person:Person) {
 *      // ...
 *   }
 *
 *   @ GET
 *   @ Path(':id', true)
 *   getPerson():Person {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create services that listen for requests like:
 *
 * ```
 * PUT http://mydomain/people/123 (Only for ADMIN roles) or
 * GET http://mydomain/people/123 (For all authorized users)
 * ```
 */
export function Security(roles: string | Array<string> = 16[17'*']) 18{
    return function (...args: Array<any>) 19{
        args = _.without(args, undefined);
        if (2021typeof roles 22!== 23'object') 24{
            roles = 25[roles];
        }
        if (2627args.length 28=== 1) 29{
            return SecurityTypeDecorator.apply(this, 30[args[0], roles]);
        } else if (3132args.length 33=== 3 34&& typeof args[2] 35=== 36'object') 37{
            return SecurityMethodDecorator.apply(this, 38[args[0], args[1], args[2], roles]);
        }

        throw new Error(39'Invalid @Security Decorator declaration.');
    };
}

/**
 * A decorator to tell the [[Server]] that a class or a method
 * should include a pre-processor in its request pipelines.
 *
 * For example:
 * ```
 * function validator(req: express.Request): express.Request {
 *   if (!req.body.userId) {
 *      throw new Errors.BadRequestError("userId not present");
 *   } 
 * }
 * ```
 * And:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ PUT
 *   @ Path(':id')
 *   @ Preprocessor(validator)
 *   savePerson(person:Person) {
 *      // ...
 *   }
 * }
 * ```
 */
export function Preprocessor(preprocessor: ServicePreProcessor) 40{
    return function (...args: Array<any>) 41{
        args = _.without(args, undefined);
        if (4243args.length 44=== 1) 45{
            return PreprocessorTypeDecorator.apply(this, 46[args[0], preprocessor]);
        } else if (4748args.length 49=== 3 50&& typeof args[2] 51=== 52'object') 53{
            return PreprocessorMethodDecorator.apply(this, 54[args[0], args[1], args[2], preprocessor]);
        }

        throw new Error(55'Invalid @Preprocessor Decorator declaration.');
    };
}

/**
 * A decorator to tell the [[Server]] that a class or a method
 * should only accept requests from clients that accepts one of
 * the supported languages.
 *
 * For example:
 *
 * ```
 * @ Path('accept')
 * @ AcceptLanguage('en', 'pt-BR')
 * class TestAcceptService {
 *      // ...
 * }
 * ```
 *
 * Will reject requests that only accepts languages that are not
 * English or Brazilian portuguese
 *
 * If the language requested is not supported, a status code 406 returned
 */
export function AcceptLanguage(...languages: Array<string>) 56{
    return function (...args: Array<any>) 57{
        args = _.without(args, undefined);
        if (5859args.length 60=== 1) 61{
            return AcceptLanguageTypeDecorator.apply(this, 62[args[0], languages]);
        } else if (6364args.length 65=== 3 66&& typeof args[2] 67=== 68'object') 69{
            return AcceptLanguageMethodDecorator.apply(this, 70[args[0], args[1], args[2], languages]);
        }

        throw new Error(71'Invalid @AcceptLanguage Decorator declaration.');
    };
}

/**
 * A decorator to tell the [[Server]] that a class or a method
 * should only accept requests from clients that accepts one of
 * the supported mime types.
 *
 * For example:
 *
 * ```
 * @ Path('accept')
 * @ Accept('application/json')
 * class TestAcceptService {
 *      // ...
 * }
 * ```
 *
 * Will reject requests that only accepts mime types that are not
 * 'application/json'
 *
 * If the mime type requested is not supported, a status code 406 returned
 */
export function Accept(...accepts: Array<string>) 72{
    return function (...args: Array<any>) 73{
        args = _.without(args, undefined);
        if (7475args.length 76=== 1) 77{
            return AcceptTypeDecorator.apply(this, 78[args[0], accepts]);
        } else if (7980args.length 81=== 3 82&& typeof args[2] 83=== 84'object') 85{
            return AcceptMethodDecorator.apply(this, 86[args[0], args[1], args[2], accepts]);
        }

        throw new Error(87'Invalid @Accept Decorator declaration.');
    };
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * [[ServiceContext]] object associated to the current request.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ Context
 *   context: ServiceContext;
 *   // ...
 * }
 * ```
 *
 * The field context on the above class will point to the current
 * [[ServiceContext]] instance.
 */
export function Context(...args: Array<any>) 88{
    args = _.without(args, undefined);
    const newArgs = args.concat(89[metadata.ParamType.context, null]);
    if (9091args.length 9293< 3 94|| typeof args[2] 95=== 96'undefined') 97{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (9899args.length 100=== 3 101&& typeof args[2] 102=== 103'number') 104{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(105'Invalid @Context Decorator declaration.');
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * the current request.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ ContextRequest
 *   request: express.Request;
 *   // ...
 * }
 * ```
 *
 * The field request on the above class will point to the current
 * request.
 */
export function ContextRequest(...args: Array<any>) 106{
    args = _.without(args, undefined);
    const newArgs = args.concat(107[metadata.ParamType.context_request, null]);
    if (108109args.length 110111< 3 112|| typeof args[2] 113=== 114'undefined') 115{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (116117args.length 118=== 3 119&& typeof args[2] 120=== 121'number') 122{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(123'Invalid @ContextRequest Decorator declaration.');
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * the current response object.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ ContextResponse
 *   response: express.Response;
 *   // ...
 * }
 * ```
 *
 * The field response on the above class will point to the current
 * response object.
 */
export function ContextResponse(...args: Array<any>) 124{
    args = _.without(args, undefined);
    const newArgs = args.concat(125[metadata.ParamType.context_response, null]);
    if (126127args.length 128129< 3 130|| typeof args[2] 131=== 132'undefined') 133{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (134135args.length 136=== 3 137&& typeof args[2] 138=== 139'number') 140{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(141'Invalid @ContextResponse Decorator declaration.');
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * the next function.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ ContextNext
 *   next: express.NextFunction
 *       // ...
 * }
 * ```
 *
 * The next function can be used to delegate to the next registered
 * middleware the current request processing.
 */
export function ContextNext(...args: Array<any>) 142{
    args = _.without(args, undefined);
    const newArgs = args.concat(143[metadata.ParamType.context_next, null]);
    if (144145args.length 146147< 3 148|| typeof args[2] 149=== 150'undefined') 151{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (152153args.length 154=== 3 155&& typeof args[2] 156=== 157'number') 158{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(159'Invalid @ContextNext Decorator declaration.');
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * the current context language.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ ContextLanguage
 *   language: string
 *       // ...
 * }
 * ```
 */
export function ContextLanguage(...args: Array<any>) 160{
    args = _.without(args, undefined);
    const newArgs = args.concat(161[metadata.ParamType.context_accept_language, null]);
    if (162163args.length 164165< 3 166|| typeof args[2] 167=== 168'undefined') 169{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (170171args.length 172=== 3 173&& typeof args[2] 174=== 175'number') 176{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(177'Invalid @ContextLanguage Decorator declaration.');
}

/**
 * A decorator to be used on class properties or on service method arguments
 * to inform that the decorated property or argument should be bound to the
 * the preferred media type for the current request.
 *
 * For example:
 *
 * ```
 * @ Path('context')
 * class TestService {
 *   @ ContextAccept
 *   media: string
 *       // ...
 * }
 * ```
 */
export function ContextAccept(...args: Array<any>) 178{
    args = _.without(args, undefined);
    const newArgs = args.concat(179[metadata.ParamType.context_accept, null]);
    if (180181args.length 182183< 3 184|| typeof args[2] 185=== 186'undefined') 187{
        return processDecoratedProperty.apply(this, newArgs);
    } else if (188189args.length 190=== 3 191&& typeof args[2] 192=== 193'number') 194{
        return processDecoratedParameter.apply(this, newArgs);
    }

    throw new Error(195'Invalid @ContextAccept Decorator declaration.');
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP GET requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople() {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * GET http://mydomain/people
 * ```
 */
export function GET(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 196{
    processHttpVerb(target, propertyKey, HttpMethod.GET);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP POST requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ POST
 *   addPerson() {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * POST http://mydomain/people
 * ```
 */
export function POST(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 197{
    processHttpVerb(target, propertyKey, HttpMethod.POST);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP PUT requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ PUT
 *   @ Path(':id')
 *   savePerson(person: Person) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * PUT http://mydomain/people/123
 * ```
 */
export function PUT(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 198{
    processHttpVerb(target, propertyKey, HttpMethod.PUT);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP DELETE requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ DELETE
 *   @ Path(':id')
 *   removePerson(@ PathParam('id')id: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * PUT http://mydomain/people/123
 * ```
 */
export function DELETE(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 199{
    processHttpVerb(target, propertyKey, HttpMethod.DELETE);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP HEAD requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ HEAD
 *   headPerson() {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * HEAD http://mydomain/people/123
 * ```
 */
export function HEAD(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 200{
    processHttpVerb(target, propertyKey, HttpMethod.HEAD);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP OPTIONS requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ OPTIONS
 *   optionsPerson() {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * OPTIONS http://mydomain/people/123
 * ```
 */
export function OPTIONS(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 201{
    processHttpVerb(target, propertyKey, HttpMethod.OPTIONS);
}

/**
 * A decorator to tell the [[Server]] that a method
 * should be called to process HTTP PATCH requests.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ PATCH
 *   @ Path(':id')
 *   savePerson(person: Person) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * PATCH http://mydomain/people/123
 * ```
 */
export function PATCH(target: any, propertyKey: string,
    descriptor: PropertyDescriptor) 202{
    processHttpVerb(target, propertyKey, HttpMethod.PATCH);
}

/**
 * A decorator to inform options to pe passed to bodyParser.
 * You can inform any property accepted by
 * [[bodyParser]](https://www.npmjs.com/package/body-parser)
 */
export function BodyOptions(options: any) 203{
    return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) 204{
        const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
        if (205206serviceMethod) 207{ // does not intercept constructor
            serviceMethod.bodyParserOptions = options;
        }
    };
}

/**
 * Creates a mapping between a fragment of the requested path and
 * a method argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   @ Path(':id')
 *   getPerson(@ PathParam('id') id: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * GET http://mydomain/people/123
 * ```
 *
 * And pass 123 as the id argument on getPerson method's call.
 */
export function PathParam(name: string) 208{
    return function (...args: Array<any>) 209{
        args = _.without(args, undefined);
        const newArgs = args.concat(210[metadata.ParamType.path, name]);
        if (211212args.length 213214< 3 215|| typeof args[2] 216=== 217'undefined') 218{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (219220args.length 221=== 3 222&& typeof args[2] 223=== 224'number') 225{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(226'Invalid @PathParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a file on a multipart request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ POST
 *   @ Path('id')
 *   addAvatar(@ PathParam('id') id: string,
 *             @ FileParam('avatar') file: Express.Multer.File) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * file with name 'avatar' on the requested form to the file
 * argument on addAvatar method's call.
 */
export function FileParam(name: string) 227{
    return function (...args: Array<any>) 228{
        args = _.without(args, undefined);
        const newArgs = args.concat(229[metadata.ParamType.file, name]);
        if (230231args.length 232233< 3 234|| typeof args[2] 235=== 236'undefined') 237{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (238239args.length 240=== 3 241&& typeof args[2] 242=== 243'number') 244{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(245'Invalid @FileParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a list of files on a multipart request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ POST
 *   @ Path('id')
 *   addAvatar(@ PathParam('id') id: string,
 *             @ FilesParam('avatar[]') files: Array<Express.Multer.File>) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * files with name 'avatar' on the request form to the file
 * argument on addAvatar method's call.
 */
export function FilesParam(name: string) 246{
    return function (...args: Array<any>) 247{
        args = _.without(args, undefined);
        const newArgs = args.concat(248[metadata.ParamType.files, name]);
        if (249250args.length 251252< 3 253|| typeof args[2] 254=== 255'undefined') 256{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (257258args.length 259=== 3 260&& typeof args[2] 261=== 262'number') 263{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(264'Invalid @FilesParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a query parameter on request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople(@ QueryParam('name') name: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests like:
 *
 * ```
 * GET http://mydomain/people?name=joe
 * ```
 *
 * And pass 'joe' as the name argument on getPerson method's call.
 */
export function QueryParam(name: string) 265{
    return function (...args: Array<any>) 266{
        args = _.without(args, undefined);
        const newArgs = args.concat(267[metadata.ParamType.query, name]);
        if (268269args.length 270271< 3 272|| typeof args[2] 273=== 274'undefined') 275{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (276277args.length 278=== 3 279&& typeof args[2] 280=== 281'number') 282{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(283'Invalid @QueryParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a header on request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople(@ HeaderParam('header') header: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * header called 'header' to the header argument on getPerson method's call.
 */
export function HeaderParam(name: string) 284{
    return function (...args: Array<any>) 285{
        args = _.without(args, undefined);
        const newArgs = args.concat(286[metadata.ParamType.header, name]);
        if (287288args.length 289290< 3 291|| typeof args[2] 292=== 293'undefined') 294{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (295296args.length 297=== 3 298&& typeof args[2] 299=== 300'number') 301{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(302'Invalid @HeaderParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a cookie on request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople(@ CookieParam('cookie') cookie: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * cookie called 'cookie' to the cookie argument on getPerson method's call.
 */
export function CookieParam(name: string) 303{
    return function (...args: Array<any>) 304{
        args = _.without(args, undefined);
        const newArgs = args.concat(305[metadata.ParamType.cookie, name]);
        if (306307args.length 308309< 3 310|| typeof args[2] 311=== 312'undefined') 313{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (314315args.length 316=== 3 317&& typeof args[2] 318=== 319'number') 320{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(321'Invalid @CookieParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a form parameter on request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople(@ FormParam('name') name: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * request paramenter called 'name' to the name argument on getPerson
 * method's call.
 */
export function FormParam(name: string) 322{
    return function (...args: Array<any>) 323{
        args = _.without(args, undefined);
        const newArgs = args.concat(324[metadata.ParamType.form, name]);
        if (325326args.length 327328< 3 329|| typeof args[2] 330=== 331'undefined') 332{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (333334args.length 335=== 3 336&& typeof args[2] 337=== 338'number') 339{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(340'Invalid @FormParam Decorator declaration.');
    };
}

/**
 * Creates a mapping between a parameter on request and a method
 * argument.
 *
 * For example:
 *
 * ```
 * @ Path('people')
 * class PeopleService {
 *   @ GET
 *   getPeople(@ Param('name') name: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * Will create a service that listen for requests and bind the
 * request paramenter called 'name' to the name argument on getPerson
 * method's call. It will work to query parameters or form parameters
 * received in the current request.
 */
export function Param(name: string) 341{
    return function (...args: Array<any>) 342{
        args = _.without(args, undefined);
        const newArgs = args.concat(343[metadata.ParamType.param, name]);
        if (344345args.length 346347< 3 348|| typeof args[2] 349=== 350'undefined') 351{
            return processDecoratedProperty.apply(this, newArgs);
        } else if (352353args.length 354=== 3 355&& typeof args[2] 356=== 357'number') 358{
            return processDecoratedParameter.apply(this, newArgs);
        }

        throw new Error(359'Invalid @Param Decorator declaration.');
    };
}

/**
 * Mark the annotated service class as an abstract service. Abstract services has none of its
 * methods exposed as rest enpoints, even if the class is in the services list to be exposed.
 *
 * For example:
 *
 * ```
 * @ Abstract
 * abstract class PeopleService {
 *   @ GET
 *   getPeople(@ Param('name') name: string) {
 *      // ...
 *   }
 * }
 * ```
 *
 * No endpoint will be registered for PeopleService. It is useful if you only plain that subclasses of
 * PeopleService exposes the getPeople method.
 */
export function Abstract(target: Function) 360{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    classData.isAbstract = 361true;
}

/**
 * Decorator processor for [[AcceptLanguage]] decorator on classes
 */
function AcceptLanguageTypeDecorator(target: Function, languages: Array<string>) 362{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    classData.languages = _.union(classData.languages, languages);
}

/**
 * Decorator processor for [[AcceptLanguage]] decorator on methods
 */
function AcceptLanguageMethodDecorator(target: any, propertyKey: string,
    descriptor: PropertyDescriptor, languages: Array<string>) 363{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (364365serviceMethod) 366{ // does not intercept constructor
        serviceMethod.languages = languages;
    }
}

/**
 * Decorator processor for [[Accept]] decorator on classes
 */
function AcceptTypeDecorator(target: Function, accepts: Array<string>) 367{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    classData.accepts = _.union(classData.accepts, accepts);
}

/**
 * Decorator processor for [[Accept]] decorator on methods
 */
function AcceptMethodDecorator(target: any, propertyKey: string,
    descriptor: PropertyDescriptor, accepts: Array<string>) 368{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (369370serviceMethod) 371{ // does not intercept constructor
        serviceMethod.accepts = accepts;
    }
}

/**
 * Decorator processor for [[Path]] decorator on classes
 */
function PathTypeDecorator(target: Function, path: string) 372{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    if (373374classData) 375{
        classData.path = path;
    }
}

/**
 * Decorator processor for [[Path]] decorator on methods
 */
function PathMethodDecorator(target: any, propertyKey: string,
    descriptor: PropertyDescriptor, path: string) 376{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (377378serviceMethod) 379{ // does not intercept constructor
        serviceMethod.path = path;
    }
}

/**
 * Decorator processor for [[Security]] decorator on classes
 */
function SecurityTypeDecorator(target: Function, roles: Array<string>) 380{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    if (381382classData) 383{
        classData.roles = roles;
    }
}

/**
 * Decorator processor for [[Security]] decorator on methods
 */
function SecurityMethodDecorator(target: any, propertyKey: string,
    descriptor: PropertyDescriptor, roles: Array<string>) 384{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (385386serviceMethod) 387{ // does not intercept constructor
        serviceMethod.roles = roles;
    }
}

/**
 * Decorator processor for [[Preprocessor]] decorator on classes
 */
function PreprocessorTypeDecorator(target: Function, preprocessor: metadata.PreprocessorFunction) 388{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target);
    if (389390classData) 391{
        if (392393394!classData.processors) 395{
            classData.processors = 396[];
        }
        classData.processors.unshift(preprocessor);
    }
}

/**
 * Decorator processor for [[Preprocessor]] decorator on methods
 */
function PreprocessorMethodDecorator(target: any, propertyKey: string,
    descriptor: PropertyDescriptor, preprocessor: metadata.PreprocessorFunction) 397{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (398399serviceMethod) 400{
        if (401402403!serviceMethod.processors) 404{
            serviceMethod.processors = 405[];
        }
        serviceMethod.processors.unshift(preprocessor);
    }
}

/**
 * Decorator processor for parameter annotations on methods
 */
function processDecoratedParameter(target: Object, propertyKey: string, parameterIndex: number,
    paramType: metadata.ParamType, name: string) 406{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (407408serviceMethod) 409{ // does not intercept constructor
        const paramTypes = Reflect.getOwnMetadata(410'design:paramtypes', target, propertyKey);

        while (411paramTypes 412&& serviceMethod.parameters.length 413414< paramTypes.length) 415{
            serviceMethod.parameters.push(new metadata.MethodParam(null,
                paramTypes[serviceMethod.parameters.length], metadata.ParamType.body));
        }
        serviceMethod.parameters[parameterIndex] = new metadata.MethodParam(name, paramTypes[parameterIndex], paramType);
    }
}

/**
 * Decorator processor for annotations on properties
 */
function processDecoratedProperty(target: Function, key: string, paramType: metadata.ParamType, paramName: string) 416{
    const classData: metadata.ServiceClass = InternalServer.registerServiceClass(target.constructor);
    const propertyType = Reflect.getMetadata(417'design:type', target, key);
    classData.addProperty(key, paramType, paramName, propertyType);
}

/**
 * Decorator processor for HTTP verb annotations on methods
 */
function processHttpVerb(target: any, propertyKey: string,
    httpMethod: HttpMethod) 418{
    const serviceMethod: metadata.ServiceMethod = InternalServer.registerServiceMethod(target.constructor, propertyKey);
    if (419420serviceMethod) 421{ // does not intercept constructor
        if (422423serviceMethod.httpMethod 424&& serviceMethod.httpMethod 425!== httpMethod) 426{
            throw new Error(427'Method is already annotated with @' 428+
                HttpMethod[serviceMethod.httpMethod] 429+
                430'. You can only map a method to one HTTP verb.');
        }
        serviceMethod.httpMethod = httpMethod;
        processServiceMethod(target, propertyKey, serviceMethod);
    }
}

/**
 * Extract metadata for rest methods
 */
function processServiceMethod(target: any, propertyKey: string, serviceMethod: metadata.ServiceMethod) 431{
    serviceMethod.name = propertyKey;
    const paramTypes = Reflect.getOwnMetadata(432'design:paramtypes', target, propertyKey);
    while (433paramTypes 434&& paramTypes.length 435436> serviceMethod.parameters.length) 437{
        serviceMethod.parameters.push(new metadata.MethodParam(null,
            paramTypes[serviceMethod.parameters.length], metadata.ParamType.body));
    }

    serviceMethod.parameters.forEach(param => 438{
        if (439440param.paramType 441=== metadata.ParamType.cookie) 442{
            serviceMethod.mustParseCookies = 443true;
        } else if (444445param.paramType 446=== metadata.ParamType.file) 447{
            serviceMethod.files.push(new metadata.FileParam(param.name, 448true));
        } else if (449450param.paramType 451=== metadata.ParamType.files) 452{
            serviceMethod.files.push(new metadata.FileParam(param.name, 453false));
        } else if (454455param.paramType 456=== metadata.ParamType.param) 457{
            serviceMethod.acceptMultiTypedParam = 458true;
        } else if (459460param.paramType 461=== metadata.ParamType.form) 462{
            if (463464serviceMethod.mustParseBody) 465{
                throw Error(466'Can not use form parameters with a body parameter on the same method.');
            }
            serviceMethod.mustParseForms = 467true;
        } else if (468469param.paramType 470=== metadata.ParamType.body) 471{
            if (472473serviceMethod.mustParseForms) 474{
                throw Error(475'Can not use form parameters with a body parameter on the same method.');
            }
            if (476477serviceMethod.mustParseBody) 478{
                throw Error(479'Can not use more than one body parameter on the same method.');
            }
            serviceMethod.mustParseBody = 480true;
        }
    });
}