Merge pull request #1001 from objectstack-ai/copilot/fix-api-endpoint-responses

fix(studio): replace custom getRequestListener with handle() from @hono/node-server/vercel

Author: hotlong

.changeset/fix-vercel-api-html-response.md

@@ -0,0 +1,18 @@
+---
+"@objectstack/studio": patch
+---
+
+Fix Vercel deployment API endpoints returning HTML instead of JSON.
+
+Replace the custom `getRequestListener` export in `server/index.ts` with the
+standard `handle()` adapter from `@hono/node-server/vercel` and the
+outer→inner Hono delegation pattern (`inner.fetch(c.req.raw)`).
+
+- The `handle()` adapter correctly wraps the Hono app with the
+  `(IncomingMessage, ServerResponse) => Promise<void>` signature that
+  Vercel's Node.js runtime expects for serverless functions in `api/`.
+- `@hono/node-server/vercel`'s `getRequestListener()` already handles
+  Vercel's pre-buffered `rawBody` natively, removing the need for the
+  custom body-extraction helper.
+- The outer→inner delegation pattern matches the documented ObjectStack
+  Vercel deployment guide and the `@objectstack/hono` adapter test suite.

apps/studio/server/index.ts

@@ -10,15 +10,14 @@
  * legacy `(IncomingMessage, ServerResponse)` signature — NOT the Web standard
  * `(Request) → Response` format.
  *
- * We use `getRequestListener()` from `@hono/node-server` which properly
- * converts `IncomingMessage → Request`, calls our fetch callback, then writes
- * the `Response` back to `ServerResponse`.
+ * We use `handle()` from `@hono/node-server/vercel` which is the standard
+ * Vercel adapter for Hono.  It internally uses `getRequestListener()` to
+ * convert `IncomingMessage → Request` (including Vercel's pre-buffered
+ * `rawBody`) and writes the `Response` back to `ServerResponse`.
  *
- * For POST/PUT/PATCH requests, Vercel pre-buffers the body on the
- * IncomingMessage as `rawBody` (Buffer) or `body` (parsed).  We extract it
- * directly and build a clean `Request` so the inner Hono app receives a
- * body it can `.json()` without depending on Node stream-to-ReadableStream
- * conversion (which can hang when the stream has already been consumed).
+ * The outer Hono app delegates all requests to the inner ObjectStack Hono
+ * app via `inner.fetch(c.req.raw)`, matching the pattern documented in
+ * the ObjectStack deployment guide and validated by the hono adapter tests.
  *
  * All kernel/service initialisation is co-located here so there are no
  * extensionless relative module imports — which would break Node's ESM
@@ -34,8 +33,8 @@ import { SecurityPlugin } from '@objectstack/plugin-security';
 import { AuditPlugin } from '@objectstack/plugin-audit';
 import { FeedServicePlugin } from '@objectstack/service-feed';
 import { MetadataPlugin } from '@objectstack/metadata';
-import { getRequestListener } from '@hono/node-server';
-import type { Hono } from 'hono';
+import { handle } from '@hono/node-server/vercel';
+import { Hono } from 'hono';
 import { createBrokerShim } from '../src/lib/create-broker-shim.js';
 import studioConfig from '../objectstack.config.js';
 
@@ -198,93 +197,41 @@ async function ensureApp(): Promise<Hono> {
     return _app;
 }
 
-// ---------------------------------------------------------------------------
-// Body extraction helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Extract the request body from the Vercel IncomingMessage.
- *
- * Vercel's Node.js runtime pre-buffers the full request body and attaches it
- * to the IncomingMessage as `rawBody` (Buffer) and/or `body` (parsed).
- * Reading from these properties is synchronous and avoids the fragile
- * IncomingMessage → ReadableStream conversion that can hang when the
- * underlying Node stream has already been consumed.
- *
- * Returns `null` for GET/HEAD/OPTIONS or when no body is available.
- */
-function extractBody(incoming: any, method: string, contentType: string | undefined): BodyInit | null {
-    if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS') {
-        return null;
-    }
-
-    // 1. rawBody (Buffer or string) — most reliable, set by Vercel runtime
-    if (incoming?.rawBody != null) {
-        if (typeof incoming.rawBody === 'string') return incoming.rawBody;
-        if (typeof incoming.rawBody.toString === 'function') return incoming.rawBody;
-        return String(incoming.rawBody);
-    }
-
-    // 2. body (parsed by Vercel) — re-serialize based on content-type
-    if (incoming?.body != null) {
-        if (typeof incoming.body === 'string') return incoming.body;
-        if (contentType?.includes('application/json')) return JSON.stringify(incoming.body);
-        return String(incoming.body);
-    }
-
-    return null;
-}
-
 // ---------------------------------------------------------------------------
 // Vercel handler
 // ---------------------------------------------------------------------------
 
 /**
- * `getRequestListener` from `@hono/node-server` converts
- * `IncomingMessage → Request`, calls our fetch callback, then writes the
- * `Response` back to `ServerResponse` (including `res.end()`).
+ * Outer Hono app — delegates all requests to the inner ObjectStack app.
+ *
+ * `handle()` from `@hono/node-server/vercel` wraps any Hono app and returns
+ * the `(IncomingMessage, ServerResponse) => Promise<void>` signature that
+ * Vercel's Node.js runtime expects for serverless functions.  Internally it
+ * uses `getRequestListener()`, which already handles Vercel's pre-buffered
+ * `rawBody` (Buffer) on the IncomingMessage for POST/PUT/PATCH requests.
  *
- * For requests with a body, we extract it from the IncomingMessage directly
- * (bypassing the Node stream → ReadableStream conversion) and create a new
- * Request that the inner Hono app can safely `.json()`.
+ * The outer→inner delegation pattern (`inner.fetch(c.req.raw)`) is the
+ * standard ObjectStack Vercel deployment pattern documented in the deployment
+ * guide and covered by the @objectstack/hono adapter test suite.
  */
-export default getRequestListener(async (request, env) => {
-    const method = request.method;
-    const url = request.url;
+const app = new Hono();
 
-    console.log(`[Vercel] ${method} ${url}`);
+app.all('*', async (c) => {
+    console.log(`[Vercel] ${c.req.method} ${c.req.url}`);
 
     try {
-        const app = await ensureApp();
-        const incoming = (env as any)?.incoming;
-
-        // For body methods, extract body from IncomingMessage and build a clean Request
-        if (method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && incoming) {
-            const contentType = incoming.headers?.['content-type'];
-            const body = extractBody(incoming, method, contentType);
-
-            if (body != null) {
-                console.log(`[Vercel] Body extracted from IncomingMessage (${typeof body === 'string' ? body.length + ' chars' : 'Buffer'})`);
-                const newReq = new Request(url, {
-                    method,
-                    headers: request.headers,
-                    body,
-                });
-                return await app.fetch(newReq);
-            }
-
-            console.log('[Vercel] No rawBody/body on IncomingMessage — using proxy request');
-        }
-
-        return await app.fetch(request);
+        const inner = await ensureApp();
+        return await inner.fetch(c.req.raw);
     } catch (err: any) {
         console.error('[Vercel] Handler error:', err?.message || err);
-        return new Response(
-            JSON.stringify({
+        return c.json(
+            {
                 success: false,
                 error: { message: err?.message || 'Internal Server Error', code: 500 },
-            }),
-            { status: 500, headers: { 'Content-Type': 'application/json' } },
+            },
+            500,
         );
     }
 });
+
+export default handle(app);