use h3 instead of trpc

src/server/api/trpc/[trpc].ts

@@ -1,8 +0,0 @@
-import { createNuxtApiHandler } from 'trpc-nuxt'
-import { createContext } from '~/server/trpc/context'
-import { appRouter } from '~/server/trpc/routers'
-
-export default createNuxtApiHandler({
-  createContext,
-  router: appRouter,
-})

src/server/trpc/context.ts

@@ -1,19 +0,0 @@
-import { PrismaClient } from '@prisma/client'
-import type { inferAsyncReturnType } from '@trpc/server'
-import type { H3Event } from 'h3'
-
-let prisma: PrismaClient | undefined
-
-export function createContext(_event: H3Event) {
-  if (!prisma) {
-    prisma = new PrismaClient({
-      log: ['warn', 'info', 'error'],
-    })
-  }
-
-  return {
-    prisma,
-  }
-}
-
-export type Context = inferAsyncReturnType<typeof createContext>

src/server/trpc/routers/announcement.ts

@@ -1,12 +0,0 @@
-import { publicProcedure, router } from '../trpc'
-
-export default router({
-  get: publicProcedure
-    .query(async ({ ctx }) => {
-      return await ctx.prisma.announcement.findFirst({
-        orderBy: {
-          createdAt: 'desc',
-        },
-      })
-    }),
-})

src/server/trpc/routers/index.ts

@@ -1,14 +0,0 @@
-import { router } from '../trpc'
-import announcement from './announcement'
-import maintenance from './maintenance'
-import post from './post'
-import talents from './talents'
-
-export const appRouter = router({
-  announcement,
-  post,
-  talents,
-  maintenance,
-})
-
-export type AppRouter = typeof appRouter

src/server/trpc/routers/maintenance.ts

@@ -1,29 +0,0 @@
-import { publicProcedure, router } from '../trpc'
-
-export default router({
-  get: publicProcedure
-    .query(async ({ ctx }) => {
-      return await ctx.prisma.maintenance.findFirst({
-        orderBy: {
-          createdAt: 'desc',
-        },
-      })
-    }),
-  is: publicProcedure
-    .query(async ({ ctx }) => {
-      const maintenance = await ctx.prisma.maintenance.findFirst({
-        orderBy: {
-          createdAt: 'desc',
-        },
-      })
-
-      if (process.env.NODE_ENV === 'development')
-        return false
-
-      const today = new Date()
-      return !!maintenance
-      && maintenance.enabled
-      && maintenance.beginAt.getTime() < today.getTime()
-      && maintenance.endAt.getTime() > today.getTime()
-    }),
-})

src/server/trpc/routers/post.ts

@@ -1,68 +0,0 @@
-import { z } from 'zod'
-import { publicProcedure, router } from '../trpc'
-
-const PostSchema = z.object({
-  slug: z.string(),
-})
-
-export default router({
-  createOrUpdate: publicProcedure
-    .input(PostSchema)
-    .mutation(async ({ ctx, input }) => {
-      return await ctx.prisma.post.upsert({
-        where: {
-          slug: input.slug,
-        },
-        update: {},
-        create: {
-          slug: input.slug,
-        },
-      })
-    }),
-  getTotalViews: publicProcedure
-    .query(async ({ ctx }) => {
-      const views = await ctx.prisma.post.aggregate({
-        _sum: {
-          views: true,
-        },
-      })
-      return views._sum.views || 0
-    }),
-  view: publicProcedure
-    .input(PostSchema)
-    .mutation(async ({ ctx, input }) => {
-      return await ctx.prisma.post.update({
-        where: {
-          slug: input.slug,
-        },
-        data: {
-          views: {
-            increment: 1,
-          },
-        },
-      })
-    }),
-  getTotalLikes: publicProcedure
-    .query(async ({ ctx }) => {
-      const likes = await ctx.prisma.post.aggregate({
-        _sum: {
-          likes: true,
-        },
-      })
-      return likes._sum.likes || 0
-    }),
-  like: publicProcedure
-    .input(PostSchema)
-    .mutation(async ({ ctx, input }) => {
-      return await ctx.prisma.post.update({
-        where: {
-          slug: input.slug,
-        },
-        data: {
-          likes: {
-            increment: 1,
-          },
-        },
-      })
-    }),
-})

src/server/trpc/routers/talents.ts

@@ -1,112 +0,0 @@
-import { z } from 'zod'
-import { publicProcedure, router } from '../trpc'
-
-export default router({
-  getTalents: publicProcedure
-    .input(z.object({
-      favorite: z.boolean(),
-      category: z.union([z.string(), z.literal('all')]),
-    }))
-    .query(async ({ ctx, input }) => {
-      if (input.favorite) {
-        return input.category === 'all'
-          ? await ctx.prisma.talent.findMany({
-            orderBy: {
-              createdAt: 'desc',
-            },
-            include: {
-              categories: {
-                include: {
-                  talent: true,
-                  category: true,
-                },
-                orderBy: {
-                  category: {
-                    name: 'asc',
-                  },
-                },
-              },
-            },
-            where: {
-              favorite: true,
-              categories: { every: { category: {} } },
-            },
-          })
-          : await ctx.prisma.talent.findMany({
-            orderBy: {
-              createdAt: 'desc',
-            },
-            include: {
-              categories: {
-                include: {
-                  talent: true,
-                  category: true,
-                },
-                orderBy: {
-                  category: {
-                    name: 'asc',
-                  },
-                },
-              },
-            },
-            where: {
-              favorite: true,
-              categories: { some: { category: { slug: input.category } } },
-            },
-          })
-      }
-      else {
-        return input.category === 'all'
-          ? await ctx.prisma.talent.findMany({
-            orderBy: {
-              createdAt: 'desc',
-            },
-            include: {
-              categories: {
-                include: {
-                  talent: true,
-                  category: true,
-                },
-                orderBy: {
-                  category: {
-                    name: 'asc',
-                  },
-                },
-              },
-            },
-            where: {
-              categories: { every: { category: {} } },
-            },
-          })
-          : await ctx.prisma.talent.findMany({
-            orderBy: {
-              createdAt: 'desc',
-            },
-            include: {
-              categories: {
-                include: {
-                  talent: true,
-                  category: true,
-                },
-                orderBy: {
-                  category: {
-                    name: 'asc',
-                  },
-                },
-              },
-            },
-            where: {
-              categories: { some: { category: { slug: input.category } } },
-            },
-          })
-      }
-    }),
-  getCategories: publicProcedure
-    .query(async ({ ctx }) => {
-      return await ctx.prisma.category.findMany({
-        where: {
-          type: 'TALENT',
-        },
-      })
-    }),
-})

src/server/trpc/trpc.ts

@@ -1,12 +0,0 @@
-import { initTRPC } from '@trpc/server'
-import SuperJSON from 'superjson'
-import type { Context } from './context'
-
-const trpc = initTRPC.context<Context>().create({
-  transformer: SuperJSON,
-})
-
-export const publicProcedure = trpc.procedure
-export const router = trpc.router
-export const middleware = trpc.middleware
-export const mergeRouters = trpc.mergeRouters