feat: add featured events route

Author: brage-andreas

apps/rpc/src/modules/event/event-repository.ts

@@ -1,6 +1,8 @@
-import type { DBHandle, Prisma } from "@dotkomonline/db"
+import type { DBHandle, Prisma, findFeaturedEvents } from "@dotkomonline/db"
 import {
   type AttendanceId,
+  type BaseEvent,
+  BaseEventSchema,
   type CompanyId,
   type DeregisterReason,
   DeregisterReasonSchema,
@@ -40,6 +42,8 @@ const INCLUDE_COMPANY_AND_GROUPS = {
 export interface EventRepository {
   create(handle: DBHandle, data: EventWrite): Promise<Event>
   update(handle: DBHandle, eventId: EventId, data: Partial<EventWrite>): Promise<Event>
+  updateEventAttendance(handle: DBHandle, eventId: EventId, attendanceId: AttendanceId): Promise<Event>
+  updateEventParent(handle: DBHandle, eventId: EventId, parentEventId: EventId | null): Promise<Event>
   /**
    * Soft-delete an event by setting its status to "DELETED".
    */
@@ -80,15 +84,17 @@ export interface EventRepository {
     page: Pageable
   ): Promise<Event[]>
   findByParentEventId(handle: DBHandle, parentEventId: EventId): Promise<Event[]>
+  findEventsWithUnansweredFeedbackFormByUserId(handle: DBHandle, userId: UserId): Promise<Event[]>
+  findManyDeregisterReasonsWithEvent(handle: DBHandle, page: Pageable): Promise<DeregisterReasonWithEvent[]>
+  // This cannot use `Pageable` due to raw query needing numerical offset and not cursor based pagination
+  findFeaturedEvents(handle: DBHandle, offset: number, limit: number): Promise<BaseEvent[]>
+
   addEventHostingGroups(handle: DBHandle, eventId: EventId, hostingGroupIds: Set<GroupId>): Promise<void>
-  addEventCompanies(handle: DBHandle, eventId: EventId, companyIds: Set<CompanyId>): Promise<void>
   deleteEventHostingGroups(handle: DBHandle, eventId: EventId, hostingGroupIds: Set<GroupId>): Promise<void>
+  addEventCompanies(handle: DBHandle, eventId: EventId, companyIds: Set<CompanyId>): Promise<void>
   deleteEventCompanies(handle: DBHandle, eventId: EventId, companyIds: Set<CompanyId>): Promise<void>
-  updateEventAttendance(handle: DBHandle, eventId: EventId, attendanceId: AttendanceId): Promise<Event>
-  updateEventParent(handle: DBHandle, eventId: EventId, parentEventId: EventId | null): Promise<Event>
-  findEventsWithUnansweredFeedbackFormByUserId(handle: DBHandle, userId: UserId): Promise<Event[]>
+
   createDeregisterReason(handle: DBHandle, data: DeregisterReasonWrite): Promise<DeregisterReason>
-  findManyDeregisterReasonsWithEvent(handle: DBHandle, page: Pageable): Promise<DeregisterReasonWithEvent[]>
 }
 
 export function getEventRepository(): EventRepository {
@@ -309,6 +315,25 @@ export function getEventRepository(): EventRepository {
       )
     },
 
+    async findFeaturedEvents(handle, offset, limit) {
+      // Events will primarily be ranked by their type in the following order (lower number is higher ranking):
+      // 1. GENERAL_ASSEMBLY
+      // 2. COMPANY, ACADEMIC
+      // 3. SOCIAL, INTERNAL, OTHER, WELCOME
+      //
+      // Within each bucket they will be ranked like this:
+      // 1. Event in future, registration open and not full AND attendance capacity is limited (>0)
+      // 2. Event in future, registration not started yet (attendance capacity does not matter)
+      // 3. Event in future, no attendance registration OR attendance capacity is unlimited (=0)
+      // 4. Event in future, registration full (registration status does not matter)
+      //
+      // Past events are not featured. We would rather have no featured events than "stale" events.
+
+      const events = await handle.$queryRawTyped(findFeaturedEvents(offset, limit))
+
+      return parseOrReport(BaseEventSchema.array(), events)
+    },
+
     async addEventHostingGroups(handle, eventId, hostingGroupIds) {
       await handle.eventHostingGroup.createMany({
         data: hostingGroupIds

apps/rpc/src/modules/event/event-router.ts

@@ -1,6 +1,8 @@
 import type { PresignedPost } from "@aws-sdk/s3-presigned-post"
 import {
+  AttendanceSchema,
   AttendanceWriteSchema,
+  BaseEventSchema,
   CompanySchema,
   EventFilterQuerySchema,
   EventSchema,
@@ -153,7 +155,12 @@ const allEventsProcedure = procedure
 export type AllByAttendingUserIdInput = inferProcedureInput<typeof allByAttendingUserIdProcedure>
 export type AllByAttendingUserIdOutput = inferProcedureOutput<typeof allByAttendingUserIdProcedure>
 const allByAttendingUserIdProcedure = procedure
-  .input(BasePaginateInputSchema.extend({ filter: EventFilterQuerySchema.optional(), id: UserSchema.shape.id }))
+  .input(
+    BasePaginateInputSchema.extend({
+      filter: EventFilterQuerySchema.optional(),
+      id: UserSchema.shape.id,
+    })
+  )
   .output(
     z.object({
       items: EventWithAttendanceSchema.array(),
@@ -172,7 +179,7 @@ const allByAttendingUserIdProcedure = procedure
 
     const eventsWithAttendance = events.map((event) => ({
       event,
-      attendance: attendances.find((attendance) => attendance.id === event.attendanceId) || null,
+      attendance: attendances.find((attendance) => attendance.id === event.attendanceId) ?? null,
     }))
 
     return {
@@ -244,7 +251,7 @@ const findChildEventsProcedure = procedure
     )
     return events.map((event) => ({
       event,
-      attendance: attendances.find((attendance) => attendance.id === event.attendanceId) || null,
+      attendance: attendances.find((attendance) => attendance.id === event.attendanceId) ?? null,
     }))
   })
 
@@ -290,6 +297,33 @@ const findManyDeregisterReasonsWithEventProcedure = procedure
     }
   })
 
+export type FindFeaturedEventsInput = inferProcedureInput<typeof findFeaturedEventsProcedure>
+export type FindFeaturedEventsOutput = inferProcedureOutput<typeof findFeaturedEventsProcedure>
+const findFeaturedEventsProcedure = procedure
+  .input(
+    z.object({
+      offset: z.number().min(0).default(0),
+      limit: z.number().min(1).max(100).default(10),
+    })
+  )
+  .output(z.object({ event: BaseEventSchema, attendance: AttendanceSchema.nullable() }).array())
+  .use(withDatabaseTransaction())
+  .query(async ({ input, ctx }) => {
+    const events = await ctx.eventService.findFeaturedEvents(ctx.handle, input.offset, input.limit)
+
+    const attendances = await ctx.attendanceService.getAttendancesByIds(
+      ctx.handle,
+      events.map((item) => item.attendanceId).filter((id) => id !== null)
+    )
+
+    const eventsWithAttendance = events.map((event) => ({
+      event,
+      attendance: attendances.find((attendance) => attendance.id === event.attendanceId) ?? null,
+    }))
+
+    return eventsWithAttendance
+  })
+
 export type CreateFileUploadInput = inferProcedureInput<typeof createFileUploadProcedure>
 export type CreateFileUploadOutput = inferProcedureOutput<typeof createFileUploadProcedure>
 const createFileUploadProcedure = procedure

apps/rpc/src/modules/event/event-service.ts

@@ -4,6 +4,7 @@ import type { DBHandle } from "@dotkomonline/db"
 import { getLogger } from "@dotkomonline/logger"
 import type {
   AttendanceId,
+  BaseEvent,
   CompanyId,
   DeregisterReason,
   DeregisterReasonWithEvent,
@@ -45,6 +46,7 @@ export interface EventService {
   findByParentEventId(handle: DBHandle, parentEventId: EventId): Promise<Event[]>
   findEventById(handle: DBHandle, eventId: EventId): Promise<Event | null>
   findEventsWithUnansweredFeedbackFormByUserId(handle: DBHandle, userId: UserId): Promise<Event[]>
+  findFeaturedEvents(handle: DBHandle, offset: number, limit: number): Promise<BaseEvent[]>
   /**
    * Get an event by its id
    *
@@ -98,6 +100,10 @@ export function getEventService(
       return await eventRepository.findEventsWithUnansweredFeedbackFormByUserId(handle, userId)
     },
 
+    async findFeaturedEvents(handle, offset, limit) {
+      return await eventRepository.findFeaturedEvents(handle, offset, limit)
+    },
+
     async getEventById(handle, eventId) {
       const event = await eventRepository.findById(handle, eventId)
       if (!event) {

apps/web/src/app/page.tsx

@@ -10,7 +10,7 @@ import type { Attendance, Event, EventWithAttendance, UserId } from "@dotkomonli
 import { RichText, cn } from "@dotkomonline/ui"
 import { Text, Tilt, Title } from "@dotkomonline/ui"
 import { Button } from "@dotkomonline/ui"
-import { getCurrentUTC, slugify } from "@dotkomonline/utils"
+import { slugify } from "@dotkomonline/utils"
 import { IconArrowRight, IconCalendarEvent } from "@tabler/icons-react"
 import { formatDate } from "date-fns"
 import { nb } from "date-fns/locale"
@@ -20,17 +20,8 @@ import type { FC } from "react"
 export default async function App() {
   const [session, isStaff] = await Promise.all([auth.getServerSession(), server.user.isStaff.query()])
 
-  const { items: events } = await server.event.all.query({
-    take: 3,
-    filter: {
-      byEndDate: {
-        max: null,
-        min: getCurrentUTC(),
-      },
-      excludingOrganizingGroup: ["velkom"],
-      excludingType: isStaff ? [] : undefined,
-      orderBy: "asc",
-    },
+  const events = await server.event.findFeaturedEvents.query({
+    limit: 3,
   })
 
   const featuredEvent = events[0] ?? null

packages/db/prisma.config.ts

@@ -12,4 +12,7 @@ export default defineConfig({
   migrations: {
     path: "./prisma/migrations/",
   },
+  typedSql: {
+    path: "./prisma/sql",
+  },
 })

packages/db/prisma/schema.prisma

@@ -2,7 +2,7 @@ generator client {
   provider = "prisma-client"
   output   = "../generated/prisma"
 
-  previewFeatures = ["relationJoins"]
+  previewFeatures = ["relationJoins", "typedSql"]
 }
 
 generator zod {
@@ -220,13 +220,20 @@ enum EventStatus {
 }
 
 enum EventType {
-  SOCIAL           @map("SOCIAL")
-  ACADEMIC         @map("ACADEMIC")
-  COMPANY          @map("COMPANY")
-  // This is called "Generalforsamling" in Norwegian and happens twice a year.
+  /// Generalforsamling
   GENERAL_ASSEMBLY @map("GENERAL_ASSEMBLY")
+  /// Bedriftspresentasjon
+  COMPANY          @map("COMPANY")
+  /// Kurs
+  ACADEMIC         @map("ACADEMIC")
+  SOCIAL           @map("SOCIAL")
+  // These are for the rare occations we have events that are only open to committee members
   INTERNAL         @map("INTERNAL")
   OTHER            @map("OTHER")
+  // These are for a committe called "velkom" and are special social events for new students.
+  // These have a separate type because we have historically hid these from event lists to not
+  // spam students that are not new with these events. In older versions of OnlineWeb these
+  // were even treated as a completely separate event entity.
   WELCOME          @map("WELCOME")
 
   @@map("event_type")

packages/db/prisma/sql/findFeaturedEvents.sql

@@ -0,0 +1,101 @@
+-- @param {Int} $1:offset
+-- @param {Int} $2:limit
+
+-- DOCS: https://www.prisma.io/docs/orm/prisma-client/using-raw-sql/typedsql
+
+-- This SQL query is used in EventRepository#findFeaturedEvents to find featured events, as this is too complex to do
+-- with Prisma's normal query API.
+
+-- Events will primarily be ranked by their type in the following order (lower number is higher ranking):
+--   1. GENERAL_ASSEMBLY
+--   2. COMPANY, ACADEMIC
+--   3. SOCIAL, INTERNAL, OTHER, WELCOME
+--
+-- Within each bucket they will be ranked like this:
+--   1. Event in future, registration open and not full AND attendance capacities is limited (>0)
+--   2. Event in future, registration not started yet (attendance capacities does not matter)
+--   3. Event in future, no attendance registration OR attendance capacities is unlimited (=0)
+--   4. Event in future, registration full (registration status does not matter)
+--
+-- Past events are not featured. We would rather have no featured events than "stale" events.
+
+WITH
+  capacities AS (
+    SELECT
+      "attendanceId",
+      SUM("capacity") AS sum
+    FROM "attendance_pool"
+    GROUP BY "attendanceId"
+  ),
+
+  attendees AS (
+    SELECT
+      "attendanceId",
+      COUNT(*) AS count
+    FROM "attendee"
+    GROUP BY "attendanceId"
+  )
+
+SELECT
+  "event".*,
+  COALESCE(capacities.sum, 0) AS "totalCapacity",
+  COALESCE(attendees.count, 0) AS "attendeeCount",
+
+  -- 1,2,3: event type buckets
+  CASE "event"."type"
+    WHEN 'GENERAL_ASSEMBLY' THEN 1
+    WHEN 'COMPANY'          THEN 2
+    WHEN 'ACADEMIC'         THEN 2
+    ELSE 3
+  END AS "typeRank",
+
+  -- 1-4: registration buckets
+  CASE
+    -- 1. Future, registration open and not full AND capacities limited (> 0)
+    WHEN "event"."attendanceId" IS NOT NULL
+      AND NOW() BETWEEN attendance."registerStart" AND attendance."registerEnd"
+      AND COALESCE(capacities.sum, 0) > 0
+      AND COALESCE(attendees.count, 0) < COALESCE(capacities.sum, 0)
+    THEN 1
+
+    -- 2. Future, registration not started yet (capacities doesn't matter)
+    WHEN "event"."attendanceId" IS NOT NULL
+      AND NOW() < attendance."registerStart"
+    THEN 2
+
+    -- 3. Future, no registration OR unlimited capacities (total capacities = 0)
+    WHEN "event"."attendanceId" IS NULL
+      OR COALESCE(capacities.sum, 0) = 0
+    THEN 3
+
+    -- 4. Future, registration full (status doesn't matter)
+    WHEN "event"."attendanceId" IS NOT NULL
+      AND COALESCE(capacities.sum, 0) > 0
+      AND COALESCE(attendees.count, 0) >= COALESCE(capacities.sum, 0)
+    THEN 4
+
+    -- Fallback: treat as bucket 4
+    ELSE 4
+  END AS "registrationBucket"
+
+FROM "event"
+LEFT JOIN "attendance"
+  ON "attendance"."id" = "event"."attendanceId"
+LEFT JOIN capacities
+  ON capacities."attendanceId" = "event"."attendanceId"
+LEFT JOIN attendees
+  ON attendees."attendanceId" = "event"."attendanceId"
+
+WHERE
+  "event"."status" = 'PUBLIC'
+  -- Past events are not featured
+  AND "event"."start" > NOW()
+
+ORDER BY
+  "typeRank" ASC,
+  "registrationBucket" ASC,
+  -- Tie breaker with earlier events first
+  "event"."start" ASC
+
+OFFSET $1
+LIMIT $2;

packages/types/src/event.ts

@@ -12,14 +12,17 @@ import { GroupSchema } from "./group"
  * companies, attendance pools, and attendees.
  */
 
-export type EventId = Event["id"]
-export type EventType = Event["type"]
-export type EventStatus = Event["status"]
+export type BaseEvent = z.infer<typeof BaseEventSchema>
+export const BaseEventSchema = schemas.EventSchema.extend({})
+
 export type Event = z.infer<typeof EventSchema>
 export const EventSchema = schemas.EventSchema.extend({
   companies: z.array(CompanySchema),
   hostingGroups: z.array(GroupSchema),
 })
+export type EventId = Event["id"]
+export type EventType = Event["type"]
+export type EventStatus = Event["status"]
 
 export const EventTypeSchema = schemas.EventTypeSchema
 export const EventStatusSchema = schemas.EventStatusSchema