Cannot determine GraphQL input type for argument named

Question

I have two relationed models:

1.- RoleEntity

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.- UserEntity

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;
}

And this is the resolver for user:

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;
    }
}

but, i get this error:

(node:14788) UnhandledPromiseRejectionWarning: Error: Cannot determine GraphQL input type for argument named 'role' of 'createUser' of 'UserResolver' class. Does the value used as its TS type or explicit type is decorated with a proper decorator or is it a proper input value?

I need your help please.

Answer 1

The error is because you can't use ObjectType arguments in mutations¹, just plain scalar types or InputType:
https://typegraphql.com/docs/resolvers.html#input-types

¹: the RoleEntity ObjectType in your case.

Answer 2

I solved my problem, I modified my two models, in UserEntity I removed:

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

and i added

@Field()
@Column({name: 'role_id'})
roleId!: string;

@Field(() => RoleEntity)
role!: RoleEntity;
@ManyToOne(() => RoleEntity, role => role.userConnection)
@JoinColumn({name: 'role_id'})
roleConnection!: Promise<RoleEntity>

and in RoleEntity, i added:

@OneToMany(() => UserEntity, user => user.roleConnection)
userConnection!: Promise<UserEntity[]>

But, I don't know if I'm doing my test in right way (Playground):

query users {
  users {
    firstName
    username
    roleId
    role {
      description
    }
  }
}

and part of the error is:

"message": "Cannot return null for non-nullable field UserEntity.role.",

Somebody can explain to me, what or where is the error?

Thanks.