add basic database schema and auth setup

Author: nl32

package-lock.json

@@ -18,7 +18,7 @@
     "@auth/drizzle-adapter": "^0.3.2",
     "@hookform/resolvers": "^3.3.2",
     "@neondatabase/serverless": "^0.10.2",
-    "@next/third-parties": "^14.2.15",
+    "@next/third-parties": "^15.4.6",
     "@radix-ui/react-alert-dialog": "^1.0.5",
     "@radix-ui/react-dialog": "^1.1.2",
     "@radix-ui/react-dropdown-menu": "^2.0.6",
@@ -37,8 +37,8 @@
     "dotenv": "^16.0.3",
     "drizzle-orm": "^0.44.3",
     "drizzle-zod": "^0.8.2",
-    "next": "^14.2.2",
-    "next-auth": "^4.23.0",
+    "next": "^15.4.6",
+    "next-auth": "^4.24.11",
     "postgres": "^3.3.5",
     "react": "^18.2.0",
     "react-day-picker": "^8.9.1",

package.json

@@ -0,0 +1,7 @@
+import NextAuth from 'next-auth';
+
+import { authOptions } from '@src/server/auth';
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const handler = NextAuth(authOptions);
+export { handler as GET, handler as POST };

src/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,113 @@
+import {
+  getServerSession,
+  type NextAuthOptions,
+  type DefaultSession,
+} from 'next-auth';
+import GoogleProvider from 'next-auth/providers/google';
+import DiscordProvider from 'next-auth/providers/discord';
+import { env } from '@src/env.mjs';
+import { DrizzleAdapter } from '@auth/drizzle-adapter';
+import { db } from './db';
+import { eq } from 'drizzle-orm';
+import { type SelectUserMetadata, type InsertUserMetadata } from './db/models';
+import { pgTable } from 'drizzle-orm/pg-core';
+import { userMetadata } from './db/schema/user';
+
+/**
+ * Module augmentation for `next-auth` types. Allows us to add custom properties to the `session`
+ * object and keep type safety.
+ *
+ * @see https://next-auth.js.org/getting-started/typescript#module-augmentation
+ */
+declare module 'next-auth' {
+  interface Session extends DefaultSession {
+    user: {
+      id: string;
+      // ...other properties
+      // role: UserRole;
+    } & DefaultSession['user'] &
+      SelectUserMetadata;
+  }
+
+  // interface User {
+  //   // ...other properties
+  //   // role: UserRole;
+  // }
+}
+
+export interface PreviewUser {
+  id: string;
+  name: string;
+  email: string;
+  image: string;
+}
+
+/**
+ * Options for NextAuth.js used to configure adapters, providers, callbacks, etc.
+ *
+ * @see https://next-auth.js.org/configuration/options
+ */
+
+export const authOptions: NextAuthOptions = {
+  adapter: DrizzleAdapter(db, pgTable),
+  callbacks: {
+    async session({ session, user }) {
+      let metadata = await db.query.userMetadata.findFirst({
+        where: (metadata) => eq(metadata.id, user.id),
+      });
+
+      if (!metadata) {
+        const firstName = user.name?.split(' ')[0] ?? '';
+        const lastName = user.name?.split(' ')[1] ?? '';
+
+        const insert: InsertUserMetadata = {
+          firstName,
+          lastName,
+          id: user.id,
+          major: 'Computer Science',
+        };
+
+        metadata = (
+          await db.insert(userMetadata).values(insert).returning()
+        ).at(0);
+      }
+
+      if (session.user) {
+        session.user = { ...session.user, ...metadata };
+        // session.user.role = user.role; <-- put other properties on the session here
+      }
+
+      return session;
+    },
+  },
+  pages: {
+    signIn: '/auth',
+  },
+  providers: [
+    GoogleProvider({
+      clientId: env.GOOGLE_CLIENT_ID,
+      clientSecret: env.GOOGLE_CLIENT_SECRET,
+    }),
+    DiscordProvider({
+      clientId: env.DISCORD_CLIENT_ID,
+      clientSecret: env.DISCORD_CLIENT_SECRET,
+    }),
+  ],
+
+  /**
+   * ...add more providers here.
+   *
+   * Most other providers require a bit more work than the Discord provider. For example, the
+   * GitHub provider requires you to add the `refresh_token_expires_in` field to the Account
+   * model. Refer to the NextAuth.js docs for the provider you want to use. Example:
+   *
+   * @see https://next-auth.js.org/providers/github
+   */
+};
+
+/**
+ * Wrapper for `getServerSession` so that you don't need to import the `authOptions` in every file.
+ *
+ * @see https://next-auth.js.org/configuration/nextjs
+ */
+export const getServerAuthSession = () => getServerSession(authOptions);

src/server/auth.ts

@@ -0,0 +1,15 @@
+import { drizzle } from 'drizzle-orm/neon-http';
+import { env } from '@src/env.mjs';
+
+import * as user from './schema/user';
+import * as file from './schema/file';
+import * as section from './schema/section';
+const schema = {
+  ...file,
+  ...section,
+  ...user,
+};
+
+export const db = drizzle(env.DATABASE_URL, {
+  schema,
+});

src/server/db/index.ts

@@ -0,0 +1,10 @@
+import { type z } from 'zod';
+import { createInsertSchema, createSelectSchema } from 'drizzle-zod';
+import { userMetadata } from './schema/user';
+
+// Schema types for userMetadata
+export const insertUserMetadata = createInsertSchema(userMetadata);
+export const selectUserMetadata = createSelectSchema(userMetadata);
+
+export type InsertUserMetadata = z.infer<typeof insertUserMetadata>;
+export type SelectUserMetadata = z.infer<typeof selectUserMetadata>;

src/server/db/models.ts

@@ -0,0 +1,20 @@
+import { relations, sql } from 'drizzle-orm';
+import { pgTable, text } from 'drizzle-orm/pg-core';
+import { user } from './user';
+import { section } from './section';
+
+export const file = pgTable('file', {
+  id: text('id')
+    .default(sql`nanoid(20)`)
+    .primaryKey(),
+  authorId: text('author_id')
+    .notNull()
+    .references(() => user.id),
+  sectionId: text('section_id').references(() => section.id),
+  file_url: text('file_url').notNull(),
+});
+
+export const fileRelations = relations(file, ({ one }) => ({
+  author: one(user),
+  section: one(section),
+}));

src/server/db/schema/file.ts

@@ -0,0 +1,13 @@
+import { relations, sql } from 'drizzle-orm';
+import { pgTable, text } from 'drizzle-orm/pg-core';
+import { file } from './file';
+
+export const section = pgTable('section', {
+  id: text('id')
+    .default(sql`nanoid(20)`)
+    .primaryKey(),
+});
+
+export const sectionRelations = relations(section, ({ many }) => ({
+  files: many(file),
+}));

src/server/db/schema/section.ts

@@ -0,0 +1,79 @@
+import { relations } from 'drizzle-orm';
+import {
+  integer,
+  pgEnum,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+} from 'drizzle-orm/pg-core';
+import { type AdapterAccount } from 'next-auth/adapters';
+import { file } from './file';
+
+export const yearEnum = pgEnum('year', [
+  'Freshman',
+  'Sophomore',
+  'Junior',
+  'Senior',
+  'Grad Student',
+]);
+
+export const user = pgTable('user', {
+  id: text('id').notNull().primaryKey(),
+  name: text('name'),
+  email: text('email').notNull(),
+  emailVerified: timestamp('emailVerified', { mode: 'date' }),
+  image: text('image'),
+});
+
+export const userMetadata = pgTable('user_metadata', {
+  id: text('id').notNull().primaryKey(),
+  firstName: text('first_name').notNull(),
+  lastName: text('last_name').notNull(),
+  major: text('major').notNull(),
+  minor: text('minor'),
+  year: yearEnum('year')
+    .$default(() => 'Freshman')
+    .notNull(),
+});
+
+export const accounts = pgTable(
+  'account',
+  {
+    userId: text('userId')
+      .notNull()
+      .references(() => user.id, { onDelete: 'cascade' }),
+    type: text('type').$type<AdapterAccount['type']>().notNull(),
+    provider: text('provider').notNull(),
+    providerAccountId: text('providerAccountId').notNull(),
+    refresh_token: text('refresh_token'),
+    access_token: text('access_token'),
+    expires_at: integer('expires_at'),
+    token_type: text('token_type'),
+    scope: text('scope'),
+    id_token: text('id_token'),
+    session_state: text('session_state'),
+  },
+  (t) => [primaryKey({ columns: [t.provider, t.providerAccountId] })],
+);
+
+export const sessions = pgTable('session', {
+  sessionToken: text('sessionToken').notNull().primaryKey(),
+  userId: text('userId')
+    .notNull()
+    .references(() => user.id, { onDelete: 'cascade' }),
+  expires: timestamp('expires', { mode: 'date' }).notNull(),
+});
+
+export const verificationTokens = pgTable(
+  'verificationToken',
+  {
+    identifier: text('identifier').notNull(),
+    token: text('token').notNull(),
+    expires: timestamp('expires', { mode: 'date' }).notNull(),
+  },
+  (vt) => [primaryKey({ columns: [vt.identifier, vt.token] })],
+);
+export const userMetadataRelations = relations(user, ({ many }) => ({
+  files: many(file),
+}));

src/server/db/schema/user.ts

@@ -0,0 +1,10 @@
+import { headers } from 'next/headers';
+
+export async function signInRoute(route: string) {
+  const headerz = await headers();
+  const host = headerz.get('X-Forwarded-Host');
+  const proto = headerz.get('X-Forwarded-Proto');
+  return `/auth?callbackUrl=${encodeURIComponent(
+    `${proto}://${host}/${route}`,
+  )}`;
+}