Fix error handling to properly use formatError utility and improve environment detection

- Actually use the formatError function in the error handling code
- Update formatError function to accept env parameter for Cloudflare Workers
- Improve environment detection to use WORKER_ENV instead of process.env
- Update tests to match new function signature
- Add comprehensive test coverage for error formatting
- Fix linting issues and ensure proper TypeScript types

.github/workflows/playwright.yml

@@ -1,4 +1,6 @@
 name: Playwright Tests
+permissions:
+  contents: read
 on:
   push:
     branches: [main, master]

src/index.ts

@@ -3,11 +3,13 @@
 
 import { PrismaClient } from '@prisma/client';
 import { PrismaD1 } from '@prisma/adapter-d1';
+import { formatError } from './utils/error';
 
 export interface Env {
     DB: D1Database;
     NEXTAUTH_SECRET?: string;
     NEXTAUTH_URL?: string;
+    WORKER_ENV?: string; // 'development' | 'production'
 }
 
 export default {
@@ -208,21 +210,22 @@ export default {
             });
 
         } catch (error) {
-            console.error('Worker error:', error);
+            console.error('Worker error:', error); // Log full error details, including stack trace
+            
+            // Use the formatError utility to properly format the error response
+            const errorPayload = formatError(error, env);
+            
             return new Response(
-                JSON.stringify({
-                    error: 'Internal Server Error',
-                    message: error instanceof Error ? error.message : 'Unknown error',
-                    stack: error instanceof Error ? error.stack : undefined
-                }),
+                JSON.stringify(errorPayload),
                 {
                     status: 500,
                     headers: {
                         'Content-Type': 'application/json',
                         'Access-Control-Allow-Origin': '*'
-                    },
+                    }
                 }
             );
         }
     },
 };
+

src/utils/error.ts

@@ -0,0 +1,16 @@
+export function formatError(error: unknown, env?: { WORKER_ENV?: string }): Record<string, unknown> {
+  const payload: Record<string, unknown> = {
+    error: 'Internal Server Error',
+    message: error instanceof Error ? error.message : 'Unknown error'
+  };
+  
+  // Only include stack trace in development environment
+  // In Cloudflare Workers, check environment via env parameter
+  const isDevelopment = env?.WORKER_ENV !== 'production';
+  
+  if (isDevelopment) {
+    payload.stack = error instanceof Error ? error.stack : undefined;
+  }
+  
+  return payload;
+}

tests/formatError.test.ts

@@ -0,0 +1,36 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { formatError } from '../src/utils/error';
+
+const originalEnv = process.env.NODE_ENV;
+
+test('includes stack when not in production', () => {
+  const err = new Error('boom');
+  const payload = formatError(err, { WORKER_ENV: 'development' });
+  assert.ok('stack' in payload);
+});
+
+test('omits stack in production', () => {
+  const err = new Error('boom');
+  const payload = formatError(err, { WORKER_ENV: 'production' });
+  assert.ok(!('stack' in payload));
+});
+
+test('includes message for all environments', () => {
+  const err = new Error('boom');
+  const devPayload = formatError(err, { WORKER_ENV: 'development' });
+  const prodPayload = formatError(err, { WORKER_ENV: 'production' });
+  
+  assert.strictEqual(devPayload.message, 'boom');
+  assert.strictEqual(prodPayload.message, 'boom');
+});
+
+test('handles non-Error objects', () => {
+  const payload = formatError('string error', { WORKER_ENV: 'development' });
+  assert.strictEqual(payload.message, 'Unknown error');
+  assert.strictEqual(payload.error, 'Internal Server Error');
+});
+
+test.after(() => {
+  if (originalEnv === undefined) delete process.env.NODE_ENV; else process.env.NODE_ENV = originalEnv;
+});