Lint code

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

server/api/activity.get.ts

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

server/api/announcement.get.ts

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

server/api/article.post.ts

@@ -3,14 +3,14 @@ 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}
+  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

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

server/api/categories.get.ts

@@ -1,4 +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))
+  const { type } = getQuery<{ type: 'talent' | 'bookmark' }>(event)
+  return useDB().select().from(tables.categories).where(eq(tables.categories.type, type))
 })

server/api/like.put.ts

@@ -3,11 +3,11 @@ 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}
+  const { slug } = await readValidatedBody(event, PostSchema)
+  return useDB().update(tables.posts)
+    .set({
+      likes: sql`${tables.posts.likes}
       + 1`,
-		})
-		.where(eq(tables.posts.slug, slug))
+    })
+    .where(eq(tables.posts.slug, slug))
 })

server/api/maintenance.get.ts

@@ -1,22 +1,22 @@
 export default defineEventHandler(async () => {
-	const maintenance = await useDB().query.maintenances.findFirst({
-		orderBy: [asc(tables.maintenances.createdAt)],
-	})
-	let enabled = true
+  const maintenance = await useDB().query.maintenances.findFirst({
+    orderBy: [asc(tables.maintenances.createdAt)],
+  })
+  let enabled = true
 
-	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()
-	}
+  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,
-	}
+  return {
+    enabled,
+    maintenance,
+  }
 })

server/api/message.delete.ts

@@ -1,13 +1,13 @@
 import {z} from 'zod'
 
 const MessageValidator = z.object({
-	id: z.number(),
+  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))
+  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

@@ -1,30 +1,30 @@
 import {z} from 'zod'
 
 const MessageValidator = z.object({
-	message: z.string(),
+  message: z.string(),
 }).parse
 
 export default defineEventHandler(async (event) => {
-	const { message } = await readValidatedBody(event, MessageValidator)
-	const { user } = await requireUserSession(event)
-	const config = useRuntimeConfig(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,
-			},
-		})
+  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

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

server/api/stats.get.ts

@@ -1,15 +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,
-	}
+  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,
+  maxAge: 60 * 60 * 3, // 3 hours,
 })

server/api/suggestion.post.ts

@@ -1,34 +1,34 @@
 import {z} from 'zod'
 
 const SuggestionValidator = z.object({
-	content: z.string(),
+  content: z.string(),
 }).parse
 
 export default defineEventHandler(async (event) => {
-	const { content } = await readValidatedBody(event, SuggestionValidator)
-	const { user } = await requireUserSession(event)
-	const config = useRuntimeConfig(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,
-	})
+  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}
+  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,
-		})
+    }).returning({
+      content: tables.suggestions.content,
+    })
 })

server/api/talents.get.ts

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

server/api/view.put.ts

@@ -1,13 +1,13 @@
-import { z } from 'zod'
+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}
+  const { slug } = await readValidatedBody(event, PostSchema)
+  return useDB().update(tables.posts)
+    .set({
+      views: sql`${tables.posts.views}
       + 1`,
-		})
-		.where(eq(tables.posts.slug, slug))
+    })
+    .where(eq(tables.posts.slug, slug))
 })

server/database/schema.ts

@@ -4,125 +4,125 @@ 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(),
+  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(),
+  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(),
+  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(),
+  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] }),
+  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(),
+  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(),
+  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(),
+  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' }),
+  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(),
+  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' }),
+  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] }),
+  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),
+  talentCategories: many(talentsToCategories),
 }))
 
 export const bookmarksRelations = relations(bookmarks, ({ many }) => ({
-	bookmarkCategories: many(bookmarksToCategories),
+  bookmarkCategories: many(bookmarksToCategories),
 }))
 
 export const categoriesRelations = relations(categories, ({ many }) => ({
-	talentsToCategories: many(talentsToCategories),
-	bookmarksToCategories: many(bookmarksToCategories),
+  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],
-	}),
+  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],
-	}),
+  bookmark: one(bookmarks, {
+    references: [bookmarks.id],
+    fields: [bookmarksToCategories.bookmarkId],
+  }),
+  category: one(categories, {
+    references: [categories.id],
+    fields: [bookmarksToCategories.categoryId],
+  }),
 }))

server/routes/auth/github.get.ts

@@ -1,19 +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)
-	},
+  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

@@ -1,16 +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)
-	},
+  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/utils/db.ts

@@ -9,5 +9,5 @@ const connectionString = process.env.DATABASE_URL as string
 const client = postgres(connectionString, { prepare: false })
 
 export function useDB() {
-	return drizzle(client, { schema })
+  return drizzle(client, { schema })
 }

server/utils/discord.ts

@@ -1,28 +1,28 @@
 import type {RuntimeConfig} from 'nuxt/schema'
 
 interface WebhookContent {
-	title: string
-	description: string
-	color: number
+  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',
-		},
-	})
+  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',
+    },
+  })
 }