Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://vercel.com/docs/functions/runtimes/node-js below:

Using the Node.js Runtime with Vercel Functions

You can create Vercel Function in JavaScript or TypeScript by using the Node.js runtime. By default, the runtime builds and serves any function created within the /api directory of a project to Vercel.

Node.js-powered functions are suited to computationally intense or large functions and provide benefits like:

• More RAM and CPU power: For computationally intense workloads, or functions that have bundles up to 250 MB in size, this runtime is ideal
• Complete Node.js compatibility: The Node.js runtime offers access to all Node.js APIs, making it a powerful tool for many applications

In order to use the Node.js runtime, create a file inside the api directory with a function using the Web signature. No additional configuration is needed:

export function GET(request: Request) {
  return new Response('Hello from Vercel!');
}

Alternatively, a Node.js handler that takes the standard Node.js Request and Response objects is as follows:

import { VercelRequest, VercelResponse } from '@vercel/node';
 
export default function handler(req: VercelRequest, res: VercelResponse) {
  const name = req.query.name ?? 'World';
  res.writeHead(200);
  res.write(`Hello ${name}!`);
  res.end();
}

To learn more about creating Vercel Functions, see the Functions API Reference. If you need more advanced behavior, such as a custom build step or private npm modules, see the advanced Node.js usage page.

Vercel Functions using the Node.js runtime support all Node.js APIs, including standard Web APIs such as the Request and Response Objects.

To learn more about the supported Node.js versions on Vercel, see Supported Node.js Versions.

For dependencies listed in a package.json file at the root of a project, the following behavior is used:

• If bun.lock or bun.lockb is present, bun install is executed
• If yarn.lock is present yarn install is executed
• If pnpm-lock.yaml is present, pnpm install is executed
  • See supported package managers for pnpm detection details
• If package-lock.json is present, npm install is executed
• If vlt-lock.json is present, vlt install is executed
• Otherwise, npm install is executed

If you need to select a specific version of a package manager, see corepack.

The Node.js runtime supports files ending with .ts inside of the /api directory as TypeScript files to compile and serve when deploying.

An example TypeScript file that exports a Web signature handler is as follows:

export async function GET(request: Request) {
  const url = new URL(request.url);
  const name = url.searchParams.get('name') || 'World';
 
  return Response.json({ message: `Hello ${name}!` });
}

You can use a tsconfig.json file at the root of your project to configure the TypeScript compiler. Most options are supported aside from "Path Mappings" and "Project References".

Each request to a Node.js Vercel Function gives access to Request and Response objects. These objects are the standard HTTP Request and Response objects from Node.js.

Vercel additionally provides helper methods inside of the Request and Response objects passed to Node.js Vercel Functions. These methods are:

The following Node.js Vercel Function example showcases the use of request.query, request.cookies and request.body helpers:

import { VercelRequest, VercelResponse } from "@vercel/node";
 
module.exports = (request: VercelRequest, response: VercelResponse) => {
  let who = 'anonymous';
 
  if (request.body && request.body.who) {
    who = request.body.who;
  } else if (request.query.who) {
    who = request.query.who;
  } else if (request.cookies.who) {
    who = request.cookies.who;
  }
 
  response.status(200).send(`Hello ${who}!`);
};

Example Node.js Vercel Function using the request.query, request.cookies, and request.body helpers. It returns greetings for the user specified using request.send().

We populate the request.body property with a parsed version of the content sent with the request when possible.

We follow a set of rules on the Content-type header sent by the request to do so:

With the request.body helper, you can build applications without extra dependencies or having to parse the content of the request manually.

When the request body contains malformed JSON, accessing request.body will throw an error. You can catch that error by wrapping request.body with try...catch:

try {
  request.body;
} catch (error) {
  return response.status(400).json({ error: 'My custom 400 error' });
}

Catching the error thrown by request.body with try...catch.

Express.js is a popular framework used with Node.js. For information on how to use Express with Vercel, see the guide: Using Express.js with Vercel.

The Node.js runtime can be used as an experimental feature to run middleware. To enable, add the flag to your next.config.ts file:

import type { NextConfig } from 'next';
 
const nextConfig: NextConfig = {
  experimental: {
    nodeMiddleware: true,
  },
};
 
export default nextConfig;

Then in your middleware file, set the runtime to nodejs in the config object:

export const config = {
  matcher: '/about/:path*',
  runtime: 'nodejs',
};

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4