fix(aws-lambda): always send the metadata prelude (#101)

On AWS Lambda, `sendStandardResponse` could send a response without its
metadata prelude, so the status, headers, and cookies were lost.
`HttpResponseStream.from()` only sets the prelude up, and the runtime
sends it just before the first `write()` call. `end(chunk)` skips that,
and empty bodies never call `write()`. The fix makes one empty write
right after `from()` so every response sends its prelude.

## Fixes

- JSON, URLSearchParams, `undefined`, empty-Blob, and empty-stream
responses now send their status, headers, and cookies. Before, they
reached the wire as just the body, or as zero bytes.
- Non-empty streamed responses are unaffected, apart from sending their
status and headers right away instead of waiting for the first chunk.

## Testing

- Checked against the stream code in `aws-lambda-ric` 4.0.2 (3.3.0 uses
the same prelude logic). The bytes were captured by a local HTTP server
standing in for the Lambda API. Every body type now carries the prelude
and delimiter exactly once. Not tested on a real Lambda deployment.
- The unit-test mock used to write the prelude itself, which hid the
bug. It now waits for the first `write()` like the runtime. Without the
fix, 3 tests fail: `buffered (empty)`, `buffered (json)`, and the new
`chunked (empty)`.

Author: dinwwwh

packages/aws-lambda/src/response.test.ts

@@ -11,10 +11,15 @@ const DELIMITER = new Uint8Array(8)
 
 const fromSpy = vi.fn((responseStream: HttpResponseStream, metadata: Record<string, unknown>) => {
   // mimics what the lambda runtime does: send the metadata prelude
-  // ahead of the body on the very same stream
+  // ahead of the first `write` call only, `end(chunk)` bypasses it
   responseStream.setContentType('application/vnd.awslambda.http-integration-response')
-  responseStream.write(JSON.stringify(metadata))
-  responseStream.write(DELIMITER)
+  const write = responseStream.write.bind(responseStream)
+  responseStream.write = (chunk: unknown) => {
+    responseStream.write = write
+    write(JSON.stringify(metadata))
+    write(DELIMITER)
+    return write(chunk)
+  }
   return responseStream
 })
 
@@ -159,6 +164,23 @@ describe('sendStandardResponse', () => {
     expect(responseStream.writableEnded).toBe(true)
   })
 
+  it('chunked (empty)', async () => {
+    const responseStream = createResponseStream()
+
+    await sendStandardResponse(responseStream, {
+      status: 200,
+      headers: {},
+      body: new Blob([]),
+    })
+
+    expect(metadataOf(responseStream)).toMatchObject({
+      statusCode: 200,
+    })
+
+    expect(bodyOf(responseStream)).toBe('')
+    expect(responseStream.writableEnded).toBe(true)
+  })
+
   it('destroys the response stream when the body stream errors during streaming', async () => {
     const responseStream = createResponseStream()
 

packages/aws-lambda/src/response.ts

@@ -46,7 +46,7 @@ export async function sendStandardResponse(
 
     const [headers, setCookies] = toLambdaHeaders(resHeaders)
 
-    // sends the metadata prelude (status, headers, cookies) and
+    // arms the metadata prelude (status, headers, cookies) and
     // returns the stream the body should be written to
     const res = awslambda.HttpResponseStream.from(responseStream, {
       statusCode: standardResponse.status,
@@ -57,6 +57,10 @@ export async function sendStandardResponse(
     res.once('error', reject)
     res.once('close', resolve)
 
+    // The runtime only sends the armed prelude ahead of the first `write` call:
+    // `end(chunk)` bypasses it and an empty body never writes, so trigger it now
+    res.write('')
+
     if (resBody === undefined) {
       // NOTE: Lambda functions don't allow passing undefined to `res.end`
       res.end()

packages/aws-lambda/src/types.ts

@@ -105,7 +105,8 @@ export interface AwsLambdaGlobal {
 
   HttpResponseStream: {
     /**
-     * Sends the metadata prelude and returns the stream to write the body to.
+     * Arms the metadata prelude and returns the stream to write the body to.
+     * The prelude is only sent ahead of the first `write` call, never by `end(chunk)`.
      */
     from(
       responseStream: HttpResponseStream,