@striae-org/striae 4.0.0 → 4.0.2

package/workers/keys-worker/wrangler.jsonc.example

@@ -2,7 +2,7 @@
   "name": "KEYS_WORKER_NAME",
   "account_id": "ACCOUNT_ID",
   "main": "src/keys.ts",
-  "compatibility_date": "2026-03-15",
+  "compatibility_date": "2026-03-17",
   "compatibility_flags": [
     "nodejs_compat"
   ], 

package/workers/pdf-worker/src/pdf-worker.example.ts

@@ -1,12 +1,28 @@
-import { launch } from "@cloudflare/puppeteer";
 import type { PDFGenerationData, PDFGenerationRequest, ReportModule } from './report-types';
 
 interface Env {
   BROWSER: Fetcher;
   PDF_WORKER_AUTH: string;
+  ACCOUNT_ID?: string;
+  CLOUDFLARE_ACCOUNT_ID?: string;
+  BROWSER_API_TOKEN?: string;
+  API_TOKEN?: string;
 }
 
 const DEFAULT_REPORT_FORMAT = 'striae';
+const BROWSER_PDF_TIMEOUT_MS = 90_000;
+const BROWSER_RENDERING_API_BASE = 'https://api.cloudflare.com/client/v4/accounts';
+
+const DEFAULT_PDF_OPTIONS = {
+  printBackground: true,
+  format: 'letter',
+  margin: {
+    top: '0.5in',
+    bottom: '0.5in',
+    left: '0.5in',
+    right: '0.5in',
+  },
+};
 
 const reportModuleLoaders: Record<string, () => Promise<ReportModule>> = {
   // Default Striae report format module
@@ -22,6 +38,45 @@ const corsHeaders: Record<string, string> = {
 const hasValidHeader = (request: Request, env: Env): boolean =>
   request.headers.get('X-Custom-Auth-Key') === env.PDF_WORKER_AUTH;
 
+function isTimeoutError(error: unknown): boolean {
+  return error instanceof Error && (
+    error.name === 'AbortError' ||
+    error.name === 'TimeoutError' ||
+    /timed out/i.test(error.message)
+  );
+}
+
+function jsonResponse(body: unknown, status: number): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { ...corsHeaders, 'content-type': 'application/json' },
+  });
+}
+
+function resolveBrowserApiToken(env: Env): string {
+  const candidates = [env.BROWSER_API_TOKEN, env.API_TOKEN];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim().length > 0) {
+      return candidate.trim();
+    }
+  }
+
+  return '';
+}
+
+function resolveAccountId(env: Env): string {
+  const candidates = [env.ACCOUNT_ID, env.CLOUDFLARE_ACCOUNT_ID];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim().length > 0) {
+      return candidate.trim();
+    }
+  }
+
+  return '';
+}
+
 function normalizeReportFormat(format: unknown): string {
   if (typeof format !== 'string') {
     return DEFAULT_REPORT_FORMAT;
@@ -69,6 +124,84 @@ async function renderReport(reportFormat: string, data: PDFGenerationData): Prom
   return reportModule.renderReport(data);
 }
 
+async function renderPdfViaRestEndpoint(env: Env, html: string): Promise<Response> {
+  const accountId = resolveAccountId(env);
+  const browserApiToken = resolveBrowserApiToken(env);
+
+  if (!accountId || !browserApiToken) {
+    return jsonResponse(
+      {
+        error: 'Missing required Browser Rendering credentials',
+        requiredSecrets: ['ACCOUNT_ID', 'BROWSER_API_TOKEN'],
+        note: 'Set ACCOUNT_ID and a Browser Rendering - Edit token (BROWSER_API_TOKEN) on this worker.',
+      },
+      502
+    );
+  }
+
+  const endpoint = `${BROWSER_RENDERING_API_BASE}/${accountId}/browser-rendering/pdf`;
+  const requestBody = JSON.stringify({
+    html,
+    pdfOptions: DEFAULT_PDF_OPTIONS,
+  });
+
+  let endpointResponse: Response;
+
+  try {
+    endpointResponse = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${browserApiToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: requestBody,
+      signal: AbortSignal.timeout(BROWSER_PDF_TIMEOUT_MS),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown browser endpoint error';
+    return jsonResponse(
+      {
+        error: 'Unable to reach Browser Rendering endpoint',
+        endpoint,
+        message,
+      },
+      isTimeoutError(error) ? 504 : 502
+    );
+  }
+
+  if (!endpointResponse.ok) {
+    const failureText = await endpointResponse.text().catch(() => '');
+    return jsonResponse(
+      {
+        error: 'Browser Rendering endpoint returned an error',
+        endpoint,
+        status: endpointResponse.status,
+        details: failureText.slice(0, 512) || endpointResponse.statusText || 'Unknown endpoint failure',
+      },
+      endpointResponse.status === 504 ? 504 : 502
+    );
+  }
+
+  const responseHeaders = new Headers(endpointResponse.headers);
+  if (!responseHeaders.has('content-type')) {
+    responseHeaders.set('content-type', 'application/pdf');
+  }
+
+  if (!responseHeaders.has('cache-control')) {
+    responseHeaders.set('cache-control', 'no-store');
+  }
+
+  for (const [headerName, headerValue] of Object.entries(corsHeaders)) {
+    responseHeaders.set(headerName, headerValue);
+  }
+
+  return new Response(endpointResponse.body, {
+    status: endpointResponse.status,
+    statusText: endpointResponse.statusText,
+    headers: responseHeaders,
+  });
+}
+
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     if (request.method === 'OPTIONS') {
@@ -76,55 +209,27 @@ export default {
     }
 
     if (!hasValidHeader(request, env)) {
-      return new Response(JSON.stringify({ error: 'Forbidden' }), {
-        status: 403,
-        headers: { ...corsHeaders, 'content-type': 'application/json' },
-      });
+      return jsonResponse({ error: 'Forbidden' }, 403);
     }
 
     if (request.method === 'POST') {
-      let browser: Awaited<ReturnType<typeof launch>> | undefined;
-
       try {
         const payload = await request.json() as PDFGenerationData | PDFGenerationRequest;
         const { reportFormat, data } = resolveReportRequest(payload);
-
-        browser = await launch(env.BROWSER);
-        const page = await browser.newPage();
-
-        // Render report from module selected by report format name.
         const document = await renderReport(reportFormat, data);
-        await page.setContent(document);
-
-        const pdfBuffer = await page.pdf({
-          printBackground: true,
-          format: 'letter',
-          margin: { top: '0.5in', bottom: '0.5in', left: '0.5in', right: '0.5in' },
-        });
-
-        return new Response(new Uint8Array(pdfBuffer), {
-          headers: {
-            ...corsHeaders,
-            'content-type': 'application/pdf',
-          },
-        });
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
 
-        return new Response(JSON.stringify({ error: errorMessage }), {
-          status: 500,
-          headers: { ...corsHeaders, 'content-type': 'application/json' },
-        });
-      } finally {
-        if (browser) {
-          await browser.close();
+        return await renderPdfViaRestEndpoint(env, document);
+      } catch (error) {
+        if (isTimeoutError(error)) {
+          const timeoutMessage = error instanceof Error ? error.message : 'PDF generation timed out';
+          return jsonResponse({ error: timeoutMessage }, 504);
         }
+
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        return jsonResponse({ error: errorMessage }, 500);
       }
     }
 
-    return new Response(JSON.stringify({ error: 'Method not allowed' }), {
-      status: 405,
-      headers: { ...corsHeaders, 'content-type': 'application/json' },
-    });
+    return jsonResponse({ error: 'Method not allowed' }, 405);
   },
 };