chore: release v5.2.0

* made text dependent on host's refund policy by conditionally rendering refund message

* add more conditions in case of no refund message

* made refund message more appropriate

* Update apps/web/public/static/locales/en/common.json

* Update apps/web/public/static/locales/en/common.json

* Update apps/web/modules/bookings/views/bookings-single-view.tsx

---------

Co-authored-by: romit <romitgabani1@gmail.com>
Co-authored-by: Tushar Bhatt <95581504+TusharBhatt1@users.noreply.github.com>

apps/api/v1/pages/api/slots/_get.ts

@@ -3,7 +3,6 @@ import utc from "dayjs/plugin/utc";
 import type { NextApiRequest, NextApiResponse } from "next";
 
 import dayjs from "@calcom/dayjs";
-import { IS_PRODUCTION } from "@calcom/lib/constants";
 import { isSupportedTimeZone } from "@calcom/lib/date-fns";
 import { HttpError } from "@calcom/lib/http-error";
 import { defaultResponder } from "@calcom/lib/server/defaultResponder";
@@ -18,15 +17,8 @@ import { getHTTPStatusCodeFromError } from "@trpc/server/http";
 dayjs.extend(utc);
 dayjs.extend(timezone);
 
-let isColdStart = true;
-
 async function handler(req: NextApiRequest, res: NextApiResponse) {
   try {
-    if (isColdStart && IS_PRODUCTION) {
-      console.log("Cold start of /v1/slots detected");
-      isColdStart = false;
-    }
-
     const { usernameList, isTeamEvent, ...rest } = req.query;
     const parsedIsTeamEvent = String(isTeamEvent).toLowerCase() === "true";
     let slugs = usernameList;

apps/web/app/(use-page-wrapper)/(main-nav)/ShellMainAppDir.tsx

@@ -19,18 +19,22 @@ export function ShellMainAppDir(props: LayoutProps) {
             <header
               className={classNames(props.large && "py-8", "flex w-full max-w-full items-center truncate")}>
               {props.HeadingLeftIcon && <div className="ltr:mr-4">{props.HeadingLeftIcon}</div>}
-              <div className={classNames("w-full truncate ltr:mr-4 rtl:ml-4", props.headerClassName)}>
+              <div
+                className={classNames(
+                  "hidden w-full truncate ltr:mr-4 rtl:ml-4 md:block",
+                  props.headerClassName
+                )}>
                 {props.heading && (
                   <h3
                     className={classNames(
-                      "font-cal text-emphasis max-w-28 sm:max-w-72 md:max-w-80 truncate text-lg font-semibold tracking-wide sm:text-xl xl:max-w-full",
+                      "font-cal text-emphasis max-w-28 sm:max-w-72 md:max-w-80 inline truncate text-lg font-semibold tracking-wide sm:text-xl md:block xl:max-w-full",
                       props.smallHeading ? "text-base" : "text-xl"
                     )}>
                     {props.heading}
                   </h3>
                 )}
                 {props.subtitle && (
-                  <p className="text-default text-sm" data-testid="subtitle">
+                  <p className="text-default hidden text-sm md:block" data-testid="subtitle">
                     {props.subtitle}
                   </p>
                 )}

apps/web/app/api/me/route.ts

@@ -7,8 +7,6 @@ import { performance } from "@calcom/lib/server/perfObserver";
 
 import { buildLegacyRequest } from "@lib/buildLegacyCtx";
 
-let isCold = true;
-
 async function getHandler() {
   const prePrismaDate = performance.now();
   const prisma = (await import("@calcom/prisma")).default;
@@ -30,7 +28,6 @@ async function getHandler() {
 
   const lastUpdate = performance.now();
 
-  // Create response with headers
   const response = NextResponse.json({
     message: `Hello ${user.name}`,
     prePrismaDate,
@@ -40,13 +37,8 @@ async function getHandler() {
     preUserDate,
     userDuration: `User took ${lastUpdate - preUserDate}ms`,
     lastUpdate,
-    wasCold: isCold,
   });
 
-  // Set custom header
-  response.headers.set("x-is-cold", isCold.toString());
-  isCold = false;
-
   return response;
 }
 

apps/web/modules/availability/availability-view.tsx

@@ -218,7 +218,7 @@ export const AvailabilityCTA = () => {
   return (
     <div className="flex gap-2">
       <ToggleGroup
-        className="hidden md:block"
+        className="min-h-10 hidden md:flex md:items-center"
         defaultValue={searchParams?.get("type") ?? "mine"}
         onValueChange={(value) => {
           if (!value) return;

apps/web/modules/bookings/views/bookings-single-view.getServerSideProps.tsx

@@ -11,7 +11,7 @@ import { markdownToSafeHTML } from "@calcom/lib/markdownToSafeHTML";
 import { maybeGetBookingUidFromSeat } from "@calcom/lib/server/maybeGetBookingUidFromSeat";
 import { BookingRepository } from "@calcom/lib/server/repository/booking";
 import prisma from "@calcom/prisma";
-import { customInputSchema, EventTypeMetaDataSchema } from "@calcom/prisma/zod-utils";
+import { customInputSchema, eventTypeMetaDataSchemaWithTypedApps } from "@calcom/prisma/zod-utils";
 import { meRouter } from "@calcom/trpc/server/routers/viewer/me/_router";
 
 import type { inferSSRProps } from "@lib/types/inferSSRProps";
@@ -129,7 +129,7 @@ export async function getServerSideProps(context: GetServerSidePropsContext) {
     ...eventTypeRaw,
     periodStartDate: eventTypeRaw.periodStartDate?.toString() ?? null,
     periodEndDate: eventTypeRaw.periodEndDate?.toString() ?? null,
-    metadata: EventTypeMetaDataSchema.parse(eventTypeRaw.metadata),
+    metadata: eventTypeMetaDataSchemaWithTypedApps.parse(eventTypeRaw.metadata),
     recurringEvent: parseRecurringEvent(eventTypeRaw.recurringEvent),
     customInputs: customInputSchema.array().parse(eventTypeRaw.customInputs),
     bookingFields: eventTypeRaw.bookingFields.map((field) => {

apps/web/modules/bookings/views/bookings-single-view.tsx

@@ -42,6 +42,7 @@ import { useRouterQuery } from "@calcom/lib/hooks/useRouterQuery";
 import useTheme from "@calcom/lib/hooks/useTheme";
 import isSmsCalEmail from "@calcom/lib/isSmsCalEmail";
 import { markdownToSafeHTML } from "@calcom/lib/markdownToSafeHTML";
+import { RefundPolicy } from "@calcom/lib/payment/types";
 import { getEveryFreqFor } from "@calcom/lib/recurringStrings";
 import { getIs24hClockFromLocalStorage, isBrowserLocale24h } from "@calcom/lib/timeFormat";
 import { CURRENT_TIMEZONE } from "@calcom/lib/timezoneConstants";
@@ -507,7 +508,37 @@ export default function Success(props: PageProps) {
                               t("booking_with_payment_cancelled")}
                             {props.paymentStatus.success &&
                               !props.paymentStatus.refunded &&
-                              t("booking_with_payment_cancelled_already_paid")}
+                              (() => {
+                                const refundPolicy = eventType?.metadata?.apps?.stripe?.refundPolicy;
+                                const refundDaysCount = eventType?.metadata?.apps?.stripe?.refundDaysCount;
+
+                                // Handle missing team or event type owner (same in processPaymentRefund.ts)
+                                if (!eventType?.teamId && !eventType?.owner) {
+                                  return t("booking_with_payment_cancelled_no_refund");
+                                }
+
+                                // Handle DAYS policy with expired refund window
+                                else if (refundPolicy === RefundPolicy.DAYS && refundDaysCount) {
+                                  const startTime = new Date(bookingInfo.startTime);
+                                  const cancelTime = new Date();
+                                  const daysDiff = Math.floor(
+                                    (cancelTime.getTime() - startTime.getTime()) / (1000 * 60 * 60 * 24)
+                                  );
+
+                                  if (daysDiff > refundDaysCount) {
+                                    return t("booking_with_payment_cancelled_refund_window_expired");
+                                  }
+                                }
+                                // Handle NEVER policy
+                                else if (refundPolicy === RefundPolicy.NEVER) {
+                                  return t("booking_with_payment_cancelled_no_refund");
+                                }
+
+                                // Handle ALWAYS policy
+                                else {
+                                  return t("booking_with_payment_cancelled_already_paid");
+                                }
+                              })()}
                             {props.paymentStatus.refunded && t("booking_with_payment_cancelled_refunded")}
                           </h4>
                         )}

apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcom/web",
-  "version": "5.1.21",
+  "version": "5.2.0",
   "private": true,
   "scripts": {
     "analyze": "ANALYZE=true next build",

apps/web/public/static/locales/en/common.json

@@ -1988,6 +1988,8 @@
   "booking_with_payment_cancelled": "Paying for this event is no longer possible",
   "booking_with_payment_cancelled_already_paid": "A refund for this booking payment is on its way.",
   "booking_with_payment_cancelled_refunded": "This booking payment has been refunded.",
+  "booking_with_payment_cancelled_no_refund": "As per the event's refund policy, the booking payment is non-refundable.",
+  "booking_with_payment_cancelled_refund_window_expired": "The event's refund window has expired. Hence, booking payment is non-refundable.",
   "booking_confirmation_failed": "Booking confirmation failed",
   "not_enough_seats": "Not enough seats",
   "form_builder_field_already_exists": "A field with this name already exists",

packages/app-store/giphy/lib/giphyManager.ts

@@ -2,18 +2,16 @@ import { HttpError } from "@calcom/lib/http-error";
 
 import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
 
-let api_key = "";
-
 const checkGiphyApiKey = async () => {
   const appKeys = await getAppKeysFromSlug("giphy");
-  if (typeof appKeys.api_key === "string") api_key = appKeys.api_key;
-  if (!api_key) throw new HttpError({ statusCode: 400, message: "Missing Giphy api_key" });
+  if (typeof appKeys.api_key === "string") return appKeys.api_key;
+  throw new HttpError({ statusCode: 400, message: "Missing Giphy api_key" });
 };
 
 export const searchGiphy = async (locale: string, keyword: string, offset = 0) => {
-  await checkGiphyApiKey();
+  const apiKey = await checkGiphyApiKey();
   const queryParams = new URLSearchParams({
-    api_key,
+    api_key: apiKey,
     q: keyword,
     limit: "1",
     offset: String(offset),
@@ -36,9 +34,9 @@ export const searchGiphy = async (locale: string, keyword: string, offset = 0) =
 };
 
 export const getGiphyById = async (giphyId: string) => {
-  await checkGiphyApiKey();
+  const apiKey = await checkGiphyApiKey();
   const queryParams = new URLSearchParams({
-    api_key,
+    api_key: apiKey,
   });
   const response = await fetch(`https://api.giphy.com/v1/gifs/${giphyId}?${queryParams.toString()}`, {
     method: "GET",

packages/app-store/hubspot/api/add.ts

@@ -8,19 +8,19 @@ import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
 const scopes = ["crm.objects.contacts.read", "crm.objects.contacts.write"];
 
-let client_id = "";
 const hubspotClient = new hubspot.Client();
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method !== "GET") return res.status(405).json({ message: "Method not allowed" });
 
   const appKeys = await getAppKeysFromSlug("hubspot");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (!client_id) return res.status(400).json({ message: "HubSpot client id missing." });
+  let clientId = "";
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (!clientId) return res.status(400).json({ message: "HubSpot client id missing." });
 
   const redirectUri = `${WEBAPP_URL_FOR_OAUTH}/api/integrations/hubspot/callback`;
   const url = hubspotClient.oauth.getAuthorizationUrl(
-    client_id,
+    clientId,
     redirectUri,
     scopes.join(" "),
     undefined,

packages/app-store/hubspot/api/callback.ts

@@ -11,8 +11,6 @@ import createOAuthAppCredential from "../../_utils/oauth/createOAuthAppCredentia
 import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 import metadata from "../_metadata";
 
-let client_id = "";
-let client_secret = "";
 const hubspotClient = new hubspot.Client();
 
 export interface HubspotToken extends TokenResponseIF {
@@ -32,18 +30,20 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return res.status(401).json({ message: "You must be logged in to do this" });
   }
 
+  let clientId = "";
+  let clientSecret = "";
   const appKeys = await getAppKeysFromSlug("hubspot");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (!client_id) return res.status(400).json({ message: "HubSpot client id missing." });
-  if (!client_secret) return res.status(400).json({ message: "HubSpot client secret missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (!clientId) return res.status(400).json({ message: "HubSpot client id missing." });
+  if (!clientSecret) return res.status(400).json({ message: "HubSpot client secret missing." });
 
   const hubspotToken: HubspotToken = await hubspotClient.oauth.tokensApi.createToken(
     "authorization_code",
     code,
     `${WEBAPP_URL_FOR_OAUTH}/api/integrations/hubspot/callback`,
-    client_id,
-    client_secret
+    clientId,
+    clientSecret
   );
 
   // set expiry date as offset from current time.

packages/app-store/intercom/api/add.ts

@@ -6,18 +6,17 @@ import { WEBAPP_URL_FOR_OAUTH } from "@calcom/lib/constants";
 import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
 import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
-let client_id = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method === "GET") {
+    let clientId = "";
     const appKeys = await getAppKeysFromSlug("intercom");
-    if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-    if (!client_id) return res.status(400).json({ message: "Intercom client_id missing." });
+    if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+    if (!clientId) return res.status(400).json({ message: "Intercom client_id missing." });
 
     const state = encodeOAuthState(req);
 
     const params = {
-      client_id,
+      client_id: clientId,
       redirect_uri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/intercom/callback`,
       state,
       response_type: "code",

packages/app-store/intercom/api/callback.ts

@@ -12,9 +12,6 @@ import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 
 const log = logger.getSubLogger({ prefix: [`[[intercom/api/callback]`] });
 
-let client_id = "";
-let client_secret = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { code } = req.query;
 
@@ -26,12 +23,14 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return res.status(401).json({ message: "You must be logged in to do this" });
   }
 
+  let clientId = "";
+  let clientSecret = "";
   const appKeys = await getAppKeysFromSlug("intercom");
 
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (!client_id) return res.status(400).json({ message: "Intercom client_id missing." });
-  if (!client_secret) return res.status(400).json({ message: "Intercom client_secret missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (!clientId) return res.status(400).json({ message: "Intercom client_id missing." });
+  if (!clientSecret) return res.status(400).json({ message: "Intercom client_secret missing." });
 
   const response = await fetch(`https://api.intercom.io/auth/eagle/token`, {
     method: "POST",
@@ -40,8 +39,8 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     },
     body: JSON.stringify({
       code,
-      client_id,
-      client_secret,
+      client_id: clientId,
+      client_secret: clientSecret,
     }),
   });
 

packages/app-store/office365calendar/api/add.ts

@@ -8,18 +8,17 @@ import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
 const scopes = ["User.Read", "Calendars.Read", "Calendars.ReadWrite", "offline_access"];
 
-let client_id = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method === "GET") {
+    let clientId = "";
     const appKeys = await getAppKeysFromSlug("office365-calendar");
-    if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-    if (!client_id) return res.status(400).json({ message: "Office 365 client_id missing." });
+    if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+    if (!clientId) return res.status(400).json({ message: "Office 365 client_id missing." });
     const state = encodeOAuthState(req);
     const params = {
       response_type: "code",
       scope: scopes.join(" "),
-      client_id,
+      client_id: clientId,
       prompt: "select_account",
       redirect_uri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/office365calendar/callback`,
       state,

packages/app-store/office365calendar/api/callback.ts

@@ -14,9 +14,6 @@ import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 
 const scopes = ["offline_access", "Calendars.Read", "Calendars.ReadWrite"];
 
-let client_id = "";
-let client_secret = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { code } = req.query;
   const state = decodeOAuthState(req);
@@ -34,11 +31,13 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return;
   }
 
+  let clientId = "";
+  let clientSecret = "";
   const appKeys = await getAppKeysFromSlug("office365-calendar");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (!client_id) return res.status(400).json({ message: "Office 365 client_id missing." });
-  if (!client_secret) return res.status(400).json({ message: "Office 365 client_secret missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (!clientId) return res.status(400).json({ message: "Office 365 client_id missing." });
+  if (!clientSecret) return res.status(400).json({ message: "Office 365 client_secret missing." });
 
   const toUrlEncoded = (payload: Record<string, string>) =>
     Object.keys(payload)
@@ -46,12 +45,12 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
       .join("&");
 
   const body = toUrlEncoded({
-    client_id,
+    client_id: clientId,
     grant_type: "authorization_code",
     code,
     scope: scopes.join(" "),
     redirect_uri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/office365calendar/callback`,
-    client_secret,
+    client_secret: clientSecret,
   });
 
   const response = await fetch("https://login.microsoftonline.com/common/oauth2/v2.0/token", {

packages/app-store/office365video/api/add.ts

@@ -8,18 +8,17 @@ import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
 const scopes = ["OnlineMeetings.ReadWrite", "offline_access"];
 
-let client_id = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method === "GET") {
+    let clientId = "";
     const appKeys = await getAppKeysFromSlug("msteams");
-    if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-    if (!client_id) return res.status(400).json({ message: "Office 365 client_id missing." });
+    if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+    if (!clientId) return res.status(400).json({ message: "Office 365 client_id missing." });
     const state = encodeOAuthState(req);
     const params = {
       response_type: "code",
       scope: scopes.join(" "),
-      client_id,
+      client_id: clientId,
       redirect_uri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/office365video/callback`,
       state,
     };

packages/app-store/office365video/api/callback.ts

@@ -11,9 +11,6 @@ import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 
 const scopes = ["OnlineMeetings.ReadWrite", "offline_access"];
 
-let client_id = "";
-let client_secret = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { code } = req.query;
   const state = decodeOAuthState(req);
@@ -31,11 +28,13 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return;
   }
 
+  let clientId = "";
+  let clientSecret = "";
   const appKeys = await getAppKeysFromSlug("msteams");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (!client_id) return res.status(400).json({ message: "Office 365 client_id missing." });
-  if (!client_secret) return res.status(400).json({ message: "Office 365 client_secret missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (!clientId) return res.status(400).json({ message: "Office 365 client_id missing." });
+  if (!clientSecret) return res.status(400).json({ message: "Office 365 client_secret missing." });
 
   const toUrlEncoded = (payload: Record<string, string>) =>
     Object.keys(payload)
@@ -43,12 +42,12 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
       .join("&");
 
   const body = toUrlEncoded({
-    client_id,
+    client_id: clientId,
     grant_type: "authorization_code",
     code,
     scope: scopes.join(" "),
     redirect_uri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/office365video/callback`,
-    client_secret,
+    client_secret: clientSecret,
   });
 
   const response = await fetch("https://login.microsoftonline.com/common/oauth2/v2.0/token", {

packages/app-store/routing-forms/trpc/utils.ts

@@ -12,18 +12,6 @@ import type { Ensure } from "@calcom/types/utils";
 import type { SerializableField, OrderedResponses } from "../types/types";
 import type { FormResponse, SerializableForm } from "../types/types";
 
-let tasker: Tasker;
-
-if (typeof window === "undefined") {
-  import("@calcom/features/tasker")
-    .then((module) => {
-      tasker = module.default;
-    })
-    .catch((error) => {
-      console.error("Failed to load tasker:", error);
-    });
-}
-
 const moduleLogger = logger.getSubLogger({ prefix: ["routing-forms/trpc/utils"] });
 
 type SelectFieldWebhookResponse = string | number | string[] | { label: string; id: string | null };
@@ -171,6 +159,18 @@ export async function onFormSubmission(
     });
   });
 
+  let tasker: Tasker;
+
+  if (typeof window === "undefined") {
+    import("@calcom/features/tasker")
+      .then((module) => {
+        tasker = module.default;
+      })
+      .catch((error) => {
+        console.error("Failed to load tasker:", error);
+      });
+  }
+
   const promisesFormSubmittedNoEvent = webhooksFormSubmittedNoEvent.map((webhook) => {
     const scheduledAt = dayjs().add(15, "minute").toDate();
 

packages/app-store/salesforce/api/add.ts

@@ -6,18 +6,17 @@ import { WEBAPP_URL_FOR_OAUTH } from "@calcom/lib/constants";
 import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
 import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
-let consumer_key = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method !== "GET") return res.status(405).json({ message: "Method not allowed" });
 
+  let consumerKey = "";
   const appKeys = await getAppKeysFromSlug("salesforce");
-  if (typeof appKeys.consumer_key === "string") consumer_key = appKeys.consumer_key;
-  if (!consumer_key) return res.status(400).json({ message: "Salesforce client id missing." });
+  if (typeof appKeys.consumer_key === "string") consumerKey = appKeys.consumer_key;
+  if (!consumerKey) return res.status(400).json({ message: "Salesforce client id missing." });
 
   const salesforceClient = new jsforce.Connection({
     oauth2: {
-      clientId: consumer_key,
+      clientId: consumerKey,
       redirectUri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/salesforce/callback`,
     },
   });

packages/app-store/salesforce/api/callback.ts

@@ -10,9 +10,6 @@ import createOAuthAppCredential from "../../_utils/oauth/createOAuthAppCredentia
 import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 import appConfig from "../config.json";
 
-let consumer_key = "";
-let consumer_secret = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   const { code } = req.query;
   const state = decodeOAuthState(req);
@@ -26,16 +23,18 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return res.status(401).json({ message: "You must be logged in to do this" });
   }
 
+  let consumerKey = "";
+  let consumerSecret = "";
   const appKeys = await getAppKeysFromSlug("salesforce");
-  if (typeof appKeys.consumer_key === "string") consumer_key = appKeys.consumer_key;
-  if (typeof appKeys.consumer_secret === "string") consumer_secret = appKeys.consumer_secret;
-  if (!consumer_key) return res.status(400).json({ message: "Salesforce consumer key missing." });
-  if (!consumer_secret) return res.status(400).json({ message: "Salesforce consumer secret missing." });
+  if (typeof appKeys.consumer_key === "string") consumerKey = appKeys.consumer_key;
+  if (typeof appKeys.consumer_secret === "string") consumerSecret = appKeys.consumer_secret;
+  if (!consumerKey) return res.status(400).json({ message: "Salesforce consumer key missing." });
+  if (!consumerSecret) return res.status(400).json({ message: "Salesforce consumer secret missing." });
 
   const conn = new jsforce.Connection({
     oauth2: {
-      clientId: consumer_key,
-      clientSecret: consumer_secret,
+      clientId: consumerKey,
+      clientSecret: consumerSecret,
       redirectUri: `${WEBAPP_URL_FOR_OAUTH}/api/integrations/salesforce/callback`,
     },
   });

packages/app-store/tandemvideo/api/add.ts

@@ -6,9 +6,6 @@ import prisma from "@calcom/prisma";
 
 import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
 
-let client_id = "";
-let base_url = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (req.method === "GET") {
     // Get user
@@ -21,20 +18,22 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
       },
     });
 
+    let clientId = "";
+    let baseUrl = "";
     const appKeys = await getAppKeysFromSlug("tandem");
-    if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-    if (typeof appKeys.base_url === "string") base_url = appKeys.base_url;
-    if (!client_id) return res.status(400).json({ message: "Tandem client_id missing." });
-    if (!base_url) return res.status(400).json({ message: "Tandem base_url missing." });
+    if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+    if (typeof appKeys.base_url === "string") baseUrl = appKeys.base_url;
+    if (!clientId) return res.status(400).json({ message: "Tandem client_id missing." });
+    if (!baseUrl) return res.status(400).json({ message: "Tandem base_url missing." });
 
     const redirect_uri = encodeURI(`${WEBAPP_URL}/api/integrations/tandemvideo/callback`);
 
     const params = {
-      client_id,
+      client_id: clientId,
       redirect_uri,
     };
     const query = stringify(params);
-    const url = `${base_url}/oauth/approval?${query}`;
+    const url = `${baseUrl}/oauth/approval?${query}`;
     res.status(200).json({ url });
   }
 }

packages/app-store/tandemvideo/api/callback.ts

@@ -8,10 +8,6 @@ import getInstalledAppPath from "../../_utils/getInstalledAppPath";
 import createOAuthAppCredential from "../../_utils/oauth/createOAuthAppCredential";
 import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 
-let client_id = "";
-let client_secret = "";
-let base_url = "https://tandem.chat";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
   if (!req.query.code) {
     res.status(401).json({ message: "Missing code" });
@@ -21,20 +17,23 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
   const code = req.query.code as string;
   const state = decodeOAuthState(req);
 
+  let clientId = "";
+  let clientSecret = "";
+  let baseUrl = "https://tandem.chat";
   const appKeys = await getAppKeysFromSlug("tandem");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (typeof appKeys.base_url === "string") base_url = appKeys.base_url;
-  if (!client_id) return res.status(400).json({ message: "Tandem client_id missing." });
-  if (!client_secret) return res.status(400).json({ message: "Tandem client_secret missing." });
-  if (!base_url) return res.status(400).json({ message: "Tandem base_url missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (typeof appKeys.base_url === "string") baseUrl = appKeys.base_url;
+  if (!clientId) return res.status(400).json({ message: "Tandem client_id missing." });
+  if (!clientSecret) return res.status(400).json({ message: "Tandem client_secret missing." });
+  if (!baseUrl) return res.status(400).json({ message: "Tandem base_url missing." });
 
-  const result = await fetch(`${base_url}/api/v1/oauth/v2/token`, {
+  const result = await fetch(`${baseUrl}/api/v1/oauth/v2/token`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
     },
-    body: JSON.stringify({ code, client_id, client_secret }),
+    body: JSON.stringify({ code, client_id: clientId, client_secret: clientSecret }),
   });
 
   const responseBody = await result.json();

packages/app-store/tandemvideo/lib/VideoApiAdapter.ts

@@ -32,28 +32,36 @@ interface ITandemCreateMeetingResponse {
   };
 }
 
-let client_id = "";
-let client_secret = "";
-let base_url = "";
+const loadConfiguration = async () => {
+  const appKeys = await getAppKeysFromSlug("tandem");
+  let clientId = "";
+  let clientSecret = "";
+  let baseUrl = "";
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (typeof appKeys.base_url === "string") baseUrl = appKeys.base_url;
+  if (!clientId) throw new HttpError({ statusCode: 400, message: "Tandem client_id missing." });
+  if (!clientSecret) throw new HttpError({ statusCode: 400, message: "Tandem client_secret missing." });
+  if (!baseUrl) throw new HttpError({ statusCode: 400, message: "Tandem base_url missing." });
+
+  return {
+    clientId,
+    clientSecret,
+    baseUrl,
+  };
+};
 
 const tandemAuth = async (credential: CredentialPayload) => {
-  const appKeys = await getAppKeysFromSlug("tandem");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (typeof appKeys.base_url === "string") base_url = appKeys.base_url;
-  if (!client_id) throw new HttpError({ statusCode: 400, message: "Tandem client_id missing." });
-  if (!client_secret) throw new HttpError({ statusCode: 400, message: "Tandem client_secret missing." });
-  if (!base_url) throw new HttpError({ statusCode: 400, message: "Tandem base_url missing." });
-
+  const configuration = await loadConfiguration();
   const credentialKey = credential.key as unknown as TandemToken;
   const isTokenValid = (token: TandemToken) => token && token.access_token && token.expiry_date < Date.now();
 
   const refreshAccessToken = async (refreshToken: string) => {
-    const result = await fetch(`${base_url}/api/v1/oauth/v2/token`, {
+    const result = await fetch(`${configuration.baseUrl}/api/v1/oauth/v2/token`, {
       method: "POST",
       body: new URLSearchParams({
-        client_id,
-        client_secret,
+        client_id: configuration.clientId,
+        client_secret: configuration.clientSecret,
         code: refreshToken,
       }),
     });
@@ -121,8 +129,9 @@ const TandemVideoApiAdapter = (credential: CredentialPayload): VideoApiAdapter =
     },
     createMeeting: async (event: CalendarEvent): Promise<VideoCallData> => {
       const accessToken = await (await auth).getToken();
+      const configuration = await loadConfiguration();
 
-      const result = await fetch(`${base_url}/api/v1/meetings`, {
+      const result = await fetch(`${configuration.baseUrl}/api/v1/meetings`, {
         method: "POST",
         headers: {
           Authorization: `Bearer ${accessToken}`,
@@ -137,8 +146,9 @@ const TandemVideoApiAdapter = (credential: CredentialPayload): VideoApiAdapter =
 
     deleteMeeting: async (uid: string): Promise<void> => {
       const accessToken = await (await auth).getToken();
+      const configuration = await loadConfiguration();
 
-      await fetch(`${base_url}/api/v1/meetings/${uid}`, {
+      await fetch(`${configuration.baseUrl}/api/v1/meetings/${uid}`, {
         method: "DELETE",
         headers: {
           Authorization: `Bearer ${accessToken}`,
@@ -150,8 +160,9 @@ const TandemVideoApiAdapter = (credential: CredentialPayload): VideoApiAdapter =
 
     updateMeeting: async (bookingRef: PartialReference, event: CalendarEvent): Promise<VideoCallData> => {
       const accessToken = await (await auth).getToken();
+      const configuration = await loadConfiguration();
 
-      const result = await fetch(`${base_url}/api/v1/meetings/${bookingRef.meetingId}`, {
+      const result = await fetch(`${configuration.baseUrl}/api/v1/meetings/${bookingRef.meetingId}`, {
         method: "PUT",
         headers: {
           Authorization: `Bearer ${accessToken}`,

packages/app-store/zohocrm/api/_getAdd.ts

@@ -6,16 +6,15 @@ import { WEBAPP_URL } from "@calcom/lib/constants";
 import getAppKeysFromSlug from "../../_utils/getAppKeysFromSlug";
 import { encodeOAuthState } from "../../_utils/oauth/encodeOAuthState";
 
-let client_id = "";
-
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  let clientId = "";
   const appKeys = await getAppKeysFromSlug("zohocrm");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (!client_id) return res.status(400).json({ message: "zohocrm client id missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (!clientId) return res.status(400).json({ message: "zohocrm client id missing." });
   const state = encodeOAuthState(req);
 
   const params = {
-    client_id,
+    client_id: clientId,
     response_type: "code",
     redirect_uri: `${WEBAPP_URL}/api/integrations/zohocrm/callback`,
     scope: ["ZohoCRM.modules.ALL", "ZohoCRM.users.READ", "AaaServer.profile.READ"],

packages/app-store/zohocrm/api/callback.ts

@@ -11,8 +11,6 @@ import createOAuthAppCredential from "../../_utils/oauth/createOAuthAppCredentia
 import { decodeOAuthState } from "../../_utils/oauth/decodeOAuthState";
 import appConfig from "../config.json";
 
-let client_id = "";
-let client_secret = "";
 function isAuthorizedAccountsServerUrl(accountsServer: string) {
   // As per https://www.zoho.com/crm/developer/docs/api/v6/multi-dc.html#:~:text=US:%20https://accounts.zoho,https://accounts.zohocloud.ca&text=The%20%22location=us%22%20parameter,domain%20in%20all%20API%20endpoints.&text=You%20must%20make%20the%20authorization,.zoho.com.cn.
   const authorizedAccountServers = [
@@ -49,17 +47,19 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse)
     return res.status(401).json({ message: "You must be logged in to do this" });
   }
 
+  let clientId = "";
+  let clientSecret = "";
   const appKeys = await getAppKeysFromSlug("zohocrm");
-  if (typeof appKeys.client_id === "string") client_id = appKeys.client_id;
-  if (typeof appKeys.client_secret === "string") client_secret = appKeys.client_secret;
-  if (!client_id) return res.status(400).json({ message: "Zoho Crm consumer key missing." });
-  if (!client_secret) return res.status(400).json({ message: "Zoho Crm consumer secret missing." });
+  if (typeof appKeys.client_id === "string") clientId = appKeys.client_id;
+  if (typeof appKeys.client_secret === "string") clientSecret = appKeys.client_secret;
+  if (!clientId) return res.status(400).json({ message: "Zoho Crm consumer key missing." });
+  if (!clientSecret) return res.status(400).json({ message: "Zoho Crm consumer secret missing." });
   const url = `${accountsServer}/oauth/v2/token`;
   const redirectUri = `${WEBAPP_URL}/api/integrations/zohocrm/callback`;
   const formData = {
     grant_type: "authorization_code",
-    client_id: client_id,
-    client_secret: client_secret,
+    client_id: clientId,
+    client_secret: clientSecret,
     redirect_uri: redirectUri,
     code: code,
   };

packages/features/data-table/components/filters/DateRangeFilter.tsx

@@ -25,6 +25,7 @@ import {
   PRESET_OPTIONS,
   getDefaultStartDate,
   getDefaultEndDate,
+  getDateRangeFromPreset,
   type PresetOption,
 } from "../../lib/dateRange";
 import type { FilterableColumn, DateRangeFilterOptions } from "../../lib/types";
@@ -36,44 +37,6 @@ type DateRangeFilterProps = {
   showClearButton?: boolean;
 };
 
-const getDateRangeFromPreset = (val: string | null) => {
-  let startDate;
-  let endDate;
-  const preset = PRESET_OPTIONS.find((o) => o.value === val);
-  if (!preset) {
-    return { startDate: getDefaultStartDate(), endDate: getDefaultEndDate(), preset: CUSTOM_PRESET };
-  }
-
-  switch (val) {
-    case "tdy": // Today
-      startDate = dayjs().startOf("day");
-      endDate = dayjs().endOf("day");
-      break;
-    case "w": // Last 7 days
-      startDate = dayjs().subtract(1, "week").startOf("day");
-      endDate = dayjs().endOf("day");
-      break;
-    case "t": // Last 30 days
-      startDate = dayjs().subtract(30, "day").startOf("day");
-      endDate = dayjs().endOf("day");
-      break;
-    case "m": // Month to Date
-      startDate = dayjs().startOf("month");
-      endDate = dayjs().endOf("day");
-      break;
-    case "y": // Year to Date
-      startDate = dayjs().startOf("year");
-      endDate = dayjs().endOf("day");
-      break;
-    default:
-      startDate = getDefaultStartDate();
-      endDate = getDefaultEndDate();
-      break;
-  }
-
-  return { startDate, endDate, preset };
-};
-
 export const DateRangeFilter = ({ column, options, showClearButton = false }: DateRangeFilterProps) => {
   const filterValue = useFilterValue(column.id, ZDateRangeFilterValue);
   const { updateFilter, removeFilter } = useDataTable();
@@ -137,11 +100,11 @@ export const DateRangeFilter = ({ column, options, showClearButton = false }: Da
         endDate,
       });
     } else {
-      const r = getDateRangeFromPreset(val);
+      const { preset, startDate, endDate } = getDateRangeFromPreset(val);
       updateValues({
-        preset: r.preset,
-        startDate: r.startDate,
-        endDate: r.endDate,
+        preset,
+        startDate,
+        endDate,
       });
     }
   };

packages/features/data-table/hooks/useSegments.ts

@@ -4,7 +4,9 @@ import { useCallback, useMemo, useEffect } from "react";
 
 import { trpc } from "@calcom/trpc/react";
 
+import { recalculateDateRange } from "../lib/dateRange";
 import { ZSegmentStorage, type UseSegments } from "../lib/types";
+import { isDateRangeFilterValue } from "../lib/utils";
 
 export const useSegments: UseSegments = ({
   tableIdentifier,
@@ -25,9 +27,27 @@ export const useSegments: UseSegments = ({
   setPageIndex,
   setSearchTerm,
 }) => {
-  const { data: segments, isFetching: isFetchingSegments } = trpc.viewer.filterSegments.list.useQuery({
+  const { data: rawSegments, isFetching: isFetchingSegments } = trpc.viewer.filterSegments.list.useQuery({
     tableIdentifier,
   });
+
+  // Recalculate date ranges based on the current timestamp
+  const segments = useMemo(() => {
+    if (!rawSegments) return [];
+    return rawSegments.map((segment) => ({
+      ...segment,
+      activeFilters: segment.activeFilters.map((filter) => {
+        if (isDateRangeFilterValue(filter.v)) {
+          return {
+            ...filter,
+            v: recalculateDateRange(filter.v),
+          };
+        }
+        return filter;
+      }),
+    }));
+  }, [rawSegments]);
+
   const selectedSegment = useMemo(
     () => segments?.find((segment) => segment.id === segmentId),
     [segments, segmentId]

packages/features/data-table/lib/dateRange.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from "vitest";
+
+import dayjs from "@calcom/dayjs";
+
+import {
+  getDateRangeFromPreset,
+  recalculateDateRange,
+  PRESET_OPTIONS,
+  CUSTOM_PRESET,
+  DEFAULT_PRESET,
+  CUSTOM_PRESET_VALUE,
+} from "./dateRange";
+import { ColumnFilterType, type DateRangeFilterValue } from "./types";
+
+// Mock dayjs to have consistent timestamps in tests
+vi.mock("@calcom/dayjs", () => {
+  const mockDayjs = vi.fn(() => ({
+    startOf: vi.fn().mockReturnThis(),
+    endOf: vi.fn().mockReturnThis(),
+    subtract: vi.fn().mockReturnThis(),
+    toISOString: vi.fn().mockReturnValue("2024-03-20T00:00:00.000Z"),
+  }));
+  return {
+    default: mockDayjs,
+  };
+});
+
+describe("getDateRangeFromPreset", () => {
+  it("should return default dates for null value", () => {
+    const result = getDateRangeFromPreset(null);
+    expect(result.preset).toEqual(CUSTOM_PRESET);
+    expect(dayjs).toHaveBeenCalled();
+  });
+
+  it("should return today's date range for 'tdy' preset", () => {
+    const result = getDateRangeFromPreset("tdy");
+    expect(result.preset.value).toBe("tdy");
+    expect(dayjs).toHaveBeenCalled();
+  });
+
+  it("should return last 7 days range for 'w' preset", () => {
+    const result = getDateRangeFromPreset("w");
+    expect(result.preset.value).toBe("w");
+    expect(dayjs).toHaveBeenCalled();
+  });
+
+  it("should return last 30 days range for 't' preset", () => {
+    const result = getDateRangeFromPreset("t");
+    expect(result.preset.value).toBe("t");
+    expect(dayjs).toHaveBeenCalled();
+  });
+
+  it("should return month to date range for 'm' preset", () => {
+    const result = getDateRangeFromPreset("m");
+    expect(result.preset.value).toBe("m");
+    expect(dayjs).toHaveBeenCalled();
+  });
+
+  it("should return year to date range for 'y' preset", () => {
+    const result = getDateRangeFromPreset("y");
+    expect(result.preset.value).toBe("y");
+    expect(dayjs).toHaveBeenCalled();
+  });
+});
+
+describe("recalculateDateRange", () => {
+  it("should return custom range as is", () => {
+    const customFilter: DateRangeFilterValue = {
+      type: ColumnFilterType.DATE_RANGE,
+      data: {
+        preset: CUSTOM_PRESET_VALUE,
+        startDate: "2024-03-01T00:00:00.000Z",
+        endDate: "2024-03-15T00:00:00.000Z",
+      },
+    };
+
+    const result = recalculateDateRange(customFilter);
+    expect(result).toEqual(customFilter);
+  });
+
+  it("should recalculate dates for non-custom presets", () => {
+    const filter: DateRangeFilterValue = {
+      type: ColumnFilterType.DATE_RANGE,
+      data: {
+        preset: "w",
+        startDate: "2024-03-01T00:00:00.000Z",
+        endDate: "2024-03-15T00:00:00.000Z",
+      },
+    };
+
+    const result = recalculateDateRange(filter);
+    expect(result.type).toBe(ColumnFilterType.DATE_RANGE);
+    expect(result.data.preset).toBe("w");
+    expect(result.data.startDate).toBe("2024-03-20T00:00:00.000Z");
+    expect(result.data.endDate).toBe("2024-03-20T00:00:00.000Z");
+  });
+});
+
+describe("PRESET_OPTIONS", () => {
+  it("should contain all expected preset options", () => {
+    const expectedValues = ["tdy", "w", "t", "m", "y", "c"];
+    expect(PRESET_OPTIONS.map((o) => o.value)).toEqual(expectedValues);
+  });
+
+  it("should have correct default preset", () => {
+    expect(DEFAULT_PRESET.value).toBe("w");
+    expect(DEFAULT_PRESET.i18nOptions).toEqual({ count: 7 });
+  });
+
+  it("should have correct custom preset", () => {
+    expect(CUSTOM_PRESET.value).toBe(CUSTOM_PRESET_VALUE);
+    expect(CUSTOM_PRESET.labelKey).toBe("custom_range");
+  });
+});

packages/features/data-table/lib/dateRange.ts

@@ -1,5 +1,7 @@
 import dayjs from "@calcom/dayjs";
 
+import { ColumnFilterType, type DateRangeFilterValue } from "./types";
+
 export type PresetOptionValue = "c" | "w" | "m" | "y" | "t" | "tdy";
 
 export type PresetOption = {
@@ -29,3 +31,58 @@ export const PRESET_OPTIONS: PresetOption[] = [
 export const getDefaultStartDate = () => dayjs().subtract(1, "week").startOf("day");
 
 export const getDefaultEndDate = () => dayjs().endOf("day");
+
+export const getDateRangeFromPreset = (val: string | null) => {
+  let startDate;
+  let endDate;
+  const preset = PRESET_OPTIONS.find((o) => o.value === val);
+  if (!preset) {
+    return { startDate: getDefaultStartDate(), endDate: getDefaultEndDate(), preset: CUSTOM_PRESET };
+  }
+
+  switch (val) {
+    case "tdy": // Today
+      startDate = dayjs().startOf("day");
+      endDate = dayjs().endOf("day");
+      break;
+    case "w": // Last 7 days
+      startDate = dayjs().subtract(1, "week").startOf("day");
+      endDate = dayjs().endOf("day");
+      break;
+    case "t": // Last 30 days
+      startDate = dayjs().subtract(30, "day").startOf("day");
+      endDate = dayjs().endOf("day");
+      break;
+    case "m": // Month to Date
+      startDate = dayjs().startOf("month");
+      endDate = dayjs().endOf("day");
+      break;
+    case "y": // Year to Date
+      startDate = dayjs().startOf("year");
+      endDate = dayjs().endOf("day");
+      break;
+    default:
+      throw new Error(`Invalid preset value: ${val}`);
+  }
+
+  return { startDate, endDate, preset };
+};
+
+export const recalculateDateRange = (filterValue: DateRangeFilterValue): DateRangeFilterValue => {
+  // If it's a custom range, return as is
+  if (filterValue.data.preset === CUSTOM_PRESET_VALUE) {
+    return filterValue;
+  }
+
+  // Recalculate dates based on the current timestamp
+  const { startDate, endDate } = getDateRangeFromPreset(filterValue.data.preset);
+
+  return {
+    type: ColumnFilterType.DATE_RANGE,
+    data: {
+      ...filterValue.data,
+      startDate: startDate.toISOString(),
+      endDate: endDate.toISOString(),
+    },
+  };
+};

packages/features/ee/workflows/lib/reminders/providers/sendgridProvider.ts

@@ -10,15 +10,11 @@ import { addHTMLStyles } from "@calcom/emails/templates/workflow-email";
 import { SENDER_NAME } from "@calcom/lib/constants";
 import { setTestEmail } from "@calcom/lib/testEmails";
 
-let sendgridAPIKey: string;
-let senderEmail: string;
-
 const testMode = process.env.NEXT_PUBLIC_IS_E2E || process.env.INTEGRATION_TEST_MODE;
 
 function assertSendgrid() {
   if (process.env.SENDGRID_API_KEY && process.env.SENDGRID_EMAIL) {
-    sendgridAPIKey = process.env.SENDGRID_API_KEY as string;
-    senderEmail = process.env.SENDGRID_EMAIL as string;
+    const sendgridAPIKey = process.env.SENDGRID_API_KEY as string;
     sgMail.setApiKey(sendgridAPIKey);
     client.setApiKey(sendgridAPIKey);
   } else {
@@ -52,7 +48,7 @@ export function sendSendgridMail(
       setTestEmail({
         to: mailData.to?.toString() || "",
         from: {
-          email: senderEmail,
+          email: process.env.SENDGRID_EMAIL as string,
           name: mailData.sender || SENDER_NAME,
         },
         subject: mailData.subject || "",
@@ -66,7 +62,7 @@ export function sendSendgridMail(
     return new Promise((r) => r("Skipped sendEmail for Unit Tests"));
   }
 
-  if (!sendgridAPIKey) {
+  if (!process.env.SENDGRID_API_KEY) {
     console.info("No sendgrid API key provided, skipping email");
     return Promise.resolve();
   }
@@ -74,13 +70,13 @@ export function sendSendgridMail(
   return sgMail.send({
     to: mailData.to,
     from: {
-      email: senderEmail,
+      email: process.env.SENDGRID_EMAIL as string,
       name: mailData.sender || SENDER_NAME,
     },
     subject: mailData.subject,
     html: addHTMLStyles(mailData.html),
     batchId: mailData.batchId,
-    replyTo: mailData.replyTo || senderEmail,
+    replyTo: mailData.replyTo || (process.env.SENDGRID_EMAIL as string),
     attachments: mailData.attachments,
     sendAt: mailData.sendAt,
   });

packages/features/shell/Shell.tsx

@@ -158,7 +158,7 @@ export function ShellMain(props: LayoutProps) {
                 {props.heading && (
                   <h3
                     className={classNames(
-                      "font-cal text-emphasis max-w-28 sm:max-w-72 md:max-w-80 truncate text-lg font-semibold tracking-wide sm:text-xl xl:max-w-full",
+                      "font-cal text-emphasis max-w-28 sm:max-w-72 md:max-w-80 hidden truncate text-lg font-semibold tracking-wide sm:text-xl md:block xl:max-w-full",
                       props.smallHeading ? "text-base" : "text-xl"
                     )}>
                     {!isLocaleReady ? <SkeletonText invisible /> : props.heading}

packages/lib/rateLimit.ts

@@ -16,22 +16,13 @@ export type RateLimitHelper = {
   onRateLimiterResponse?: (response: RatelimitResponse) => void;
 };
 
-let warningDisplayed = false;
-
-/** Prevent flooding the logs while testing/building */
-function logOnce(message: string) {
-  if (warningDisplayed) return;
-  log.warn(message);
-  warningDisplayed = true;
-}
-
 export const API_KEY_RATE_LIMIT = 30;
 
 export function rateLimiter() {
   const { UNKEY_ROOT_KEY } = process.env;
 
   if (!UNKEY_ROOT_KEY) {
-    logOnce("Disabled due to not finding UNKEY_ROOT_KEY env variable");
+    log.warn("Disabled due to not finding UNKEY_ROOT_KEY env variable");
     return () => ({ success: true, limit: 10, remaining: 999, reset: 0 } as RatelimitResponse);
   }
   const timeout = {

packages/platform/atoms/hooks/event-types/public/useTeamEventType.ts

@@ -11,8 +11,6 @@ export const QUERY_KEY = "use-team-event-type";
 
 export const useTeamEventType = (teamId: number | undefined, eventSlug: string, isTeamEvent: boolean | undefined, hostsLimit?: number) => {
   const { organizationId } = useAtomsContext();
-
-
   const requestEventSlug = eventSlug;
 
   let pathname = `/organizations/${organizationId}/teams/${teamId}/event-types?eventSlug=${requestEventSlug}`;

packages/trpc/server/routers/loggedInViewer/_router.tsx

@@ -1,5 +1,5 @@
 import authedProcedure from "../../procedures/authedProcedure";
-import { importHandler, router } from "../../trpc";
+import { router } from "../../trpc";
 import { ZAddNotificationsSubscriptionInputSchema } from "./addNotificationsSubscription.schema";
 import { ZAddSecondaryEmailInputSchema } from "./addSecondaryEmail.schema";
 import { ZConnectAndJoinInputSchema } from "./connectAndJoin.schema";
@@ -10,10 +10,6 @@ import { ZRemoveNotificationsSubscriptionInputSchema } from "./removeNotificatio
 import { ZRoutingFormOrderInputSchema } from "./routingFormOrder.schema";
 import { ZSubmitFeedbackInputSchema } from "./submitFeedback.schema";
 
-const NAMESPACE = "loggedInViewer";
-
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 type AppsRouterHandlerCache = {
   stripeCustomer?: typeof import("./stripeCustomer.handler").stripeCustomerHandler;
   eventTypeOrder?: typeof import("./eventTypeOrder.handler").eventTypeOrderHandler;
@@ -27,145 +23,59 @@ type AppsRouterHandlerCache = {
   markNoShow?: typeof import("./markNoShow.handler").markNoShow;
 };
 
-const UNSTABLE_HANDLER_CACHE: AppsRouterHandlerCache = {};
-
 export const loggedInViewerRouter = router({
   stripeCustomer: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.stripeCustomer) {
-      UNSTABLE_HANDLER_CACHE.stripeCustomer = (
-        await import("./stripeCustomer.handler")
-      ).stripeCustomerHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.stripeCustomer) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.stripeCustomer({ ctx });
+    const { stripeCustomerHandler } = await import("./stripeCustomer.handler");
+    return stripeCustomerHandler({ ctx });
   }),
 
   unlinkConnectedAccount: authedProcedure.mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("unlinkConnectedAccount"),
-      () => import("./unlinkConnectedAccount.handler")
+    const unlinkConnectedAccountHandler = await import("./unlinkConnectedAccount.handler").then(
+      (mod) => mod.default
     );
-    return handler(opts);
+    return unlinkConnectedAccountHandler(opts);
   }),
 
   eventTypeOrder: authedProcedure.input(ZEventTypeOrderInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.eventTypeOrder) {
-      UNSTABLE_HANDLER_CACHE.eventTypeOrder = (
-        await import("./eventTypeOrder.handler")
-      ).eventTypeOrderHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.eventTypeOrder) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.eventTypeOrder({ ctx, input });
+    const { eventTypeOrderHandler } = await import("./eventTypeOrder.handler");
+    return eventTypeOrderHandler({ ctx, input });
   }),
 
   routingFormOrder: authedProcedure.input(ZRoutingFormOrderInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.routingFormOrder) {
-      UNSTABLE_HANDLER_CACHE.routingFormOrder = (
-        await import("./routingFormOrder.handler")
-      ).routingFormOrderHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.routingFormOrder) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.routingFormOrder({ ctx, input });
+    const { routingFormOrderHandler } = await import("./routingFormOrder.handler");
+    return routingFormOrderHandler({ ctx, input });
   }),
 
   //Comment for PR: eventTypePosition is not used anywhere
   submitFeedback: authedProcedure.input(ZSubmitFeedbackInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.submitFeedback) {
-      UNSTABLE_HANDLER_CACHE.submitFeedback = (
-        await import("./submitFeedback.handler")
-      ).submitFeedbackHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.submitFeedback) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.submitFeedback({ ctx, input });
+    const { submitFeedbackHandler } = await import("./submitFeedback.handler");
+    return submitFeedbackHandler({ ctx, input });
   }),
   teamsAndUserProfilesQuery,
   connectAndJoin: authedProcedure.input(ZConnectAndJoinInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.connectAndJoin) {
-      UNSTABLE_HANDLER_CACHE.connectAndJoin = (await import("./connectAndJoin.handler")).Handler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.connectAndJoin) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.connectAndJoin({ ctx, input });
+    const { Handler } = await import("./connectAndJoin.handler");
+    return Handler({ ctx, input });
   }),
   addSecondaryEmail: authedProcedure.input(ZAddSecondaryEmailInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.addSecondaryEmail) {
-      UNSTABLE_HANDLER_CACHE.addSecondaryEmail = (
-        await import("./addSecondaryEmail.handler")
-      ).addSecondaryEmailHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.addSecondaryEmail) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.addSecondaryEmail({ ctx, input });
+    const { addSecondaryEmailHandler } = await import("./addSecondaryEmail.handler");
+    return addSecondaryEmailHandler({ ctx, input });
   }),
   addNotificationsSubscription: authedProcedure
     .input(ZAddNotificationsSubscriptionInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.addNotificationsSubscription) {
-        UNSTABLE_HANDLER_CACHE.addNotificationsSubscription = (
-          await import("./addNotificationsSubscription.handler")
-        ).addNotificationsSubscriptionHandler;
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.addNotificationsSubscription) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.addNotificationsSubscription({ ctx, input });
+      const { addNotificationsSubscriptionHandler } = await import("./addNotificationsSubscription.handler");
+      return addNotificationsSubscriptionHandler({ ctx, input });
     }),
   removeNotificationsSubscription: authedProcedure
     .input(ZRemoveNotificationsSubscriptionInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.removeNotificationsSubscription) {
-        UNSTABLE_HANDLER_CACHE.removeNotificationsSubscription = (
-          await import("./removeNotificationsSubscription.handler")
-        ).removeNotificationsSubscriptionHandler;
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.removeNotificationsSubscription) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.removeNotificationsSubscription({ ctx, input });
+      const { removeNotificationsSubscriptionHandler } = await import(
+        "./removeNotificationsSubscription.handler"
+      );
+      return removeNotificationsSubscriptionHandler({ ctx, input });
     }),
   markNoShow: authedProcedure.input(ZNoShowInputSchema).mutation(async (opts) => {
-    if (!UNSTABLE_HANDLER_CACHE.markNoShow) {
-      UNSTABLE_HANDLER_CACHE.markNoShow = (await import("./markNoShow.handler")).markNoShow;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.markNoShow) {
-      throw new Error("Failed to load handler");
-    }
-    return UNSTABLE_HANDLER_CACHE.markNoShow(opts);
+    const { markNoShow } = await import("./markNoShow.handler");
+    return markNoShow(opts);
   }),
 });

packages/trpc/server/routers/publicViewer/_router.tsx

@@ -1,5 +1,5 @@
 import publicProcedure from "../../procedures/publicProcedure";
-import { importHandler, router } from "../../trpc";
+import { router } from "../../trpc";
 import { ZUserEmailVerificationRequiredSchema } from "./checkIfUserEmailVerificationRequired.schema";
 import { ZMarkHostAsNoShowInputSchema } from "./markHostAsNoShow.schema";
 import { event } from "./procedures/event";
@@ -16,50 +16,35 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 export const publicViewerRouter = router({
   session,
   countryCode: publicProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("countryCode"), () => import("./countryCode.handler"));
+    const { default: handler } = await import("./countryCode.handler");
     return handler(opts);
   }),
   submitRating: publicProcedure.input(ZSubmitRatingInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("submitRating"), () => import("./submitRating.handler"));
+    const { default: handler } = await import("./submitRating.handler");
     return handler(opts);
   }),
   markHostAsNoShow: publicProcedure.input(ZMarkHostAsNoShowInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("markHostAsNoShow"),
-      () => import("./markHostAsNoShow.handler")
-    );
+    const { default: handler } = await import("./markHostAsNoShow.handler");
     return handler(opts);
   }),
   samlTenantProduct: publicProcedure.input(ZSamlTenantProductInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("samlTenantProduct"),
-      () => import("./samlTenantProduct.handler")
-    );
+    const { default: handler } = await import("./samlTenantProduct.handler");
     return handler(opts);
   }),
   stripeCheckoutSession: publicProcedure.input(ZStripeCheckoutSessionInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("stripeCheckoutSession"),
-      () => import("./stripeCheckoutSession.handler")
-    );
+    const { default: handler } = await import("./stripeCheckoutSession.handler");
     return handler(opts);
   }),
   event,
   ssoConnections: publicProcedure.query(async () => {
-    const handler = await importHandler(
-      namespaced("ssoConnections"),
-      () => import("./ssoConnections.handler")
-    );
+    const { default: handler } = await import("./ssoConnections.handler");
     return handler();
   }),
 
   checkIfUserEmailVerificationRequired: publicProcedure
     .input(ZUserEmailVerificationRequiredSchema)
     .query(async (opts) => {
-      const handler = await importHandler(
-        namespaced("checkIfUserEmailVerificationRequired"),
-        () => import("./checkIfUserEmailVerificationRequired.handler")
-      );
+      const { default: handler } = await import("./checkIfUserEmailVerificationRequired.handler");
       return handler(opts);
     }),
 });

packages/trpc/server/routers/publicViewer/procedures/event.ts

@@ -1,6 +1,5 @@
 import { getUserSession } from "../../../middlewares/sessionMiddleware";
 import publicProcedure from "../../../procedures/publicProcedure";
-import { importHandler } from "../../../trpc";
 import { ZEventInputSchema } from "../event.schema";
 
 const NAMESPACE = "publicViewer";
@@ -8,6 +7,6 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 
 export const event = publicProcedure.input(ZEventInputSchema).query(async (opts) => {
   const { user } = await getUserSession(opts.ctx);
-  const handler = await importHandler(namespaced("event"), () => import("../event.handler"));
+  const { default: handler } = await import("../event.handler");
   return handler({ input: opts.input, userId: user?.id });
 });

packages/trpc/server/routers/publicViewer/procedures/session.ts

@@ -1,12 +1,11 @@
 import sessionMiddleware from "../../../middlewares/sessionMiddleware";
 import publicProcedure from "../../../procedures/publicProcedure";
-import { importHandler } from "../../../trpc";
 
 const NAMESPACE = "publicViewer";
 
 const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 
 export const session = publicProcedure.use(sessionMiddleware).query(async (opts) => {
-  const handler = await importHandler(namespaced("session"), () => import("../session.handler"));
+  const { default: handler } = await import("../session.handler");
   return handler(opts);
 });

packages/trpc/server/routers/publicViewer/timezones/_router.tsx

@@ -1,5 +1,5 @@
 import publicProcedure from "../../../procedures/publicProcedure";
-import { importHandler, router } from "../../../trpc";
+import { router } from "../../../trpc";
 import { cityTimezonesSchema } from "./cityTimezones.schema";
 
 const NAMESPACE = "publicViewer";
@@ -9,10 +9,7 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 // things that unauthenticated users can query about themselves
 export const timezonesRouter = router({
   cityTimezones: publicProcedure.input(cityTimezonesSchema).query(async () => {
-    const handler = await importHandler(
-      namespaced("cityTimezones"),
-      () => import("@calcom/features/cityTimezones/cityTimezonesHandler")
-    );
+    const { default: handler } = await import("@calcom/features/cityTimezones/cityTimezonesHandler");
     return handler();
   }),
 });

packages/trpc/server/routers/viewer/admin/_router.ts

@@ -1,5 +1,5 @@
 import { authedAdminProcedure } from "../../../procedures/authedProcedure";
-import { importHandler, router } from "../../../trpc";
+import { router } from "../../../trpc";
 import { ZCreateSelfHostedLicenseSchema } from "./createSelfHostedLicenseKey.schema";
 import { ZListMembersSchema } from "./listPaginated.schema";
 import { ZAdminLockUserAccountSchema } from "./lockUserAccount.schema";
@@ -21,97 +21,61 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 
 export const adminRouter = router({
   listPaginated: authedAdminProcedure.input(ZListMembersSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("listPaginated"), () => import("./listPaginated.handler"));
+    const { default: handler } = await import("./listPaginated.handler");
     return handler(opts);
   }),
   sendPasswordReset: authedAdminProcedure.input(ZAdminPasswordResetSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("sendPasswordReset"),
-      () => import("./sendPasswordReset.handler")
-    );
+    const { default: handler } = await import("./sendPasswordReset.handler");
     return handler(opts);
   }),
   lockUserAccount: authedAdminProcedure.input(ZAdminLockUserAccountSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("lockUserAccount"),
-      () => import("./lockUserAccount.handler")
-    );
+    const { default: handler } = await import("./lockUserAccount.handler");
     return handler(opts);
   }),
   toggleFeatureFlag,
   removeTwoFactor: authedAdminProcedure.input(ZAdminRemoveTwoFactor).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("removeTwoFactor"),
-      () => import("./removeTwoFactor.handler")
-    );
+    const { default: handler } = await import("./removeTwoFactor.handler");
     return handler(opts);
   }),
   getSMSLockStateTeamsUsers: authedAdminProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getSMSLockStateTeamsUsers"),
-      () => import("./getSMSLockStateTeamsUsers.handler")
-    );
+    const { default: handler } = await import("./getSMSLockStateTeamsUsers.handler");
     return handler(opts);
   }),
   setSMSLockState: authedAdminProcedure.input(ZSetSMSLockState).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("setSMSLockState"),
-      () => import("./setSMSLockState.handler")
-    );
+    const { default: handler } = await import("./setSMSLockState.handler");
     return handler(opts);
   }),
   createSelfHostedLicense: authedAdminProcedure
     .input(ZCreateSelfHostedLicenseSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("createSelfHostedLicense"),
-        () => import("./createSelfHostedLicenseKey.handler")
-      );
+      const { default: handler } = await import("./createSelfHostedLicenseKey.handler");
       return handler(opts);
     }),
   verifyWorkflows: authedAdminProcedure.input(ZAdminVerifyWorkflowsSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("verifyWorkflows"),
-      () => import("./verifyWorkflows.handler")
-    );
+    const { default: handler } = await import("./verifyWorkflows.handler");
     return handler(opts);
   }),
   workspacePlatform: router({
     list: authedAdminProcedure.query(async () => {
-      const handler = await importHandler(
-        namespaced("workspacePlatforms.list"),
-        () => import("./workspacePlatform/list.handler")
-      );
+      const { default: handler } = await import("./workspacePlatform/list.handler");
       return handler();
     }),
     add: authedAdminProcedure.input(workspacePlatformCreateSchema).mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("workspacePlatforms.add"),
-        () => import("./workspacePlatform/add.handler")
-      );
+      const { default: handler } = await import("./workspacePlatform/add.handler");
       return handler(opts);
     }),
     update: authedAdminProcedure.input(workspacePlatformUpdateSchema).mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("workspacePlatforms.update"),
-        () => import("./workspacePlatform/update.handler")
-      );
+      const { default: handler } = await import("./workspacePlatform/update.handler");
       return handler(opts);
     }),
     updateServiceAccount: authedAdminProcedure
       .input(workspacePlatformUpdateServiceAccountSchema)
       .mutation(async (opts) => {
-        const handler = await importHandler(
-          namespaced("workspacePlatforms.updateServiceAccount"),
-          () => import("./workspacePlatform/updateServiceAccount.handler")
-        );
+        const { default: handler } = await import("./workspacePlatform/updateServiceAccount.handler");
         return handler(opts);
       }),
     toggleEnabled: authedAdminProcedure.input(workspacePlatformToggleEnabledSchema).mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("workspacePlatforms.toggleEnabled"),
-        () => import("./workspacePlatform/toggleEnabled.handler")
-      );
+      const { default: handler } = await import("./workspacePlatform/toggleEnabled.handler");
       return handler(opts);
     }),
   }),

packages/trpc/server/routers/viewer/admin/toggleFeatureFlag.procedure.ts

@@ -1,13 +1,9 @@
 import { authedAdminProcedure } from "../../../procedures/authedProcedure";
-import { importHandler } from "../../../trpc";
 import { ZAdminToggleFeatureFlagSchema } from "./toggleFeatureFlag.schema";
 
 export const toggleFeatureFlag = authedAdminProcedure
   .input(ZAdminToggleFeatureFlagSchema)
   .mutation(async (opts) => {
-    const handler = await importHandler(
-      "admin.toggleFeatureFlag",
-      () => import("./toggleFeatureFlag.handler")
-    );
+    const { default: handler } = await import("./toggleFeatureFlag.handler");
     return handler(opts);
   });

packages/trpc/server/routers/viewer/apiKeys/_router.tsx

@@ -13,39 +13,21 @@ type ApiKeysRouterHandlerCache = {
   delete?: typeof import("./delete.handler").deleteHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: ApiKeysRouterHandlerCache = {};
-
 export const apiKeysRouter = router({
   // List keys
   list: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      UNSTABLE_HANDLER_CACHE.list = await import("./list.handler").then((mod) => mod.listHandler);
-    }
+    const { listHandler } = await import("./list.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.list({
+    return listHandler({
       ctx,
     });
   }),
 
   // Find key of type
   findKeyOfType: authedProcedure.input(ZFindKeyOfTypeInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.findKeyOfType) {
-      UNSTABLE_HANDLER_CACHE.findKeyOfType = await import("./findKeyOfType.handler").then(
-        (mod) => mod.findKeyOfTypeHandler
-      );
-    }
+    const { findKeyOfTypeHandler } = await import("./findKeyOfType.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.findKeyOfType) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.findKeyOfType({
+    return findKeyOfTypeHandler({
       ctx,
       input,
     });
@@ -53,48 +35,27 @@ export const apiKeysRouter = router({
 
   // Create a new key
   create: authedProcedure.input(ZCreateInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      UNSTABLE_HANDLER_CACHE.create = await import("./create.handler").then((mod) => mod.createHandler);
-    }
+    const { createHandler } = await import("./create.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.create({
+    return createHandler({
       ctx,
       input,
     });
   }),
 
   edit: authedProcedure.input(ZEditInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.edit) {
-      UNSTABLE_HANDLER_CACHE.edit = await import("./edit.handler").then((mod) => mod.editHandler);
-    }
+    const { editHandler } = await import("./edit.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.edit) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.edit({
+    return editHandler({
       ctx,
       input,
     });
   }),
 
   delete: authedProcedure.input(ZDeleteInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      UNSTABLE_HANDLER_CACHE.delete = await import("./delete.handler").then((mod) => mod.deleteHandler);
-    }
+    const { deleteHandler } = await import("./delete.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.delete({
+    return deleteHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/apps/_router.tsx

@@ -30,143 +30,61 @@ type AppsRouterHandlerCache = {
   updateUserDefaultConferencingApp?: typeof import("./updateUserDefaultConferencingApp.handler").updateUserDefaultConferencingAppHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: AppsRouterHandlerCache = {};
-
 export const appsRouter = router({
   appById: authedProcedure.input(ZAppByIdInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.appById) {
-      UNSTABLE_HANDLER_CACHE.appById = (await import("./appById.handler")).appByIdHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.appById) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.appById({ ctx, input });
+    const { appByIdHandler } = await import("./appById.handler");
+    return appByIdHandler({ ctx, input });
   }),
 
   appCredentialsByType: authedProcedure
     .input(ZAppCredentialsByTypeInputSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.appCredentialsByType) {
-        UNSTABLE_HANDLER_CACHE.appCredentialsByType = (
-          await import("./appCredentialsByType.handler")
-        ).appCredentialsByTypeHandler;
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.appCredentialsByType) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.appCredentialsByType({ ctx, input });
+      const { appCredentialsByTypeHandler } = await import("./appCredentialsByType.handler");
+      return appCredentialsByTypeHandler({ ctx, input });
     }),
   getUsersDefaultConferencingApp: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getUsersDefaultConferencingApp) {
-      UNSTABLE_HANDLER_CACHE.getUsersDefaultConferencingApp = (
-        await import("./getUsersDefaultConferencingApp.handler")
-      ).getUsersDefaultConferencingAppHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getUsersDefaultConferencingApp) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getUsersDefaultConferencingApp({ ctx });
+    const { getUsersDefaultConferencingAppHandler } = await import(
+      "./getUsersDefaultConferencingApp.handler"
+    );
+    return getUsersDefaultConferencingAppHandler({ ctx });
   }),
   integrations: authedProcedure.input(ZIntegrationsInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.integrations) {
-      UNSTABLE_HANDLER_CACHE.integrations = (await import("./integrations.handler")).integrationsHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.integrations) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.integrations({ ctx, input });
+    const { integrationsHandler } = await import("./integrations.handler");
+    return integrationsHandler({ ctx, input });
   }),
 
   listLocal: authedAdminProcedure.input(ZListLocalInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.listLocal) {
-      UNSTABLE_HANDLER_CACHE.listLocal = await import("./listLocal.handler").then(
-        (mod) => mod.listLocalHandler
-      );
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.listLocal) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.listLocal({
+    const { listLocalHandler } = await import("./listLocal.handler");
+    return listLocalHandler({
       ctx,
       input,
     });
   }),
 
   locationOptions: authedProcedure.input(ZLocationOptionsInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.locationOptions) {
-      UNSTABLE_HANDLER_CACHE.locationOptions = (
-        await import("./locationOptions.handler")
-      ).locationOptionsHandler;
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.locationOptions) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.locationOptions({ ctx, input });
+    const { locationOptionsHandler } = await import("./locationOptions.handler");
+    return locationOptionsHandler({ ctx, input });
   }),
 
   toggle: authedAdminProcedure.input(ZToggleInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.toggle) {
-      UNSTABLE_HANDLER_CACHE.toggle = await import("./toggle.handler").then((mod) => mod.toggleHandler);
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.toggle) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.toggle({
+    const { toggleHandler } = await import("./toggle.handler");
+    return toggleHandler({
       ctx,
       input,
     });
   }),
 
   saveKeys: authedAdminProcedure.input(ZSaveKeysInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.saveKeys) {
-      UNSTABLE_HANDLER_CACHE.saveKeys = await import("./saveKeys.handler").then((mod) => mod.saveKeysHandler);
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.saveKeys) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.saveKeys({
+    const { saveKeysHandler } = await import("./saveKeys.handler");
+    return saveKeysHandler({
       ctx,
       input,
     });
   }),
 
   checkForGCal: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.checkForGCal) {
-      UNSTABLE_HANDLER_CACHE.checkForGCal = await import("./checkForGCal.handler").then(
-        (mod) => mod.checkForGCalHandler
-      );
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.checkForGCal) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.checkForGCal({
+    const { checkForGCalHandler } = await import("./checkForGCal.handler");
+    return checkForGCalHandler({
       ctx,
     });
   }),
@@ -174,18 +92,8 @@ export const appsRouter = router({
   setDefaultConferencingApp: authedProcedure
     .input(ZSetDefaultConferencingAppSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.setDefaultConferencingApp) {
-        UNSTABLE_HANDLER_CACHE.setDefaultConferencingApp = await import(
-          "./setDefaultConferencingApp.handler"
-        ).then((mod) => mod.setDefaultConferencingAppHandler);
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.setDefaultConferencingApp) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.setDefaultConferencingApp({
+      const { setDefaultConferencingAppHandler } = await import("./setDefaultConferencingApp.handler");
+      return setDefaultConferencingAppHandler({
         ctx,
         input,
       });
@@ -193,18 +101,8 @@ export const appsRouter = router({
   updateAppCredentials: authedProcedure
     .input(ZUpdateAppCredentialsInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.updateAppCredentials) {
-        UNSTABLE_HANDLER_CACHE.updateAppCredentials = await import("./updateAppCredentials.handler").then(
-          (mod) => mod.updateAppCredentialsHandler
-        );
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.updateAppCredentials) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.updateAppCredentials({
+      const { updateAppCredentialsHandler } = await import("./updateAppCredentials.handler");
+      return updateAppCredentialsHandler({
         ctx,
         input,
       });
@@ -213,35 +111,15 @@ export const appsRouter = router({
   queryForDependencies: authedProcedure
     .input(ZQueryForDependenciesInputSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.queryForDependencies) {
-        UNSTABLE_HANDLER_CACHE.queryForDependencies = await import("./queryForDependencies.handler").then(
-          (mod) => mod.queryForDependenciesHandler
-        );
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.queryForDependencies) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.queryForDependencies({
+      const { queryForDependenciesHandler } = await import("./queryForDependencies.handler");
+      return queryForDependenciesHandler({
         ctx,
         input,
       });
     }),
   checkGlobalKeys: authedProcedure.input(checkGlobalKeysSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.checkGlobalKeys) {
-      UNSTABLE_HANDLER_CACHE.checkGlobalKeys = await import("./checkGlobalKeys.handler").then(
-        (mod) => mod.checkForGlobalKeysHandler
-      );
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.checkGlobalKeys) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.checkGlobalKeys({
+    const { checkForGlobalKeysHandler } = await import("./checkGlobalKeys.handler");
+    return checkForGlobalKeysHandler({
       ctx,
       input,
     });
@@ -249,17 +127,9 @@ export const appsRouter = router({
   updateUserDefaultConferencingApp: authedProcedure
     .input(ZUpdateUserDefaultConferencingAppInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.updateUserDefaultConferencingApp) {
-        UNSTABLE_HANDLER_CACHE.updateUserDefaultConferencingApp = (
-          await import("./updateUserDefaultConferencingApp.handler")
-        ).updateUserDefaultConferencingAppHandler;
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.updateUserDefaultConferencingApp) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.updateUserDefaultConferencingApp({ ctx, input });
+      const { updateUserDefaultConferencingAppHandler } = await import(
+        "./updateUserDefaultConferencingApp.handler"
+      );
+      return updateUserDefaultConferencingAppHandler({ ctx, input });
     }),
 });

packages/trpc/server/routers/viewer/attributes/_router.ts

@@ -1,7 +1,7 @@
 import type { z } from "zod";
 
 import authedProcedure, { authedOrgAdminProcedure } from "../../../procedures/authedProcedure";
-import { router, importHandler } from "../../../trpc";
+import { router } from "../../../trpc";
 import { assignUserToAttributeSchema } from "./assignUserToAttribute.schema";
 import { bulkAssignAttributesSchema } from "./bulkAssignAttributes.schema";
 import { createAttributeSchema } from "./create.schema";
@@ -12,72 +12,59 @@ import { getAttributeSchema } from "./get.schema";
 import { getByUserIdSchema } from "./getByUserId.schema";
 import { toggleActiveSchema } from "./toggleActive.schema";
 
-const NAMESPACE = "attributes";
-
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 export type TFindTeamMembersMatchingAttributeLogicInputSchema = z.infer<
   typeof ZFindTeamMembersMatchingAttributeLogicInputSchema
 >;
 
 export const attributesRouter = router({
   list: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("list"), () => import("./list.handler"));
+    const { default: handler } = await import("./list.handler");
     return handler(opts);
   }),
   get: authedProcedure.input(getAttributeSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("get"), () => import("./get.handler"));
+    const { default: handler } = await import("./get.handler");
     return handler(opts);
   }),
   getByUserId: authedProcedure.input(getByUserIdSchema).query(async ({ ctx, input }) => {
-    const handler = await importHandler(namespaced("getByUserId"), () => import("./getByUserId.handler"));
+    const { default: handler } = await import("./getByUserId.handler");
     return handler({ ctx, input });
   }),
   // Mutations
   create: authedOrgAdminProcedure.input(createAttributeSchema).mutation(async ({ ctx, input }) => {
-    const handler = await importHandler(namespaced("create"), () => import("./create.handler"));
+    const { default: handler } = await import("./create.handler");
     return handler({ ctx, input });
   }),
   edit: authedOrgAdminProcedure.input(editAttributeSchema).mutation(async ({ ctx, input }) => {
-    const handler = await importHandler(namespaced("edit"), () => import("./edit.handler"));
+    const { default: handler } = await import("./edit.handler");
     return handler({ ctx, input });
   }),
   delete: authedOrgAdminProcedure.input(deleteAttributeSchema).mutation(async ({ ctx, input }) => {
-    const handler = await importHandler(namespaced("delete"), () => import("./delete.handler"));
+    const { default: handler } = await import("./delete.handler");
     return handler({ ctx, input });
   }),
   toggleActive: authedOrgAdminProcedure.input(toggleActiveSchema).mutation(async ({ ctx, input }) => {
-    const handler = await importHandler(namespaced("toggleActive"), () => import("./toggleActive.handler"));
+    const { default: handler } = await import("./toggleActive.handler");
     return handler({ ctx, input });
   }),
 
   assignUserToAttribute: authedOrgAdminProcedure
     .input(assignUserToAttributeSchema)
     .mutation(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("assignUserToAttribute"),
-        () => import("./assignUserToAttribute.handler")
-      );
+      const { default: handler } = await import("./assignUserToAttribute.handler");
       return handler({ ctx, input });
     }),
 
   bulkAssignAttributes: authedOrgAdminProcedure
     .input(bulkAssignAttributesSchema)
     .mutation(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("bulkAssignAttributes"),
-        () => import("./bulkAssignAttributes.handler")
-      );
+      const { default: handler } = await import("./bulkAssignAttributes.handler");
       return handler({ ctx, input });
     }),
 
   findTeamMembersMatchingAttributeLogic: authedProcedure
     .input(ZFindTeamMembersMatchingAttributeLogicInputSchema)
     .query(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("findTeamMembersMatchingAttributeLogic"),
-        () => import("./findTeamMembersMatchingAttributeLogic.handler")
-      );
+      const { default: handler } = await import("./findTeamMembersMatchingAttributeLogic.handler");
       return handler({ ctx, input });
     }),
 });

packages/trpc/server/routers/viewer/auth/_router.tsx

@@ -18,110 +18,55 @@ type AuthRouterHandlerCache = {
   createAccountPassword?: typeof import("./createAccountPassword.handler").createAccountPasswordHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: AuthRouterHandlerCache = {};
-
 export const authRouter = router({
   changePassword: authedProcedure.input(ZChangePasswordInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.changePassword) {
-      UNSTABLE_HANDLER_CACHE.changePassword = await import("./changePassword.handler").then(
-        (mod) => mod.changePasswordHandler
-      );
-    }
+    const { changePasswordHandler } = await import("./changePassword.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.changePassword) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.changePassword({
+    return changePasswordHandler({
       ctx,
       input,
     });
   }),
 
   verifyPassword: authedProcedure.input(ZVerifyPasswordInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.verifyPassword) {
-      UNSTABLE_HANDLER_CACHE.verifyPassword = await import("./verifyPassword.handler").then(
-        (mod) => mod.verifyPasswordHandler
-      );
-    }
+    const { verifyPasswordHandler } = await import("./verifyPassword.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.verifyPassword) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.verifyPassword({
+    return verifyPasswordHandler({
       ctx,
       input,
     });
   }),
 
   verifyCodeUnAuthenticated: publicProcedure.input(ZVerifyCodeInputSchema).mutation(async ({ input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.verifyCodeUnAuthenticated) {
-      UNSTABLE_HANDLER_CACHE.verifyCodeUnAuthenticated = await import(
-        "./verifyCodeUnAuthenticated.handler"
-      ).then((mod) => mod.verifyCodeUnAuthenticatedHandler);
-    }
+    const { verifyCodeUnAuthenticatedHandler } = await import("./verifyCodeUnAuthenticated.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.verifyCodeUnAuthenticated) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.verifyCodeUnAuthenticated({
+    return verifyCodeUnAuthenticatedHandler({
       input,
     });
   }),
 
   sendVerifyEmailCode: publicProcedure.input(ZSendVerifyEmailCodeSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.sendVerifyEmailCode) {
-      UNSTABLE_HANDLER_CACHE.sendVerifyEmailCode = await import("./sendVerifyEmailCode.handler").then(
-        (mod) => mod.sendVerifyEmailCodeHandler
-      );
-    }
+    const { sendVerifyEmailCodeHandler } = await import("./sendVerifyEmailCode.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.sendVerifyEmailCode) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.sendVerifyEmailCode({
+    return sendVerifyEmailCodeHandler({
       input,
       req: ctx.req,
     });
   }),
 
   resendVerifyEmail: authedProcedure.input(ZResendVerifyEmailSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.resendVerifyEmail) {
-      UNSTABLE_HANDLER_CACHE.resendVerifyEmail = await import("./resendVerifyEmail.handler").then(
-        (mod) => mod.resendVerifyEmail
-      );
-    }
+    const { resendVerifyEmail } = await import("./resendVerifyEmail.handler");
 
-    if (!UNSTABLE_HANDLER_CACHE.resendVerifyEmail) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.resendVerifyEmail({
+    return resendVerifyEmail({
       input,
       ctx,
     });
   }),
 
   createAccountPassword: authedProcedure.mutation(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.createAccountPassword) {
-      UNSTABLE_HANDLER_CACHE.createAccountPassword = await import("./createAccountPassword.handler").then(
-        (mod) => mod.createAccountPasswordHandler
-      );
-    }
+    const { createAccountPasswordHandler } = await import("./createAccountPassword.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.createAccountPassword) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.createAccountPassword({
+    return createAccountPasswordHandler({
       ctx,
     });
   }),

packages/trpc/server/routers/viewer/availability/_router.tsx

@@ -12,70 +12,36 @@ type AvailabilityRouterHandlerCache = {
   listTeamAvailability?: typeof import("./team/listTeamAvailability.handler").listTeamAvailabilityHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: AvailabilityRouterHandlerCache = {};
-
 export const availabilityRouter = router({
   list: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      UNSTABLE_HANDLER_CACHE.list = await import("./list.handler").then((mod) => mod.listHandler);
-    }
+    const { listHandler } = await import("./list.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.list({
+    return listHandler({
       ctx,
     });
   }),
 
   user: authedProcedure.input(ZUserInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.user) {
-      UNSTABLE_HANDLER_CACHE.user = await import("./user.handler").then((mod) => mod.userHandler);
-    }
+    const { userHandler } = await import("./user.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.user) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.user({
+    return userHandler({
       ctx,
       input,
     });
   }),
   listTeam: authedProcedure.input(ZListTeamAvailaiblityScheme).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.listTeamAvailability) {
-      UNSTABLE_HANDLER_CACHE.listTeamAvailability = await import("./team/listTeamAvailability.handler").then(
-        (mod) => mod.listTeamAvailabilityHandler
-      );
-    }
+    const { listTeamAvailabilityHandler } = await import("./team/listTeamAvailability.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.listTeamAvailability) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.listTeamAvailability({
+    return listTeamAvailabilityHandler({
       ctx,
       input,
     });
   }),
   schedule: scheduleRouter,
   calendarOverlay: authedProcedure.input(ZCalendarOverlayInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.calendarOverlay) {
-      UNSTABLE_HANDLER_CACHE.calendarOverlay = await import("./calendarOverlay.handler").then(
-        (mod) => mod.calendarOverlayHandler
-      );
-    }
+    const { calendarOverlayHandler } = await import("./calendarOverlay.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.calendarOverlay) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.calendarOverlay({
+    return calendarOverlayHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/availability/schedule/_router.tsx

@@ -22,140 +22,74 @@ type ScheduleRouterHandlerCache = {
   bulkUpdateToDefaultAvailability?: typeof import("./bulkUpdateDefaultAvailability.handler").bulkUpdateToDefaultAvailabilityHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: ScheduleRouterHandlerCache = {};
-
 export const scheduleRouter = router({
   get: authedProcedure.input(ZGetInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.get) {
-      UNSTABLE_HANDLER_CACHE.get = await import("./get.handler").then((mod) => mod.getHandler);
-    }
+    const { getHandler } = await import("./get.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.get) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.get({
+    return getHandler({
       ctx,
       input,
     });
   }),
 
   create: authedProcedure.input(ZCreateInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      UNSTABLE_HANDLER_CACHE.create = await import("./create.handler").then((mod) => mod.createHandler);
-    }
+    const { createHandler } = await import("./create.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.create({
+    return createHandler({
       ctx,
       input,
     });
   }),
 
   delete: authedProcedure.input(ZDeleteInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      UNSTABLE_HANDLER_CACHE.delete = await import("./delete.handler").then((mod) => mod.deleteHandler);
-    }
+    const { deleteHandler } = await import("./delete.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.delete({
+    return deleteHandler({
       ctx,
       input,
     });
   }),
 
   update: authedProcedure.input(ZUpdateInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      UNSTABLE_HANDLER_CACHE.update = await import("./update.handler").then((mod) => mod.updateHandler);
-    }
+    const { updateHandler } = await import("./update.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.update({
+    return updateHandler({
       ctx,
       input,
     });
   }),
 
   duplicate: authedProcedure.input(ZScheduleDuplicateSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.duplicate) {
-      UNSTABLE_HANDLER_CACHE.duplicate = await import("./duplicate.handler").then(
-        (mod) => mod.duplicateHandler
-      );
-    }
+    const { duplicateHandler } = await import("./duplicate.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.duplicate) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.duplicate({
+    return duplicateHandler({
       ctx,
       input,
     });
   }),
 
   getScheduleByUserId: authedProcedure.input(ZGetByUserIdInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getScheduleByUserId) {
-      UNSTABLE_HANDLER_CACHE.getScheduleByUserId = await import("./getScheduleByUserId.handler").then(
-        (mod) => mod.getScheduleByUserIdHandler
-      );
-    }
+    const { getScheduleByUserIdHandler } = await import("./getScheduleByUserId.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getScheduleByUserId) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getScheduleByUserId({
+    return getScheduleByUserIdHandler({
       ctx,
       input,
     });
   }),
 
   getAllSchedulesByUserId: authedProcedure.input(ZGetAllByUserIdInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getAllSchedulesByUserId) {
-      UNSTABLE_HANDLER_CACHE.getAllSchedulesByUserId = await import("./getAllSchedulesByUserId.handler").then(
-        (mod) => mod.getAllSchedulesByUserIdHandler
-      );
-    }
+    const { getAllSchedulesByUserIdHandler } = await import("./getAllSchedulesByUserId.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getAllSchedulesByUserId) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getAllSchedulesByUserId({
+    return getAllSchedulesByUserIdHandler({
       ctx,
       input,
     });
   }),
 
   getScheduleByEventSlug: authedProcedure.input(ZGetByEventSlugInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getScheduleByEventSlug) {
-      UNSTABLE_HANDLER_CACHE.getScheduleByEventSlug = await import(
-        "./getScheduleByEventTypeSlug.handler"
-      ).then((mod) => mod.getScheduleByEventSlugHandler);
-    }
+    const { getScheduleByEventSlugHandler } = await import("./getScheduleByEventTypeSlug.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getScheduleByEventSlug) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getScheduleByEventSlug({
+    return getScheduleByEventSlugHandler({
       ctx,
       input,
     });
@@ -163,17 +97,11 @@ export const scheduleRouter = router({
   bulkUpdateToDefaultAvailability: authedProcedure
     .input(ZBulkUpdateToDefaultAvailabilityInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultAvailability) {
-        UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultAvailability = await import(
-          "./bulkUpdateDefaultAvailability.handler"
-        ).then((mod) => mod.bulkUpdateToDefaultAvailabilityHandler);
-      }
+      const { bulkUpdateToDefaultAvailabilityHandler } = await import(
+        "./bulkUpdateDefaultAvailability.handler"
+      );
 
-      if (!UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultAvailability) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultAvailability({
+      return bulkUpdateToDefaultAvailabilityHandler({
         ctx,
         input,
       });

packages/trpc/server/routers/viewer/bookings/_router.tsx

@@ -22,89 +22,47 @@ type BookingsRouterHandlerCache = {
   getInstantBookingLocation?: typeof import("./getInstantBookingLocation.handler").getHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: BookingsRouterHandlerCache = {};
-
 export const bookingsRouter = router({
   get: authedProcedure.input(ZGetInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.get) {
-      UNSTABLE_HANDLER_CACHE.get = await import("./get.handler").then((mod) => mod.getHandler);
-    }
+    const { getHandler } = await import("./get.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.get) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.get({
+    return getHandler({
       ctx,
       input,
     });
   }),
 
   requestReschedule: authedProcedure.input(ZRequestRescheduleInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.requestReschedule) {
-      UNSTABLE_HANDLER_CACHE.requestReschedule = await import("./requestReschedule.handler").then(
-        (mod) => mod.requestRescheduleHandler
-      );
-    }
+    const { requestRescheduleHandler } = await import("./requestReschedule.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.requestReschedule) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.requestReschedule({
+    return requestRescheduleHandler({
       ctx,
       input,
     });
   }),
 
   editLocation: bookingsProcedure.input(ZEditLocationInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.editLocation) {
-      UNSTABLE_HANDLER_CACHE.editLocation = await import("./editLocation.handler").then(
-        (mod) => mod.editLocationHandler
-      );
-    }
+    const { editLocationHandler } = await import("./editLocation.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.editLocation) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.editLocation({
+    return editLocationHandler({
       ctx,
       input,
     });
   }),
+
   addGuests: authedProcedure.input(ZAddGuestsInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.addGuests) {
-      UNSTABLE_HANDLER_CACHE.addGuests = await import("./addGuests.handler").then(
-        (mod) => mod.addGuestsHandler
-      );
-    }
+    const { addGuestsHandler } = await import("./addGuests.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.addGuests) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.addGuests({
+    return addGuestsHandler({
       ctx,
       input,
     });
   }),
 
   confirm: authedProcedure.input(ZConfirmInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.confirm) {
-      UNSTABLE_HANDLER_CACHE.confirm = await import("./confirm.handler").then((mod) => mod.confirmHandler);
-    }
+    const { confirmHandler } = await import("./confirm.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.confirm) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.confirm({
+    return confirmHandler({
       ctx,
       input,
     });
@@ -113,34 +71,18 @@ export const bookingsRouter = router({
   getBookingAttendees: authedProcedure
     .input(ZGetBookingAttendeesInputSchema)
     .query(async ({ input, ctx }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getBookingAttendees) {
-        UNSTABLE_HANDLER_CACHE.getBookingAttendees = await import("./getBookingAttendees.handler").then(
-          (mod) => mod.getBookingAttendeesHandler
-        );
-      }
+      const { getBookingAttendeesHandler } = await import("./getBookingAttendees.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getBookingAttendees) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.getBookingAttendees({
+      return getBookingAttendeesHandler({
         ctx,
         input,
       });
     }),
 
   find: publicProcedure.input(ZFindInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.find) {
-      UNSTABLE_HANDLER_CACHE.find = await import("./find.handler").then((mod) => mod.getHandler);
-    }
+    const { getHandler } = await import("./find.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.find) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.find({
+    return getHandler({
       ctx,
       input,
     });
@@ -149,18 +91,9 @@ export const bookingsRouter = router({
   getInstantBookingLocation: publicProcedure
     .input(ZInstantBookingInputSchema)
     .query(async ({ input, ctx }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getInstantBookingLocation) {
-        UNSTABLE_HANDLER_CACHE.getInstantBookingLocation = await import(
-          "./getInstantBookingLocation.handler"
-        ).then((mod) => mod.getHandler);
-      }
+      const { getHandler } = await import("./getInstantBookingLocation.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getInstantBookingLocation) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.getInstantBookingLocation({
+      return getHandler({
         ctx,
         input,
       });

packages/trpc/server/routers/viewer/calVideo/_router.tsx

@@ -8,40 +8,22 @@ type CalVideoRouterHandlerCache = {
   getDownloadLinkOfCalVideoRecordings?: typeof import("./getDownloadLinkOfCalVideoRecordings.handler").getDownloadLinkOfCalVideoRecordingsHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: CalVideoRouterHandlerCache = {};
-
 export const calVideoRouter = router({
   getCalVideoRecordings: authedProcedure
     .input(ZGetCalVideoRecordingsInputSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getCalVideoRecordings) {
-        UNSTABLE_HANDLER_CACHE.getCalVideoRecordings = (
-          await import("./getCalVideoRecordings.handler")
-        ).getCalVideoRecordingsHandler;
-      }
+      const { getCalVideoRecordingsHandler } = await import("./getCalVideoRecordings.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getCalVideoRecordings) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.getCalVideoRecordings({ ctx, input });
+      return getCalVideoRecordingsHandler({ ctx, input });
     }),
 
   getDownloadLinkOfCalVideoRecordings: authedProcedure
     .input(ZGetDownloadLinkOfCalVideoRecordingsInputSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getDownloadLinkOfCalVideoRecordings) {
-        UNSTABLE_HANDLER_CACHE.getDownloadLinkOfCalVideoRecordings = (
-          await import("./getDownloadLinkOfCalVideoRecordings.handler")
-        ).getDownloadLinkOfCalVideoRecordingsHandler;
-      }
+      const { getDownloadLinkOfCalVideoRecordingsHandler } = await import(
+        "./getDownloadLinkOfCalVideoRecordings.handler"
+      );
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getDownloadLinkOfCalVideoRecordings) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.getDownloadLinkOfCalVideoRecordings({ ctx, input });
+      return getDownloadLinkOfCalVideoRecordingsHandler({ ctx, input });
     }),
 });

packages/trpc/server/routers/viewer/calendars/_router.tsx

@@ -8,38 +8,18 @@ type CalendarsRouterHandlerCache = {
   setDestinationCalendar?: typeof import("./setDestinationCalendar.handler").setDestinationCalendarHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: CalendarsRouterHandlerCache = {};
-
 export const calendarsRouter = router({
   connectedCalendars: authedProcedure.input(ZConnectedCalendarsInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.connectedCalendars) {
-      UNSTABLE_HANDLER_CACHE.connectedCalendars = (
-        await import("./connectedCalendars.handler")
-      ).connectedCalendarsHandler;
-    }
+    const { connectedCalendarsHandler } = await import("./connectedCalendars.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.connectedCalendars) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.connectedCalendars({ ctx, input });
+    return connectedCalendarsHandler({ ctx, input });
   }),
 
   setDestinationCalendar: authedProcedure
     .input(ZSetDestinationCalendarInputSchema)
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.setDestinationCalendar) {
-        UNSTABLE_HANDLER_CACHE.setDestinationCalendar = (
-          await import("./setDestinationCalendar.handler")
-        ).setDestinationCalendarHandler;
-      }
+      const { setDestinationCalendarHandler } = await import("./setDestinationCalendar.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.setDestinationCalendar) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.setDestinationCalendar({ ctx, input });
+      return setDestinationCalendarHandler({ ctx, input });
     }),
 });

packages/trpc/server/routers/viewer/credentials/_router.tsx

@@ -6,21 +6,10 @@ type CredentialsRouterHandlerCache = {
   deleteCredential?: typeof import("./deleteCredential.handler").deleteCredentialHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: CredentialsRouterHandlerCache = {};
-
 export const credentialsRouter = router({
   delete: authedProcedure.input(ZDeleteCredentialInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.deleteCredential) {
-      UNSTABLE_HANDLER_CACHE.deleteCredential = (
-        await import("./deleteCredential.handler")
-      ).deleteCredentialHandler;
-    }
+    const { deleteCredentialHandler } = await import("./deleteCredential.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.deleteCredential) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.deleteCredential({ ctx, input });
+    return deleteCredentialHandler({ ctx, input });
   }),
 });

packages/trpc/server/routers/viewer/delegationCredential/_router.ts

@@ -4,7 +4,7 @@ import { getTranslation } from "@calcom/lib/server/i18n";
 import { TRPCError } from "@trpc/server";
 
 import authedProcedure, { authedOrgAdminProcedure } from "../../../procedures/authedProcedure";
-import { router, importHandler } from "../../../trpc";
+import { router } from "../../../trpc";
 import {
   DelegationCredentialCreateSchema,
   DelegationCredentialUpdateSchema,
@@ -12,9 +12,6 @@ import {
   DelegationCredentialToggleEnabledSchema,
 } from "./schema";
 
-const NAMESPACE = "delegationCredential";
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 const checkDelegationCredentialFeature = async ({
   ctx,
   next,
@@ -48,45 +45,39 @@ const checkDelegationCredentialFeature = async ({
 
 export const delegationCredentialRouter = router({
   list: authedOrgAdminProcedure.use(checkDelegationCredentialFeature).query(async (opts) => {
-    const handler = await importHandler(namespaced("list"), () => import("./list.handler"));
+    const handler = await import("./list.handler").then((mod) => mod.default);
     return handler(opts);
   }),
   update: authedOrgAdminProcedure
     .use(checkDelegationCredentialFeature)
     .input(DelegationCredentialUpdateSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(namespaced("update"), () => import("./update.handler"));
+      const handler = await import("./update.handler").then((mod) => mod.default);
       return handler(opts);
     }),
   add: authedOrgAdminProcedure
     .use(checkDelegationCredentialFeature)
     .input(DelegationCredentialCreateSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(namespaced("add"), () => import("./add.handler"));
+      const handler = await import("./add.handler").then((mod) => mod.default);
       return handler(opts);
     }),
   toggleEnabled: authedOrgAdminProcedure
     .use(checkDelegationCredentialFeature)
     .input(DelegationCredentialToggleEnabledSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("toggleEnabled"),
-        () => import("./toggleEnabled.handler")
-      );
+      const handler = await import("./toggleEnabled.handler").then((mod) => mod.default);
       return handler(opts);
     }),
   delete: authedOrgAdminProcedure
     .use(checkDelegationCredentialFeature)
     .input(DelegationCredentialDeleteSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(namespaced("delete"), () => import("./delete.handler"));
+      const handler = await import("./delete.handler").then((mod) => mod.default);
       return handler(opts);
     }),
   listWorkspacePlatforms: authedProcedure.use(checkDelegationCredentialFeature).query(async () => {
-    const handler = await importHandler(
-      namespaced("listWorkspacePlatforms"),
-      () => import("./listWorkspacePlatforms.handler")
-    );
+    const handler = await import("./listWorkspacePlatforms.handler").then((mod) => mod.default);
     return handler();
   }),
 });

packages/trpc/server/routers/viewer/deploymentSetup/_router.tsx

@@ -6,20 +6,11 @@ type DeploymentSetupRouterHandlerCache = {
   update?: typeof import("./update.handler").updateHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: DeploymentSetupRouterHandlerCache = {};
-
 export const deploymentSetupRouter = router({
   update: authedAdminProcedure.input(ZUpdateInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      UNSTABLE_HANDLER_CACHE.update = await import("./update.handler").then((mod) => mod.updateHandler);
-    }
+    const { updateHandler } = await import("./update.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.update({
+    return updateHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/dsync/_router.tsx

@@ -1,28 +1,24 @@
 import authedOrgAdminProcedure from "../../../procedures/authedProcedure";
-import { router, importHandler } from "../../../trpc";
+import { router } from "../../../trpc";
 import { ZCreateInputSchema } from "./create.schema";
 import { ZDeleteInputSchema } from "./delete.schema";
 import { ZGetInputSchema } from "./get.schema";
 import { teamGroupMappingRouter } from "./teamGroupMapping/_router";
 
-const NAMESPACE = "dsync";
-
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 export const dsyncRouter = router({
   // Create directory sync connection
   create: authedOrgAdminProcedure.input(ZCreateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("create"), () => import("./create.handler"));
+    const { default: handler } = await import("./create.handler");
     return handler(opts);
   }),
   // Get directory sync connection
   get: authedOrgAdminProcedure.input(ZGetInputSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("get"), () => import("./get.handler"));
+    const { default: handler } = await import("./get.handler");
     return handler(opts);
   }),
   // Delete directory sync connection
   delete: authedOrgAdminProcedure.input(ZDeleteInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("delete"), () => import("./delete.handler"));
+    const { default: handler } = await import("./delete.handler");
     return handler(opts);
   }),
 

packages/trpc/server/routers/viewer/dsync/teamGroupMapping/_router.tsx

@@ -1,24 +1,20 @@
 import authedOrgAdminProcedure from "@calcom/trpc/server/procedures/authedProcedure";
-import { router, importHandler } from "@calcom/trpc/server/trpc";
+import { router } from "@calcom/trpc/server/trpc";
 
 import { ZCreateInputSchema } from "./create.schema";
 import { ZDeleteInputSchema } from "./delete.schema";
 
-const NAMESPACE = "teamGroupMapping";
-
-const namespaced = (s: string) => `${NAMESPACE}.${s}`;
-
 export const teamGroupMappingRouter = router({
   get: authedOrgAdminProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("get"), () => import("./get.handler"));
+    const { default: handler } = await import("./get.handler");
     return handler(opts);
   }),
   create: authedOrgAdminProcedure.input(ZCreateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("create"), () => import("./create.handler"));
+    const { default: handler } = await import("./create.handler");
     return handler(opts);
   }),
   delete: authedOrgAdminProcedure.input(ZDeleteInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("delete"), () => import("./delete.handler"));
+    const { default: handler } = await import("./delete.handler");
     return handler(opts);
   }),
 });

packages/trpc/server/routers/viewer/eventTypes/_router.ts

@@ -29,25 +29,14 @@ type BookingsRouterHandlerCache = {
   bulkUpdateToDefaultLocation?: typeof import("./bulkUpdateToDefaultLocation.handler").bulkUpdateToDefaultLocationHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: BookingsRouterHandlerCache = {};
-
 export const eventTypesRouter = router({
   // REVIEW: What should we name this procedure?
   getByViewer: authedProcedure.input(ZEventTypeInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getByViewer) {
-      UNSTABLE_HANDLER_CACHE.getByViewer = await import("./getByViewer.handler").then(
-        (mod) => mod.getByViewerHandler
-      );
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getByViewer) {
-      throw new Error("Failed to load handler");
-    }
+    const { getByViewerHandler } = await import("./getByViewer.handler");
 
     const timer = logP(`getByViewer(${ctx.user.id})`);
 
-    const result = await UNSTABLE_HANDLER_CACHE.getByViewer({
+    const result = await getByViewerHandler({
       ctx,
       input,
     });
@@ -57,20 +46,11 @@ export const eventTypesRouter = router({
     return result;
   }),
   getUserEventGroups: authedProcedure.input(ZEventTypeInputSchema).query(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getUserEventGroups) {
-      UNSTABLE_HANDLER_CACHE.getUserEventGroups = await import("./getUserEventGroups.handler").then(
-        (mod) => mod.getUserEventGroups
-      );
-    }
-
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getUserEventGroups) {
-      throw new Error("Failed to load handler");
-    }
+    const { getUserEventGroups } = await import("./getUserEventGroups.handler");
 
     const timer = logP(`getUserEventGroups(${ctx.user.id})`);
 
-    const result = await UNSTABLE_HANDLER_CACHE.getUserEventGroups({
+    const result = await getUserEventGroups({
       ctx,
       input,
     });
@@ -83,20 +63,11 @@ export const eventTypesRouter = router({
   getEventTypesFromGroup: authedProcedure
     .input(ZGetEventTypesFromGroupSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getEventTypesFromGroup) {
-        UNSTABLE_HANDLER_CACHE.getEventTypesFromGroup = await import("./getEventTypesFromGroup.handler").then(
-          (mod) => mod.getEventTypesFromGroup
-        );
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getEventTypesFromGroup) {
-        throw new Error("Failed to load handler");
-      }
+      const { getEventTypesFromGroup } = await import("./getEventTypesFromGroup.handler");
 
       const timer = logP(`getEventTypesFromGroup(${ctx.user.id})`);
 
-      const result = await UNSTABLE_HANDLER_CACHE.getEventTypesFromGroup({
+      const result = await getEventTypesFromGroup({
         ctx,
         input,
       });
@@ -109,20 +80,11 @@ export const eventTypesRouter = router({
   getTeamAndEventTypeOptions: authedProcedure
     .input(ZGetTeamAndEventTypeOptionsSchema)
     .query(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.getTeamAndEventTypeOptions) {
-        UNSTABLE_HANDLER_CACHE.getTeamAndEventTypeOptions = await import(
-          "./getTeamAndEventTypeOptions.handler"
-        ).then((mod) => mod.getTeamAndEventTypeOptions);
-      }
-
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.getTeamAndEventTypeOptions) {
-        throw new Error("Failed to load handler");
-      }
+      const { getTeamAndEventTypeOptions } = await import("./getTeamAndEventTypeOptions.handler");
 
       const timer = logP(`getTeamAndEventTypeOptions(${ctx.user.id})`);
 
-      const result = await UNSTABLE_HANDLER_CACHE.getTeamAndEventTypeOptions({
+      const result = await getTeamAndEventTypeOptions({
         ctx,
         input,
       });
@@ -133,48 +95,25 @@ export const eventTypesRouter = router({
     }),
 
   list: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      UNSTABLE_HANDLER_CACHE.list = await import("./list.handler").then((mod) => mod.listHandler);
-    }
+    const { listHandler } = await import("./list.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.list({
+    return listHandler({
       ctx,
     });
   }),
 
   listWithTeam: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.listWithTeam) {
-      UNSTABLE_HANDLER_CACHE.listWithTeam = await import("./listWithTeam.handler").then(
-        (mod) => mod.listWithTeamHandler
-      );
-    }
+    const { listWithTeamHandler } = await import("./listWithTeam.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.listWithTeam) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.listWithTeam({
+    return listWithTeamHandler({
       ctx,
     });
   }),
 
   create: authedProcedure.input(ZCreateInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      UNSTABLE_HANDLER_CACHE.create = await import("./create.handler").then((mod) => mod.createHandler);
-    }
+    const { createHandler } = await import("./create.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.create({
+    return createHandler({
       ctx,
       input,
     });
@@ -183,68 +122,36 @@ export const eventTypesRouter = router({
   get,
 
   update: eventOwnerProcedure.input(ZUpdateInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      UNSTABLE_HANDLER_CACHE.update = await import("./update.handler").then((mod) => mod.updateHandler);
-    }
+    const { updateHandler } = await import("./update.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.update({
+    return updateHandler({
       ctx,
       input,
     });
   }),
 
   delete: eventOwnerProcedure.input(ZDeleteInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      UNSTABLE_HANDLER_CACHE.delete = await import("./delete.handler").then((mod) => mod.deleteHandler);
-    }
+    const { deleteHandler } = await import("./delete.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.delete({
+    return deleteHandler({
       ctx,
       input,
     });
   }),
 
   duplicate: eventOwnerProcedure.input(ZDuplicateInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.duplicate) {
-      UNSTABLE_HANDLER_CACHE.duplicate = await import("./duplicate.handler").then(
-        (mod) => mod.duplicateHandler
-      );
-    }
+    const { duplicateHandler } = await import("./duplicate.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.duplicate) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.duplicate({
+    return duplicateHandler({
       ctx,
       input,
     });
   }),
 
   bulkEventFetch: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.bulkEventFetch) {
-      UNSTABLE_HANDLER_CACHE.bulkEventFetch = await import("./bulkEventFetch.handler").then(
-        (mod) => mod.bulkEventFetchHandler
-      );
-    }
+    const { bulkEventFetchHandler } = await import("./bulkEventFetch.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.bulkEventFetch) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.bulkEventFetch({
+    return bulkEventFetchHandler({
       ctx,
     });
   }),
@@ -256,18 +163,9 @@ export const eventTypesRouter = router({
       })
     )
     .mutation(async ({ ctx, input }) => {
-      if (!UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultLocation) {
-        UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultLocation = await import(
-          "./bulkUpdateToDefaultLocation.handler"
-        ).then((mod) => mod.bulkUpdateToDefaultLocationHandler);
-      }
+      const { bulkUpdateToDefaultLocationHandler } = await import("./bulkUpdateToDefaultLocation.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultLocation) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.bulkUpdateToDefaultLocation({
+      return bulkUpdateToDefaultLocationHandler({
         ctx,
         input,
       });

packages/trpc/server/routers/viewer/filterSegments/_router.tsx

@@ -12,68 +12,38 @@ type FilterSegmentsRouterHandlerCache = {
   delete?: typeof import("./delete.handler").deleteHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: FilterSegmentsRouterHandlerCache = {};
-
 export const filterSegmentsRouter = router({
   list: authedProcedure.input(ZListFilterSegmentsInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      UNSTABLE_HANDLER_CACHE.list = await import("./list.handler").then((mod) => mod.listHandler);
-    }
+    const { listHandler } = await import("./list.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.list) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.list({
+    return listHandler({
       ctx,
       input,
     });
   }),
 
   create: authedProcedure.input(ZCreateFilterSegmentInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      UNSTABLE_HANDLER_CACHE.create = await import("./create.handler").then((mod) => mod.createHandler);
-    }
+    const { createHandler } = await import("./create.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.create) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.create({
+    return createHandler({
       ctx,
       input,
     });
   }),
 
   update: authedProcedure.input(ZUpdateFilterSegmentInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      UNSTABLE_HANDLER_CACHE.update = await import("./update.handler").then((mod) => mod.updateHandler);
-    }
+    const { updateHandler } = await import("./update.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.update) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.update({
+    return updateHandler({
       ctx,
       input,
     });
   }),
 
   delete: authedProcedure.input(ZDeleteFilterSegmentInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      UNSTABLE_HANDLER_CACHE.delete = await import("./delete.handler").then((mod) => mod.deleteHandler);
-    }
+    const { deleteHandler } = await import("./delete.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.delete) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.delete({
+    return deleteHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/googleWorkspace/_router.tsx

@@ -7,54 +7,25 @@ type GoogleWorkspaceCache = {
   removeCurrentGoogleWorkspaceConnection?: typeof import("./googleWorkspace.handler").removeCurrentGoogleWorkspaceConnection;
 };
 
-const UNSTABLE_HANDLER_CACHE: GoogleWorkspaceCache = {};
-
 export const googleWorkspaceRouter = router({
   checkForGWorkspace: authedProcedure.query(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.checkForGWorkspace) {
-      UNSTABLE_HANDLER_CACHE.checkForGWorkspace = await import("./googleWorkspace.handler").then(
-        (mod) => mod.checkForGWorkspace
-      );
-    }
+    const { checkForGWorkspace } = await import("./googleWorkspace.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.checkForGWorkspace) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.checkForGWorkspace({
+    return checkForGWorkspace({
       ctx,
     });
   }),
   getUsersFromGWorkspace: authedProcedure.mutation(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getUsersFromGWorkspace) {
-      UNSTABLE_HANDLER_CACHE.getUsersFromGWorkspace = await import("./googleWorkspace.handler").then(
-        (mod) => mod.getUsersFromGWorkspace
-      );
-    }
+    const { getUsersFromGWorkspace } = await import("./googleWorkspace.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getUsersFromGWorkspace) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getUsersFromGWorkspace({
+    return getUsersFromGWorkspace({
       ctx,
     });
   }),
   removeCurrentGoogleWorkspaceConnection: authedProcedure.mutation(async ({ ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.removeCurrentGoogleWorkspaceConnection) {
-      UNSTABLE_HANDLER_CACHE.removeCurrentGoogleWorkspaceConnection = await import(
-        "./googleWorkspace.handler"
-      ).then((mod) => mod.removeCurrentGoogleWorkspaceConnection);
-    }
+    const { removeCurrentGoogleWorkspaceConnection } = await import("./googleWorkspace.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.removeCurrentGoogleWorkspaceConnection) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.removeCurrentGoogleWorkspaceConnection({
+    return removeCurrentGoogleWorkspaceConnection({
       ctx,
     });
   }),

packages/trpc/server/routers/viewer/highPerf/_router.tsx

@@ -6,23 +6,12 @@ type SlotsRouterHandlerCache = {
   getTeamSchedule?: typeof import("./getTeamSchedule.handler").getTeamScheduleHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: SlotsRouterHandlerCache = {};
-
 /** This should be called getAvailableSlots */
 export const highPerfRouter = router({
   getTeamSchedule: publicProcedure.input(ZGetTeamScheduleInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getTeamSchedule) {
-      UNSTABLE_HANDLER_CACHE.getTeamSchedule = await import("./getTeamSchedule.handler").then(
-        (mod) => mod.getTeamScheduleHandler
-      );
-    }
+    const { getTeamScheduleHandler } = await import("./getTeamSchedule.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getTeamSchedule) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getTeamSchedule({
+    return getTeamScheduleHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/oAuth/_router.tsx

@@ -11,56 +11,27 @@ type OAuthRouterHandlerCache = {
   generateAuthCode?: typeof import("./generateAuthCode.handler").generateAuthCodeHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: OAuthRouterHandlerCache = {};
-
 export const oAuthRouter = router({
   getClient: authedProcedure.input(ZGetClientInputSchema).query(async ({ input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getClient) {
-      UNSTABLE_HANDLER_CACHE.getClient = await import("./getClient.handler").then(
-        (mod) => mod.getClientHandler
-      );
-    }
+    const { getClientHandler } = await import("./getClient.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getClient) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getClient({
+    return getClientHandler({
       input,
     });
   }),
 
   addClient: authedAdminProcedure.input(ZAddClientInputSchema).mutation(async ({ input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.addClient) {
-      UNSTABLE_HANDLER_CACHE.addClient = await import("./addClient.handler").then(
-        (mod) => mod.addClientHandler
-      );
-    }
+    const { addClientHandler } = await import("./addClient.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.addClient) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.addClient({
+    return addClientHandler({
       input,
     });
   }),
 
   generateAuthCode: authedProcedure.input(ZGenerateAuthCodeInputSchema).mutation(async ({ ctx, input }) => {
-    if (!UNSTABLE_HANDLER_CACHE.generateAuthCode) {
-      UNSTABLE_HANDLER_CACHE.generateAuthCode = await import("./generateAuthCode.handler").then(
-        (mod) => mod.generateAuthCodeHandler
-      );
-    }
+    const { generateAuthCodeHandler } = await import("./generateAuthCode.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.generateAuthCode) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.generateAuthCode({
+    return generateAuthCodeHandler({
       ctx,
       input,
     });

packages/trpc/server/routers/viewer/organizations/_router.tsx

@@ -5,7 +5,7 @@ import authedProcedure, {
   authedAdminProcedure,
   authedOrgAdminProcedure,
 } from "../../../procedures/authedProcedure";
-import { importHandler, router } from "../../../trpc";
+import { router } from "../../../trpc";
 import { eventOwnerProcedure } from "../eventTypes/util";
 import { ZAddMembersToEventTypes } from "./addMembersToEventTypes.schema";
 import { ZAddMembersToTeams } from "./addMembersToTeams.schema";
@@ -35,171 +35,135 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 
 export const viewerOrganizationsRouter = router({
   getOrganizationOnboarding: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getOrganizationOnboarding"),
-      () => import("./getOrganizationOnboarding.handler")
-    );
+    const { default: handler } = await import("./getOrganizationOnboarding.handler");
     return handler(opts);
   }),
 
   create: authedProcedure.input(ZCreateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("create"), () => import("./create.handler"));
+    const { default: handler } = await import("./create.handler");
     return handler(opts);
   }),
   intentToCreateOrg: authedProcedure.input(ZIntentToCreateOrgInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("intentToCreateOrg"),
-      () => import("./intentToCreateOrg.handler")
-    );
+    const { default: handler } = await import("./intentToCreateOrg.handler");
     return handler(opts);
   }),
   createWithPaymentIntent: authedProcedure
     .input(ZCreateWithPaymentIntentInputSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("createWithPaymentIntent"),
-        () => import("./createWithPaymentIntent.handler")
-      );
+      const { default: handler } = await import("./createWithPaymentIntent.handler");
       return handler(opts);
     }),
   update: authedProcedure.input(ZUpdateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("update"), () => import("./update.handler"));
+    const { default: handler } = await import("./update.handler");
     return handler(opts);
   }),
   verifyCode: authedProcedure.input(ZVerifyCodeInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("verifyCode"), () => import("./verifyCode.handler"));
+    const { default: handler } = await import("./verifyCode.handler");
     return handler(opts);
   }),
   createTeams: authedProcedure.input(ZCreateTeamsSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("createTeams"), () => import("./createTeams.handler"));
+    const { default: handler } = await import("./createTeams.handler");
     return handler(opts);
   }),
   listCurrent: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("listCurrent"), () => import("./list.handler"));
+    const { default: handler } = await import("./list.handler");
     return handler(opts);
   }),
   checkIfOrgNeedsUpgrade: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("checkIfOrgNeedsUpgrade"),
-      () => import("./checkIfOrgNeedsUpgrade.handler")
-    );
+    const { default: handler } = await import("./checkIfOrgNeedsUpgrade.handler");
     return handler(opts);
   }),
   publish: authedProcedure.mutation(async (opts) => {
-    const handler = await importHandler(namespaced("publish"), () => import("./publish.handler"));
+    const { default: handler } = await import("./publish.handler");
     return handler(opts);
   }),
   setPassword: authedProcedure.input(ZSetPasswordSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("setPassword"), () => import("./setPassword.handler"));
+    const { default: handler } = await import("./setPassword.handler");
     return handler(opts);
   }),
   getMembers: authedProcedure.input(ZGetMembersInput).query(async (opts) => {
-    const handler = await importHandler(namespaced("getMembers"), () => import("./getMembers.handler"));
+    const { default: handler } = await import("./getMembers.handler");
     return handler(opts);
   }),
   listMembers: authedProcedure.input(ZListMembersInputSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("listMembers"), () => import("./listMembers.handler"));
+    const { default: handler } = await import("./listMembers.handler");
     return handler(opts);
   }),
   getBrand: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("getBrand"), () => import("./getBrand.handler"));
+    const { default: handler } = await import("./getBrand.handler");
     return handler(opts);
   }),
   getUser: authedProcedure.input(ZGetUserInput).query(async (opts) => {
-    const handler = await importHandler(namespaced("getUser"), () => import("./getUser.handler"));
+    const { default: handler } = await import("./getUser.handler");
     return handler(opts);
   }),
   updateUser: authedProcedure.input(ZUpdateUserInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("updateUser"), () => import("./updateUser.handler"));
+    const { default: handler } = await import("./updateUser.handler");
     return handler(opts);
   }),
   getTeams: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("getTeams"), () => import("./getTeams.handler"));
+    const { default: handler } = await import("./getTeams.handler");
     return handler(opts);
   }),
   addMembersToTeams: authedProcedure.input(ZAddMembersToTeams).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("addMembersToTeams"),
-      () => import("./addMembersToTeams.handler")
-    );
+    const { default: handler } = await import("./addMembersToTeams.handler");
     return handler(opts);
   }),
   addMembersToEventTypes: authedProcedure.input(ZAddMembersToEventTypes).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("addMembersToEventTypes"),
-      () => import("./addMembersToEventTypes.handler")
-    );
+    const { default: handler } = await import("./addMembersToEventTypes.handler");
     return handler(opts);
   }),
   removeHostsFromEventTypes: authedProcedure.input(ZRemoveHostsFromEventTypes).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("removeHostsFromEventTypes"),
-      () => import("./removeHostsFromEventTypes.handler")
-    );
+    const { default: handler } = await import("./removeHostsFromEventTypes.handler");
     return handler(opts);
   }),
   bulkDeleteUsers: authedProcedure.input(ZBulkUsersDelete).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("bulkDeleteUsers"),
-      () => import("./bulkDeleteUsers.handler")
-    );
+    const { default: handler } = await import("./bulkDeleteUsers.handler");
     return handler(opts);
   }),
   listOtherTeamMembers: authedOrgAdminProcedure.input(ZListOtherTeamMembersSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("listOtherTeamMembers"),
-      () => import("./listOtherTeamMembers.handler")
-    );
+    const { default: handler } = await import("./listOtherTeamMembers.handler");
     return handler(opts);
   }),
   getOtherTeam: authedOrgAdminProcedure.input(ZGetOtherTeamInputSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("getOtherTeam"), () => import("./getOtherTeam.handler"));
+    const { default: handler } = await import("./getOtherTeam.handler");
     return handler(opts);
   }),
   listOtherTeams: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("listOtherTeams"),
-      () => import("./listOtherTeams.handler")
-    );
+    const { default: handler } = await import("./listOtherTeams.handler");
     return handler(opts);
   }),
   deleteTeam: authedOrgAdminProcedure.input(ZDeleteTeamInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("deleteTeam"), () => import("./deleteTeam.handler"));
+    const { default: handler } = await import("./deleteTeam.handler");
     return handler(opts);
   }),
 
   adminGetAll: authedAdminProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("adminGetAll"), () => import("./adminGetAll.handler"));
+    const { default: handler } = await import("./adminGetAll.handler");
     return handler(opts);
   }),
   adminGet: authedAdminProcedure.input(ZAdminGet).query(async (opts) => {
-    const handler = await importHandler(namespaced("adminGet"), () => import("./adminGet.handler"));
+    const { default: handler } = await import("./adminGet.handler");
     return handler(opts);
   }),
   adminUpdate: authedAdminProcedure.input(ZAdminUpdate).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("adminUpdate"), () => import("./adminUpdate.handler"));
+    const { default: handler } = await import("./adminUpdate.handler");
     return handler(opts);
   }),
   adminVerify: authedAdminProcedure.input(ZAdminVerifyInput).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("adminVerify"), () => import("./adminVerify.handler"));
+    const { default: handler } = await import("./adminVerify.handler");
     return handler(opts);
   }),
   adminDelete: authedAdminProcedure.input(ZAdminDeleteInput).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("adminDelete"), () => import("./adminDelete.handler"));
+    const { default: handler } = await import("./adminDelete.handler");
     return handler(opts);
   }),
   createPhoneCall: eventOwnerProcedure.input(createPhoneCallSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("createPhoneCall"),
-      () => import("./createPhoneCall.handler")
-    );
+    const { default: handler } = await import("./createPhoneCall.handler");
     return handler(opts);
   }),
   getFacetedValues: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getFacetedValues"),
-      () => import("./getFacetedValues.handler")
-    );
+    const { default: handler } = await import("./getFacetedValues.handler");
     return handler(opts);
   }),
 });

packages/trpc/server/routers/viewer/routing-forms/_router.ts

@@ -1,6 +1,6 @@
 import authedProcedure from "../../../procedures/authedProcedure";
 import publicProcedure from "../../../procedures/publicProcedure";
-import { router, importHandler } from "../../../trpc";
+import { router } from "../../../trpc";
 import { ZFindTeamMembersMatchingAttributeLogicOfRouteInputSchema } from "./findTeamMembersMatchingAttributeLogicOfRoute.schema";
 import { ZResponseInputSchema } from "./response.schema";
 
@@ -12,16 +12,13 @@ export const routingFormsRouter = router({
   findTeamMembersMatchingAttributeLogicOfRoute: authedProcedure
     .input(ZFindTeamMembersMatchingAttributeLogicOfRouteInputSchema)
     .mutation(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("findTeamMembersMatchingAttributeLogicOfRoute"),
-        () => import("./findTeamMembersMatchingAttributeLogicOfRoute.handler")
-      );
+      const { default: handler } = await import("./findTeamMembersMatchingAttributeLogicOfRoute.handler");
       return handler({ ctx, input });
     }),
 
   public: router({
     response: publicProcedure.input(ZResponseInputSchema).mutation(async ({ ctx, input }) => {
-      const handler = await importHandler(namespaced("response"), () => import("./response.handler"));
+      const { default: handler } = await import("./response.handler");
       return handler({ ctx, input });
     }),
   }),

packages/trpc/server/routers/viewer/slots/_router.tsx

@@ -13,40 +13,20 @@ type SlotsRouterHandlerCache = {
   isAvailable?: typeof import("./isAvailable.handler").isAvailableHandler;
 };
 
-const UNSTABLE_HANDLER_CACHE: SlotsRouterHandlerCache = {};
-
 /** This should be called getAvailableSlots */
 export const slotsRouter = router({
   getSchedule: publicProcedure.input(ZGetScheduleInputSchema).query(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.getSchedule) {
-      UNSTABLE_HANDLER_CACHE.getSchedule = await import("./getSchedule.handler").then(
-        (mod) => mod.getScheduleHandler
-      );
-    }
+    const { getScheduleHandler } = await import("./getSchedule.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.getSchedule) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.getSchedule({
+    return getScheduleHandler({
       ctx,
       input,
     });
   }),
   reserveSlot: publicProcedure.input(ZReserveSlotInputSchema).mutation(async ({ input, ctx }) => {
-    if (!UNSTABLE_HANDLER_CACHE.reserveSlot) {
-      UNSTABLE_HANDLER_CACHE.reserveSlot = await import("./reserveSlot.handler").then(
-        (mod) => mod.reserveSlotHandler
-      );
-    }
+    const { reserveSlotHandler } = await import("./reserveSlot.handler");
 
-    // Unreachable code but required for type safety
-    if (!UNSTABLE_HANDLER_CACHE.reserveSlot) {
-      throw new Error("Failed to load handler");
-    }
-
-    return UNSTABLE_HANDLER_CACHE.reserveSlot({
+    return reserveSlotHandler({
       ctx: { ...ctx, req: ctx.req as NextApiRequest, res: ctx.res as NextApiResponse },
       input,
     });
@@ -55,18 +35,9 @@ export const slotsRouter = router({
     .input(ZIsAvailableInputSchema)
     .output(ZIsAvailableOutputSchema)
     .query(async ({ input, ctx }) => {
-      if (!UNSTABLE_HANDLER_CACHE.isAvailable) {
-        UNSTABLE_HANDLER_CACHE.isAvailable = await import("./isAvailable.handler").then(
-          (mod) => mod.isAvailableHandler
-        );
-      }
+      const { isAvailableHandler } = await import("./isAvailable.handler");
 
-      // Unreachable code but required for type safety
-      if (!UNSTABLE_HANDLER_CACHE.isAvailable) {
-        throw new Error("Failed to load handler");
-      }
-
-      return UNSTABLE_HANDLER_CACHE.isAvailable({
+      return isAvailableHandler({
         ctx: { ...ctx, req: ctx.req as NextApiRequest },
         input,
       });

packages/trpc/server/routers/viewer/teams/_router.tsx

@@ -1,5 +1,5 @@
 import authedProcedure from "../../../procedures/authedProcedure";
-import { importHandler, router } from "../../../trpc";
+import { router } from "../../../trpc";
 import { ZAcceptOrLeaveInputSchema } from "./acceptOrLeave.schema";
 import { ZAddMembersToEventTypes } from "./addMembersToEventTypes.schema";
 import { ZChangeMemberRoleInputSchema } from "./changeMemberRole.schema";
@@ -38,222 +38,156 @@ const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 export const viewerTeamsRouter = router({
   // Retrieves team by id
   get: authedProcedure.input(ZGetSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("get"), () => import("./get.handler"));
+    const { default: handler } = await import("./get.handler");
     return handler(opts);
   }),
   // Returns teams I a member of
   list: authedProcedure.input(ZGetListSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("list"), () => import("./list.handler"));
+    const { default: handler } = await import("./list.handler");
     return handler(opts);
   }),
   // Returns Teams I am a owner/admin of
   listOwnedTeams: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("list"), () => import("./list.handler"));
+    const { default: handler } = await import("./list.handler");
     return handler(opts);
   }),
   create: authedProcedure.input(ZCreateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("create"), () => import("./create.handler"));
+    const { default: handler } = await import("./create.handler");
     return handler(opts);
   }),
   // Allows team owner to update team metadata
   update: authedProcedure.input(ZUpdateInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("update"), () => import("./update.handler"));
+    const { default: handler } = await import("./update.handler");
     return handler(opts);
   }),
   delete: authedProcedure.input(ZDeleteInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("delete"), () => import("./delete.handler"));
+    const { default: handler } = await import("./delete.handler");
     return handler(opts);
   }),
   removeMember: authedProcedure.input(ZRemoveMemberInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("removeMember"), () => import("./removeMember.handler"));
+    const { default: handler } = await import("./removeMember.handler");
     return handler(opts);
   }),
   inviteMember: authedProcedure.input(ZInviteMemberInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("inviteMember"),
-      () => import("./inviteMember/inviteMember.handler")
-    );
+    const { default: handler } = await import("./inviteMember/inviteMember.handler");
     return handler(opts);
   }),
   acceptOrLeave: authedProcedure.input(ZAcceptOrLeaveInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("acceptOrLeave"), () => import("./acceptOrLeave.handler"));
+    const { default: handler } = await import("./acceptOrLeave.handler");
     return handler(opts);
   }),
   changeMemberRole: authedProcedure.input(ZChangeMemberRoleInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("changeMemberRole"),
-      () => import("./changeMemberRole.handler")
-    );
+    const { default: handler } = await import("./changeMemberRole.handler");
     return handler(opts);
   }),
   getMemberAvailability: authedProcedure.input(ZGetMemberAvailabilityInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getMemberAvailability"),
-      () => import("./getMemberAvailability.handler")
-    );
+    const { default: handler } = await import("./getMemberAvailability.handler");
     return handler(opts);
   }),
   getMembershipbyUser: authedProcedure.input(ZGetMembershipbyUserInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getMembershipbyUser"),
-      () => import("./getMembershipbyUser.handler")
-    );
+    const { default: handler } = await import("./getMembershipbyUser.handler");
     return handler(opts);
   }),
   updateMembership: authedProcedure.input(ZUpdateMembershipInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("updateMembership"),
-      () => import("./updateMembership.handler")
-    );
+    const { default: handler } = await import("./updateMembership.handler");
     return handler(opts);
   }),
   publish: authedProcedure.input(ZPublishInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("publish"), () => import("./publish.handler"));
+    const { default: handler } = await import("./publish.handler");
     return handler(opts);
   }),
   /** This is a temporal endpoint so we can progressively upgrade teams to the new billing system. */
   getUpgradeable: authedProcedure.query(async ({ ctx }) => {
-    const handler = await importHandler(
-      namespaced("getUpgradeable"),
-      () => import("./getUpgradeable.handler")
-    );
+    const { default: handler } = await import("./getUpgradeable.handler");
     return handler({ userId: ctx.user.id });
   }),
   listMembers: authedProcedure.input(ZListMembersInputSchema).query(async (opts) => {
-    const handler = await importHandler(namespaced("listMembers"), () => import("./listMembers.handler"));
+    const { default: handler } = await import("./listMembers.handler");
     return handler(opts);
   }),
   listSimpleMembers: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("listSimpleMembers"),
-      () => import("./listSimpleMembers.handler")
-    );
+    const { default: handler } = await import("./listSimpleMembers.handler");
     return handler(opts);
   }),
   legacyListMembers: authedProcedure.input(ZLegacyListMembersInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("legacyListMembers"),
-      () => import("./legacyListMembers.handler")
-    );
+    const { default: handler } = await import("./legacyListMembers.handler");
     return handler(opts);
   }),
   getUserConnectedApps: authedProcedure.input(ZGetUserConnectedAppsInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getUserConnectedApps"),
-      () => import("./getUserConnectedApps.handler")
-    );
+    const { default: handler } = await import("./getUserConnectedApps.handler");
     return handler(opts);
   }),
   hasTeamPlan,
   listInvites: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(namespaced("listInvites"), () => import("./listInvites.handler"));
+    const { default: handler } = await import("./listInvites.handler");
     return handler(opts);
   }),
   createInvite: authedProcedure.input(ZCreateInviteInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("createInvite"), () => import("./createInvite.handler"));
+    const { default: handler } = await import("./createInvite.handler");
     return handler(opts);
   }),
   setInviteExpiration: authedProcedure.input(ZSetInviteExpirationInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("setInviteExpiration"),
-      () => import("./setInviteExpiration.handler")
-    );
+    const { default: handler } = await import("./setInviteExpiration.handler");
     return handler(opts);
   }),
   deleteInvite: authedProcedure.input(ZDeleteInviteInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(namespaced("deleteInvite"), () => import("./deleteInvite.handler"));
+    const { default: handler } = await import("./deleteInvite.handler");
     return handler(opts);
   }),
   inviteMemberByToken: authedProcedure.input(ZInviteMemberByTokenSchemaInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("inviteMemberByToken"),
-      () => import("./inviteMemberByToken.handler")
-    );
+    const { default: handler } = await import("./inviteMemberByToken.handler");
     return handler(opts);
   }),
   hasEditPermissionForUser: authedProcedure.input(ZHasEditPermissionForUserSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("hasEditPermissionForUser"),
-      () => import("./hasEditPermissionForUser.handler")
-    );
+    const { default: handler } = await import("./hasEditPermissionForUser.handler");
     return handler(opts);
   }),
   resendInvitation: authedProcedure.input(ZResendInvitationInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("resendInvitation"),
-      () => import("./resendInvitation.handler")
-    );
+    const { default: handler } = await import("./resendInvitation.handler");
     return handler(opts);
   }),
   roundRobinReassign: authedProcedure.input(ZRoundRobinReassignInputSchema).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("roundRobinReassign"),
-      () => import("./roundRobin/roundRobinReassign.handler")
-    );
+    const { default: handler } = await import("./roundRobin/roundRobinReassign.handler");
     return handler(opts);
   }),
   roundRobinManualReassign: authedProcedure
     .input(ZRoundRobinManualReassignInputSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("roundRobinManualReassign"),
-        () => import("./roundRobin/roundRobinManualReassign.handler")
-      );
+      const { default: handler } = await import("./roundRobin/roundRobinManualReassign.handler");
       return handler(opts);
     }),
   getRoundRobinHostsToReassign: authedProcedure.input(ZGetRoundRobinHostsInputSchema).query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("getRoundRobinHostsToReassign"),
-      () => import("./roundRobin/getRoundRobinHostsToReasign.handler")
-    );
+    const { default: handler } = await import("./roundRobin/getRoundRobinHostsToReasign.handler");
     return handler(opts);
   }),
   checkIfMembershipExists: authedProcedure
     .input(ZCheckIfMembershipExistsInputSchema)
     .mutation(async (opts) => {
-      const handler = await importHandler(
-        namespaced("checkIfMembershipExists"),
-        () => import("./checkIfMembershipExists.handler")
-      );
+      const { default: handler } = await import("./checkIfMembershipExists.handler");
       return handler(opts);
     }),
   addMembersToEventTypes: authedProcedure.input(ZAddMembersToEventTypes).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("addMembersToEventTypes"),
-      () => import("./addMembersToEventTypes.handler")
-    );
+    const { default: handler } = await import("./addMembersToEventTypes.handler");
     return handler(opts);
   }),
   removeHostsFromEventTypes: authedProcedure.input(ZRemoveHostsFromEventTypes).mutation(async (opts) => {
-    const handler = await importHandler(
-      namespaced("removeHostsFromEventTypes"),
-      () => import("./removeHostsFromEventTypes.handler")
-    );
+    const { default: handler } = await import("./removeHostsFromEventTypes.handler");
     return handler(opts);
   }),
   getInternalNotesPresets: authedProcedure
     .input(ZGetInternalNotesPresetsInputSchema)
     .query(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("getInternalNotesPresets"),
-        () => import("./getInternalNotesPresets.handler")
-      );
+      const { default: handler } = await import("./getInternalNotesPresets.handler");
       return handler({ ctx, input });
     }),
   updateInternalNotesPresets: authedProcedure
     .input(ZUpdateInternalNotesPresetsInputSchema)
     .mutation(async ({ ctx, input }) => {
-      const handler = await importHandler(
-        namespaced("updateInternalNotesPresets"),
-        () => import("./updateInternalNotesPresets.handler")
-      );
+      const { default: handler } = await import("./updateInternalNotesPresets.handler");
       return handler({ ctx, input });
     }),
   hasActiveTeamPlan: authedProcedure.query(async (opts) => {
-    const handler = await importHandler(
-      namespaced("hasActiveTeamPlan"),
-      () => import("./hasActiveTeamPlan.handler")
-    );
+    const { default: handler } = await import("./hasActiveTeamPlan.handler");
     return handler(opts);
   }),
 });

packages/trpc/server/routers/viewer/teams/procedures/hasTeamPlan.ts

@@ -1,10 +1,10 @@
 import authedProcedure from "../../../../procedures/authedProcedure";
-import { importHandler } from "../../../../trpc";
+import "../../../../trpc";
 
 const NAMESPACE = "teams";
 const namespaced = (s: string) => `${NAMESPACE}.${s}`;
 
 export const hasTeamPlan = authedProcedure.query(async (opts) => {
-  const handler = await importHandler(namespaced("hasTeamPlan"), () => import("../hasTeamPlan.handler"));
+  const { default: handler } = await import("../hasTeamPlan.handler");
   return handler(opts);
 });

packages/trpc/server/trpc.ts

@@ -13,41 +13,3 @@ export const mergeRouters = tRPCContext.mergeRouters;
 export const middleware = tRPCContext.middleware;
 export const procedure = tRPCContext.procedure;
 export const createCallerFactory = tRPCContext.createCallerFactory;
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-const UNSTABLE_HANDLER_CACHE: Record<string, Function> = {};
-
-/**
- * This function will import the module defined in importer just once and then cache the default export of that module.
- *
- * It gives you the default export of the module.
- *
- * **Note: It is your job to ensure that the name provided is unique across all routes.**
- * @example
- * ```ts
-const handler = await importHandler("myUniqueNameSpace", () => import("./getUser.handler"));
-return handler({ ctx, input });
- * ```
- */
-export const importHandler = async <
-  T extends {
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    default: Function;
-  }
->(
-  /**
-   * The name of the handler in cache. It has to be unique across all routes
-   */
-  name: string,
-  importer: () => Promise<T>
-) => {
-  const nameInCache = name as keyof typeof UNSTABLE_HANDLER_CACHE;
-
-  if (!UNSTABLE_HANDLER_CACHE[nameInCache]) {
-    const importedModule = await importer();
-    UNSTABLE_HANDLER_CACHE[nameInCache] = importedModule.default;
-    return importedModule.default as T["default"];
-  }
-
-  return UNSTABLE_HANDLER_CACHE[nameInCache] as unknown as T["default"];
-};