Skip to content

Your favorite shift management application!

9.5 KB
Raw Blame
import { NextRequest, NextResponse } from "next/server";
import { db } from "@/lib/db";
import {
  calendars,
  calendarShares,
  userCalendarSubscriptions,
} from "@/lib/db/schema";
import { getSessionUser } from "@/lib/auth/sessions";
import { eq, and, or, ne, isNotNull, isNull, inArray } from "drizzle-orm";
import { undismissCalendar } from "@/lib/auth/permissions";
import {
  applyGuestCeiling,
  sanitizeCapabilities,
  type Capability,
} from "@/lib/permission-bundles";
import type { CalendarBundleRef } from "@/lib/types";

/**
 * A guest bundle's capabilities, ceiling-filtered like every other guest/link
 * source (5.2). Used for "what would I get" previews of a public calendar's
 * guest access — deliberately NOT resolveCalendarAccess()/
 * getEffectiveAccessSummary(), which require an active "subscribed"
 * subscription and would return no access at all for a calendar the caller
 * hasn't subscribed to (or has dismissed) yet, exactly the two cases this
 * preview needs to cover.
 */
function previewGuestCapabilities(capabilities: unknown) {
  return applyGuestCeiling(sanitizeCapabilities(capabilities));
}

/**
 * GET /api/calendars/subscriptions
 * List all available calendars for discovery
 * Returns two lists:
 * - available: Calendars user can browse (public calendars, showing subscription status)
 * - dismissed: Calendars user has dismissed (both shared and guest-subscribed)
 */
export async function GET(request: NextRequest) {
  const user = await getSessionUser(request.headers);

  if (!user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  try {
    // Get all public calendars (guestBundleId set, not owned by user)
    const allPublicCalendars = await db.query.calendars.findMany({
      where: and(
        isNotNull(calendars.guestBundleId),
        or(isNull(calendars.ownerId), ne(calendars.ownerId, user.id))
      ),
      with: {
        owner: {
          columns: {
            id: true,
            name: true,
            email: true,
          },
        },
        guestBundle: {
          columns: { id: true, name: true, seedKey: true, capabilities: true },
        },
      },
    });

    // Get all user's subscriptions (both subscribed and dismissed)
    const userSubscriptions = await db.query.userCalendarSubscriptions.findMany(
      {
        where: eq(userCalendarSubscriptions.userId, user.id),
      }
    );

    const subscribedIds = new Set(
      userSubscriptions
        .filter((sub) => sub.status === "subscribed")
        .map((sub) => sub.calendarId)
    );

    const dismissedSubs = userSubscriptions.filter(
      (sub) => sub.status === "dismissed"
    );

    // Get user's explicit shares (not dismissed)
    const userShares = await db.query.calendarShares.findMany({
      where: eq(calendarShares.userId, user.id),
      with: {
        bundle: {
          columns: { id: true, name: true, seedKey: true, capabilities: true },
        },
        calendar: {
          with: {
            owner: {
              columns: {
                id: true,
                name: true,
              },
            },
            guestBundle: {
              columns: { id: true, name: true, seedKey: true },
            },
          },
        },
      },
    });

    // A share's capabilities come straight from its bundle — shares are never
    // ceilinged (5.2) — so this avoids a getEffectiveAccessSummary() /
    // resolveCalendarAccess() re-fetch of the same share row per calendar.
    const shareAccess = (
      share: (typeof userShares)[number]
    ): { capabilities: Capability[]; bundle: CalendarBundleRef } => ({
      capabilities: sanitizeCapabilities(share.bundle.capabilities),
      bundle: {
        id: share.bundle.id,
        name: share.bundle.name,
        seedKey: share.bundle.seedKey,
      },
    });

    const dismissedIds = new Set(dismissedSubs.map((sub) => sub.calendarId));

    // Filter out dismissed shares from userShares before building sharedIds
    const activeShares = userShares.filter(
      (share) => !dismissedIds.has(share.calendarId)
    );
    const sharedIds = new Set(activeShares.map((share) => share.calendarId));

    // Build available calendars list (public calendars, excluding ones with active shares or dismissed)
    const publicCalendars = allPublicCalendars
      .filter(
        (cal) =>
          !sharedIds.has(cal.id) && // Exclude if user has active share
          !dismissedIds.has(cal.id) // Exclude if user has dismissed this calendar
      )
      .map((cal) => ({
        id: cal.id,
        name: cal.name,
        color: cal.color,
        capabilities: cal.guestBundle
          ? previewGuestCapabilities(cal.guestBundle.capabilities)
          : [],
        bundle: cal.guestBundle ?? null,
        owner: cal.owner
          ? {
              id: cal.owner.id,
              name: cal.owner.name,
            }
          : null,
        isSubscribed: subscribedIds.has(cal.id),
        source: "guest" as const,
      }));

    // Add shared calendars to available list (already filtered for dismissed
    // in activeShares). A share is unaffected by subscription/dismissal
    // status, so its bundle always applies.
    const sharedCalendars = activeShares.map((share) => {
      const access = shareAccess(share);
      return {
        id: share.calendar.id,
        name: share.calendar.name,
        color: share.calendar.color,
        capabilities: access.capabilities,
        bundle: access.bundle,
        guestBundle: share.calendar.guestBundle ?? null, // for reference
        owner: share.calendar.owner
          ? {
              id: share.calendar.owner.id,
              name: share.calendar.owner.name,
            }
          : null,
        isSubscribed: subscribedIds.has(share.calendarId),
        source: "shared" as const,
      };
    });

    const availableCalendars = [...publicCalendars, ...sharedCalendars];

    // Build dismissed calendars list (both shared and guest-subscribed). A
    // share-backed one uses its bundle directly, same as sharedCalendars
    // above; a guest-only one previews the guest bundle directly, since
    // dismissing sets status to "dismissed" and resolveCalendarAccess()
    // would otherwise report no access at all for it.
    // Batched (one query for every dismissed calendar) rather than one
    // findFirst per row — this list scales with how many calendars a user
    // has dismissed over time, not just their currently-visible ones.
    const dismissedCalendarIds = dismissedSubs.map((sub) => sub.calendarId);
    const dismissedCalendarRows =
      dismissedCalendarIds.length > 0
        ? await db.query.calendars.findMany({
            where: inArray(calendars.id, dismissedCalendarIds),
            with: {
              owner: {
                columns: {
                  id: true,
                  name: true,
                },
              },
              guestBundle: {
                columns: {
                  id: true,
                  name: true,
                  seedKey: true,
                  capabilities: true,
                },
              },
            },
          })
        : [];
    const dismissedCalendarById = new Map(
      dismissedCalendarRows.map((cal) => [cal.id, cal])
    );

    const dismissedCalendars = dismissedSubs.map((sub) => {
      const calendar = dismissedCalendarById.get(sub.calendarId);
      if (!calendar) return null;

      // Check if it's also a shared calendar
      const share = userShares.find((s) => s.calendarId === sub.calendarId);
      const access = share ? shareAccess(share) : null;

      const capabilities = access
        ? access.capabilities
        : calendar.guestBundle
          ? previewGuestCapabilities(calendar.guestBundle.capabilities)
          : [];
      const bundle = access ? access.bundle : (calendar.guestBundle ?? null);

      return {
        id: calendar.id,
        name: calendar.name,
        color: calendar.color,
        capabilities,
        bundle,
        owner: calendar.owner
          ? {
              id: calendar.owner.id,
              name: calendar.owner.name,
            }
          : null,
        source: sub.source,
      };
    });

    // Filter out nulls
    const validDismissedCalendars = dismissedCalendars.filter(
      (cal): cal is NonNullable<typeof cal> => cal !== null
    );

    return NextResponse.json({
      available: availableCalendars,
      dismissed: validDismissedCalendars,
    });
  } catch (error) {
    console.error("Error fetching subscription calendars:", error);
    return NextResponse.json(
      { error: "Failed to fetch calendars" },
      { status: 500 }
    );
  }
}

/**
 * POST /api/calendars/subscriptions
 * Subscribe to a calendar or re-subscribe to a dismissed calendar
 * Body: { calendarId: string }
 */
export async function POST(request: NextRequest) {
  const user = await getSessionUser(request.headers);

  if (!user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  try {
    const body = await request.json();
    const { calendarId } = body;

    if (!calendarId) {
      return NextResponse.json(
        { error: "Calendar ID is required" },
        { status: 400 }
      );
    }

    // Use the helper function to handle both scenarios
    await undismissCalendar(user.id, calendarId);

    return NextResponse.json({ success: true }, { status: 200 });
  } catch (error) {
    console.error("Error subscribing to calendar:", error);
    const message =
      error instanceof Error ? error.message : "Failed to subscribe";
    return NextResponse.json({ error: message }, { status: 400 });
  }
}