feat: add tRPC and Drizzle ORM integration

Author: kyle1an

.editorconfig

@@ -5,7 +5,8 @@ root = true
 [*]
 charset = utf-8
 indent_style = space
-indent_size = 2
+# https://github.com/microsoft/vscode/issues/6447#issuecomment-221075881
+# indent_size = 2
 end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true

backend/.env.example

@@ -1,3 +1,3 @@
-SUPABASE_URL=
-SUPABASE_KEY=
-DATABASE_URL=
+PUBLIC_SUPABASE_URL=
+SUPABASE_ANON_KEY=
+POSTGRES_URL=

backend/app.ts

@@ -1,40 +1,64 @@
 import type { ErrorRequestHandler, NextFunction, Request, Response } from 'express'
 
+import * as trpcExpress from '@trpc/server/adapters/express'
 import cookieParser from 'cookie-parser'
 import cors from 'cors'
 import Debug from 'debug'
 import express from 'express'
 import createError from 'http-errors'
 import logger from 'morgan'
 import { createServer } from 'node:http'
-import path from 'node:path'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'pathe'
 
+import { userRouter } from './src/routes/auth.js'
 import routes from './src/routes/index.js'
+import { router } from './src/routes/trpc.js'
 
 const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
+const __dirname = dirname(__filename)
+
+function createContext({
+  req,
+  res,
+}: trpcExpress.CreateExpressContextOptions) {
+  return {}
+}
+type Context = Awaited<ReturnType<typeof createContext>>
 
 const app = express()
 
 app.use(cors({
+  origin: true,
   credentials: true,
   exposedHeaders: ['set-cookie'],
 }))
 
-app.set('views', path.join(__dirname, 'views'))
-app.set('view engine', 'hbs')
+export const appRouter = router({
+  user: userRouter,
+})
+
+export type AppRouter = typeof appRouter
+
+app.use(
+  '/trpc',
+  trpcExpress.createExpressMiddleware({
+    router: appRouter,
+    createContext,
+  }),
+)
 
 app.use(logger('dev'))
 app.use(express.json())
 app.use(express.urlencoded({ extended: false }))
 // need cookieParser middleware before we can do anything with cookies
 app.use(cookieParser())
 // let static middleware do its job
-app.use(express.static(path.join(__dirname, 'public')))
+app.use(express.static(join(__dirname, 'public')))
 
 app.use('/', routes)
+app.get(/favicon.*/, (req, res) => res.status(204).end())
 
 // catch 404 and forward to error handler
 app.use(function (req, res, next) {
@@ -46,9 +70,8 @@ app.use(function (err: Parameters<ErrorRequestHandler>[0], req: Request, res: Re
   res.locals.message = err.message
   res.locals.error = req.app.get('env') === 'development' ? err : {}
 
-  // render the error page
   res.status(err.status || 500)
-  res.render('error')
+  res.send('error')
 })
 
 const PORT = Number(process.env.PORT || '5001')
@@ -70,12 +93,10 @@ server.on('error', function onError(error: NodeJS.ErrnoException) {
   switch (error.code) {
     case 'EACCES':
       console.error(bind + ' requires elevated privileges')
-      process.exit(1)
-      break
+      throw error
     case 'EADDRINUSE':
       console.error(bind + ' is already in use')
-      process.exit(1)
-      break
+      throw error
     default:
       throw error
   }

backend/drizzle.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'drizzle-kit'
+
+import { env } from './env'
+
+export default defineConfig({
+  schemaFilter: ['auth', 'public'],
+  dialect: 'postgresql',
+  out: './drizzle',
+  schema: './drizzle/schema.ts',
+  dbCredentials: {
+    url: env.POSTGRES_URL,
+  },
+})

backend/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,2 @@
+{
+}

backend/drizzle/meta/_journal.json

@@ -0,0 +1,5 @@
+{
+  "version": "7",
+  "dialect": "postgresql",
+  "entries": []
+}

backend/drizzle/relations.ts

@@ -0,0 +1,112 @@
+import { relations } from "drizzle-orm/relations";
+import { flowStateInAuth, samlRelayStatesInAuth, ssoProvidersInAuth, ssoDomainsInAuth, mfaFactorsInAuth, mfaChallengesInAuth, sessionsInAuth, mfaAmrClaimsInAuth, samlProvidersInAuth, usersInAuth, oneTimeTokensInAuth, refreshTokensInAuth, identitiesInAuth, userVocabRecord, profiles } from "./schema";
+
+export const samlRelayStatesInAuthRelations = relations(samlRelayStatesInAuth, ({one}) => ({
+	flowStateInAuth: one(flowStateInAuth, {
+		fields: [samlRelayStatesInAuth.flowStateId],
+		references: [flowStateInAuth.id]
+	}),
+	ssoProvidersInAuth: one(ssoProvidersInAuth, {
+		fields: [samlRelayStatesInAuth.ssoProviderId],
+		references: [ssoProvidersInAuth.id]
+	}),
+}));
+
+export const flowStateInAuthRelations = relations(flowStateInAuth, ({many}) => ({
+	samlRelayStatesInAuths: many(samlRelayStatesInAuth),
+}));
+
+export const ssoProvidersInAuthRelations = relations(ssoProvidersInAuth, ({many}) => ({
+	samlRelayStatesInAuths: many(samlRelayStatesInAuth),
+	ssoDomainsInAuths: many(ssoDomainsInAuth),
+	samlProvidersInAuths: many(samlProvidersInAuth),
+}));
+
+export const ssoDomainsInAuthRelations = relations(ssoDomainsInAuth, ({one}) => ({
+	ssoProvidersInAuth: one(ssoProvidersInAuth, {
+		fields: [ssoDomainsInAuth.ssoProviderId],
+		references: [ssoProvidersInAuth.id]
+	}),
+}));
+
+export const mfaChallengesInAuthRelations = relations(mfaChallengesInAuth, ({one}) => ({
+	mfaFactorsInAuth: one(mfaFactorsInAuth, {
+		fields: [mfaChallengesInAuth.factorId],
+		references: [mfaFactorsInAuth.id]
+	}),
+}));
+
+export const mfaFactorsInAuthRelations = relations(mfaFactorsInAuth, ({one, many}) => ({
+	mfaChallengesInAuths: many(mfaChallengesInAuth),
+	usersInAuth: one(usersInAuth, {
+		fields: [mfaFactorsInAuth.userId],
+		references: [usersInAuth.id]
+	}),
+}));
+
+export const mfaAmrClaimsInAuthRelations = relations(mfaAmrClaimsInAuth, ({one}) => ({
+	sessionsInAuth: one(sessionsInAuth, {
+		fields: [mfaAmrClaimsInAuth.sessionId],
+		references: [sessionsInAuth.id]
+	}),
+}));
+
+export const sessionsInAuthRelations = relations(sessionsInAuth, ({one, many}) => ({
+	mfaAmrClaimsInAuths: many(mfaAmrClaimsInAuth),
+	refreshTokensInAuths: many(refreshTokensInAuth),
+	usersInAuth: one(usersInAuth, {
+		fields: [sessionsInAuth.userId],
+		references: [usersInAuth.id]
+	}),
+}));
+
+export const samlProvidersInAuthRelations = relations(samlProvidersInAuth, ({one}) => ({
+	ssoProvidersInAuth: one(ssoProvidersInAuth, {
+		fields: [samlProvidersInAuth.ssoProviderId],
+		references: [ssoProvidersInAuth.id]
+	}),
+}));
+
+export const oneTimeTokensInAuthRelations = relations(oneTimeTokensInAuth, ({one}) => ({
+	usersInAuth: one(usersInAuth, {
+		fields: [oneTimeTokensInAuth.userId],
+		references: [usersInAuth.id]
+	}),
+}));
+
+export const usersInAuthRelations = relations(usersInAuth, ({many}) => ({
+	oneTimeTokensInAuths: many(oneTimeTokensInAuth),
+	identitiesInAuths: many(identitiesInAuth),
+	sessionsInAuths: many(sessionsInAuth),
+	mfaFactorsInAuths: many(mfaFactorsInAuth),
+	userVocabRecords: many(userVocabRecord),
+	profiles: many(profiles),
+}));
+
+export const refreshTokensInAuthRelations = relations(refreshTokensInAuth, ({one}) => ({
+	sessionsInAuth: one(sessionsInAuth, {
+		fields: [refreshTokensInAuth.sessionId],
+		references: [sessionsInAuth.id]
+	}),
+}));
+
+export const identitiesInAuthRelations = relations(identitiesInAuth, ({one}) => ({
+	usersInAuth: one(usersInAuth, {
+		fields: [identitiesInAuth.userId],
+		references: [usersInAuth.id]
+	}),
+}));
+
+export const userVocabRecordRelations = relations(userVocabRecord, ({one}) => ({
+	usersInAuth: one(usersInAuth, {
+		fields: [userVocabRecord.userId],
+		references: [usersInAuth.id]
+	}),
+}));
+
+export const profilesRelations = relations(profiles, ({one}) => ({
+	usersInAuth: one(usersInAuth, {
+		fields: [profiles.id],
+		references: [usersInAuth.id]
+	}),
+}));