GraphQL - How can I tell if my delete mutation has been created?

Question

My react, apollo, prisma, nextjs typescript app seems to think I have not made a deleteIssueGroup mutation. I think I have.

I am using:

"devDependencies": {
    "@graphql-codegen/add": "3.2.1",
    "@graphql-codegen/cli": "2.13.7",
    "@graphql-codegen/typescript": "2.8.0",
    "@graphql-codegen/typescript-operations": "2.5.5",
    "@graphql-codegen/typescript-react-apollo": "3.3.5",
    "@types/cookie": "0.5.1",
    "@types/react": "17.0.51",
    "@types/react-dom": "17.0.17",
    "eslint-config-next": "12.3.1"
  

It's strange because I defined a deleteGroup mutation at the same time as I made the createGroup mutation and the AllGroups query, but my app thinks I don't have a deleteGroup mutation (it's right, the @generated file doesn't have it in there - except for it being listed in the list of mutations - there are no individual line items in graphql.tsx that define useDeleteIssueMutation in the same way that there are such lines for the create type). I don't know why. Is there a way to force the creation, or the recognition that there is only one of everything?

I can see in my graphql.tsx that I have:

export type MutationDeleteGroupArgs = {
  id: Scalars['String'];
};

which I think means I should have the delete mutation, but in the form, when I'm trying to use it, I get an error in the terminal that says it doesn't exist.

When I run my yarn db:migrate script, it goes through the motions of running the prisma migrations (they are all up to date, but it then runs the code gen and concludes successfully).

My code is (I made a new one called IssueGroup to try and see if it was just a random unlucky twist that is causing this mess):

Prisma model

model IssueGroup {
  id              String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
  title           String
  description     String
  issues          Issue[]
  createdAt       DateTime @default(now()) @db.Timestamptz(6)
  updatedAt       DateTime @default(now()) @updatedAt @db.Timestamptz(6)
}

model

import * as Prisma from "@prisma/client"
import { Field, ObjectType } from "type-graphql"

import { BaseModel } from "../shared/base.model"

@ObjectType()
export class IssueGroup extends BaseModel implements Prisma.IssueGroup {
  @Field()
  title: string

  @Field()
  description: string

  

  @Field(type => String)
  issues: Prisma.Issue[];

  
}

group service:

import { prisma } from "../../lib/prisma"
import { Service } from "typedi"
import { IssueGroupInput } from "./inputs/create.input"

import { Resolver } from "type-graphql"
import { IssueGroup } from "./issueGroup.model"

@Service()
@Resolver(() => IssueGroup)
export class IssueGroupService {
  async createIssueGroup(data: IssueGroupInput) {
    return await prisma.issueGroup.create({
      data,
    })
  }

  async deleteIssueGroup(id: string) {
    return await prisma.issueGroup.delete({ where: { id } })
  }

  async updateIssueGroup(id: string, data: IssueGroupInput) {
    const issueGroup = await prisma.issueGroup.findUnique({ where: { id } })
    if (!issueGroup) {
      throw new Error("Issue not found")
    }
    return await prisma.issueGroup.update({ where: { id }, data })
  }

  async getAllIssueGroups() {
    return await (await prisma.issueGroup.findMany({orderBy: {title: 'asc'}}))
  }

  async getIssueGroup(id: string) {
    return await prisma.issueGroup.findUnique({
      where: {
        id,
      },
    })
  }
}

resolver

import { Arg,  Mutation,  Query, Resolver } from "type-graphql"
import { IssueGroup } from "./issueGroup.model"
import { IssueGroupService } from "./issueGroup.service"
import { IssueGroupInput } from "./inputs/create.input"
import { Inject, Service } from "typedi"

@Service()

@Resolver(() => IssueGroup)

export default class IssueGroupResolver {
    @Inject(() => IssueGroupService)
        issueGroupService: IssueGroupService

    @Query(() => [IssueGroup])
        async issueGroups() {
            return await this.issueGroupService.getAllIssueGroups()
        }
    
    @Query(() => IssueGroup)
    async issueGroup(@Arg("id") id: string) {
        return await this.issueGroupService.getIssueGroup(id)
    }

    @Mutation(() => IssueGroup)
    async createIssueGroup(@Arg("data") data: IssueGroupInput) {
        return await this.issueGroupService.createIssueGroup(data)
    }
        // : Promise<IssueGroup[]> {

    
    @Mutation(() => IssueGroup)
    async updateIssueGroup(
        @Arg("id") id: string,
        @Arg("data") data: IssueGroupInput
    ) {
        return this.issueGroupService.updateIssueGroup(id, data)
    }
    
    @Mutation(() => IssueGroup)
    async deleteIssueGroup(@Arg("id") id: string) {
        return this.issueGroupService.deleteIssueGroup(id)
    }
}

I have seen this post and can see the warning about naming queries uniquely - but I cannot see how I have offended the principle.

I have seen this post and tried following the suggestion to change my codegen.yml from:

documents:
  - "src/components/**/*.{ts,tsx}"
  - "src/lib/**/*.{ts,tsx}"
  - "src/pages/**/*.{ts,tsx}"

to:

documents:
  - "src/components/**/!(*.types).{ts,tsx}"
  - "src/lib/**/!(*.types).{ts,tsx}"
  - "src/pages/**/!(*.types).{ts,tsx}"

but I still get the same issue - my vsCode is suggesting I might want to use create instead of delete.