Nestjs Decorator to mark Models properties as sortable and Validtor to check if given properties are sortable

Controller.ts

@Get()
    async get(
        @Req() req: Request,
        @Query() orderQueryParams?: OrderQueryParam<IItemResponse>
    ): Promise<{ items: IItemResponse[] }> {
     // your code here...     
    }

OrderQueryParam.ts

export class OrderQueryParam<T extends {}> {
    @IsOptional()
    @IsString()
    @IsAlphanumeric()
    @IsSortable(ItemResponse)
    orderBy: keyof T | undefined;

    @IsBoolean()
    @IsOptional()
    @Transform(params => params.value === "true" ? true : params.value === "false" ? false : undefined)
    asc: boolean | undefined;
}

ResponseItem.ts

export class ResponseItem {
    unsortable: anyType;
    @Sortable
    creationDate: number;
    @Sortable
    name: string;
}

Sortable.ts

import {registerDecorator, ValidationArguments, ValidationOptions} from "class-validator";

export const sortableFields = "sortableFields";

/**
 * Decorator to define which Properties can be used to order result list
 * @param target
 * @param key
 */
export function Sortable(target: {}, key: string): void {
    target[sortableFields] = target[sortableFields] !== undefined
        ? [...target[sortableFields], key]
        : [key];
}

/**
 * Check if a property is valid as order argument
 * @param ModelConstructor What model shall the property be validated against?
 * Use @Sortable to define sortable properties
 * @param validationOptions
 * @constructor
 */
export function IsSortable(
    ModelConstructor: new (...any) => {}, validationOptions?: ValidationOptions
): (object: Object, propertyName: string) => void {
    return (object: Object, propertyName: string): void => {
        registerDecorator({
            name: "isSortable",
            target: object.constructor,
            propertyName: propertyName,
            constraints: [ModelConstructor],
            options: validationOptions,
            validator: {
                defaultMessage() {
                    return "orderBy=$value is not allowed!";
                },
                validate(value: unknown, args: ValidationArguments) {
                    const [constructor] = args.constraints;
                    return typeof value === "string"
                        && typeof constructor === "function"
                        && constructor.prototype.sortableFields !== undefined
                        && constructor.prototype.sortableFields.includes(value);
                }
            }
        });
    };
}