feature: cache events

src/compositions/Blocks/EventsBlock.tsx

@@ -32,7 +32,7 @@ export async function EventsBlock({
         <Title color={'contrast'} title={title || 'Veranstaltungen'} />
         <Events
           events={transformOccurrences(occurrenceDocs)}
-          n={itemsPerPage || 6}
+          n={6}
           schema={'contrast'}
         />
       </Section>

src/fetch/eventOccurrences.ts

@@ -1,7 +1,10 @@
 import { getPayload, PaginatedDocs } from 'payload'
+import { unstable_cache } from 'next/cache'
 import config from '@/payload.config'
 import { EventOccurrence } from '@/payload-types'
 
+const CACHE_TTL = 300 // 5 minutes
+
 type ListArgs = {
   parishId?: string
   groupId?: string
@@ -12,32 +15,41 @@ type ListArgs = {
   toDate?: Date
 }
 
+// Resolved args use ISO strings so they serialize into a stable cache key.
+type ResolvedArgs = {
+  parishId?: string
+  groupId?: string
+  eventId?: string
+  limit: number
+  page: number
+  fromDate?: string
+  toDate?: string
+}
+
+// Round down to the cache window so a default `new Date()` (millisecond
+// precision) produces a stable key for the duration of the TTL.
+function roundDownToTtl(date: Date): Date {
+  const ms = CACHE_TTL * 1000
+  return new Date(Math.floor(date.getTime() / ms) * ms)
+}
+
 /**
  * Fetch upcoming event occurrences, joined to their parent event. Always
  * filters to occurrences whose parent event is published.
  */
-export async function fetchUpcomingOccurrences(
+const getUpcomingOccurrences = unstable_cache(
-  args?: ListArgs,
+  async (args: ResolvedArgs): Promise<PaginatedDocs<EventOccurrence>> => {
-): Promise<PaginatedDocs<EventOccurrence>> {
+    const { parishId, groupId, eventId, limit, page, fromDate, toDate } = args
-  const {
-    parishId,
-    groupId,
-    eventId,
-    limit = 30,
-    page = 0,
-    fromDate = new Date(),
-    toDate,
-  } = args || {}
 
     const query: any = {
       and: [
-      { date: { greater_than_equal: fromDate.toISOString() } },
+        { date: { greater_than_equal: fromDate } },
         { 'event._status': { equals: 'published' } },
       ],
     }
 
     if (toDate) {
-    query.and.push({ date: { less_than: toDate.toISOString() } })
+      query.and.push({ date: { less_than: toDate } })
     }
     if (eventId) {
       query.and.push({ event: { equals: eventId } })
@@ -58,13 +70,12 @@ export async function fetchUpcomingOccurrences(
       limit,
       page,
     }) as Promise<PaginatedDocs<EventOccurrence>>
-}
+  },
+  ['fetchUpcomingOccurrences'],
+  { revalidate: CACHE_TTL },
+)
 
-/**
+export async function fetchUpcomingOccurrences(
- * Fetch past event occurrences (most recent first), joined to their parent
- * event. Always filters to occurrences whose parent event is published.
- */
-export async function fetchPastOccurrences(
   args?: ListArgs,
 ): Promise<PaginatedDocs<EventOccurrence>> {
   const {
@@ -73,19 +84,38 @@ export async function fetchPastOccurrences(
     eventId,
     limit = 30,
     page = 0,
-    fromDate,
+    fromDate = new Date(),
-    toDate = new Date(),
+    toDate,
   } = args || {}
 
+  return getUpcomingOccurrences({
+    parishId,
+    groupId,
+    eventId,
+    limit,
+    page,
+    fromDate: roundDownToTtl(fromDate).toISOString(),
+    toDate: toDate?.toISOString(),
+  })
+}
+
+/**
+ * Fetch past event occurrences (most recent first), joined to their parent
+ * event. Always filters to occurrences whose parent event is published.
+ */
+const getPastOccurrences = unstable_cache(
+  async (args: ResolvedArgs): Promise<PaginatedDocs<EventOccurrence>> => {
+    const { parishId, groupId, eventId, limit, page, fromDate, toDate } = args
+
     const query: any = {
       and: [
-      { date: { less_than: toDate.toISOString() } },
+        { date: { less_than: toDate } },
         { 'event._status': { equals: 'published' } },
       ],
     }
 
     if (fromDate) {
-    query.and.push({ date: { greater_than_equal: fromDate.toISOString() } })
+      query.and.push({ date: { greater_than_equal: fromDate } })
     }
     if (eventId) {
       query.and.push({ event: { equals: eventId } })
@@ -106,6 +136,33 @@ export async function fetchPastOccurrences(
       limit,
       page,
     }) as Promise<PaginatedDocs<EventOccurrence>>
+  },
+  ['fetchPastOccurrences'],
+  { revalidate: CACHE_TTL },
+)
+
+export async function fetchPastOccurrences(
+  args?: ListArgs,
+): Promise<PaginatedDocs<EventOccurrence>> {
+  const {
+    parishId,
+    groupId,
+    eventId,
+    limit = 30,
+    page = 0,
+    fromDate,
+    toDate = new Date(),
+  } = args || {}
+
+  return getPastOccurrences({
+    parishId,
+    groupId,
+    eventId,
+    limit,
+    page,
+    fromDate: fromDate?.toISOString(),
+    toDate: roundDownToTtl(toDate).toISOString(),
+  })
 }
 
 /**