server.ts

import { serve } from "https://deno.land/std@0.224.0/http/server.ts";
import { initializeWorkers } from "./src/workerPool.ts";
import { initializeCache } from "./src/playerCache.ts";
import { handleDecryptSignature } from "./src/handlers/decryptSignature.ts";
import { handleGetSts } from "./src/handlers/getSts.ts";
import { handleResolveUrl } from "./src/handlers/resolveUrl.ts";
import { handleGetPoToken } from "./src/handlers/getPoToken.ts";
import { withMetrics } from "./src/middleware.ts";
import { withPlayer } from "./src/middleware/player.ts";
import { withValidation } from "./src/validation.ts";
import { registry } from "./src/metrics.ts";
import type { ApiRequest, RequestContext } from "./src/types.ts";

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

async function baseHandler(req: Request): Promise<Response> {
  const { pathname } = new URL(req.url);

  if (req.method === "GET") {
    if (pathname === "/") {
      try {
        const file = await Deno.readFile("./docs/index.html");
        return new Response(file, {
          status: 200,
          headers: { "Content-Type": "text/html" },
        });
      } catch {
        return new Response(
          "Homepage not found. Please refer to the API spec at https://github.com/kikkia/yt-cipher?tab=readme-ov-file#api-specification",
          {
            status: 404,
            headers: { "Content-Type": "text/plain" },
          },
        );
      }
    }
    if (pathname === "/swagger.yaml") {
      try {
        const file = await Deno.readFile("./docs/swagger.yaml");
        return new Response(file, {
          status: 200,
          headers: { "Content-Type": "application/yaml" },
        });
      } catch {
        return new Response("Swagger spec not found", {
          status: 404,
          headers: { "Content-Type": "text/plain" },
        });
      }
    }
  }

  if (pathname === "/metrics") {
    return new Response(registry.metrics(), {
      headers: { "Content-Type": "text/plain" },
    });
  }

  const authHeader = req.headers.get("authorization");
  if (API_TOKEN && API_TOKEN !== "") {
    if (authHeader !== API_TOKEN) {
      const error = authHeader ? "Invalid API token" : "Missing API token";
      return new Response(JSON.stringify({ error }), {
        status: 401,
        headers: { "Content-Type": "application/json" },
      });
    }
  }

  let handle: (ctx: RequestContext) => Promise<Response>;

  if (pathname === "/decrypt_signature") {
    handle = handleDecryptSignature;
  } else if (pathname === "/get_sts") {
    handle = handleGetSts;
  } else if (pathname === "/resolve_url") {
    handle = handleResolveUrl;
  } else if (pathname === "/get_pot") {
    handle = handleGetPoToken;
  } else {
    return new Response(JSON.stringify({ error: "Not Found" }), {
      status: 404,
      headers: { "Content-Type": "application/json" },
    });
  }

  let body;
  try {
    body = (await req.json()) as ApiRequest;
  } catch {
    return new Response(JSON.stringify({ error: "Invalid JSON body" }), {
      status: 400,
      headers: { "Content-Type": "application/json" },
    });
  }
  const ctx: RequestContext = { req, body };

  const composedHandler =
    pathname === "/get_pot"
      ? withValidation(withMetrics(handle))
      : withValidation(withPlayer(withMetrics(handle)));
  return await composedHandler(ctx);
}

const handler = baseHandler;

const port = Deno.env.get("PORT") || 8001;
const host = Deno.env.get("HOST") || "0.0.0.0";

await initializeCache();
initializeWorkers();

console.log(`Server listening on http://${host}:${port}`);
await serve(handler, { port: Number(port), hostname: host });