elysia-connect-middleware/dist/index.js

This plugin allows you to use express/connect middleware directly in Elysia!

import Connect from 'connect';
import { Elysia } from 'elysia';
import { createRequest, createResponse as createResponse$1 } from 'node-mocks-http';

function mockAppAtRequest(message, connectApp) {
  message.app = connectApp;
  message.app.get = (data) => {
    return false;
  };
  return message;
}
async function transformRequestToIncomingMessage(connectApp, request, options) {
  const parsedURL = new URL(request.url, "http://localhost");
  const query = {};
  for (const [key, value] of parsedURL.searchParams.entries()) {
    query[key] = value;
  }
  let body;
  try {
    body = await request.clone().json();
  } catch {
    body = void 0;
  }
  const message = createRequest({
    method: request.method.toUpperCase(),
    url: parsedURL.pathname + parsedURL.search,
    path: parsedURL.pathname,
    originalUrl: parsedURL.pathname + parsedURL.search,
    baseUrl: parsedURL.origin,
    headers: request.headers.toJSON(),
    query,
    body,
    ...options
  });
  return mockAppAtRequest(message, connectApp);
}
function transformResponseToServerResponse(serverResponse) {
  return new Response(
    serverResponse._getData() || serverResponse._getBuffer(),
    {
      status: serverResponse.statusCode,
      statusText: serverResponse.statusMessage,
      // @ts-expect-error
      headers: serverResponse.getHeaders()
    }
  );
}
function createResponse(request, resolve) {
  const response = createResponse$1({
    req: request
  });
  if (!response._implicitHeader)
    response._implicitHeader = () => {
    };
  const end = response.end;
  response.end = (...args) => {
    const call = end.call(response, ...args);
    const webResponse = transformResponseToServerResponse(response);
    resolve(webResponse);
    return call;
  };
  return response;
}

function connect(...middlewares) {
  const connectApp = Connect();
  for (const middleware of middlewares) {
    connectApp.use(middleware);
  }
  return new Elysia({
    name: "connect",
    seed: middlewares
  }).onRequest(async function processConnectMiddlewares({ request, set }) {
    const message = await transformRequestToIncomingMessage(connectApp, request);
    return await new Promise((resolve) => {
      const response = createResponse(message, resolve);
      connectApp.handle(message, response, () => {
        const webResponse = transformResponseToServerResponse(response);
        webResponse.headers.forEach((value, key) => {
          set.headers[key] = value;
        });
        set.status = webResponse.status;
        resolve(void 0);
      });
    });
  });
}

export { connect };