How to write GraphQL-Prisma queries for Next-Auth User obejcts.

[EricPezzulo]

Question 💬

I'd like to write some GraphQL Nexus queries on behalf of the User object Next-Auth creates. I don't really know where to start though considering I don't have a User object type defined anywhere because Next-Auth takes care of all of that for you. I already adjusted the prisma.schema file as well.

I'd like to query for all the favorite animals of the current user. I can edit the fields just fine in prisma studio, but where can I edit and extend upon these queries. Next-Auth doesn't create a file that you can look at and adjust.

I have a Animals.ts file where I define the objectType and write the logic for the queries and mutations.

How / where can I do something similar for the User model Next-Auth creates for me?
Beause as of now, even though Animal and User are related and you can see the relation in prisma studio, prisma doesnt recognize user as a an object type. (I'm not exporting any objectType for User)

How to reproduce ☕️

//prisma.schema

model Animal {
  id                    String        @id @default(cuid())
  createdAt             DateTime      @default(now())
  updatedAt             DateTime      @updatedAt
  imageUrl              String        
  name                  String        
  species               String      
  dob                   String
  breed                 String
  color                 String
  gender                String
  weight                String
  childFriendly         Boolean
  catFriendly           Boolean
  dogFriendly           Boolean
  vaccinationsUptoDate  Boolean
  description           String
  additionalInfo        String?
  favoritedBy           User?   @relation(fields: [userId], references:[id])
  userId                String?

}

model Account {
  id                 String  @id @default(cuid())
  userId             String
  type               String
  provider           String
  providerAccountId  String
  refresh_token      String?  @db.Text
  access_token       String?  @db.Text
  expires_at         Int?
  token_type         String?
  scope              String?
  id_token           String?  @db.Text
  session_state      String?
  oauth_token_secret String?
  oauth_token        String?

  user User @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@unique([provider, providerAccountId])
}

model Session {
  id           String   @id @default(cuid())
  sessionToken String   @unique
  userId       String
  expires      DateTime
  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
}

model User {
  id              String    @id @default(cuid())
  name            String?
  email           String?   @unique
  emailVerified   DateTime? @map("email_verified")
  image           String?
  accounts        Account[]
  sessions        Session[]
  favoriteAnimals Animal[]
}

model VerificationToken {
  identifier String
  token      String   @unique
  expires    DateTime

  @@unique([identifier, token])
}

//Animals.ts

import {
  booleanArg,
  extendType,
  nonNull,
  nullable,
  objectType,
  stringArg,
} from "nexus";

export const Animal = objectType({
  name: "Animal",
  definition(t) {
    t.string("id");
    t.string("species");
    t.string("name");
    t.string("dob");
    t.string("breed");
    t.string("color");
    t.string("gender");
    t.string("weight");
    t.boolean("childFriendly");
    t.boolean("dogFriendly");
    t.boolean("catFriendly");
    t.boolean("vaccinationsUptoDate");
    t.string("description");
    t.string("additionalInfo");
    t.string("imageUrl");
  },
});

export const FetchAllAnimals = extendType({
  type: "Query",
  definition(t: any) {
    t.nonNull.list.field("fetchAllAnimals", {
      type: "Animal",
      async resolve(_root: any, _args: any, context: any) {
        return await context.prisma.animal.findMany();
      },
    });
  },
});

export const FetchAnimal = extendType({
  type: "Query",
  definition(t: any) {
    t.nonNull.list.field("fetchAnimal", {
      type: "Animal",
      args: {
        id: nonNull(stringArg()),
      },
      async resolve(_root: any, args: any, context: any) {
        return await context.prisma.animal.findMany({
          where: { id: args.id },
        });
      },
    });
  },
});
export const FetchFavoriteAnimals = extendType({
  type: "Query",
  definition(t: any) {
    t.nonNull.list.field("fetchFavoriteAnimals", {
      type: "Animal",
      args: {
        id: nonNull(stringArg()),
      },
      async resolve(_root: any, args: any, context: any) {
        return await context.prisma.animal.findMany({
          where: {
            user: {
              is: { id: "ckzk79zih0010bjfr2dcvrhog" },
            },
          },
        });
      },
    });
  },
});
export const FetchBySpecies = extendType({
  type: "Query",
  definition(t) {
    t.nonNull.list.field("fetchBySpecies", {
      type: "Animal",
      args: {
        species: nonNull(stringArg()),
      },
      async resolve(_root: any, args: any, context: any) {
        return await context.prisma.animal.findMany({
          where: {
            species: args.species,
          },
        });
      },
    });
  },
});

export const CreateNewAnimalListing = extendType({
  type: "Mutation",
  definition(t) {
    t.field("createNewAnimalListing", {
      type: "Animal",
      args: {
        name: nonNull(stringArg()),
        dob: nonNull(stringArg()),
        weight: nonNull(stringArg()),
        color: nonNull(stringArg()),
        gender: nonNull(stringArg()),
        breed: nonNull(stringArg()),
        species: nonNull(stringArg()),
        childFriendly: nonNull(booleanArg()),
        dogFriendly: nonNull(booleanArg()),
        catFriendly: nonNull(booleanArg()),
        vaccinationsUptoDate: nonNull(booleanArg()),
        description: nonNull(stringArg()),
        imageUrl: nonNull(stringArg()),
        additionalInfo: nullable(stringArg()),
      },
      async resolve(_root: any, args: any, context: any) {
        const newAnimal = {
          name: args.name,
          dob: args.dob,
          weight: args.weight,
          color: args.color,
          breed: args.breed,
          gender: args.gender,
          species: args.species,
          childFriendly: args.childFriendly,
          dogFriendly: args.dogFriendly,
          catFriendly: args.catFriendly,
          vaccinationsUptoDate: args.vaccinationsUptoDate,
          description: args.description,
          imageUrl: args.imageUrl,
          additionalInfo: args.additionalInfo,
        };
        return await context.prisma.animal.create({ data: newAnimal });
      },
    });
  },
});

export const DeleteAnimal = extendType({
  type: "Mutation",
  definition(t) {
    t.nonNull.field("deleteAnimal", {
      type: "Animal",
      args: {
        id: nonNull(stringArg()),
      },
      async resolve(_root: any, args: any, context: any) {
        return await context.prisma.animal.delete({
          where: {
            id: args.id,
          },
        });
      },
    });
  },
});

Contributing 🙌🏽

No, I am afraid I cannot help regarding this

[EricPezzulo]

As it turns out, all I had to do was create a User object type and export it just like I did with the Animal.ts file.
I guess I was worrying for no reason

//User.ts

import { extendType, objectType, nonNull } from "nexus";
import { Animal } from "./Animal";

export const User = objectType({
  name: "User",
  definition(t: any) {
    t.string("id"),
      t.string("name"),
      t.string("image"),
      t.string("email"),
      t.list.field("favoriteAnimals", {
        type: Animal,
        async resolve(parent: any, _args: any, context: any) {
          return await context.prisma.user
            .findUnique({
              where: {
                id: parent.id,
              },
            })
            .favoriteAnimals();
        },
      });
  },
});

export const FetchAllUsers = extendType({
  type: "Query",
  definition(t: any) {
    t.nonNull.list.field("fetchAllUsers", {
      type: "User",
      async resolve(_root: any, _args: any, context: any) {
        return await context.prisma.user.findMany();
      },
    });
  },
});

This works fine and pull up all the correct data from the Next-Auth user