Import drizzle replacing prisma

Signed-off-by: Arthur DANJOU <arthurdanjou@outlook.fr>

server/api/activity.get.ts

@@ -0,0 +1,4 @@
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event)
+  return await $fetch(`https://api.lanyard.rest/v1/users/${config.discordUserId}`)
+})

server/api/announcement.get.ts

@@ -0,0 +1,5 @@
+export default defineEventHandler(async () => {
+  return useDB().query.announcements.findFirst({
+    orderBy: (announcement, {asc}) => [asc(announcement.createdAt)]
+  })
+})

server/api/article.post.ts

@@ -0,0 +1,16 @@
+import {z} from 'zod'
+
+const PostSchema = z.object({ slug: z.string() }).parse
+
+export default defineEventHandler(async (event) => {
+  const { slug } = await readValidatedBody(event, PostSchema)
+  return useDB().insert(tables.posts).values({
+    slug
+  }).onConflictDoUpdate({
+    target: tables.posts.id,
+    set: {
+      views: sql`${tables.posts.views}
+      + 1`
+    }
+  })
+})

server/api/bookmarks.get.ts

@@ -0,0 +1,20 @@
+export default defineEventHandler(async (event) => {
+  const { favorite, category } = getQuery(event)
+
+  const bookmarks = await useDB().query.bookmarks
+    .findMany({
+      orderBy: [asc(tables.talents.id)],
+      with: {
+        bookmarkCategories: {
+          with: {
+            category: true
+          }
+        }
+      }
+    })
+
+  return bookmarks.filter(bookmark =>
+    (category === 'all' || bookmark.bookmarkCategories.some(cat => cat.category.slug === category))
+    && (favorite === 'false' || bookmark.favorite)
+  )
+})

server/api/categories.get.ts

@@ -0,0 +1,4 @@
+export default defineEventHandler(async (event) => {
+  const { type } = getQuery<{ type: 'talent' | 'bookmark' }>(event)
+  return useDB().select().from(tables.categories).where(eq(tables.categories.type, type))
+})

server/api/like.put.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const PostSchema = z.object({ slug: z.string() }).parse
+
+export default defineEventHandler(async (event) => {
+  const { slug } = await readValidatedBody(event, PostSchema)
+  return useDB().update(tables.posts)
+    .set({
+      likes: sql`${tables.posts.likes}
+      + 1`
+    })
+    .where(eq(tables.posts.slug, slug))
+})

server/api/maintenance.get.ts

@@ -0,0 +1,22 @@
+export default defineEventHandler(async () => {
+  const maintenance = await useDB().query.maintenances.findFirst({
+    orderBy: [asc(tables.maintenances.createdAt)]
+  })
+  let enabled = true
+  // eslint-disable-next-line node/prefer-global/process
+  if (process.env.NODE_ENV === 'development') {
+    enabled = false
+  }
+  else {
+    const today = new Date()
+    enabled = !!maintenance
+    && maintenance.enabled
+    && new Date(maintenance.beginAt).getTime() < today.getTime()
+    && new Date(maintenance.endAt).getTime() > today.getTime()
+  }
+
+  return {
+    enabled,
+    maintenance
+  }
+})

server/api/message.delete.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const MessageValidator = z.object({
+  id: z.number()
+}).parse
+
+export default defineEventHandler(async (event) => {
+  const { id } = await readValidatedBody(event, MessageValidator)
+  const { user } = await requireUserSession(event)
+  if (!user.admin)
+    throw createError({ statusCode: 400, message: 'You need the permission to delete a message!' })
+  return useDB().delete(tables.guestbookMessages).where(eq(tables.guestbookMessages.id, id))
+})

server/api/message.post.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod'
+
+const MessageValidator = z.object({
+  message: z.string()
+}).parse
+
+export default defineEventHandler(async (event) => {
+  const { message } = await readValidatedBody(event, MessageValidator)
+  const { user } = await requireUserSession(event)
+  const config = useRuntimeConfig(event)
+
+  await sendDiscordWebhookMessage(config, {
+    title: 'New guestbook message ✨',
+    description: `**${user.username}** has signed the book : "*${message}*"`,
+    color: 15893567
+  })
+  return useDB().insert(tables.guestbookMessages)
+    .values({
+      message,
+      email: user.email,
+      username: user.username,
+      image: user.picture
+    })
+    .onConflictDoUpdate({
+      target: tables.guestbookMessages.email,
+      set: {
+        message
+      }
+    })
+})

server/api/messages.get.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(async () => {
+  return useDB().select().from(tables.guestbookMessages).orderBy(asc(tables.guestbookMessages.createdAt))
+})

server/api/stats.get.ts

@@ -0,0 +1,15 @@
+export default defineCachedEventHandler(async (event) => {
+  const config = useRuntimeConfig(event)
+  const coding = await $fetch(`https://wakatime.com/share/${config.wakatimeUserId}/${config.wakatimeCodig}.json`)
+  const editors = await $fetch(`https://wakatime.com/share/${config.wakatimeUserId}/${config.wakatimeEditors}.json`)
+  const os = await $fetch(`https://wakatime.com/share/${config.wakatimeUserId}/${config.wakatimeOs}.json`)
+  const languages = await $fetch(`https://wakatime.com/share/${config.wakatimeUserId}/${config.wakatimeLanguages}.json`)
+  return {
+    coding,
+    editors,
+    os,
+    languages
+  }
+}, {
+  maxAge: 60 * 60 * 3 // 3 hours,
+})

server/api/suggestion.post.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod'
+
+const SuggestionValidator = z.object({
+  content: z.string()
+}).parse
+
+export default defineEventHandler(async (event) => {
+  const { content } = await readValidatedBody(event, SuggestionValidator)
+  const { user } = await requireUserSession(event)
+  const config = useRuntimeConfig(event)
+
+  await sendDiscordWebhookMessage(config, {
+    title: 'New suggestion ✨',
+    description: `**${user.username}** has requested **${content}** for the talents page.`,
+    color: 15237114
+  })
+
+  return useDB().insert(tables.suggestions)
+    .values({
+      email: user.email,
+      content
+    })
+    .onConflictDoUpdate({
+      target: tables.suggestions.email,
+      set: {
+        content
+      },
+      setWhere: sql`${tables.suggestions.email}
+      =
+      ${user.email}`
+    }).returning({
+      content: tables.suggestions.content
+    })
+})

server/api/talents.get.ts

@@ -0,0 +1,20 @@
+export default defineEventHandler(async (event) => {
+  const { favorite, category } = getQuery(event)
+
+  const talents = await useDB().query.talents
+    .findMany({
+      orderBy: [asc(tables.talents.id)],
+      with: {
+        talentCategories: {
+          with: {
+            category: true
+          }
+        }
+      }
+    })
+
+  return talents.filter(talent =>
+    (category === 'all' || talent.talentCategories.some(cat => cat.category.slug === category))
+    && (favorite === 'false' || talent.favorite)
+  )
+})

server/api/view.put.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod'
+
+const PostSchema = z.object({ slug: z.string() }).parse
+
+export default defineEventHandler(async (event) => {
+  const { slug } = await readValidatedBody(event, PostSchema)
+  return useDB().update(tables.posts)
+    .set({
+      views: sql`${tables.posts.views}
+      + 1`
+    })
+    .where(eq(tables.posts.slug, slug))
+})

server/database/schema.ts

@@ -0,0 +1,128 @@
+import { boolean, date, integer, pgEnum, pgTable, primaryKey, serial, text, timestamp } from 'drizzle-orm/pg-core'
+import { relations } from 'drizzle-orm'
+
+// O B J E C T S
+
+export const maintenances = pgTable('maintenances', {
+  id: serial('id').primaryKey(),
+  reason: text('reason').default(''),
+  enabled: boolean('enabled').default(false).notNull(),
+  beginAt: date('begin_at').defaultNow().notNull(),
+  endAt: date('end_at').defaultNow().notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const announcements = pgTable('announcements', {
+  id: serial('id').primaryKey(),
+  content: text('content').default('').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const posts = pgTable('posts', {
+  id: serial('id').primaryKey(),
+  slug: text('slug').notNull(),
+  likes: integer('likes').default(0).notNull(),
+  views: integer('views').default(0).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const suggestions = pgTable('suggestions', {
+  id: serial('id').notNull(),
+  email: text('email').notNull().unique(),
+  content: text('content').notNull(),
+  added: boolean('added').default(false).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull()
+}, t => ({
+  pk: primaryKey({columns: [t.id, t.email]})
+}))
+
+export const guestbookMessages = pgTable('guestbook_messages', {
+  id: serial('id').primaryKey(),
+  message: text('message').notNull(),
+  email: text('email').notNull().unique(),
+  username: text('username').notNull(),
+  image: text('image').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const categoriesType = pgEnum('categoryType', ['talent', 'bookmark'])
+
+export const categories = pgTable('categories', {
+  id: serial('id').primaryKey(),
+  slug: text('slug').unique().notNull(),
+  name: text('name').notNull(),
+  type: categoriesType('type').notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const talents = pgTable('talents', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  logo: text('logo').default('').notNull(),
+  website: text('website').default('').notNull(),
+  work: text('work').default('').notNull(),
+  favorite: boolean('favorite').default(false).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const talentsToCategories = pgTable('talents_categories', {
+  talentId: integer('talent_id').notNull()
+    .references(() => talents.id, { onDelete: 'cascade' }),
+  categoryId: integer('category_id').notNull()
+    .references(() => categories.id, {onDelete: 'cascade'})
+})
+
+export const bookmarks = pgTable('bookmarks', {
+  id: serial('id').primaryKey(),
+  name: text('name').notNull(),
+  website: text('website').default('').notNull(),
+  favorite: boolean('favorite').default(false).notNull(),
+  createdAt: timestamp('created_at').defaultNow().notNull()
+})
+
+export const bookmarksToCategories = pgTable('bookmarks_categories', {
+  bookmarkId: integer('bookmark_id').notNull()
+    .references(() => bookmarks.id, { onDelete: 'cascade' }),
+  categoryId: integer('category_id').notNull()
+    .references(() => categories.id, {onDelete: 'cascade'})
+}, t => ({
+  pk: primaryKey({columns: [t.bookmarkId, t.categoryId]})
+}))
+
+// R E L A T I O N S
+
+export const talentsRelations = relations(talents, ({ many }) => ({
+  talentCategories: many(talentsToCategories)
+}))
+
+export const bookmarksRelations = relations(bookmarks, ({ many }) => ({
+  bookmarkCategories: many(bookmarksToCategories)
+}))
+
+export const categoriesRelations = relations(categories, ({ many }) => ({
+  talentsToCategories: many(talentsToCategories),
+  bookmarksToCategories: many(bookmarksToCategories)
+}))
+
+export const talentsToCategoriesRelations = relations(talentsToCategories, ({ one }) => ({
+  talent: one(talents, {
+    references: [talents.id],
+    fields: [talentsToCategories.talentId]
+  }),
+  category: one(categories, {
+    references: [categories.id],
+    fields: [talentsToCategories.categoryId]
+  })
+}))
+
+export const bookmarksToCategoriesRelations = relations(bookmarksToCategories, ({ one }) => ({
+  bookmark: one(bookmarks, {
+    references: [bookmarks.id],
+    fields: [bookmarksToCategories.bookmarkId]
+  }),
+  category: one(categories, {
+    references: [categories.id],
+    fields: [bookmarksToCategories.categoryId]
+  })
+}))

server/routes/auth/github.get.ts

@@ -0,0 +1,19 @@
+export default oauth.githubEventHandler({
+  config: {
+    emailRequired: true
+  },
+  async onSuccess(event, {user}) {
+    await setUserSession(event, {
+      user: {
+        email: user.email,
+        picture: user.avatar_url,
+        username: String(user.name).trim(),
+        admin: user.email === process.env.NUXT_AUTH_ADMIN_EMAIL
+      }
+    })
+    return sendRedirect(event, getCookie(event, 'last-route') || '/')
+  },
+  onError(error) {
+    console.error('GitHub OAuth error:', error)
+  }
+})

server/routes/auth/google.get.ts

@@ -0,0 +1,16 @@
+export default oauth.googleEventHandler({
+  async onSuccess(event, {user}) {
+    await setUserSession(event, {
+      user: {
+        email: user.email,
+        picture: user.picture,
+        username: String(user.name).trim(),
+        admin: user.email === process.env.NUXT_AUTH_ADMIN_EMAIL
+      }
+    })
+    return sendRedirect(event, getCookie(event, 'last-route') || '/')
+  },
+  onError(error) {
+    console.error('Google OAuth error:', error)
+  }
+})

server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../.nuxt/tsconfig.server.json"
+}

server/utils/db.ts

@@ -0,0 +1,14 @@
+import { drizzle } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+import * as schema from '../database/schema'
+
+export const tables = schema
+export { sql, eq, and, or, asc, desc, sum, inArray } from 'drizzle-orm'
+
+// eslint-disable-next-line node/prefer-global/process
+const connectionString = process.env.DATABASE_URL as string
+const client = postgres(connectionString, { prepare: false })
+
+export function useDB() {
+  return drizzle(client, { schema })
+}

server/utils/discord.ts

@@ -0,0 +1,28 @@
+import type { RuntimeConfig } from 'nuxt/schema'
+
+interface WebhookContent {
+  title: string
+  description: string
+  color: number
+}
+
+export async function sendDiscordWebhookMessage(config: RuntimeConfig, content: WebhookContent) {
+  await $fetch(`https://discordapp.com/api/webhooks/${config.discordId}/${config.discordToken}`, {
+    method: 'POST',
+    body: {
+      embeds: [
+        {
+          title: content.title,
+          description: content.description,
+          color: content.color,
+          url: 'https://arthurdanjou.fr/talents',
+          footer: {
+            text: 'Powered by Nuxt'
+          },
+          timestamp: new Date().toISOString()
+        }
+      ],
+      username: 'ArtDanjRobot - Website'
+    }
+  })
+}