Using with express to mock a function URL

[HeskethGD]

Is it possible to use this package together with express to mock a locally running Lambda function url that I can ping from a locally running frontend? I wanted to do something like the below but cannot seem to figure out how to marry the response object in express to the responseStream in the handler which is wrapped with streamifyResponse:

app.get("/", async (req: Request, res: Response) => {
    // Do something here to transform req to event...
    // Do something to connect res and responseStream somehow?...
    await handler(
        event: APIGatewayProxyEventV2,
        responseStream: ResponseStream,
        null
    );
})

I have read in a few places that the response object in express is a stream but can't seem to make this work.

[tkempkensteffen]

Well, it works but it's not that easy because the default ResponseStream implementation simply collects chunks and returns them as a normal Lambda call would do.

This uses an extended version of the original ResponseStream and delegates stream-writes and setContentType to callback functions, so you can use them to call the express functions:

Notes:

• convertRequestToEvent() does not implement the full context object...maybe something is missing for your use-case
• I also added writeStatusCode() to the ResponseStream, but this is not a function available using the awslambda global...if you want to use it, check for the awslamba global and decide to call awslambda.HttpResponseStream.from or setStatusCode() (See my stream handler below)

import { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from 'aws-lambda';
import { APIGatewayProxyEventHeaders } from 'aws-lambda/trigger/api-gateway-proxy';
import { raw } from 'body-parser';
import cors from 'cors';
import express, { Request, Response } from 'express';
import { ResponseStream } from 'lambda-stream';
import { handler as streamHandler } from './stream';

const app = express();

app.use(
  raw({
    inflate: true,
    limit: '20mb',
    type: 'application/json',
  }),
);
app.use(
  cors({
    origin: '*',
  }),
);

const convertRequestToEvent = (req: Request) => {
  return {
    version: '2.0',
    routeKey: '$default',
    headers: req.headers as APIGatewayProxyEventHeaders,
    body: req.body,
    rawPath: req.url,
    rawQueryString: '',
    requestContext: {
      http: {
        method: req.method,
        path: req.url,
        protocol: req.protocol,
        sourceIp: '127.0.0.1',
        userAgent: 'none',
      },
    } as any,
    isBase64Encoded: false,
  } satisfies APIGatewayProxyEventV2;
};

class MyResponseStream extends ResponseStream {
  constructor(
    private readonly writeChunk: (chunk: any) => void,
    private readonly writeContentType: (contentType: string) => void,
    private readonly writeStatusCode: (statusCode: number) => void,
  ) {
    super();
  }

  _write(chunk: any, encoding: any, callback: (error?: Error | null) => void) {
    this.writeChunk(Buffer.from(chunk, encoding));
    callback();
  }

  setContentType(contentType: string) {
    this.writeContentType(contentType);
  }

  setStatusCode(statusCode: number) {
    this.writeStatusCode(statusCode);
  }
}

app.post('/stream', async (req, res) => {
  const streamResponse = new MyResponseStream(
    (chunk: any) => {
      res.write(chunk);
    },
    (contentType) => {
      res.setHeader('Content-Type', contentType);
    },
    (statusCode: number) => {
      res.status(statusCode);
    },
  );

  await streamHandler(
    convertRequestToEvent(req),
    streamResponse,
    {} as any,
    () => {},
  );

  res.end();
});

app.listen(4000, () => {
  console.log(`[dev server]: Server is running at http://localhost:4000`);
});

stream.ts

export const handler = streamifyResponse(async (event, responseStream, _) => {
  const sendErrorResponse = (message: string, statusCode = 400) => {
    // Set status code using awslambda global or setStatusCode() from MyResponseStream
    if ((global as any).awslambda) {
      (global as any).HttpResponseStream.from(responseStream, {
        statusCode,
      });
    } else {
      (responseStream as any).setStatusCode(statusCode);
    }

    // Set content type and write message
    responseStream.setContentType('text/plain');
    responseStream.write(message);
    responseStream.end();
  }

  if (true) return sendErrorResponse('Not found', 404);

  responseStream.write("test");
  responseStream.end();
})