slices / frontend-v2 / server / routes.ts

/// <reference lib="deno.ns" />

import type { Route } from "@std/http/unstable-route";
import {
  ADMIN_DIDS,
  createOAuthClient,
  oauthConfig,
  oauthSessions,
  oauthStorage,
  sessionStore,
  SLICE_URI,
} from "./config.ts";
import { OAuthClient } from "@slices/oauth";
import { handleDocsDetail, handleDocsIndex } from "./docs.ts";
import { initializeUserProfile } from "./profile-init.ts";
import { checkUserAccess } from "./invite-checker.ts";
import { handleLandingOGImage } from "./og-images.tsx";

// ============================================================================
// AUTH ROUTES
// ============================================================================

async function handleOAuthAuthorize(req: Request): Promise<Response> {
  try {
    const formData = await req.formData();
    const loginHint = formData.get("loginHint") as string;

    if (!loginHint) {
      return new Response("Missing login hint", { status: 400 });
    }

    const tempOAuthClient = new OAuthClient(
      oauthConfig,
      oauthStorage,
      loginHint,
    );

    const authResult = await tempOAuthClient.authorize({
      loginHint,
    });

    return Response.redirect(authResult.authorizationUrl, 302);
  } catch (error) {
    console.error("OAuth authorize error:", error);

    return Response.redirect(
      "/login?error=" +
        encodeURIComponent("Please check your handle and try again."),
      302,
    );
  }
}

async function handleOAuthCallback(req: Request): Promise<Response> {
  try {
    const url = new URL(req.url);
    const code = url.searchParams.get("code");
    const state = url.searchParams.get("state");

    // Check if state contains waitlist data
    let isWaitlistFlow = false;
    if (state) {
      try {
        const decodedState = JSON.parse(atob(state));
        isWaitlistFlow = decodedState.isWaitlistFlow === true;
      } catch {
        // State is not our custom waitlist state, continue with normal flow
      }
    }

    // If this is a waitlist flow, handle it separately
    if (isWaitlistFlow) {
      return handleWaitlistCallback(req);
    }

    if (!code || !state) {
      return Response.redirect(
        "/login?error=" + encodeURIComponent("Invalid OAuth callback"),
        302,
      );
    }

    const tempOAuthClient = new OAuthClient(oauthConfig, oauthStorage, "temp");
    const tokens = await tempOAuthClient.handleCallback({ code, state });
    const sessionId = await oauthSessions.createOAuthSession(tokens);

    if (!sessionId) {
      return Response.redirect(
        "/login?error=" + encodeURIComponent("Failed to create session"),
        302,
      );
    }

    // Initialize user profile before redirecting
    const oauthClient = createOAuthClient(sessionId);
    const userInfo = await oauthClient.getUserInfo();

    // Check waitlist access if user info is available
    if (userInfo?.sub) {
      if (!SLICE_URI || !ADMIN_DIDS) {
        console.error("Missing SLICE_URI or ADMIN_DIDS configuration");
      } else {
        const { hasAccess, isOnWaitlist } = await checkUserAccess(
          userInfo.sub,
          SLICE_URI,
        );
        if (!hasAccess) {
          // Clear OAuth session and redirect to waitlist page
          await oauthClient.logout();

          const errorCode = isOnWaitlist
            ? "already_on_waitlist"
            : "invite_required";
          return Response.redirect(
            `/waitlist?error=${errorCode}`,
            302,
          );
        }
      }
    }

    if (userInfo?.sub && userInfo?.name) {
      await initializeUserProfile(userInfo.sub, userInfo.name, {
        accessToken: tokens.accessToken,
        tokenType: tokens.tokenType,
      });
    }

    const sessionCookie = sessionStore.createSessionCookie(sessionId);

    return new Response(null, {
      status: 302,
      headers: {
        Location: "/",
        "Set-Cookie": sessionCookie,
      },
    });
  } catch (error) {
    console.error("OAuth callback error:", error);
    return Response.redirect(
      "/login?error=" + encodeURIComponent("Authentication failed"),
      302,
    );
  }
}

async function handleLogout(req: Request): Promise<Response> {
  const session = await sessionStore.getSessionFromRequest(req);

  if (session) {
    await oauthSessions.logout(session.sessionId);
  }

  const clearCookie = sessionStore.createLogoutCookie();

  return new Response(null, {
    status: 302,
    headers: {
      Location: "/login",
      "Set-Cookie": clearCookie,
    },
  });
}

// ============================================================================
// WAITLIST HANDLERS
// ============================================================================

async function handleWaitlistInitiate(req: Request): Promise<Response> {
  try {
    const formData = await req.formData();
    const handle = formData.get("handle") as string;

    if (!handle) {
      return new Response("Missing handle", { status: 400 });
    }

    // Create temporary OAuth client for waitlist flow
    const tempOAuthClient = new OAuthClient(oauthConfig, oauthStorage, handle);

    // Store waitlist flag in state parameter
    const waitlistState = btoa(
      JSON.stringify({
        isWaitlistFlow: true,
        handle,
        redirectUri: "/auth/waitlist/callback",
      }),
    );

    // Initiate OAuth with minimal scope for waitlist, passing state directly
    const authResult = await tempOAuthClient.authorize({
      loginHint: handle,
      scope: "atproto repo:network.slices.waitlist.request",
      state: waitlistState,
    });

    return Response.redirect(authResult.authorizationUrl, 302);
  } catch (error) {
    console.error("Waitlist initiate error:", error);
    return Response.redirect(
      "/waitlist?error=authorization_failed",
      302,
    );
  }
}

async function handleWaitlistCallback(req: Request): Promise<Response> {
  try {
    const url = new URL(req.url);
    const code = url.searchParams.get("code");
    const state = url.searchParams.get("state");

    if (!code || !state) {
      return Response.redirect(
        "/waitlist?error=invalid_callback",
        302,
      );
    }

    // Decode waitlist state from state parameter
    let waitlistData: {
      isWaitlistFlow?: boolean;
      handle?: string;
      redirectUri?: string;
    } = {};
    try {
      waitlistData = JSON.parse(atob(state));
    } catch {
      console.error("Failed to decode waitlist state");
    }

    // Create temp session-scoped client for waitlist (not creating actual session)
    const tempSessionId = "waitlist_" + Date.now();
    const tempOAuthClient = new OAuthClient(
      oauthConfig,
      oauthStorage,
      tempSessionId,
    );

    // Exchange code for tokens
    const tokens = await tempOAuthClient.handleCallback({ code, state });

    // Store tokens so we can fetch user info
    await oauthStorage.setTokens(tokens, tempSessionId);

    // Get user info
    const userInfo = await tempOAuthClient.getUserInfo();

    if (!userInfo) {
      return Response.redirect(
        "/waitlist?error=no_user_info",
        302,
      );
    }

    // Get slice URI from environment
    const sliceUri = Deno.env.get("VITE_SLICE_URI");
    if (!sliceUri) {
      console.error("Missing VITE_SLICE_URI environment variable");
      return Response.redirect(
        "/waitlist?error=waitlist_failed",
        302,
      );
    }

    // Create waitlist record via GraphQL mutation
    try {
      const mutation = `
        mutation CreateWaitlistRequest($slice: String!, $createdAt: String!, $rkey: String!) {
          createNetworkSlicesWaitlistRequest(
            input: {
              slice: $slice
              createdAt: $createdAt
            }
            rkey: $rkey
          ) {
            uri
          }
        }
      `;

      const graphqlUrl = `${API_URL}/graphql?slice=${
        encodeURIComponent(sliceUri)
      }`;
      const response = await fetch(graphqlUrl, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "Authorization": `${tokens.tokenType} ${tokens.accessToken}`,
        },
        body: JSON.stringify({
          query: mutation,
          variables: {
            slice: sliceUri,
            createdAt: new Date().toISOString(),
            rkey: "self",
          },
        }),
      });

      if (!response.ok) {
        throw new Error(`GraphQL request failed: ${response.statusText}`);
      }

      const result = await response.json();
      if (result.errors) {
        console.error("GraphQL mutation errors:", result.errors);
        throw new Error("Failed to create waitlist record");
      }

      // Sync user collections to populate their Bluesky profile data
      try {
        const syncMutation = `
          mutation SyncUserCollections($slice: String!) {
            syncNetworkSlicesSliceUserCollections(slice: $slice) {
              success
            }
          }
        `;

        await fetch(graphqlUrl, {
          method: "POST",
          headers: {
            "Content-Type": "application/json",
            "Authorization": `${tokens.tokenType} ${tokens.accessToken}`,
          },
          body: JSON.stringify({
            query: syncMutation,
            variables: { slice: sliceUri },
          }),
        });
      } catch (syncError) {
        console.error(
          "Failed to sync user collections for waitlist user:",
          syncError,
        );
        // Don't fail the waitlist process if sync fails
      }
    } catch (error) {
      console.error("Failed to create waitlist record:", error);
      // Continue anyway - we don't want to block the user
    }

    // Clear temp OAuth session since this is just for waitlist
    await tempOAuthClient.logout();

    // Redirect back to waitlist page with success parameter
    const handle = userInfo.name || waitlistData.handle || "user";
    const params = new URLSearchParams({
      waitlist: "success",
      handle,
    });
    return Response.redirect(`/waitlist?${params.toString()}`, 302);
  } catch (error) {
    console.error("Waitlist callback error:", error);
    return Response.redirect(
      "/waitlist?error=waitlist_failed",
      302,
    );
  }
}

// ============================================================================
// SESSION API
// ============================================================================

async function handleGetSession(req: Request): Promise<Response> {
  try {
    const session = await sessionStore.getSessionFromRequest(req);

    if (!session) {
      return Response.json({ authenticated: false }, { status: 401 });
    }

    // Get user info from OAuth client
    const oauthClient = createOAuthClient(session.sessionId);
    const userInfo = await oauthClient.getUserInfo();

    if (!userInfo) {
      return Response.json({ authenticated: false }, { status: 401 });
    }

    // Get access token for API documentation
    let accessToken: string | undefined;
    try {
      const tokens = await oauthClient.getTokens();
      accessToken = tokens?.accessToken;
    } catch (error) {
      console.error("Could not get access token:", error);
    }

    return Response.json({
      authenticated: true,
      user: {
        did: userInfo.sub,
        handle: userInfo.name,
      },
      accessToken,
    });
  } catch (error) {
    console.error("Session check error:", error);
    return Response.json({ authenticated: false }, { status: 401 });
  }
}

// ============================================================================
// GRAPHQL PROXY
// ============================================================================

const API_URL = Deno.env.get("API_URL");

if (!API_URL) {
  throw new Error(
    "Missing API_URL configuration. Please ensure .env file contains API_URL",
  );
}

async function handleGraphQLProxy(req: Request): Promise<Response> {
  try {
    const url = new URL(req.url);
    const session = await sessionStore.getSessionFromRequest(req);

    // Build request headers
    const headers: Record<string, string> = {
      "Content-Type": "application/json",
    };

    // If authenticated, add authorization header
    if (session) {
      const oauthClient = createOAuthClient(session.sessionId);
      const tokens = await oauthClient.getTokens();

      if (tokens) {
        headers["Authorization"] = `${tokens.tokenType} ${tokens.accessToken}`;
      }
    }

    // Forward the request to the GraphQL API
    const graphqlUrl = `${API_URL}/graphql${url.search}`;
    const response = await fetch(graphqlUrl, {
      method: req.method,
      headers,
      body: req.method !== "GET" ? await req.text() : undefined,
    });

    // Return the GraphQL response
    const data = await response.json();
    return Response.json(data, {
      status: response.status,
      headers: {
        "Content-Type": "application/json",
      },
    });
  } catch (error) {
    console.error("GraphQL proxy error:", error);
    return Response.json(
      { error: "GraphQL request failed" },
      { status: 500 },
    );
  }
}

// ============================================================================
// ROUTE EXPORTS
// ============================================================================

export const allRoutes: Route[] = [
  // OAuth flow
  {
    method: "POST",
    pattern: new URLPattern({ pathname: "/oauth/authorize" }),
    handler: handleOAuthAuthorize,
  },
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/oauth/callback" }),
    handler: handleOAuthCallback,
  },
  // Waitlist flow
  {
    method: "POST",
    pattern: new URLPattern({ pathname: "/auth/waitlist/initiate" }),
    handler: handleWaitlistInitiate,
  },
  // Logout
  {
    method: "POST",
    pattern: new URLPattern({ pathname: "/logout" }),
    handler: handleLogout,
  },
  // Session API
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/api/session" }),
    handler: handleGetSession,
  },
  // Docs API
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/api/docs" }),
    handler: handleDocsIndex,
  },
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/api/docs/:slug" }),
    handler: handleDocsDetail,
  },
  // GraphQL Proxy
  {
    method: "POST",
    pattern: new URLPattern({ pathname: "/graphql" }),
    handler: handleGraphQLProxy,
  },
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/graphql" }),
    handler: handleGraphQLProxy,
  },
  // OG Images
  {
    method: "GET",
    pattern: new URLPattern({ pathname: "/og-image" }),
    handler: handleLandingOGImage,
  },
];