API functions reference

import type { ApiFunctionsContext } from '@redocly/config';

export default async function (
  request: Request, 
  context: ApiFunctionsContext
) {
  // ...
}

apiFunctions:
  folders:
    - /my/api/folder/path/
    - /my/second/api/folder/path/

import type { ApiFunctionsContext } from '@redocly/config';

export default async function (request: Request, context: ApiFunctionsContext) {
  const body = await request.json();

  if (body.name) {
    // perform operations with the name parameter, for example, send it to the external database or API
    // ...
    return context.status(200).json({ message: 'Name saved', name: body.name });
  } else {
    return context.status(400).json({ error: 'Missing name' });
  }
};

import type { ApiFunctionsContext } from '@redocly/config';

export default function (request: Request, context: ApiFunctionsContext) {
  const { id } = context.params;
  // perform operations with an ID, for example, fetch the community from the external database or API
  // ...
  return context.status(200).json({ message: 'Community fetched', id });
};

import type { ApiFunctionsContext } from '@redocly/config';

export default function (request: Request, context: ApiFunctionsContext) {
  const { other } = context.params; // ['anything', 'you', 'want']
  // perform operations with other parameters, for example, fetch the community from the external database or API
  // ...
  return context.status(200).json({ message: 'Other params', other });
};

{
  "message": "Other params",
  "other": ["anything", "you", "want"]
}

rbac:
  content: 
    '@api/hello.ts': # limit access for the file and corresponding endpoint  (by file path)
      TeamA: read # TeamA has an access to the /api/hello endpoint
    '/api/communities/1': # limit access only for the community with id 1 (by url)
      TeamB: read  # TeamB has an access to the /api/communities/1 endpoint

import type { ApiFunctionsContext } from '@redocly/config';

export default async function (request: Request, context: ApiFunctionsContext) {
  const apiKey = process.env.API_KEY; 
  // get some token from the external API:
  try {
    const response = await fetch(
      `https://secret-service.com/authentication-tokens`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'SERVICE-API-KEY': apiKey
        }
      }
    );
    // Extract the token from the response
    const body = await response.json();
    return context.status(200).json({ message: 'Token fetched', token: body.token });
  } catch (error) {
    return context.status(500).json({ error: 'Internal server error' });
  }
}

context.deleteCookie(name: string) => ApiFunctionsContext

context.json(body: object) => Response

context.redirect(url: string, code?: number) => Response

context.setCookie(name: string, value: string, options?: CookieOptions) => ApiFunctionsContext

context.status(code: number) => ApiFunctionsContext

context.text(body: string) => Response

export default function () {
  // When no arguments are used, you can still return a Response object
  // This example returns a 200 OK status with a text body
  return new Response('API is working!', {
    status: 200,
    headers: {
      'Content-Type': 'text/plain'
    }
  });
}

export default async function (request: Request) {
  // Only process POST, PUT, PATCH requests with body content
  if (['POST', 'PUT', 'PATCH'].includes(request.method)) {
    try {
      // Extract JSON body from request
      const body = await request.json();
      
      // Return the body content as the response
      return new Response(JSON.stringify({
        success: true,
        message: 'Received your data',
        data: body
      }), {
        status: 200,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    } catch (error) {
      // Handle JSON parsing errors
      return new Response(JSON.stringify({
        success: false,
        message: 'Invalid JSON in request body'
      }), {
        status: 400,
        headers: {
          'Content-Type': 'application/json'
        }
      });
    }
  }
  
  // Return method not allowed for non-supported methods
  return new Response(JSON.stringify({
    success: false,
    message: 'Method not supported, use POST, PUT or PATCH'
  }), {
    status: 405,
    headers: {
      'Content-Type': 'application/json',
      'Allow': 'POST, PUT, PATCH'
    }
  });
}

import type { ApiFunctionsContext } from '@redocly/config';

export default async function (request: Request, context: ApiFunctionsContext) {
  if (context.cookies) {
    // Do something with the cookies like checking if the user is logged in
    // ...

    // If the user is not logged in, redirect to the login page
    return context.redirect('/login');
  }
  
  // Access user information if available
  if (context.user) {
    const userEmail = context.user.email;
    const userTeams = context.user.teams;
    // Additional logic using identity information
    // ...
  }

  // Handle the request as needed
  return context.status(200).json({ message: 'Hello World' });
};