Getting Current Session in GraphQL Nexus Mutations (Apollo, Prisma)

[0mjs]

Hey folks, having some difficulty at the moment with an Email/Google NextAuth setup.

Stack:
TypeScript, Next.js, NextAuth, Apollo, GraphQL, Nexus

What am I trying to do?:
Well, I'm trying to do exactly what NextAuth does for Account and Session, but for a created resource via a GraphQL Nexus Mutation. I want to add the userId that creates that resource to the resource itself. Such as Property containing userId or creatorId. Maybe kind of like how in other terms Post may have an Author, upon creation.

At the moment I can login fine with email links, or the Google login which is what I'm after, trying to avoid credentials. Anyway, I have some basic mutations setup and my schema.prisma file configured to add the Account and Session to my PostgreSQL database (hosted on Heroku, with a shadow db also hosted there).

On the client, I can get the session (inc. user ID) from useSession which is great. But my aim currently is to somehow pass the current session (and subsequent findUnique() if needed) where I can attach the userId to a resource they can create.

The main question
Is there a way via NextAuth to add the current session to every resolver/mutation? I have included a comment below on the line where I reference a "wishful thinking" function which could get the user data given a getCurrentUser(userId), where userId is gained from NextAuth getSession? Is this possible/the correct way to do so?

The code:

• [...nextauth].ts

import GoogleProvider from 'next-auth/providers/google'
import EmailProvider from 'next-auth/providers/email'
import { PrismaAdapter } from '@next-auth/prisma-adapter'
import { PrismaClient } from '@prisma/client'

const prisma = new PrismaClient()

export default NextAuth({
  secret: process.env.AUTH_SECRET,
  adapter: PrismaAdapter(prisma),
  callbacks: {
    async session({ session, token, user }) {
      session.id = user.id
      session.token = token
      return Promise.resolve(session)
    }
  },
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_ID,
      clientSecret: process.env.GOOGLE_SECRET,
    }),
    EmailProvider({
      server: {
        host: process.env.PROVIDER_SMTP_HOST,
        port: Number(process.env.PROVIDER_SMTP_PORT),
        auth: {
          user: process.env.PROVIDER_SMTP_USER,
          pass: process.env.PROVIDER_SMTP_PASSWORD,
        },
      },
      from: process.env.PROVIDER_SMTP_FROM,
    })
  ],
  cookies: cookiesPolicy,
  theme: {
    colorScheme: "light"
  }
})

• schema.prisma

// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
  shadowDatabaseUrl = env("SHADOW_DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

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?

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

  @@unique([provider, providerAccountId])
  @@map("account")
}

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

  @@map("session")
}

model User {
  id            String     @id @default(cuid())
  name          String?
  email         String?    @unique
  emailVerified DateTime?
  image         String?
  accounts      Account[]
  sessions      Session[]
  properties    Property[]

  @@map("user")
}

model VerificationToken {
  identifier String
  token      String   @unique
  expires    DateTime

  @@unique([identifier, token])
  @@map("token")
}

model Property {
  id          String   @id @default(cuid())
  userId  String? // I know this shouldn't be optional, but it should be here if I _can_ add userId to the create mutation
  address_one String
  address_two String?
  city        String
  post_code   String
  created_at  DateTime @default(now())
  updated_at  DateTime @updatedAt

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

  @@map("property")
}

• Property.ts - within graphql/types which are added to types: [] via Nexus makeSchema

import { objectType, extendType, stringArg, nonNull } from 'nexus'

export const Property = objectType({
  name: 'Property',
  definition(t) {
    t.string('id')
    t.string('creator_id')
    t.string('address_one')
    t.string('address_two')
    t.string('city')
    t.string('post_code')
  },
})

export const FindUniqueProperty = extendType({
  type: 'Query',
  definition: (t) => {
    t.nonNull.field('property', {
      type: 'Property',
      args: {
        id: nonNull(stringArg()),
      },
      resolve: (_, args, context) => {
        return context.prisma.property.findUnique({
          where: { id: args.id },
        })
      },
    })
  }
})

export const FindManyProperties = extendType({
  type: 'Query',
  definition: (t) => {
    t.list.field('properties', {
      type: 'Property',
        resolve(_root, _args, ctx) {
            return ctx.prisma.property.findMany()
        },
    })
  },
})

export const CreateProperty = extendType({
  type: 'Mutation',
  definition: (t) => {
    t.field('createOneProperty', {
      type: 'Property',
      args: {
        address_one: nonNull(stringArg()),
        address_two: stringArg(),
        city: stringArg(),
        post_code: stringArg(),
      },
      resolve: async (_, { address_one, address_two, city, post_code }, ctx) => {
        console.log(ctx.session)
        // const id = getUserId() // what I WOULD like to do, ideally
        // const user = ctx.prisma.user.findUnique({ where: { id: 'cl6e9pyih01843pn87fcr6dpi' }})
        return ctx.prisma.property.create({
          data: {
            address_one,
            address_two,
            post_code,
            city
          },
        })
      },
    })
  },
})

• User.ts

import { objectType, extendType, stringArg, nonNull } from 'nexus'
import { Property } from './Property'

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

export const UserQueries = extendType({
  type: 'Query',
  definition: (t) => {
    t.nonNull.field('user', {
      type: 'User',
      args: {
        userId: nonNull(stringArg()),
      },
      resolve: (_, args, context) => {
        return context.prisma.user.findUnique({
          where: { id: args.userId },
        })
      },
    })
  },
})

export const UserMutations = extendType({
  type: 'Mutation',
  definition: (t) => {
    t.field('createOneUser', {
      type: 'User',
      args: {
        name: stringArg(),
        email: nonNull(stringArg()),
      },
      resolve: async (_, { name, email }, context) => {
        return context.prisma.user.create({
          data: {
            name,
            email,
          },
        })
      },
    })
  },
})

Apologies for all the code, but I really want to use this stack in this way, I had this working with a Nest.js backend but want the simplicity of being within Next.js. Any help appreciated. - MS