Refactor serverless part

Author: electerious

api/index.js

@@ -1,39 +1,9 @@
-import * as serverless from '../src/serverless.js'
-
 /**
- * A serverless function handler for the '/api' route, for use with Vercel.
- * This handler follows the AWS Lambda API; Vercel deployments are opted-in
- * using the "NODEJS_AWS_HANDLER_NAME" environment variable defined in vercel.json.
- *
- * See:
- * - https://vercel.com/docs/serverless-functions/supported-languages#node.js
- * - https://vercel.com/docs/runtimes#advanced-usage/advanced-node-js-usage/aws-lambda-api
+ * Vercel Serverless Function entry point for the '/api' route.
+ * Uses the fetch Web Standard supported by Vercel.
  *
- * @param {...any} args - The arguments passed by Vercel to the handler, following the AWS Lambda API.
- * @returns {Promise<any>} - The response from the serverless handler, with multiValueHeaders converted to headers for Vercel compatibility.
- */
-export const handler = async (...args) => {
-  const response = await serverless.handler(...args)
-  return convertMultiValueHeaders(response)
-}
-
-/*
- * At the time of writing the Vercel polyfill for the AWS Lambda API doesn't support .multiValueHeaders.
- * This stops us from attaching CORS headers to requests.
- * Since all the headers we commonly attach have a single value, we can map them to .headers instead.
+ * See: https://vercel.com/docs/functions/functions-api-reference
  */
-const convertMultiValueHeaders = (response) => {
-  if (response?.multiValueHeaders == null) return response
-
-  response.headers = response.headers ?? {}
-
-  for (const [key, value] of Object.entries(response.multiValueHeaders)) {
-    if (value.length === 1) {
-      response.headers[key] = value[0]
-    } else {
-      console.warn(`multiValueHeaders is currently unsupported on Vercel. Header ${key} will be ignored.`)
-    }
-  }
+import { handler } from '../src/serverless.js'
 
-  return response
-}
+export default { fetch: handler }

functions/api.js

@@ -1,15 +1,8 @@
 [build]
   publish = "dist"
   command = "npm run build"
-  functions = "functions/"
   environment = { NODE_VERSION = "24", NODE_ENV = "production" }
 
-[[redirects]]
-  from = "/api"
-  to = "/.netlify/functions/api"
-  status = 200
-  force = true
-
 [template.environment]
   ACKEE_MONGODB = "ACKEE_MONGODB"
   ACKEE_USERNAME = "ACKEE_USERNAME"

netlify.toml

@@ -0,0 +1,11 @@
+/**
+ * Netlify Serverless Function entry point.
+ * Uses the Web API (Request/Response) supported by Netlify Functions.
+ *
+ * See: https://docs.netlify.com/functions/get-started/
+ */
+export { handler as default } from '../../src/serverless.js'
+
+export const config = {
+  path: '/api',
+}

netlify/functions/api.js

@@ -49,7 +49,6 @@
   },
   "dependencies": {
     "@apollo/server": "^5.4.0",
-    "@as-integrations/aws-lambda": "^4.0.1",
     "@as-integrations/express5": "^1.1.2",
     "@graphql-tools/merge": "^9.1.7",
     "ackee-tracker": "^5.1.2",

package-lock.json

@@ -43,7 +43,7 @@ const handleGraphError = (formattedError, error) => {
 }
 
 const attachCorsHeaders = async (request, response, next) => {
-  const matchingOrigin = await findMatchingOrigin(request, config.allowOrigin, config.autoOrigin)
+  const matchingOrigin = await findMatchingOrigin(request.headers.origin, config.allowOrigin, config.autoOrigin)
 
   if (matchingOrigin != null) {
     response.setHeader('Access-Control-Allow-Origin', matchingOrigin)

package.json

@@ -1,10 +1,10 @@
-import { handlers, startServerAndCreateLambdaHandler } from '@as-integrations/aws-lambda'
+import { HeaderMap } from '@apollo/server'
 
 import config from './utils/config.js'
 import connect from './utils/connect.js'
 import createApolloServer from './utils/createApolloServer.js'
 import { createServerlessContext } from './utils/createContext.js'
-import fullyQualifiedDomainNames from './utils/fullyQualifiedDomainNames.js'
+import findMatchingOrigin from './utils/findMatchingOrigin.js'
 
 if (config.dbUrl == null) {
   throw new Error('MongoDB connection URI missing in environment')
@@ -13,53 +13,88 @@ if (config.dbUrl == null) {
 connect(config.dbUrl)
 
 const apolloServer = createApolloServer()
+await apolloServer.start()
 
-const resolveAllowedOrigin = async (requestOrigin) => {
-  if (config.autoOrigin === true) {
-    const names = await fullyQualifiedDomainNames()
-    const origins = names.flatMap((name) => [`http://${name}`, `https://${name}`, name])
-    return origins.includes(requestOrigin) ? requestOrigin : null
+const buildCorsHeaders = (allowedOrigin) => {
+  if (allowedOrigin == null) return {}
+
+  return {
+    'access-control-allow-origin': allowedOrigin,
+    'access-control-allow-methods': 'GET, POST, PATCH, OPTIONS',
+    'access-control-allow-headers': 'Content-Type, Authorization, Time-Zone',
+    'access-control-allow-credentials': 'true',
+    'access-control-max-age': '3600',
   }
+}
 
-  if (config.allowOrigin === '*') {
-    return '*'
+/**
+ * Handles incoming requests using the Web API (Request/Response).
+ * Manages CORS, delegates GraphQL operations to Apollo Server, and returns a Web Response.
+ * Used by both Vercel and Netlify serverless entry points.
+ *
+ * @param {Request} request - The incoming web request.
+ * @returns {Promise<Response>} - The web response to send back.
+ */
+export const handler = async (request) => {
+  const requestOrigin = request.headers.get('origin')
+  const allowedOrigin = await findMatchingOrigin(requestOrigin, config.allowOrigin, config.autoOrigin)
+  const corsHeaders = buildCorsHeaders(allowedOrigin)
+
+  if (request.method === 'OPTIONS') {
+    return new Response(null, {
+      status: 204,
+      headers: corsHeaders,
+    })
   }
 
-  if (config.allowOrigin != null) {
-    const origins = config.allowOrigin.split(',')
-    return origins.includes(requestOrigin) ? requestOrigin : null
+  const url = new URL(request.url)
+
+  const headers = new HeaderMap()
+  for (const [key, value] of request.headers) {
+    headers.set(key, value)
   }
 
-  return null
-}
+  const body = request.method === 'POST' ? await request.json() : undefined
+
+  const result = await apolloServer.executeHTTPGraphQLRequest({
+    httpGraphQLRequest: {
+      method: request.method,
+      headers,
+      body,
+      search: url.search ?? '',
+    },
+    context: () => createServerlessContext(request),
+  })
+
+  const responseHeaders = new Headers()
+
+  for (const [key, value] of result.headers) {
+    responseHeaders.set(key, value)
+  }
+
+  for (const [key, value] of Object.entries(corsHeaders)) {
+    responseHeaders.set(key, value)
+  }
+
+  if (result.body.kind === 'complete') {
+    return new Response(result.body.string, {
+      status: result.status ?? 200,
+      headers: responseHeaders,
+    })
+  }
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      for await (const chunk of result.body.asyncIterator) {
+        controller.enqueue(new TextEncoder().encode(chunk))
+      }
 
-export const handler = startServerAndCreateLambdaHandler(
-  apolloServer,
-  handlers.createAPIGatewayProxyEventRequestHandler(),
-  {
-    context: createServerlessContext,
-    middleware: [
-      async (event) => {
-        // Set request context which is missing on Vercel:
-        // https://stackoverflow.com/questions/71360059/apollo-server-lambda-unable-to-determine-event-source-based-on-event
-        if (event.requestContext == null) event.requestContext = {}
-
-        const requestOrigin = event.headers?.origin || event.headers?.Origin
-        const allowedOrigin = await resolveAllowedOrigin(requestOrigin)
-
-        return (result) => {
-          if (allowedOrigin != null) {
-            result.headers = {
-              ...result.headers,
-              'access-control-allow-origin': allowedOrigin,
-              'access-control-allow-methods': 'GET, POST, PATCH, OPTIONS',
-              'access-control-allow-headers': 'Content-Type, Authorization, Time-Zone',
-              'access-control-allow-credentials': 'true',
-              'access-control-max-age': '3600',
-            }
-          }
-        }
-      },
-    ],
-  },
-)
+      controller.close()
+    },
+  })
+
+  return new Response(stream, {
+    status: result.status ?? 200,
+    headers: responseHeaders,
+  })
+}

src/server.js

@@ -5,8 +5,10 @@ import createDate from './createDate.js'
 import { isSet } from './ignoreCookie.js'
 import isAuthenticated from './isAuthenticated.js'
 
-export const createServerlessContext = (integrationContext) => {
-  return createContext(integrationContext.event.headers['client-ip'], integrationContext.event.headers)
+export const createServerlessContext = (request) => {
+  const ip = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || request.headers.get('x-real-ip')
+  const headers = Object.fromEntries(request.headers)
+  return createContext(ip, headers)
 }
 
 export const createExpressContext = ({ req }) => {

src/serverless.js

@@ -1,20 +1,18 @@
 import fullyQualifiedDomainNames from './fullyQualifiedDomainNames.js'
 
-const findOrigin = (request, origins) => {
-  return origins.find((origin) => origin === request.headers.origin)
-}
-
-export default async (request, allowedOrigins, autoOrigin) => {
+export default async (requestOrigin, allowedOrigins, autoOrigin) => {
   if (autoOrigin === true) {
     const names = await fullyQualifiedDomainNames()
     const origins = names.flatMap((name) => [`http://${name}`, `https://${name}`])
-    return findOrigin(request, origins)
+    return origins.includes(requestOrigin) ? requestOrigin : null
   }
 
   if (allowedOrigins === '*') return '*'
 
   if (allowedOrigins != null) {
     const origins = allowedOrigins.split(',')
-    return findOrigin(request, origins)
+    return origins.includes(requestOrigin) ? requestOrigin : null
   }
+
+  return null
 }