Had to change Int to Number to solve CannotDetermineGraphQLTypeError

[secretreagent]

I see that Int is used instead of Number. For example:
@Field(() => Int)
And also in resolver @Args
However, I had to change them all to Number to solve CannotDetermineGraphQLTypeError. Why is this happening to me?

[MichalLytek]

Please provide full snippet of your resolver

[secretreagent]

Yes sir.

TaxonResolver.ts

import {
  Arg,
  FieldResolver,
  Mutation,
  Query,
  Resolver,
  Root
} from 'type-graphql';

import AppDataSource from '../data-source.js';
import ResolverUtils from '../utils/ResolverUtils.js';
import { Taxon } from '../entities/Taxon.js';
import { TaxonName, TaxonNameType } from '../entities/TaxonName.js';
import { TaxonRank } from '../entities/TaxonRank.js';
import { Taxon_x_TaxonName } from '../entities/junctions/Taxon_x_TaxonName.js';
import { NewTaxon, TaxonFilter } from '../inputs/Taxon.js';
import { type_x_identifier } from '../enums/taxonNames.js';


@Resolver()
export class TaxonResolver {

  @Query(() => [Taxon])
  async taxons(
    @Arg('filter', () => TaxonFilter, { nullable: true }) filter?: TaxonFilter
  ) {
    const { ids, ncbi_ids, rank_ids, is_inclusive = true } = filter ?? {};

    let where: any;
    if (is_inclusive) {
      where = [
        ResolverUtils.in<Taxon>('id', ids),
        ResolverUtils.in<Taxon>('ncbi_id', ncbi_ids),
        ResolverUtils.in<Taxon>('rank_id', rank_ids),
      ]
    } else {
      where = {
        ...ResolverUtils.in<Taxon>('id', ids),
        ...ResolverUtils.in<Taxon>('ncbi_id', ncbi_ids),
        ...ResolverUtils.in<Taxon>('rank_id', rank_ids),
      };
    }

    return AppDataSource.getRepository(Taxon).find({
      where: where,
      relations: ['rank']
    })
  }
  
  @Mutation(() => Taxon)
  async createTaxon(
    @Arg('input') input: NewTaxon
  ): Promise<Taxon> {
    const taxonRepository = AppDataSource.getRepository(Taxon);
    const rankRepository = AppDataSource.getRepository(TaxonRank);
    const nameRepository = AppDataSource.getRepository(TaxonName);
    const junctionRepository = AppDataSource.getRepository(Taxon_x_TaxonName);

    return await AppDataSource.transaction(async (transactionalEntityManager) => {
      
      // 1. Handle Rank - find or create
      let rank: TaxonRank;
      const existingRank = await transactionalEntityManager.findOne(TaxonRank, {
        where: { name: input.rank.name }
      });

      if (existingRank) {
        rank = existingRank;
      } else {
        rank = transactionalEntityManager.create(TaxonRank, {
          name: input.rank.name
        });
        rank = await transactionalEntityManager.save(rank);
      }

      // 2. Create the main Taxon entity
      const taxon = transactionalEntityManager.create(Taxon, {
        ncbi_id: input.ncbi_id,
        rank: rank
      });
      
      const savedTaxon = await transactionalEntityManager.save(taxon);

      // 3. Handle Taxon Names and Junction table
      if (input.names && input.names.length > 0) {
        console.log(`input.names: ${JSON.stringify(input.names, null, 2)}`)
        for (const nameInput of input.names) {
          let taxonName: TaxonName;

          // Map GraphQL uppercase enum to lowercase TS enum value
          const mappedType = nameInput.type ? type_x_identifier[nameInput.type] ?? TaxonNameType.UNKNOWN : TaxonNameType.UNKNOWN;

          // Try to find an existing name with the same name + type
          const existingName = await transactionalEntityManager.findOne(TaxonName, {
            where: { name: nameInput.name, _type: nameInput.type },
          });

          if (existingName) {
            taxonName = existingName;
          } else {
            // Create new taxon name with name + type
            taxonName = transactionalEntityManager.create(TaxonName, {
              name: nameInput.name,
              _type: nameInput.type ?? TaxonNameType.UNKNOWN, // fallback if not provided
            });
            taxonName = await transactionalEntityManager.save(taxonName);
          }

          // Create junction table entry
          const junction = transactionalEntityManager.create(Taxon_x_TaxonName, {
            taxon: savedTaxon,
            name: taxonName,
          });

          await transactionalEntityManager.save(junction);
        }
      }

      // 4. Return the complete taxon with relations
      const fullTaxon = await transactionalEntityManager.findOne(Taxon, {
        where: { id: savedTaxon.id },
        relations: ['rank', 'name_links', 'name_links.name']
      });

      if (!fullTaxon) {
        throw new Error("Taxon not found after save");
      }

      return fullTaxon;
    });
  }

}

@Resolver(() => Taxon)
export class TaxonFieldResolver {

  @FieldResolver(() => [TaxonName])
  async names(@Root() x: Taxon): Promise<TaxonName[]> {
    const links = await AppDataSource.getRepository(Taxon_x_TaxonName).find({
      where: { taxon: { id: x.id } },
      relations: ['name'],
    });
    return links.map((x) => x.name);
  }

}

inputs/Taxon.ts

import { 
	Field,
	InputType,
	Int } from 'type-graphql';

import { TaxonNameInput } from './TaxonName.js';
import { RankInput } from '../inputs/TaxonRank.js';


@InputType()
export class TaxonFilter {
  
  @Field(() => [Number], { nullable: true })
  ids?: number[];

  @Field(() => [Number], { nullable: true })
  ncbi_ids?: number[];

  @Field(() => [Number], { nullable: true })
  rank_ids?: number[];

  @Field(() => Boolean, { nullable: true, defaultValue: true })
  is_inclusive?: boolean;

}

@InputType()
export class NewTaxon {

  @Field(() => Number)
  ncbi_id!: number;

  @Field(() => RankInput)
  rank!: RankInput;

  @Field(() => [TaxonNameInput])
  names!: TaxonNameInput[];

}

ResolverUtils.ts

import { In } from 'typeorm';


export default class ResolverUtils {

	/**
   * Returns a TypeORM where filter for a field if the array is non-empty,
   * otherwise returns undefined (no filtering)
	 * if (ids && ids.length > 0) {
   *   return repo.find({
   *     where: { id: In(ids) }, <- returns where clause here
   *     relations: [],
   *   });
   * }
   */
  static in<T>(col_name: keyof T, items?: (string | number)[]) {
		return items?.length ? { [col_name]: In(items) } : {};
	}

}

[MichalLytek]

And if you do:

@Field(() => [Int], { nullable: true })
ids?: number[];

It throws the error? How do you build the schema?