Adapter not populating fields from profile callback

[kilinkis]

I'm using the T3 stack, with drizzle.

For some reason I can't find out, when the user logs in and the record is created in the DB, none of the fields I return in the profile callback are stored.

is it meant to work like that? as a workaround, I'm using signIn to update the db, but feels a little hacky.

Here is my code for auth.ts

export const authOptions: NextAuthOptions = {
  callbacks: {
    jwt: async ({ token, user }) => {
      console.log("user jwt", user);
      return { ...token, ...user };
    },
    session: ({ session, user }) => {
      console.log("user in session (from db)", user, session);
      return {
        ...session,
        user: {
          ...session.user,
          id: user.id,
          name: user.name,
        },
      };
    },
    async signIn({ user, account, profile }) {
      try {
        await db
          .update(users)
          .set({ name: profile.name })
          .where(eq(users.id, user.id));
        return true; // Return true to indicate successful sign-in
      } catch (error) {
        console.error("Error updating user:", error);
        return false; // Return false to indicate failed sign-in
      }
    },
  },
  adapter: DrizzleAdapter(db, {
    usersTable: users,
    accountsTable: accounts,
    sessionsTable: sessions,
    verificationTokensTable: verificationTokens,
  }) as Adapter,
  providers: [
    {
      /
      *
      
custom provider fields removed for brefety*
/

      async profile(profile, tokens) {

        const fields = {
          id: profile.id,
          name: profile.username,
        };
        console.log("fields", fields);
        return fields;
      },
    },
  ],
};

and here's my schema:

export const users = createTable(
  "user",
  {
    id: varchar("id", { length: 255 })
      .notNull()
      .primaryKey()
      .$defaultFn(() => crypto.randomUUID()),
    name: varchar("name", { length: 255 }),
    username: varchar("username", { length: 256 }),
    email: varchar("email", { length: 255 }),
    emailVerified: timestamp("email_verified", {
      mode: "date",
      withTimezone: true,
    }).default(sql`CURRENT_TIMESTAMP`),
    image: varchar("image", { length: 255 }),
    accessToken: varchar("access_token", { length: 512 }),
    accessTokenSecret: varchar("access_token_secret", {
      length: 512,
    }),
    createdAt: timestamp("created_at", { withTimezone: true })
      .default(sql`CURRENT_TIMESTAMP`)
      .notNull(),
    updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(
      () => new Date(),
    ),
  },
  (users) => ({
    emailIndex: index("email_idx").on(users.email),
  }),
);

export const usersRelations = relations(users, ({ many }) => ({
  accounts: many(accounts),
}));

export const accounts = createTable(
  "account",
  {
    userId: varchar("user_id", { length: 255 })
      .notNull()
      .references(() => users.id),
    type: varchar("type", { length: 255 })
      .$type<AdapterAccount["type"]>()
      .notNull(),
    provider: varchar("provider", { length: 255 }).notNull(),
    providerAccountId: varchar("provider_account_id", {
      length: 255,
    }).notNull(),
    refresh_token: text("refresh_token"),
    access_token: text("access_token"),
    expires_at: integer("expires_at"),
    token_type: varchar("token_type", { length: 255 }),
    scope: varchar("scope", { length: 255 }),
    id_token: text("id_token"),
    session_state: varchar("session_state", { length: 255 }),
  },
  (account) => ({
    compoundKey: primaryKey({
      columns: [account.provider, account.providerAccountId],
    }),
    userIdIdx: index("account_user_id_idx").on(account.userId),
  }),
);