我有两个相关的模型：
1.-角色实体

import { Column, Entity, BaseEntity, OneToMany, PrimaryColumn } from "typeorm";
import { Field, ObjectType } from "type-graphql";

import { UserEntity } from "./user.entity";

@ObjectType()
@Entity({
    name: "tb_roles"
})
export class RoleEntity extends BaseEntity {

    @Field()
    @PrimaryColumn({
        name: "id",
        type: "character varying",
        length: 5
    })
    id!: string;

    @Field()
    @Column({
        name: "description",
        type: "character varying",
        nullable: true
    })
    description!: string

    @Field(() => [UserEntity])
    @OneToMany(() => UserEntity, user => user.role)
    users!: UserEntity[];
}

2.-用户实体

import {Field, ObjectType} from "type-graphql";
import { BaseEntity, Column, CreateDateColumn, Entity, JoinColumn, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";

import { RoleEntity } from "./role.entity";

@ObjectType()
@Entity({
    name: "tb_users"
})
export class UserEntity extends BaseEntity {
    @Field()
    @PrimaryGeneratedColumn("uuid", {
        name: "id"
    })
    id!: string;

    @Field()
    @Column({
        name: "username",
        type: "character varying",
        unique: true,
        nullable: false
    })
    username!: string;

    @Field()
    @Column({
        name: "last_name",
        type: "character varying",
        nullable: false
    })
    lastName!: string;

    @Field()
    @Column({
        name: "mother_last_name",
        type: "character varying",
        nullable: true
    })
    motherLastName!: string;

    @Field()
    @Column({
        name: "first_name",
        type: "character varying",
        nullable: false
    })
    firstName!: string;

    @Field()
    @Column({
        name: "middle_name",
        type: "character varying",
        nullable: true
    })
    middleName!: string;

    @Field()
    @Column({
        name: "email",
        type: "character varying",
        unique: true,
        nullable: false
    })
    email!: string;

    @Field()
    @Column({
        name: "password",
        type: "character varying",
        nullable: false
    })
    password!: string;

    @Field(() => RoleEntity)
    @ManyToOne(() => RoleEntity)
    @JoinColumn({name: "role_id"})
    role!: RoleEntity;

    @Field()
    @Column({
        name: "is_active",
        type: "character varying",
        nullable: true
    })
    isActive!: boolean;

    @Field()
    @CreateDateColumn({
        name: "created_at"
    })
    createdAt!: string;

    @Field()
    @UpdateDateColumn({
        name: "updated_at"
    })
    updatedAt!: string;
}

这是用户的解析程序：

import {Arg, Mutation, Query, Resolver} from "type-graphql";
import bcrypt from "bcryptjs";

import {UserEntity} from "../../entity/user.entity";
import {RoleEntity} from "../../entity/role.entity";

@Resolver()
export class UserResolver {
    @Query(() => [UserEntity])
    async users() {
        return await UserEntity.find();
    }

    @Mutation(() => UserEntity)
    async createUser(
        @Arg('username') username: string,
        @Arg('lastName') lastName: string,
        @Arg('motherLastName') motherLastName: string,
        @Arg('firstName') firstName: string,
        @Arg('middleName') middleName: string,
        @Arg('email') email: string,
        @Arg('password') password: string,
        @Arg('role') role: RoleEntity,
        @Arg('isActive') isActive: boolean
    ): Promise<UserEntity> {

        const hashedPassword = await bcrypt.hashSync(password, bcrypt.genSaltSync(10));

        const user = UserEntity.create({
            username,
            lastName,
            motherLastName,
            firstName,
            middleName,
            email,
            password: hashedPassword,
            role,
            isActive
        }).save();

        return user;
    }
}

但是，我得到这个错误：
(node：14788）未处理承诺拒绝警告：错误：无法确定“UserResolver”类的“createUser”的名为“role”的参数的GraphQL输入类型。用作其TS类型或显式类型的值是否使用正确的装饰器装饰，或者它是否是正确的输入值？
我需要你的帮助。