enhanced anime backend

src/api/proxy/proxy.controller.ts

@@ -1,6 +1,6 @@
-import { FastifyReply } from 'fastify';
-import { proxyRequest, processM3U8Content, streamToReadable } from './proxy.service';
-import { ProxyRequest } from '../types';
+import {FastifyReply} from 'fastify';
+import {processM3U8Content, proxyRequest, streamToReadable} from './proxy.service';
+import {ProxyRequest} from '../types';
 
 export async function handleProxy(req: ProxyRequest, reply: FastifyReply) {
     const { url, referer, origin, userAgent } = req.query;
@@ -10,7 +10,7 @@ export async function handleProxy(req: ProxyRequest, reply: FastifyReply) {
     }
 
     try {
-        const { response, contentType, isM3U8 } = await proxyRequest(url, {
+        const { response, contentType, isM3U8, contentLength } = await proxyRequest(url, {
             referer,
             origin,
             userAgent
@@ -18,28 +18,43 @@ export async function handleProxy(req: ProxyRequest, reply: FastifyReply) {
 
         reply.header('Access-Control-Allow-Origin', '*');
         reply.header('Access-Control-Allow-Methods', 'GET, OPTIONS');
+        reply.header('Access-Control-Allow-Headers', 'Content-Type, Range');
+        reply.header('Access-Control-Expose-Headers', 'Content-Length, Content-Range, Accept-Ranges');
 
         if (contentType) {
             reply.header('Content-Type', contentType);
         }
 
+        if (contentLength) {
+            reply.header('Content-Length', contentLength);
+        }
+
+        if (contentType?.startsWith('image/') || contentType?.startsWith('video/')) {
+            reply.header('Cache-Control', 'public, max-age=31536000, immutable');
+        }
+
+        reply.header('Accept-Ranges', 'bytes');
+
         if (isM3U8) {
             const text = await response.text();
             const baseUrl = new URL(response.url);
 
-            const processed = processM3U8Content(text, baseUrl, {
+            const processedContent = processM3U8Content(text, baseUrl, {
                 referer,
                 origin,
                 userAgent
             });
 
-            return processed;
+            return reply.send(processedContent);
         }
 
         return reply.send(streamToReadable(response.body!));
 
     } catch (err) {
         req.server.log.error(err);
-        return reply.code(500).send({ error: "Internal Server Error" });
+
+        if (!reply.sent) {
+            return reply.code(500).send({ error: "Internal Server Error" });
+        }
     }
-}
+}

src/api/proxy/proxy.service.ts

@@ -10,39 +10,79 @@ interface ProxyResponse {
     response: Response;
     contentType: string | null;
     isM3U8: boolean;
+    contentLength: string | null;
 }
 
 export async function proxyRequest(url: string, { referer, origin, userAgent }: ProxyHeaders): Promise<ProxyResponse> {
     const headers: Record<string, string> = {
         'User-Agent': userAgent || "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
         'Accept': '*/*',
-        'Accept-Language': 'en-US,en;q=0.9'
+        'Accept-Language': 'en-US,en;q=0.9',
+        'Accept-Encoding': 'identity',
+
+        'Connection': 'keep-alive'
     };
 
     if (referer) headers['Referer'] = referer;
     if (origin) headers['Origin'] = origin;
 
-    const response = await fetch(url, { headers, redirect: 'follow' });
+    let lastError: Error | null = null;
+    const maxRetries = 2;
 
-    if (!response.ok) {
-        throw new Error(`Proxy Error: ${response.statusText}`);
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 60000);
+
+            const response = await fetch(url, {
+                headers,
+                redirect: 'follow',
+                signal: controller.signal
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+
+                if (response.status === 404 || response.status === 403) {
+                    throw new Error(`Proxy Error: ${response.status} ${response.statusText}`);
+                }
+
+                if (attempt < maxRetries - 1) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                    continue;
+                }
+
+                throw new Error(`Proxy Error: ${response.status} ${response.statusText}`);
+            }
+
+            const contentType = response.headers.get('content-type');
+            const contentLength = response.headers.get('content-length');
+            const isM3U8 = (contentType && contentType.includes('mpegurl')) || url.includes('.m3u8');
+
+            return {
+                response,
+                contentType,
+                isM3U8,
+                contentLength
+            };
+
+        } catch (error) {
+            lastError = error as Error;
+
+            if (attempt === maxRetries - 1) {
+                throw lastError;
+            }
+
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
     }
 
-    const contentType = response.headers.get('content-type');
-    const isM3U8 = (contentType && contentType.includes('mpegurl')) || url.includes('.m3u8');
-
-    return {
-        response,
-        contentType,
-        isM3U8
-    };
+    throw lastError || new Error('Unknown error in proxyRequest');
 }
 
-export function processM3U8Content(
-    text: string,
-    baseUrl: URL,
-    { referer, origin, userAgent }: ProxyHeaders
-): string {
+export function processM3U8Content(text: string, baseUrl: URL, { referer, origin, userAgent }: ProxyHeaders): string {
     return text.replace(/^(?!#)(?!\s*$).+/gm, (line) => {
         line = line.trim();
         let absoluteUrl: string;
@@ -64,5 +104,35 @@ export function processM3U8Content(
 }
 
 export function streamToReadable(webStream: ReadableStream): Readable {
-    return Readable.fromWeb(webStream as any);
+    const reader = webStream.getReader();
+    let readTimeout: NodeJS.Timeout;
+
+    return new Readable({
+        async read() {
+            try {
+
+                const timeoutPromise = new Promise((_, reject) => {
+                    readTimeout = setTimeout(() => reject(new Error('Stream read timeout')), 10000);
+                });
+
+                const readPromise = reader.read();
+                const { done, value } = await Promise.race([readPromise, timeoutPromise]) as any;
+
+                clearTimeout(readTimeout);
+
+                if (done) {
+                    this.push(null);
+                } else {
+                    this.push(Buffer.from(value));
+                }
+            } catch (error) {
+                clearTimeout(readTimeout);
+                this.destroy(error as Error);
+            }
+        },
+        destroy(error, callback) {
+            clearTimeout(readTimeout);
+            reader.cancel().then(() => callback(error)).catch(callback);
+        }
+    });
 }