Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

♻️ Render the events list on the server with pagination

Luke Vellacfc248559616
diff --git a/CLAUDE.md b/CLAUDE.md
index 4c8bd3d0d..82c68fe9a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -218,10 +218,11 @@ These rules prepare the app for Next.js `cacheComponents` (static shell + stream
- Don't call argless `dayjs()`, `new Date()`, `Date.now()`, or `Math.random()` during server render outside request-bound components — synchronous IO fails prerendering once `cacheComponents` is enabled. Compute "now" on the client or behind a Suspense boundary after `connection()`.
### Clock-Classified Reads (upcoming/past/relative-to-now)
-Reads filtered or grouped by the viewer's present ("upcoming", "past", agenda groupings) have no cacheable answer: the classification depends on the viewer's clock and timezone. All-day events are floating calendar dates (RFC 5545), so classifying them requires the viewer's current calendar date — never drop the timezone from such a query; that silently substitutes UTC as the viewer's zone. Choose the transport by what the data is to the surface:
-- **Content of a long-lived surface** (events list, agenda/calendar): fetch on the client — server renders the shell, the client queries with `getBrowserTimeZone()` and revalidates (refetch on focus). This gives the fastest paint and keeps the data fresh while the page stays open.
-- **Passing annotation on navigation chrome** (a count badge on a tile): a server snapshot is correct. Resolve the zone device-cookie-first via `getDeviceTimeZone()` from `@/lib/datetime/server` (falls back to the stored `user.timeZone`, then UTC). The session zone override is a poll-viewing aid and must not affect classification; `getDeviceDateTimeConfig` (which honors it) is for display on public pages.
-- **Never server-prefetch a client query with a zone the client will disagree with** (e.g. prefetching with the server's own zone and refetching after hydration). Seed `initialData` from the device cookie zone or render a skeleton until the client fetch lands.
+Reads filtered or grouped by the viewer's present ("upcoming", "past", agenda groupings) have no cacheable answer: the classification depends on the viewer's clock and timezone. All-day events are floating calendar dates (RFC 5545), so classifying them requires the viewer's current calendar date — never drop the timezone from such a query; that silently substitutes UTC as the viewer's zone. The device time zone cookie (written by `TimeZoneMismatchDialog` on every space page) gives the server the viewer's zone, so these reads render on the server like any other:
+- **Resolve the zone device-cookie-first** via `getDeviceTimeZone()` from `@/lib/datetime/server`, falling back to the stored `user.timeZone`, then UTC (see `loadViewerTimeZone` in `features/space/loaders.ts`). The session zone override is a poll-viewing aid and must not affect classification; `getDeviceDateTimeConfig` (which honors it) is for display on public pages.
+- **Content of a long-lived surface** (events list): server render the list through a loader and mount `RefreshOnFocus` from `@/components/refresh-on-focus`, which calls `router.refresh()` when the tab becomes visible again, so an event that has ended since stops showing as upcoming. Filter and page changes are router navigations inside the page's `useTransition`, which shows the list skeleton while pending (reference: `app/[locale]/(space)/(dashboard)/events/`).
+- **Passing annotation on navigation chrome** (a count badge on a tile): the same server snapshot, without the focus refresh.
+- **A surface that still queries on the client** passes `getBrowserTimeZone()`. Never server-prefetch such a query with a zone the client will disagree with (e.g. prefetching with the server's own zone and refetching after hydration); seed `initialData` from the device cookie zone or render a skeleton until the client fetch lands.
### File Organization
- Route handlers follow Next.js App Router conventions
diff --git a/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-infinite-list.tsx b/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-list.tsx
similarity index 63%
rename from apps/web/src/app/[locale]/(space)/(dashboard)/events/events-infinite-list.tsx
rename to apps/web/src/app/[locale]/(space)/(dashboard)/events/events-list.tsx
index e5a6b88c8..75841e52b 100644
--- a/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-infinite-list.tsx
+++ b/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-list.tsx
@@ -11,17 +11,12 @@ import {
import { UsersIcon } from "lucide-react";
import React from "react";
import { DataList } from "@/components/data-list";
-import { ListViewContent } from "@/components/list-view";
import { OptimizedAvatarImage } from "@/components/optimized-avatar-image";
-import { Spinner } from "@/components/spinner";
import { EventConferencingSummary } from "@/features/conferencing/components/event-conferencing-summary";
import type { Conferencing } from "@/features/conferencing/schema";
import { EventTimeRange } from "@/features/scheduled-event/components/event-date-time";
import { ScheduledEventRowActions } from "@/features/scheduled-event/components/scheduled-event-row";
-import type {
- ScheduledEventStatus,
- Status,
-} from "@/features/scheduled-event/schema";
+import type { ScheduledEventStatus } from "@/features/scheduled-event/schema";
import { Trans } from "@/i18n/client";
import { CalendarDate } from "@/lib/datetime/calendar-date";
import { useDateTimeConfig } from "@/lib/datetime/client";
@@ -30,10 +25,8 @@ import {
calendarDateToUTCMidnight,
getCalendarDate,
} from "@/lib/datetime/utils";
-import { getBrowserTimeZone } from "@/lib/utils/date-time-utils";
-import { trpc } from "@/trpc/client";
-type EventRow = {
+export type EventRow = {
id: string;
title: string;
status: ScheduledEventStatus;
@@ -42,7 +35,7 @@ type EventRow = {
allDay: boolean;
timeZone: string | null;
conferencing: Conferencing | null;
- invites: { id: string }[];
+ attendeeCount: number;
createdBy: { name: string; image?: string };
};
@@ -93,7 +86,7 @@ const columns = [
) : null;
},
}),
- columnHelper.accessor((event) => event.invites.length, {
+ columnHelper.accessor("attendeeCount", {
id: "attendees",
header: () => <Trans i18nKey="eventsListAttendees" defaults="Attendees" />,
meta: {
@@ -182,7 +175,7 @@ function groupByDay(events: EventRow[], viewerTimeZone: string) {
return { sorted, dayKeyById };
}
-function EventsListSkeleton() {
+export function EventsListSkeleton() {
return (
<div aria-hidden className="py-2">
{Array.from({ length: 6 }).map((_, i) => (
@@ -199,44 +192,16 @@ function EventsListSkeleton() {
);
}
-export function EventsInfiniteList({
- status,
- search,
- member,
+export function EventsList({
+ events,
emptyState,
}: {
- status?: Status;
- search?: string;
- member?: string;
+ events: EventRow[];
emptyState: React.ReactNode;
}) {
- // Classifying upcoming/past depends on the viewer's clock and zone, so this
- // list is fetched on the client only (never server-prefetched).
- const {
- data,
- error,
- fetchNextPage,
- hasNextPage,
- isFetchingNextPage,
- status: queryStatus,
- } = trpc.events.infiniteList.useInfiniteQuery(
- {
- status,
- search,
- member,
- timeZone: getBrowserTimeZone(),
- },
- {
- getNextPageParam: (lastPage) => lastPage.nextCursor,
- },
- );
-
- const events = React.useMemo(
- () => data?.pages.flatMap((page) => page.events) ?? [],
- [data],
- );
-
- const viewerTimeZone = useDateTimeConfig().timeZone ?? getBrowserTimeZone();
+ // UTC until the provider has detected the browser zone, so the server and
+ // first client render group the same way.
+ const viewerTimeZone = useDateTimeConfig().timeZone ?? "UTC";
const { sorted, dayKeyById } = React.useMemo(
() => groupByDay(events, viewerTimeZone),
[events, viewerTimeZone],
@@ -249,97 +214,34 @@ export function EventsInfiniteList({
getRowId: (event) => event.id,
});
- const loadMoreRef = React.useRef<HTMLDivElement>(null);
-
- const handleLoadMore = React.useCallback(async () => {
- if (hasNextPage && !isFetchingNextPage) {
- await fetchNextPage();
- }
- }, [hasNextPage, isFetchingNextPage, fetchNextPage]);
-
- React.useEffect(() => {
- const loadMoreElement = loadMoreRef.current;
- if (!loadMoreElement) return;
-
- const observer = new IntersectionObserver(
- (entries) => {
- const [entry] = entries;
- if (entry.isIntersecting) {
- handleLoadMore();
- }
- },
- {
- threshold: 0.1,
- },
- );
-
- observer.observe(loadMoreElement);
-
- return () => {
- observer.unobserve(loadMoreElement);
- };
- }, [handleLoadMore]);
-
- if (queryStatus === "pending") {
- return (
- <ListViewContent>
- <EventsListSkeleton />
- </ListViewContent>
- );
- }
-
- if (queryStatus === "error") {
- return (
- <ListViewContent>
- <div className="py-8 text-center text-red-600">
- Error loading events: {error?.message}
- </div>
- </ListViewContent>
- );
- }
-
if (events.length === 0) {
- return <ListViewContent>{emptyState}</ListViewContent>;
+ return emptyState;
}
return (
- <ListViewContent>
- <DataList
- table={table}
- getGroup={(event) => {
- const key = dayKeyById.get(event.id) ?? "";
- return {
- id: key,
- label: (
- <>
- <CalendarDate
- value={calendarDateToUTCMidnight(key)}
- preset="weekday"
- className="font-medium text-foreground"
- />
- <CalendarDate
- value={calendarDateToUTCMidnight(key)}
- preset="dateLong"
- className="text-muted-foreground"
- />
- </>
- ),
- };
- }}
- className="grid-cols-[auto_minmax(0,1fr)_auto] sm:grid-cols-[auto_minmax(0,1fr)_auto_auto_auto] lg:grid-cols-[auto_minmax(0,1fr)_auto_auto_auto_auto]"
- />
- {hasNextPage && (
- <div ref={loadMoreRef} className="flex justify-center py-4">
- {isFetchingNextPage && (
- <div className="flex items-center gap-2">
- <Spinner />
- <span className="text-muted-foreground text-sm">
- <Trans i18nKey="loading" defaults="Loading..." />
- </span>
- </div>
- )}
- </div>
- )}
- </ListViewContent>
+ <DataList
+ table={table}
+ getGroup={(event) => {
+ const key = dayKeyById.get(event.id) ?? "";
+ return {
+ id: key,
+ label: (
+ <>
+ <CalendarDate
+ value={calendarDateToUTCMidnight(key)}
+ preset="weekday"
+ className="font-medium text-foreground"
+ />
+ <CalendarDate
+ value={calendarDateToUTCMidnight(key)}
+ preset="dateLong"
+ className="text-muted-foreground"
+ />
+ </>
+ ),
+ };
+ }}
+ className="grid-cols-[auto_minmax(0,1fr)_auto] sm:grid-cols-[auto_minmax(0,1fr)_auto_auto_auto] lg:grid-cols-[auto_minmax(0,1fr)_auto_auto_auto_auto]"
+ />
);
}
diff --git a/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-page.tsx b/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-page.tsx
index 074557322..2330b4fa6 100644
--- a/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-page.tsx
+++ b/apps/web/src/app/[locale]/(space)/(dashboard)/events/events-page.tsx
@@ -1,8 +1,10 @@
"use client";
+import { buttonVariants } from "@rallly/ui";
+import { Button } from "@rallly/ui/button";
import { CalendarIcon } from "lucide-react";
-import { useSearchParams } from "next/navigation";
-import type React from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import React from "react";
import {
EmptyState,
EmptyStateDescription,
@@ -10,23 +12,25 @@ import {
EmptyStateTitle,
} from "@/components/empty-state";
import { FilterPills } from "@/components/filter-pills";
+import { Link } from "@/components/link";
import {
ListView,
+ ListViewContent,
ListViewHeader,
ListViewTitle,
ListViewTitleBar,
ListViewToolbar,
} from "@/components/list-view";
import { MemberSelector } from "@/components/member-selector";
+import { RefreshOnFocus } from "@/components/refresh-on-focus";
import { SearchInput } from "@/components/search-input";
import type { Status } from "@/features/scheduled-event/schema";
import { useSpace } from "@/features/space/client";
import { Trans, useTranslation } from "@/i18n/client";
-import { trpc } from "@/trpc/client";
-import { EventsInfiniteList } from "./events-infinite-list";
+import { EventsListSkeleton } from "./events-list";
import { eventsSearchParamsSchema } from "./schema";
-function EventsEmptyState({ status }: { status: Status }) {
+export function EventsEmptyState({ status }: { status: Status }) {
const contentByStatus: Record<
Status,
{ title: React.ReactNode; description: React.ReactNode }
@@ -99,25 +103,98 @@ function EventsEmptyState({ status }: { status: Status }) {
);
}
-export function EventsPage() {
+function EventsPagination({
+ page,
+ hasNextPage,
+ startTransition,
+}: {
+ page: number;
+ hasNextPage: boolean;
+ startTransition: React.TransitionStartFunction;
+}) {
+ const searchParams = useSearchParams();
+ const router = useRouter();
+
+ if (page === 1 && !hasNextPage) {
+ return null;
+ }
+
+ const hrefFor = (target: number) => {
+ const params = new URLSearchParams(searchParams);
+ if (target === 1) {
+ params.delete("page");
+ } else {
+ params.set("page", String(target));
+ }
+ return `?${params.toString()}`;
+ };
+
+ const pageLink = (target: number, label: React.ReactNode) => {
+ const href = hrefFor(target);
+ return (
+ <Link
+ href={href}
+ scroll={false}
+ onNavigate={(e) => {
+ e.preventDefault();
+ startTransition(() => {
+ router.push(href, { scroll: false });
+ });
+ }}
+ className={buttonVariants()}
+ >
+ {label}
+ </Link>
+ );
+ };
+
+ const previousLabel = <Trans i18nKey="previous" defaults="Previous" />;
+ const nextLabel = <Trans i18nKey="next" defaults="Next" />;
+
+ return (
+ <nav className="flex items-center justify-end gap-2 px-4 py-4">
+ {page > 1 ? (
+ pageLink(page - 1, previousLabel)
+ ) : (
+ <Button disabled>{previousLabel}</Button>
+ )}
+ {hasNextPage ? (
+ pageLink(page + 1, nextLabel)
+ ) : (
+ <Button disabled>{nextLabel}</Button>
+ )}
+ </nav>
+ );
+}
+
+export function EventsPage({
+ members,
+ list,
+ page,
+ hasNextPage,
+}: {
+ members: { userId: string; name: string; image?: string }[];
+ list: React.ReactNode;
+ page: number;
+ hasNextPage: boolean;
+}) {
const searchParams = useSearchParams();
const { t } = useTranslation();
+ // Filter and page changes are server navigations that hold the current
+ // list until the new one is rendered, so show a skeleton while pending.
+ const [isNavigating, startNavigation] = React.useTransition();
const { data: space } = useSpace();
- const [{ data: members }] = trpc.spaces.listMembers.useSuspenseQuery();
// Filtering by member is pointless when the space restricts this member
// to their own events.
const showMemberFilter = space.shared;
- const { status, q, member } = eventsSearchParamsSchema.parse(
+ const { status } = eventsSearchParamsSchema.parse(
Object.fromEntries(searchParams.entries()),
);
- // Ignore a member URL param when the filter is hidden — a bookmarked
- // ?member= URL would otherwise show an empty list with no visible
- // control to clear it.
- const visibleMember = showMemberFilter ? member : undefined;
return (
<ListView>
+ <RefreshOnFocus />
<ListViewHeader>
<ListViewTitleBar>
<ListViewTitle>
@@ -145,6 +222,7 @@ export function EventsPage() {
label: <Trans i18nKey="canceled" defaults="Canceled" />,
},
]}
+ startTransition={startNavigation}
/>
<div className="flex w-full items-center gap-2 sm:ml-auto sm:w-auto">
<SearchInput
@@ -152,22 +230,28 @@ export function EventsPage() {
placeholder={t("searchEventsPlaceholder", {
defaultValue: "Search events by title...",
})}
+ startTransition={startNavigation}
/>
{showMemberFilter ? (
<MemberSelector
members={members}
className="min-w-0 sm:min-w-40"
+ startTransition={startNavigation}
/>
) : null}
</div>
</ListViewToolbar>
</ListViewHeader>
- <EventsInfiniteList
- status={status}
- search={q}
- member={visibleMember}
- emptyState={<EventsEmptyState status={status} />}
- />
+ <ListViewContent>
+ {isNavigating ? <EventsListSkeleton /> : list}
+ {isNavigating ? null : (
+ <EventsPagination
+ page={page}
+ hasNextPage={hasNextPage}
+ startTransition={startNavigation}
+ />
+ )}
+ </ListViewContent>
</ListView>
);
}
diff --git a/apps/web/src/app/[locale]/(space)/(dashboard)/events/page.tsx b/apps/web/src/app/[locale]/(space)/(dashboard)/events/page.tsx
index bc93f2305..4d0549217 100644
--- a/apps/web/src/app/[locale]/(space)/(dashboard)/events/page.tsx
+++ b/apps/web/src/app/[locale]/(space)/(dashboard)/events/page.tsx
@@ -1,20 +1,57 @@
-import { dehydrate, HydrationBoundary } from "@tanstack/react-query";
import type { Metadata } from "next";
+import { loadActiveSpace, loadEvents } from "@/features/space/loaders";
+import { loadSpaceMembers } from "@/features/space/member/loaders";
import { getTranslation } from "@/i18n/server";
-import { createPrivateSSRHelper } from "@/trpc/server/create-ssr-helper";
-import { EventsPage } from "./events-page";
+import { EventsList } from "./events-list";
+import { EventsEmptyState, EventsPage } from "./events-page";
+import { eventsSearchParamsSchema } from "./schema";
-export default async function Page() {
- const helpers = await createPrivateSSRHelper();
+export default async function Page(props: {
+ searchParams: Promise<{ [key: string]: string | string[] | undefined }>;
+}) {
+ const [space, searchParams] = await Promise.all([
+ loadActiveSpace(),
+ props.searchParams,
+ ]);
+ const { status, q, member, page, pageSize } =
+ eventsSearchParamsSchema.parse(searchParams);
+ // Ignore a member URL param when the filter is hidden — a bookmarked
+ // ?member= URL would otherwise show an empty list with no visible
+ // control to clear it.
+ const visibleMember = space.shared ? member : undefined;
- // The events list itself is fetched on the client: upcoming/past depends on
- // the viewer's clock and zone, which the server doesn't know.
- await helpers.spaces.listMembers.prefetch();
+ const [members, result] = await Promise.all([
+ loadSpaceMembers(),
+ loadEvents({ status, q, member: visibleMember, page, pageSize }),
+ ]);
return (
- <HydrationBoundary state={dehydrate(helpers.queryClient)}>
- <EventsPage />
- </HydrationBoundary>
+ <EventsPage
+ members={members.map(({ userId, name, image }) => ({
+ userId,
+ name,
+ image,
+ }))}
+ list={
+ <EventsList
+ events={result.events.map((event) => ({
+ id: event.id,
+ title: event.title,
+ status: event.status,
+ start: event.start,
+ end: event.end,
+ allDay: event.allDay,
+ timeZone: event.timeZone,
+ conferencing: event.conferencing,
+ createdBy: event.createdBy,
+ attendeeCount: event.invites.length,
+ }))}
+ emptyState={<EventsEmptyState status={status} />}
+ />
+ }
+ page={page}
+ hasNextPage={result.hasNextPage}
+ />
);
}
diff --git a/apps/web/src/app/[locale]/(space)/(dashboard)/events/schema.ts b/apps/web/src/app/[locale]/(space)/(dashboard)/events/schema.ts
index e6d30826a..dfa4d3320 100644
--- a/apps/web/src/app/[locale]/(space)/(dashboard)/events/schema.ts
+++ b/apps/web/src/app/[locale]/(space)/(dashboard)/events/schema.ts
@@ -1,9 +1,19 @@
import * as z from "zod";
import { statusSchema } from "@/features/scheduled-event/schema";
-export const DEFAULT_PAGE_SIZE = 10;
+export const DEFAULT_PAGE_SIZE = 50;
-export const pageSchema = z.coerce.number().optional().default(1);
+export const pageSchema = z.coerce.number().int().min(1).catch(1);
+
+export const pageSizeSchema = z.coerce
+ .number()
+ .optional()
+ .transform((val) => {
+ if (!val) return DEFAULT_PAGE_SIZE;
+ return Number.isNaN(val) || val < 1
+ ? DEFAULT_PAGE_SIZE
+ : Math.min(val, 100);
+ });
export const querySchema = z
.string()
@@ -23,6 +33,7 @@ export const memberSchema = z
export const eventsSearchParamsSchema = z.object({
status: eventsStatusSchema,
page: pageSchema,
+ pageSize: pageSizeSchema,
q: querySchema,
member: memberSchema,
});
diff --git a/apps/web/src/components/refresh-on-focus.tsx b/apps/web/src/components/refresh-on-focus.tsx
new file mode 100644
index 000000000..7fba0dd5d
--- /dev/null
+++ b/apps/web/src/components/refresh-on-focus.tsx
@@ -0,0 +1,28 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import React from "react";
+
+/**
+ * Re-renders the server components of the current route when the tab becomes
+ * visible again, so server data that depends on the clock (an event that has
+ * ended since) doesn't go stale while the page stays open.
+ */
+export function RefreshOnFocus() {
+ const router = useRouter();
+
+ React.useEffect(() => {
+ const handleVisibilityChange = () => {
+ if (document.visibilityState === "visible") {
+ router.refresh();
+ }
+ };
+
+ document.addEventListener("visibilitychange", handleVisibilityChange);
+ return () => {
+ document.removeEventListener("visibilitychange", handleVisibilityChange);
+ };
+ }, [router]);
+
+ return null;
+}
diff --git a/apps/web/src/features/scheduled-event/components/scheduled-event-row.tsx b/apps/web/src/features/scheduled-event/components/scheduled-event-row.tsx
index aebfcf66f..bf661f23c 100644
--- a/apps/web/src/features/scheduled-event/components/scheduled-event-row.tsx
+++ b/apps/web/src/features/scheduled-event/components/scheduled-event-row.tsx
@@ -23,6 +23,7 @@ import {
} from "@rallly/ui/dropdown-menu";
import { shortUrl } from "@rallly/utils/absolute-url";
import { CalendarPlusIcon, MoreHorizontalIcon } from "lucide-react";
+import { useRouter } from "next/navigation";
import { CopyLinkButton } from "@/components/copy-link-button";
import { AddToCalendarMenuItems } from "@/features/calendars/components/add-to-calendar-menu-items";
import { isScheduledEventEnabled } from "@/features/scheduled-event/constants";
@@ -39,9 +40,12 @@ export function ScheduledEventRowActions({
}) {
const { t } = useTranslation();
const dialog = useDialog();
+ const router = useRouter();
const cancelEvent = trpc.events.cancel.useMutation({
onSuccess: () => {
dialog.dismiss();
+ // The events list is server rendered, so refresh it.
+ router.refresh();
},
});
diff --git a/apps/web/src/features/space/loaders.ts b/apps/web/src/features/space/loaders.ts
index 1e267b3e6..2013558f9 100644
--- a/apps/web/src/features/space/loaders.ts
+++ b/apps/web/src/features/space/loaders.ts
@@ -3,7 +3,11 @@ import "server-only";
import { redirect } from "next/navigation";
import { cache } from "react";
-import { getUpcomingEventCount } from "@/features/scheduled-event/data";
+import {
+ getEventsChronological,
+ getUpcomingEventCount,
+} from "@/features/scheduled-event/data";
+import type { Status } from "@/features/scheduled-event/schema";
import {
getActiveSpaceForUser,
getOwnedSpace,
@@ -176,21 +180,57 @@ export const loadOptionalActiveSpace = cache(async () => {
* imports scheduled-event, so a scheduled-event → space/user loader would
* close a feature import cycle; space → scheduled-event is a forward edge.
*/
-export const loadUpcomingEventCount = cache(async () => {
- const [user, scope, deviceTimeZone] = await Promise.all([
+// Upcoming and past are measured against the viewer's present, so the device
+// zone wins; the stored preference is a fallback for devices whose zone
+// cookie hasn't been set yet. The session zone override never applies.
+const loadViewerTimeZone = cache(async () => {
+ const [user, deviceTimeZone] = await Promise.all([
loadUser(),
- loadActiveSpaceContentScope(),
getDeviceTimeZone(),
]);
+ return deviceTimeZone ?? normalizeTimeZone(user.timeZone) ?? "UTC";
+});
- // Upcoming is measured against the viewer's present, so the device zone
- // wins; the stored preference is a fallback for devices whose zone cookie
- // hasn't been set yet.
- const timeZone = deviceTimeZone ?? normalizeTimeZone(user.timeZone) ?? "UTC";
+export const loadUpcomingEventCount = cache(async () => {
+ const [scope, timeZone] = await Promise.all([
+ loadActiveSpaceContentScope(),
+ loadViewerTimeZone(),
+ ]);
return getUpcomingEventCount({ scope, timeZone });
});
+export const loadEvents = cache(
+ async ({
+ status,
+ q,
+ member,
+ page,
+ pageSize,
+ }: {
+ status: Status;
+ q?: string;
+ member?: string;
+ page: number;
+ pageSize: number;
+ }) => {
+ const [scope, timeZone] = await Promise.all([
+ loadActiveSpaceContentScope(),
+ loadViewerTimeZone(),
+ ]);
+
+ return getEventsChronological({
+ status,
+ search: q,
+ member,
+ page,
+ pageSize,
+ scope,
+ timeZone,
+ });
+ },
+);
+
/**
* Seat usage for the signed-in user's active space. Session scoped —
* server component/page use only, per loadActiveSpace.
diff --git a/apps/web/src/trpc/routers/events.ts b/apps/web/src/trpc/routers/events.ts
index e56eabdf7..f6fe0c92c 100644
--- a/apps/web/src/trpc/routers/events.ts
+++ b/apps/web/src/trpc/routers/events.ts
@@ -2,55 +2,11 @@ import { subject } from "@casl/ability";
import { prisma } from "@rallly/database";
import { TRPCError } from "@trpc/server";
import * as z from "zod";
-import { getEventsChronological } from "@/features/scheduled-event/data";
import { sendScheduledEventCanceledEmails } from "@/features/scheduled-event/mutations";
import { defineAbilityForMember } from "@/features/space/member/ability";
-import { timeZoneSchema } from "@/lib/datetime/schema";
-import { normalizeTimeZone } from "@/lib/datetime/utils";
import { router, spaceProcedure } from "../trpc";
export const events = router({
- infiniteList: spaceProcedure
- .input(
- z.object({
- status: z
- .enum(["upcoming", "past", "unconfirmed", "canceled"])
- .optional(),
- search: z.string().optional(),
- member: z.string().optional(),
- timeZone: timeZoneSchema.optional(),
- cursor: z.number().optional().default(1),
- limit: z.number().max(100).optional().default(20),
- }),
- )
- .query(async ({ ctx, input }) => {
- const { cursor: page, limit: pageSize, status, search, member } = input;
- const timeZone =
- input.timeZone ?? normalizeTimeZone(ctx.user.timeZone) ?? "UTC";
-
- const result = await getEventsChronological({
- status,
- search,
- member,
- page,
- pageSize,
- scope: ctx.contentScope,
- timeZone,
- });
-
- let nextCursor: number | undefined;
- if (result.hasNextPage) {
- nextCursor = page + 1;
- }
-
- return {
- events: result.events,
- nextCursor,
- hasNextPage: result.hasNextPage,
- total: result.total,
- };
- }),
-
cancel: spaceProcedure
.input(z.object({ eventId: z.string() }))
.mutation(async ({ ctx, input }) => {
diff --git a/apps/web/src/trpc/routers/spaces.ts b/apps/web/src/trpc/routers/spaces.ts
index f1c81518a..04831dba6 100644
--- a/apps/web/src/trpc/routers/spaces.ts
+++ b/apps/web/src/trpc/routers/spaces.ts
@@ -1,56 +1,10 @@
import { prisma } from "@rallly/database";
import { TRPCError } from "@trpc/server";
import * as z from "zod";
-import { fromDBRole } from "@/features/space/utils";
import { identifyGroup, track } from "@/lib/posthog";
import { privateProcedure, router, spaceProcedure } from "../trpc";
export const spaces = router({
- // ── Queries ──────────────────────────────────────────────────────────
- listMembers: spaceProcedure.query(async ({ ctx }) => {
- const [members, totalCount] = await Promise.all([
- prisma.spaceMember.findMany({
- where: {
- spaceId: ctx.space.id,
- },
- select: {
- id: true,
- userId: true,
- role: true,
- spaceId: true,
- user: {
- select: {
- name: true,
- email: true,
- image: true,
- },
- },
- },
- orderBy: {
- createdAt: "asc",
- },
- }),
- prisma.spaceMember.count({
- where: {
- spaceId: ctx.space.id,
- },
- }),
- ]);
-
- return {
- total: totalCount,
- data: members.map((member) => ({
- id: member.id,
- userId: member.userId,
- spaceId: member.spaceId,
- name: member.user.name,
- email: member.user.email,
- image: member.user.image ?? undefined,
- role: fromDBRole(member.role),
- isOwner: member.userId === ctx.space.ownerId,
- })),
- };
- }),
// ── Mutations ────────────────────────────────────────────────────────
leave: spaceProcedure.mutation(async ({ ctx }) => {
if (ctx.space.ownerId === ctx.user.id) {