Update app.js

app.js

@@ -1,86 +1,165 @@
 import express from 'express';
-import { chromium } from 'playwright-extra';
-import stealth from 'playwright-extra/plugins/stealth';
+import { chromium } from 'playwright';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import os from 'os';
+import sharp from 'sharp';
 import cluster from 'cluster';
 import { cpus } from 'os';
-import sharp from 'sharp';
 
-chromium.use(stealth());
+dotenv.config();
 
-const BROWSERS_COUNT = cpus().length;
-const PORT = process.env.PORT || 7860;
+const config = {
+    maxTextLength: 100,
+    viewport: { width: 1920, height: 1080 },
+    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    concurrentBrowsers: cpus().length // Gunakan jumlah core CPU
+};
 
-class FastBratGenerator {
+class BratGeneratorService {
     constructor() {
         this.browsers = [];
         this.pages = [];
+        this.isInitialized = false;
     }
 
-    async init() {
-        const promises = Array(BROWSERS_COUNT).fill().map(async () => {
-            const browser = await chromium.launch({ headless: true });
-            const context = await browser.newContext({ viewport: { width: 1920, height: 1080 } });
+    async initialize() {
+        if (this.isInitialized) return;
+
+        const launchPromises = Array.from({ length: config.concurrentBrowsers }, async () => {
+            const browser = await chromium.launch({ 
+                headless: true,
+                args: [
+                    '--no-sandbox',
+                    '--disable-setuid-sandbox',
+                    '--disable-dev-shm-usage'
+                ]
+            });
+            const context = await browser.newContext({
+                viewport: config.viewport,
+                userAgent: config.userAgent
+            });
+
+            await context.route('**/*', (route) => {
+                const url = route.request().url();
+                if (url.endsWith('.png') || url.endsWith('.jpg') || url.includes('google-analytics')) {
+                    return route.abort();
+                }
+                route.continue();
+            });
+
             const page = await context.newPage();
-            
-            await page.goto('https://www.bratgenerator.com/', { waitUntil: 'domcontentloaded' });
-            
+            await page.goto('https://www.bratgenerator.com/', { 
+                waitUntil: 'domcontentloaded', 
+                timeout: 5000 
+            });
+
+            try {
+                await page.click('#onetrust-accept-btn-handler', { timeout: 2000 });
+            } catch { }
+
+            await page.evaluate(() => setupTheme('white'));
+
             this.browsers.push(browser);
             this.pages.push(page);
         });
 
-        await Promise.all(promises);
+        await Promise.all(launchPromises);
+        this.isInitialized = true;
     }
 
-    async generate(text) {
-        const page = this.pages[Math.floor(Math.random() * this.pages.length)];
+    async generateBrat(text, pageIndex = 0) {
+        if (!this.pages[pageIndex]) {
+            pageIndex = 0; // Reset jika index tidak valid
+        }
+
+        const page = this.pages[pageIndex];
         await page.fill('#textInput', text);
+        const overlay = page.locator('#textOverlay');
         
-        const screenshot = await page.locator('#textOverlay').screenshot({ 
-            type: 'png', 
-            timeout: 2000 
+        const pngBuffer = await overlay.screenshot({ 
+            timeout: 3000,
+            type: 'png'
         });
         
-        return sharp(screenshot)
-            .webp({ quality: 85, speed: 6 })
+        return sharp(pngBuffer)
+            .webp({ quality: 80 })
             .toBuffer();
     }
 
     async close() {
-        await Promise.all(this.browsers.map(b => b.close()));
+        const closePromises = this.browsers.map(browser => browser.close());
+        await Promise.all(closePromises);
+        this.browsers = [];
+        this.pages = [];
+        this.isInitialized = false;
     }
 }
 
-const bratGenerator = new FastBratGenerator();
+const bratService = new BratGeneratorService();
 
 async function startServer() {
     const app = express();
     app.use(express.json());
+    app.use(cors());
+
+    // Middleware untuk membatasi panjang teks
+    const validateTextLength = (req, res, next) => {
+        const { q } = req.query;
+        if (!q || q.length > config.maxTextLength) {
+            return res.status(400).json({
+                status: false,
+                message: `Teks harus diisi dan maksimal ${config.maxTextLength} karakter`
+            });
+        }
+        next();
+    };
 
-    app.get('/', async (req, res) => {
+    app.get('*', validateTextLength, async (req, res) => {
         try {
             const { q } = req.query;
-            if (!q) return res.status(400).send('Text required');
+            const pageIndex = Math.floor(Math.random() * config.concurrentBrowsers);
             
-            const imageBuffer = await bratGenerator.generate(q);
-            res.contentType('image/webp');
+            const imageBuffer = await bratService.generateBrat(q, pageIndex);
+            res.set('Content-Type', 'image/webp');
             res.send(imageBuffer);
         } catch (error) {
-            res.status(500).send('Generation failed');
+            console.error(error);
+            res.status(500).json({
+                status: false,
+                message: 'Error generating image',
+                error: process.env.NODE_ENV === 'development' ? error.message : undefined
+            });
         }
     });
 
-    await bratGenerator.init();
-    app.listen(PORT, () => console.log(`Running on ${PORT}`));
+    const PORT = process.env.PORT || 7860;
+    await bratService.initialize();
+    
+    app.listen(PORT, () => {
+        console.log(`Server running on port ${PORT}`);
+        console.log(`Worker PID: ${process.pid}`);
+    });
 }
 
+// Gunakan cluster untuk scaling
 if (cluster.isPrimary) {
-    cpus().forEach(() => cluster.fork());
-    cluster.on('exit', (worker) => cluster.fork());
+    console.log(`Primary ${process.pid} is running`);
+    
+    // Fork workers.
+    for (let i = 0; i < cpus().length; i++) {
+        cluster.fork();
+    }
+
+    cluster.on('exit', (worker, code, signal) => {
+        console.log(`worker ${worker.process.pid} died`);
+        cluster.fork(); // Restart worker
+    });
 } else {
-    startServer();
+    startServer().catch(console.error);
 }
 
 process.on('SIGINT', async () => {
-    await bratGenerator.close();
+    await bratService.close();
     process.exit(0);
 });