Lets simplify tRPC

src/server/api/routers/room.ts

@@ -1,16 +1,16 @@
 import { z } from "zod";
 import { publishToChannel } from "~/server/ably";
 import {
-  adminRateLimitedProcedure,
   createTRPCRouter,
-  protectedRateLimitedProcedure,
+  protectedProcedure,
+  adminProcedure,
 } from "~/server/api/trpc";
 
 import { fetchCache, invalidateCache, setCache } from "~/server/redis";
 
 export const roomRouter = createTRPCRouter({
   // Create
-  create: protectedRateLimitedProcedure
+  create: protectedProcedure
     .input(
       z.object({
         name: z.string(),
@@ -46,7 +46,7 @@ export const roomRouter = createTRPCRouter({
     }),
 
   // Get One
-  get: protectedRateLimitedProcedure
+  get: protectedProcedure
     .input(z.object({ id: z.string() }))
     .query(({ ctx, input }) => {
       return ctx.prisma.room.findUnique({
@@ -67,7 +67,7 @@ export const roomRouter = createTRPCRouter({
     }),
 
   // Get All
-  getAll: protectedRateLimitedProcedure.query(async ({ ctx }) => {
+  getAll: protectedProcedure.query(async ({ ctx }) => {
     const cachedResult = await fetchCache<
       {
         id: string;
@@ -96,7 +96,7 @@ export const roomRouter = createTRPCRouter({
     }
   }),
 
-  countAll: adminRateLimitedProcedure.query(async ({ ctx }) => {
+  countAll: adminProcedure.query(async ({ ctx }) => {
     const cachedResult = await fetchCache<number>(`kv_roomcount_admin`);
 
     if (cachedResult) {
@@ -111,7 +111,7 @@ export const roomRouter = createTRPCRouter({
   }),
 
   // Update One
-  set: protectedRateLimitedProcedure
+  set: protectedProcedure
     .input(
       z.object({
         name: z.string(),
@@ -212,7 +212,7 @@ export const roomRouter = createTRPCRouter({
     }),
 
   // Delete One
-  delete: protectedRateLimitedProcedure
+  delete: protectedProcedure
     .input(z.object({ id: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const deletedRoom = await ctx.prisma.room.delete({

src/server/api/routers/session.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { adminRateLimitedProcedure, createTRPCRouter } from "~/server/api/trpc";
+import { adminProcedure, createTRPCRouter } from "~/server/api/trpc";
 import { invalidateCache } from "~/server/redis";
 
 export const sessionRouter = createTRPCRouter({
-  deleteAllByUserId: adminRateLimitedProcedure
+  deleteAllByUserId: adminProcedure
     .input(
       z.object({
         userId: z.string(),
@@ -22,7 +22,7 @@ export const sessionRouter = createTRPCRouter({
 
       return !!sessions;
     }),
-  deleteAll: adminRateLimitedProcedure.mutation(async ({ ctx }) => {
+  deleteAll: adminProcedure.mutation(async ({ ctx }) => {
     const sessions = await ctx.prisma.session.deleteMany();
 
     if (!!sessions) {

src/server/api/routers/user.ts

@@ -4,9 +4,9 @@ import { z } from "zod";
 import { Goodbye } from "~/components/templates/Goodbye";
 import { env } from "~/env.mjs";
 import {
-  adminRateLimitedProcedure,
+  adminProcedure,
   createTRPCRouter,
-  protectedRateLimitedProcedure,
+  protectedProcedure,
 } from "~/server/api/trpc";
 
 import { fetchCache, invalidateCache, setCache } from "~/server/redis";
@@ -14,7 +14,7 @@ import { fetchCache, invalidateCache, setCache } from "~/server/redis";
 const resend = new Resend(process.env.RESEND_API_KEY);
 
 export const userRouter = createTRPCRouter({
-  countAll: adminRateLimitedProcedure.query(async ({ ctx }) => {
+  countAll: adminProcedure.query(async ({ ctx }) => {
     const cachedResult = await fetchCache<number>(`kv_usercount_admin`);
 
     if (cachedResult) {
@@ -28,7 +28,7 @@ export const userRouter = createTRPCRouter({
     }
   }),
 
-  getProviders: protectedRateLimitedProcedure.query(async ({ ctx }) => {
+  getProviders: protectedProcedure.query(async ({ ctx }) => {
     const providers = await ctx.prisma.user.findUnique({
       where: {
         id: ctx.session.user.id,
@@ -46,7 +46,7 @@ export const userRouter = createTRPCRouter({
       return account.provider;
     });
   }),
-  getAll: protectedRateLimitedProcedure.query(async ({ ctx }) => {
+  getAll: protectedProcedure.query(async ({ ctx }) => {
     const cachedResult = await fetchCache<
       {
         accounts: {
@@ -98,7 +98,7 @@ export const userRouter = createTRPCRouter({
       return users;
     }
   }),
-  delete: protectedRateLimitedProcedure
+  delete: protectedProcedure
     .input(
       z
         .object({
@@ -136,7 +136,7 @@ export const userRouter = createTRPCRouter({
 
       return !!user;
     }),
-  save: protectedRateLimitedProcedure
+  save: protectedProcedure
     .input(
       z.object({
         name: z.string(),
@@ -154,7 +154,7 @@ export const userRouter = createTRPCRouter({
 
       return !!user;
     }),
-  setAdmin: adminRateLimitedProcedure
+  setAdmin: adminProcedure
     .input(
       z.object({
         userId: z.string(),
@@ -176,7 +176,7 @@ export const userRouter = createTRPCRouter({
       return !!user;
     }),
 
-  setVIP: adminRateLimitedProcedure
+  setVIP: adminProcedure
     .input(
       z.object({
         userId: z.string(),

src/server/api/routers/vote.ts

@@ -3,14 +3,14 @@ import { publishToChannel } from "~/server/ably";
 
 import type { Room } from "@prisma/client";
 import {
-  adminRateLimitedProcedure,
+  adminProcedure,
   createTRPCRouter,
-  protectedRateLimitedProcedure,
+  protectedProcedure,
 } from "~/server/api/trpc";
 import { fetchCache, invalidateCache, setCache } from "~/server/redis";
 
 export const voteRouter = createTRPCRouter({
-  countAll: adminRateLimitedProcedure
+  countAll: adminProcedure
     .input(z.void())
     .output(z.number())
     .meta({ openapi: { method: "GET", path: "/votes/count" } })
@@ -27,7 +27,7 @@ export const voteRouter = createTRPCRouter({
         return votesCount;
       }
     }),
-  getAllByRoomId: protectedRateLimitedProcedure
+  getAllByRoomId: protectedProcedure
     .input(z.object({ roomId: z.string() }))
     .query(async ({ ctx, input }) => {
       const cachedResult = await fetchCache<
@@ -71,7 +71,7 @@ export const voteRouter = createTRPCRouter({
         return votesByRoomId;
       }
     }),
-  set: protectedRateLimitedProcedure
+  set: protectedProcedure
     .input(z.object({ value: z.string(), roomId: z.string() }))
     .mutation(async ({ ctx, input }) => {
       const vote = await ctx.prisma.vote.upsert({

src/server/api/trpc.ts

@@ -113,14 +113,6 @@ const enforceUserIsAuthed = t.middleware(async ({ ctx, next }) => {
     throw new TRPCError({ code: "UNAUTHORIZED" });
   }
 
-  return next({
-    ctx: {
-      session: { ...ctx.session, user: ctx.session.user },
-    },
-  });
-});
-
-const enforceRateLimit = t.middleware(async ({ ctx, next }) => {
   const rateLimit = new Ratelimit({
     redis: Redis.fromEnv(),
     limiter: Ratelimit.slidingWindow(
@@ -129,15 +121,18 @@ const enforceRateLimit = t.middleware(async ({ ctx, next }) => {
     ),
     analytics: true,
   });
-  console.log(`${env.APP_ENV}_${ctx.session?.user.id || ctx.ip}`);
-  console.log(ctx.ip);
+
   const { success } = await rateLimit.limit(
-    `${env.APP_ENV}_${ctx.session?.user.id || ctx.ip}`
+    `${env.APP_ENV}_${ctx.session?.user.id}`
   );
 
   if (!success) throw new TRPCError({ code: "TOO_MANY_REQUESTS" });
 
-  return next();
+  return next({
+    ctx: {
+      session: { ...ctx.session, user: ctx.session.user },
+    },
+  });
 });
 
 const enforceAdminRole = t.middleware(async ({ ctx, next }) => {
@@ -161,11 +156,4 @@ const enforceAdminRole = t.middleware(async ({ ctx, next }) => {
  */
 export const protectedProcedure = t.procedure.use(enforceUserIsAuthed);
 
-export const protectedRateLimitedProcedure =
-  protectedProcedure.use(enforceRateLimit);
-
-export const publicRateLimitedProcedure = publicProcedure.use(enforceRateLimit);
-
 export const adminProcedure = t.procedure.use(enforceAdminRole);
-
-export const adminRateLimitedProcedure = adminProcedure.use(enforceAdminRole);