Create service-worker-proxy_(old)v1.ts

service-worker-proxy_(old)v1.ts

@@ -0,0 +1,224 @@
+const CONFIG = {
+  TELEGRAM_API_BASE: "https://api.telegram.org",
+  PROXY_PATH_PREFIX: "/telegram-api",
+
+  // Retry logic
+  MAX_RETRIES: 3,
+  RETRY_DELAY_MS: 300,
+  RETRYABLE_STATUS_CODES: [429, 500, 502, 503, 504],
+
+  // Request timeout
+  REQUEST_TIMEOUT_MS: 30_000,
+
+  // Security: only allow these Telegram API methods through
+  // Leave empty to allow all methods
+  ALLOWED_METHODS: [] as string[],
+
+  // Headers to strip from incoming requests
+  HEADERS_TO_STRIP: [
+    "cf-ray", "cf-connecting-ip", "x-forwarded-for",
+    "x-real-ip", "cf-ipcountry", "cf-visitor",
+    "cf-worker", "cdn-loop", "host",
+  ],
+};
+
+interface ProxyResult {
+  response: Response;
+  retries: number;
+  durationMs: number;
+}
+
+function getClientIP(request: Request): string {
+  return (
+    request.headers.get("cf-connecting-ip") ||
+    request.headers.get("x-forwarded-for")?.split(",")[0].trim() ||
+    request.headers.get("x-real-ip") ||
+    "unknown"
+  );
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function extractBotMethod(pathname: string): string | null {
+  const match = pathname.match(/^\/bot[^/]+\/([^/?]+)/);
+  return match ? match[1] : null;
+}
+
+function sanitizeHeaders(headers: Headers): Headers {
+  const cleaned = new Headers(headers);
+  for (const header of CONFIG.HEADERS_TO_STRIP) {
+    cleaned.delete(header);
+  }
+  cleaned.set("host", "api.telegram.org");
+  return cleaned;
+}
+
+function corsHeaders(): Record<string, string> {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    "Access-Control-Max-Age": "86400",
+  };
+}
+
+function errorResponse(
+  status: number,
+  code: string,
+  message: string,
+  extra?: Record<string, unknown>
+): Response {
+  return new Response(
+    JSON.stringify({ ok: false, error_code: status, code, description: message, ...extra }),
+    {
+      status,
+      headers: { "Content-Type": "application/json", ...corsHeaders() },
+    }
+  );
+}
+
+async function proxyToTelegram(
+  telegramUrl: string,
+  request: Request
+): Promise<ProxyResult> {
+  const startTime = Date.now();
+  let lastError: Error | null = null;
+  let retries = 0;
+
+  const cleanedHeaders = sanitizeHeaders(request.headers);
+  const bodyBuffer = request.body ? await request.arrayBuffer() : null;
+
+  for (let attempt = 0; attempt <= CONFIG.MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      const delay = CONFIG.RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+      await sleep(delay);
+      retries++;
+    }
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        CONFIG.REQUEST_TIMEOUT_MS
+      );
+
+      const upstreamRequest = new Request(telegramUrl, {
+        method: request.method,
+        headers: cleanedHeaders,
+        body: bodyBuffer,
+        redirect: "follow",
+        signal: controller.signal,
+      });
+
+      const response = await fetch(upstreamRequest);
+      clearTimeout(timeoutId);
+
+      if (
+        response.ok ||
+        (response.status >= 400 &&
+          response.status < 500 &&
+          response.status !== 429)
+      ) {
+        return { response, retries, durationMs: Date.now() - startTime };
+      }
+
+      if (CONFIG.RETRYABLE_STATUS_CODES.includes(response.status)) {
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          if (retryAfter) {
+            await sleep(parseInt(retryAfter) * 1000);
+          }
+        }
+        lastError = new Error(`Upstream returned ${response.status}`);
+        continue;
+      }
+
+      return { response, retries, durationMs: Date.now() - startTime };
+
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (lastError.name === "AbortError") {
+        throw new Error(`Request timed out after ${CONFIG.REQUEST_TIMEOUT_MS}ms`);
+      }
+    }
+  }
+
+  throw lastError ?? new Error("Unknown proxy error after retries");
+}
+
+export default {
+  async fetch(request: Request): Promise<Response> {
+    const startTime = Date.now();
+    const originalUrl = new URL(request.url);
+    const clientIP = getClientIP(request);
+    const requestId = crypto.randomUUID();
+
+    if (request.method === "OPTIONS") {
+      return new Response(null, { status: 204, headers: corsHeaders() });
+    }
+
+    if (originalUrl.pathname === "/health") {
+      return new Response(
+        JSON.stringify({ ok: true, timestamp: new Date().toISOString() }),
+        { headers: { "Content-Type": "application/json", ...corsHeaders() } }
+      );
+    }
+
+    if (!originalUrl.pathname.startsWith(CONFIG.PROXY_PATH_PREFIX)) {
+      return new Response("Telegram API Proxy - send requests to /telegram-api/bot{TOKEN}/{METHOD}", {
+        status: 200,
+        headers: { "Content-Type": "text/plain", ...corsHeaders() },
+      });
+    }
+
+    const telegramPath = originalUrl.pathname.replace(CONFIG.PROXY_PATH_PREFIX, "");
+    const botMethod = extractBotMethod(telegramPath);
+
+    if (
+      CONFIG.ALLOWED_METHODS.length > 0 &&
+      (!botMethod || !CONFIG.ALLOWED_METHODS.includes(botMethod))
+    ) {
+      return errorResponse(403, "METHOD_NOT_ALLOWED", `Method '${botMethod}' is not permitted`);
+    }
+
+    const telegramApiUrl = `${CONFIG.TELEGRAM_API_BASE}${telegramPath}${originalUrl.search}`;
+
+    try {
+      const { response, retries, durationMs } = await proxyToTelegram(telegramApiUrl, request);
+
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: {
+          ...Object.fromEntries(response.headers.entries()),
+          ...corsHeaders(),
+          "X-Proxy-Request-ID": requestId,
+          "X-Proxy-Duration-Ms": String(durationMs),
+          "X-Proxy-Retries": String(retries),
+        },
+      });
+
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      const isTimeout = message.includes("timed out");
+
+      console.error(JSON.stringify({
+        requestId,
+        clientIP,
+        method: request.method,
+        path: telegramPath,
+        error: message,
+        durationMs: Date.now() - startTime,
+      }));
+
+      return errorResponse(
+        isTimeout ? 504 : 502,
+        isTimeout ? "GATEWAY_TIMEOUT" : "BAD_GATEWAY",
+        message,
+        { requestId }
+      );
+    }
+  },
+};