refactor: improve file structure

Signed-off-by: seven <[email protected]>

Author: Blankll

src/context.ts

@@ -0,0 +1,21 @@
+import { Context, Event } from './types';
+import ServerlessRequest from './serverlessRequest';
+import url from 'node:url';
+import ServerlessResponse from './serverlessResponse';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const constructFrameworkContext = (event: Event, _: Context) => {
+  const request = new ServerlessRequest({
+    method: event.httpMethod,
+    headers: event.headers,
+    body: Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'utf8'),
+    remoteAddress: '',
+    url: url.format({
+      pathname: event.path,
+      query: event.queryParameters,
+    }),
+    isBase64Encoded: event.isBase64Encoded,
+  });
+  const response = new ServerlessResponse(request);
+  return { request, response };
+};

src/index.ts

@@ -1,89 +1,22 @@
 import { Express } from 'express';
-import { Writable } from 'stream';
-import { Context, Event, ServerlessAdapter } from './types';
+import { ServerlessAdapter } from './types';
 import sendRequest from './sendRequest';
-import ServerlessRequest from './serverlessRequest';
-import ServerlessResponse from './serverlessResponse';
 import { IncomingHttpHeaders } from 'http';
-import * as url from 'node:url';
-
-const constructFrameworkContext = (event: Event, context: Context) => {
-  console.log('constructFrameworkContext', event, context);
-  const request = new ServerlessRequest({
-    method: event.httpMethod,
-    headers: event.headers,
-    body: Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'utf8'),
-    remoteAddress: '',
-    url: url.format({
-      pathname: event.path,
-      query: event.queryParameters,
-    }),
-    isBase64Encoded: event.isBase64Encoded,
-  });
-  const response = new ServerlessResponse(request);
-  return { request, response };
-};
-
-const waitForStreamComplete = (stream: Writable): Promise<Writable> => {
-  if (stream.writableFinished || stream.writableEnded) {
-    return Promise.resolve(stream);
-  }
-
-  return new Promise((resolve, reject) => {
-    stream.once('error', complete);
-    stream.once('end', complete);
-    stream.once('finish', complete);
-
-    let isComplete = false;
-
-    function complete(err?: Error) {
-      if (isComplete) {
-        return;
-      }
-
-      isComplete = true;
-
-      stream.removeListener('error', complete);
-      stream.removeListener('end', complete);
-      stream.removeListener('finish', complete);
-
-      if (err) {
-        reject(err);
-      } else {
-        resolve(stream);
-      }
-    }
-  });
-};
-
-const buildResponse = ({
-  request,
-  response,
-}: {
-  request: ServerlessRequest;
-  response: ServerlessResponse;
-}) => {
-  return {
-    statusCode: response.statusCode,
-    body: ServerlessResponse.body(response).toString(request.isBase64Encoded ? 'base64' : 'utf8'),
-    headers: response.headers,
-    isBase64Encoded: request.isBase64Encoded,
-  };
-};
+import { constructFrameworkContext } from './context';
+import { buildResponse, waitForStreamComplete } from './transport';
 
 const serverlessAdapter: ServerlessAdapter = (app: Express) => {
   return async (event, context) => {
-    const ctx = constructFrameworkContext(event, context);
+    const { request, response } = constructFrameworkContext(event, context);
 
     try {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
-      await sendRequest(app, ctx.request, ctx.response);
-      await waitForStreamComplete(ctx.response);
-      return buildResponse(ctx);
+      await sendRequest(app, request, response);
+      await waitForStreamComplete(response);
+      return buildResponse({ request, response });
     } catch (err) {
       const errorResponse = { statusCode: 500, body: (err as Error).message };
-      console.log('Error occurred during request handling:', err);
       return errorResponse as unknown as {
         statusCode: number;
         body: string;

src/serverlessResponse.ts

@@ -25,8 +25,8 @@ const getString = (data: unknown): string => {
 const addData = (stream: ServerlessResponse, data: Buffer | string | Uint8Array): void => {
   try {
     stream[BODY].push(Buffer.from(data));
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (err) {
-    console.log('Error adding data to stream', err);
     throw new Error(`response.write() of unexpected type: ${typeof data}`);
   }
 };

src/transport.ts

@@ -0,0 +1,50 @@
+import { Writable } from 'stream';
+import ServerlessRequest from './serverlessRequest';
+import ServerlessResponse from './serverlessResponse';
+
+export const waitForStreamComplete = (stream: Writable): Promise<Writable> => {
+  if (stream.writableFinished || stream.writableEnded) {
+    return Promise.resolve(stream);
+  }
+
+  return new Promise((resolve, reject) => {
+    stream.once('error', complete);
+    stream.once('end', complete);
+    stream.once('finish', complete);
+
+    let isComplete = false;
+
+    function complete(err?: Error) {
+      if (isComplete) {
+        return;
+      }
+
+      isComplete = true;
+
+      stream.removeListener('error', complete);
+      stream.removeListener('end', complete);
+      stream.removeListener('finish', complete);
+
+      if (err) {
+        reject(err);
+      } else {
+        resolve(stream);
+      }
+    }
+  });
+};
+
+export const buildResponse = ({
+  request,
+  response,
+}: {
+  request: ServerlessRequest;
+  response: ServerlessResponse;
+}) => {
+  return {
+    statusCode: response.statusCode,
+    body: ServerlessResponse.body(response).toString(request.isBase64Encoded ? 'base64' : 'utf8'),
+    headers: response.headers,
+    isBase64Encoded: request.isBase64Encoded,
+  };
+};