Edge Functions

1new Router().get('/', {
2  edge_function: './path/to/function.js',
3});

1/**
2 * Handles an HTTP request and returns a response.
3 *
4 * @async
5 * @param {Request} request - Represents the incoming request.
6 * @param {Object} context - Provides additional information about the request and environment.
7 * @param {Object} context.client - The client's network information.
8 * @param {Object} context.device - The client's device capabilities.
9 * @param {Object} context.environmentVars - Environment variables as defined in the Developer Console.
10 * @param {Object} context.geo - The client's geo location.
11 * @param {Object} context.metrics - Provides functions for injecting metrics into your edge function.
12 * @param {Function} context.metrics.add - Adds a value to the metric with the given ID.
13 * @param {Function} context.metrics.startTimer - Starts a timer for the metric with the given ID. Only one timer can be active at a time for a given metric ID.
14 * @param {Function} context.metrics.stopTimer - Stops a timer for the metric with the given ID.
15 * @param {Object} context.origins - Origin servers as defined in the Edgio Console or the edgio.config.js file.
16 * @param {Object} context.requestVars - Information about this property including values set using Set Variables.
17 * @returns {Response | Promise<Response>}
18 */
19export async function handleHttpRequest(request, context) {
20  // ... function code ...
21}

1export async function handleHttpRequest(request, context) {
2  const defaultResponse = new Response('Hello World!');
3  const response = await fetch('https://your-server.com' /* origin options */);
4
5  if (!response.ok) {
6    return defaultResponse;
7  }
8
9  return response;
10}

1export async function handleHttpRequest(request, context) {
2  const resp = await fetch('https://your-server.com', {
3    // an Edgio origin must be specified in the request
4    edgio: {
5      origin: 'web',
6    },
7  });
8
9  // handle the response as needed
10  /* ... */
11
12  // return the response to the client
13  return resp;
14}

1export async function handleHttpRequest(request, context) {
2  const fetch = createFetchForOrigin('web');
3
4  const resp = await fetch('https://your-server.com');
5
6  // handle the response as needed
7  /* ... */
8
9  // return the response to the client
10  return resp;
11}

1import {connect} from '@planetscale/database';
2import {createFetchForOrigin} from './polyfills';
3
4const fetch = createFetchForOrigin('planetscale');
5
6export async function handleHttpRequest(request, context) {
7  const env = context.environmentVars;
8
9  const config = {
10    host: env.PLANETSCALE_HOST,
11    username: env.PLANETSCALE_USERNAME,
12    password: env.PLANETSCALE_PASSWORD,
13    fetch,
14  };
15
16  const conn = connect(config);
17
18  // make a request to the PlanetScale API
19  /* ... */
20
21  // return the response to the client
22  return resp;
23}

1import createFetchForOrigin from './polyfills';
2
3export async function handleHttpRequest(request, context) {
4  const fetch = createFetchForOrigin('api');
5
6  // override the global fetch() function
7  global.fetch = fetch;
8
9  // make a request to the your API
10  /* ... */
11
12  // return the response to the client
13  return resp;
14}

1edgio deploy

12023-08-14T17:37:04Z - error - external - Schema validation error: properties.0.edge_functions.quickjs_bytecode_base64 exceeds maximum size. Max: 204800, got: 417309
22023-08-14T17:37:04Z - error - external - Error: the server responded with status 400

1import './polyfills/url-parse.js';
2import './polyfills/buffer.js';
3import createFetchForOrigin from './polyfills/createFetchForOrigin';
4
5const fetch = createFetchForOrigin('web');
6
7export async function handleHttpRequest(request, context) {
8  const response = await fetch(/* ... */);
9  /* ... */
10}

1// Example router assigning edge functions to different routes.
2new Router()
3  .get('/', {
4    edge_function: './edge-functions/home-page.js',
5  })
6  .get('/products:id', {
7    edge_function: './edge-functions/product.js',
8  })
9  .get('/contacts', {
10    edge_function: './edge-functions/contacts.js',
11  });

1import createFetchForOrigin from './polyfills/createFetchForOrigin';
2
3const fetch = createFetchForOrigin('legacy_server');
4
5// Example edge function that injects a header into the response
6export async function handleHttpRequest(request, context) {
7  // Forward the incoming request to the defined origin server.
8  const response = await fetch(request);
9
10  // Add a header to the response from the origin server.
11  response.headers.set('X-Edge-Function', 'home-page.js');
12
13  // Return the response and end the edge function.
14  return resp;
15}

1import createFetchForOrigin from './polyfills/createFetchForOrigin';
2
3const fetch = createFetchForOrigin('json_api_server');
4
5// Example edge function that modifies a response from the origin server
6export async function handleHttpRequest(request, context) {
7  // Forward the incoming request to the defined origin server.
8  const response = await fetch(request);
9
10  // Parse the response body as JSON
11  const body = await response.json();
12
13  // Add the customer's postal_code to the json response
14  body.postal_code = context.geo.postal_code;
15
16  // Return the response and end the edge function.
17  // Note: Since the original response body is read-only,
18  // we must create a new response with the updated body.
19  const jsonBody = JSON.stringify(body);
20
21  return new Response(jsonBody, response);
22}

1import createFetchForOrigin from './polyfills/createFetchForOrigin';
2
3const fetch = createFetchForOrigin('json_api_server');
4
5// Example edge function makes multiple fetches
6export async function handleHttpRequest(request, context) {
7  const myBackend = 'http://api.backend-example.com';
8
9  // Get the list of phone contacts
10  const phonePromise = fetch(new Request(`${myBackend}/phone`));
11
12  // In Parallel, get the list of e-mail contacts
13  const emailPromise = fetch(new Request(`${myBackend}/email`));
14
15  // Wait for both requests to complete.
16  const [phoneResponse, emailResponse] = await Promise.all([
17    phonePromise,
18    emailPromise,
19  ]);
20
21  // Combine the two response bodies into a single response
22  const body = {
23    phone: await phoneResponse.json(),
24    email: await emailResponse.json(),
25  };
26
27  // Return the response and end the edge function as JSON
28  const jsonBody = JSON.stringify(body);
29
30  return new Response(jsonBody, 200, {
31    headers: {'Content-Type': 'application/json'},
32  });
33}