How to add custom fields (firstName/lastName) into the database

[kaisiant]

After searched through the discussions, found this #805 but it does not help much. The first_name and last_name column still null in my database.

What I want to achieve:
Set the firstName and lastName from the provider (fb,google) and save it to database.

What I have done:
models/Users

import Adapters from "next-auth/adapters"

// Extend the built-in models using class inheritance
export default class User extends Adapters.TypeORM.Models.User.model {
  // You can extend the options in a model but you should not remove the base
  // properties or change the order of the built-in options on the constructor
  constructor(name, email, image, emailVerified, firstName, lastName) {
    super(name, email, image, emailVerified)
    
    if (firstName) {
      this.firstName = firstName
    }
    if (lastName) {
      this.lastName = lastName
    }
  }
}

export const UserSchema = {
  name: "User",
  target: User,
  columns: {
    ...Adapters.TypeORM.Models.User.schema.columns,
    firstName: {
      type: "varchar",
      nullable: true,
    },
    lastName: {
      type: "varchar",
      nullable: true,
    },
  },
}

models/index

// To make importing them easier, you can export all models from single file
import User, { UserSchema } from "./User"

export default {
  User: {
    model: User,
    schema: UserSchema,
  },
}

nextAuth

import NextAuth from "next-auth"
import Adapters from "next-auth/adapters"
import Providers from "next-auth/providers"
import Models from "../../../models"

export default NextAuth({
  // Configure one or more authentication providers
  providers: [
    Providers.Credentials({
      // The name to display on the sign in form (e.g. 'Sign in with...')
      name: "Credentials",
      // The credentials is used to generate a suitable form on the sign in page.
      // You can specify whatever fields you are expecting to be submitted.
      // e.g. domain, username, password, 2FA token, etc.
      credentials: {
        email: {
          label: "Email",
          type: "email",
          placeholder: "jsmith@gmail.com",
        },
        password: { label: "Password", type: "password" },
      },
      async authorize(credentials, req) {
        // You need to provide your own logic here that takes the credentials
        // submitted and returns either a object representing a user or value
        // that is false/null if the credentials are invalid.
        // e.g. return { id: 1, name: 'J Smith', email: 'jsmith@example.com' }
        // You can also use the `req` object to obtain additional parameters
        // (i.e., the request IP address)
        const res = await fetch("http://127.0.0.1:3333/api/auth/login", {
          method: "POST",
          body: JSON.stringify(credentials),
          headers: { "Content-Type": "application/json" },
        })
        const user = await res.json()

        // If no error and we have user data, return it
        if (res.ok && user) {
          return user
        }
        // Return null if user data could not be retrieved
        return null
      },
    }),
    Providers.Facebook({
      clientId: process.env.FACEBOOK_CLIENT_ID,
      clientSecret: process.env.FACEBOOK_CLIENT_SECRET,
      profileUrl:
        "https://graph.facebook.com/me?fields=email,first_name,last_name,picture",
      profile: (_profile) => {
        return {
          id: _profile.id,
          firstName: _profile.first_name,
          lastName: _profile.last_name,
          email: _profile.email,
          image: _profile.picture.data.url,
        }
      },
    }),
    Providers.Google({
      clientId: process.env.GOOGLE_CLIENT_ID,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
      profile: (_profile) => {
        return {
          id: _profile.id,
          firstName: _profile.given_name,
          lastName: _profile.family_name,
          email: _profile.email,
        }
      },
    }),
  ],
  debug: true,
  callbacks: {
    async signIn(user, account, profile) {
      return true
    },
    async redirect(url, baseUrl) {
      return baseUrl
    },
    async session(session, user) {
      const payload = {
        id: user.id,
        accessToken: session.accessToken,
        expires: session.expires,
      }
      const res = await fetch("http://127.0.0.1:3333/api/auth/generateToken", {
        method: "POST",
        body: JSON.stringify(payload),
        headers: { "Content-Type": "application/json" },
      })
      const data = await res.json()
      session.token = data.token.token
      session.user = {
        ...session.user,
        ...data.user,
      }
      return session
    },
  },
  // A database is optional, but required to persist accounts in a database
  // database: process.env.DATABASE_URL,
  adapter: Adapters.TypeORM.Adapter(
    // The first argument should be a database connection string or TypeORM config object
    process.env.DATABASE_URL!,
    // The second argument can be used to pass custom models and schemas
    {
      models: {
        User: Models.User,
      },
    }
  ),
})

[balazsorban44]

Duplicate of https://github.com/nextauthjs/adapters/discussions/197

[javierMorales9]

Link not working

[chiragcdclg]

LINK NOT WORKING

[hiromasa0629]

link not working

[coreyward]

@balazsorban44 That link just goes to a 404… should we open a new discussion?

[conklin20]

LINK NOT WORKING

yell it harder