Support for custom param decorators

[MichalLytek]

I have seen that many people fork this repo to add custom decorators for exporting object from request object and inject it in the controllers methods params. It's a bit pain to modify switch-case in core of routing-controllers every time we need e.g. user object, jwt token or sth else.

I like the way that class-validator let us define our custom validation decorators:
https://github.com/pleerock/class-validator#custom-validation-decorators

It would be great if we could write custom decorators function to extract objects from request rather than forking and patching routing-controllers. It could be done the same way - the decorator function should call registerParamHandler with config object with required data (like in ParamMetadataArgs) and handler field - the function to call to extract:

export function CustomDecorator(customParam?: customType) {
    return function (object: Object, methodName: string, index: number) {
        let format = (Reflect as any).getMetadata("design:paramtypes", object, methodName)[index];
        registerParamHandler({
            reflectedType: format,
            isRequired: true,
            classTransformOptions: undefined,
            // other settings here
            handler: (req: Request) => {
                // do the extract operation here
                if (customParam == someValue) {
                    return req.property.more.arr[someValue];
                } else {
                    return req.property.more.value;
                }
            }
        });
    };
}

The handlers could be pushed to array of handlers and in core of routing-controllers, after matching standard param types it could traverse throught this array, call the handlers and do the transform magic 😀

[pleerock]

Here is how I do it right now in my project:

/**
 * Extends routing-controllers and socket-controllers functionality and allows to inject currently
 * authorized user (SessionUser) into controller's actions.
 */
export function InjectSessionUser(options?: { required?: boolean }) {
    return function(object: Object, methodName: string, index: number) {
        const reflectedType = (Reflect as any).getMetadata("design:paramtypes", object, methodName)[index];

        // add special param handler to routing-controllers library
        defaultRoutingMetadataArgsStorage().params.push({
            target: object.constructor,
            method: methodName,
            index: index,
            type: RoutingParamTypes.CUSTOM_CONVERTER,
            reflectedType: reflectedType,
            parseJson: false,
            isRequired: false,
            format: reflectedType,
            transform: (value, request) => handleUserAuthorization(request.headers["authorization"], options)
        });

    };
}

Yes, I agree that we need provide an easy way to create user's custom decorators like in class-validator and make it even easier.

[MichalLytek]

I've done some research and I've found the ParamTypes.CUSTOM_CONVERTER type but it's not used anywhere in the code. So it's a kinda "backdoor" that allows you to use this lib in bigger projects? 😉

There is already the transform function defined in ParamMetadata and ParamMetadataArgs:

/**
 * Transforms the value.
 */
transform?: (value?: any, request?: any, response?: any) => Promise<any>|any;

And it's used here in handleParam. Moving this part of code and move it to one place into Driver.prototype.getParamFromRequest by adding a case is a potentialy breaking change because someone might use transform without ParamTypes.CUSTOM_CONVERTER, am I right?

So I think we should add to ParamMetadata property like requestExtractionHandler, extractionHandler, requestTransform or requestExtractor and then add switch's case in getParamFromRequest:

case ParamTypes.CUSTOM_CONVERTER:
    return param.requestTransform(request);

I will do the simple wrapper around your sample code, then creating decorators will looks like this:

export function InjectSessionUser(options?: { required?: boolean }) {
    return createCustomParamDecorator({
        isRequired: required || false,
        requestTransform: (request) => handleUserAuthorization(request.headers["authorization"], options),
        // other options like validator or classTransformOptions
    });
}

createCustomParamDecorator will be a factory returning a function with signature (object: Object, methodName: string, index: number) which hide the common code and calls defaultRoutingMetadataArgsStorage stuffs 😄

[dkirchhof]

Hey,
when using a custom decorator with "required" param set to true, it wouldn't throw an error, if "value" returns null.

import { createParamDecorator } from "routing-controllers";
 
export default function MyUser()
{
    return createParamDecorator(
    {
        required: true,
        value: actionProperties =>
        {
            if(actionProperties.request.headers["authorization"])
            {
                return User.fromToken(...);
            }

            return null;
        }
    });
}

@Get("/")
async all(@MyUser() user: User): Promise<any[]>
{
   // should automatically throw an error, when authorization header is not present
    console.log(user);  
    ...
}

Am i missing anything? Should i throw the error in the decorator function?

[NoNameProvided]

Have you tried undefined?

[dkirchhof]

I also tried undefined, but no error.
Btw.: I just want to use the CurrentUser decorator without always have to define "required: true".

[pleerock]

I just want to use the CurrentUser decorator without always have to define "required: true".

What if you do it this way:

export default function CurrentUserAlwaysRequired()
{
    return CurrentUser({ required: true });
}

[pleerock]

implemented in 0.7.0

[Aleksaas]

I also have a problem with decorator not throwin error when null is returned. Any solution to this?

[github-actions]

This issue has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.