Add path.identifer

packages/lib/rateLimit.ts

@@ -81,6 +81,12 @@ export function rateLimiter() {
       prefix: "ratelimit",
       limiter: Ratelimit.fixedWindow(20, "1d"),
     }),
+    trpc: new Ratelimit({
+      redis,
+      analytics: true,
+      prefix: "ratelimit",
+      limiter: Ratelimit.fixedWindow(500, "60s"),
+    }),
   };
 
   async function rateLimit({ rateLimitingType = "core", identifier }: RateLimitHelper) {

packages/trpc/server/middlewares/rateLimitMiddleware.ts

@@ -0,0 +1,24 @@
+import type { NextApiRequest } from "next/types";
+
+import { checkRateLimitAndThrowError } from "@calcom/lib/checkRateLimitAndThrowError";
+import getIP from "@calcom/lib/getIP";
+
+import { middleware } from "../trpc";
+
+const rateLimitMiddleware = middleware(async ({ ctx, next, path, meta }) => {
+  console.log(ctx, meta);
+  if (true) {
+    const userIp = ctx.req && getIP(ctx.req as NextApiRequest);
+
+    const identifier = userIp || ctx?.user?.id.toString();
+
+    await checkRateLimitAndThrowError({
+      rateLimitingType: "core",
+      identifier: `${path}.${identifier}`,
+    });
+  }
+
+  return next();
+});
+
+export default rateLimitMiddleware;

packages/trpc/server/procedures/authedProcedure.ts

@@ -1,5 +1,6 @@
 import captureErrorsMiddleware from "../middlewares/captureErrorsMiddleware";
 import perfMiddleware from "../middlewares/perfMiddleware";
+import rateLimitMiddleware from "../middlewares/rateLimitMiddleware";
 import { isAdminMiddleware, isAuthed, isOrgAdminMiddleware } from "../middlewares/sessionMiddleware";
 import { procedure } from "../trpc";
 import publicProcedure from "./publicProcedure";
@@ -24,10 +25,22 @@ const isRateLimitedByUserIdMiddleware = ({ intervalInMs, limit }: IRateLimitOpti
       return next({ ctx: { user: ctx.user, session: ctx.session } });
     });
 */
-const authedProcedure = procedure.use(captureErrorsMiddleware).use(perfMiddleware).use(isAuthed);
+const authedProcedure = procedure
+  .use(captureErrorsMiddleware)
+  .use(rateLimitMiddleware)
+  .use(perfMiddleware)
+  .use(isAuthed);
+
 /*export const authedRateLimitedProcedure = ({ intervalInMs, limit }: IRateLimitOptions) =>
 authedProcedure.use(isRateLimitedByUserIdMiddleware({ intervalInMs, limit }));*/
-export const authedAdminProcedure = publicProcedure.use(captureErrorsMiddleware).use(isAdminMiddleware);
-export const authedOrgAdminProcedure = publicProcedure.use(captureErrorsMiddleware).use(isOrgAdminMiddleware);
+export const authedAdminProcedure = publicProcedure
+  .use(captureErrorsMiddleware)
+  .use(rateLimitMiddleware)
+  .use(isAdminMiddleware);
+
+export const authedOrgAdminProcedure = publicProcedure
+  .use(captureErrorsMiddleware)
+  .use(rateLimitMiddleware)
+  .use(isOrgAdminMiddleware);
 
 export default authedProcedure;

packages/trpc/server/procedures/publicProcedure.ts

@@ -1,7 +1,11 @@
 import captureErrorsMiddleware from "../middlewares/captureErrorsMiddleware";
 import perfMiddleware from "../middlewares/perfMiddleware";
+import rateLimitMiddleware from "../middlewares/rateLimitMiddleware";
 import { tRPCContext } from "../trpc";
 
-const publicProcedure = tRPCContext.procedure.use(captureErrorsMiddleware).use(perfMiddleware);
+const publicProcedure = tRPCContext.procedure
+  .use(captureErrorsMiddleware)
+  .use(rateLimitMiddleware)
+  .use(perfMiddleware);
 
 export default publicProcedure;