Why Edge Functions handle server-side logic in Supabase - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an Edge Function that returns a simple message.

Supabase

export async function [1](request) {
  return new Response('Hello from Edge Function!');
}

Drag options to blanks, or click blank then click option'

Afetch

BhandleRequest

Crun

Dstart

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name like 'handleRequest' or 'run' will not work.

The Edge Function must export a fetch function to handle incoming requests.

2fill in blank

medium

Complete the code to read JSON data from the request body inside an Edge Function.

Supabase

export async function fetch(request) {
  const data = await request.[1]();
  return new Response(JSON.stringify(data));
}

Drag options to blanks, or click blank then click option'

AformData

Btext

Cbody

Djson

Attempts:

3 left

💡 Hint

Common Mistakes

Using text() returns raw text, not parsed JSON.

To parse JSON data from the request body, use request.json().

3fill in blank

hard

Fix the error in the Edge Function that tries to access environment variables.

Supabase

export async function fetch(request) {
  const apiKey = [1].get('API_KEY');
  return new Response(apiKey);
}

Drag options to blanks, or click blank then click option'

Awindow.env

Bglobal.env

CDeno.env

Denv

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to access environment variables via window, process.env or global will fail.

Environment variables are accessed via Deno.env.get('API_KEY') in Edge Functions.

4fill in blank

hard

Fill both blanks to create a response with JSON content and proper headers.

Supabase

export async function fetch(request) {
  const data = { message: 'Hello' };
  return new Response(JSON.stringify(data), { [1]: { 'Content-Type': [2] } });
}

Drag options to blanks, or click blank then click option'

Aheaders

B'application/json'

C'text/plain'

Dbody

Attempts:

3 left

💡 Hint

Common Mistakes

Using body instead of headers in the options object.

The response headers must include Content-Type: 'application/json' to indicate JSON data.

5fill in blank

hard

Fill all three blanks to handle a POST request and return a JSON response with status 201.

Supabase

export async function fetch(request) {
  if (request.method === [1]) {
    const data = await request.[2]();
    return new Response(JSON.stringify(data), { status: [3], headers: { 'Content-Type': 'application/json' } });
  }
  return new Response('Method Not Allowed', { status: 405 });
}

Drag options to blanks, or click blank then click option'

A'POST'

Bjson

C201

D'GET'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong method string or status code.

To handle POST requests, check request.method === 'POST', parse JSON body with request.json(), and respond with status 201 for created.

Practice

1. Why do Supabase Edge Functions run server-side logic close to users?

easy

A. To make apps faster and more secure by processing data near users

B. To store all user data permanently on the client device

C. To replace the need for any database in the app

D. To allow users to write code directly in the browser

Solution

1. Step 1: Understand the role of Edge Functions

   Edge Functions run code on servers close to users, reducing delay and improving security.

2. Step 2: Identify benefits of running logic near users

   This setup speeds up responses and keeps sensitive logic safe from client exposure.

3. Final Answer:

   To make apps faster and more secure by processing data near users -> Option A

4. Quick Check:

   Edge Functions = speed + security [OK]

Hint: Edge Functions run near users for speed and safety [OK]

Common Mistakes:

• Thinking Edge Functions store data on client devices
• Believing Edge Functions replace databases
• Assuming users write Edge Function code in browsers

2. Which is the correct way to define a simple Supabase Edge Function in JavaScript?

easy

A. async function handler() { console.log('Hello') }

B. function handler(req, res) { return 'Hello' }

C. export async function handler(req, res) { res.send('Hello') }

D. export default async function handler(req) { return 'Hello' }

Solution

1. Step 1: Recall Supabase Edge Function syntax

   Supabase Edge Functions export a default async function that receives a request and returns a response.

2. Step 2: Check each option's correctness

   export default async function handler(req) { return 'Hello' } correctly exports an async function with one parameter and returns a response. Others miss export default or proper response handling.

3. Final Answer:

   export default async function handler(req) { return 'Hello' } -> Option D

4. Quick Check:

   Default async export with req param = correct syntax [OK]

Hint: Edge Functions use 'export default async function(req)' [OK]

Common Mistakes:

• Missing 'export default' keyword
• Not using async function
• Incorrect function parameters

3. Given this Edge Function code snippet, what will be the response when called?

export default async function handler(req) {
  const user = { id: 1, name: 'Alice' };
  return new Response(JSON.stringify(user), { headers: { 'Content-Type': 'application/json' } });
}

medium

A. {"id":1,"name":"Alice"}

B. Error: user is not defined

C. undefined

D. Plain text response 'user'

Solution

1. Step 1: Analyze the function's return value

   The function returns a Response object with JSON string of the user object and proper content-type header.

2. Step 2: Determine the actual response content

   The JSON.stringify converts the user object to '{"id":1,"name":"Alice"}', which is sent as the response body.

3. Final Answer:

   {"id":1,"name":"Alice"} -> Option A

4. Quick Check:

   JSON.stringify(user) = JSON string response [OK]

Hint: JSON.stringify returns JSON text in response [OK]

Common Mistakes:

• Expecting raw object instead of JSON string
• Confusing variable scope errors
• Ignoring response headers

4. This Edge Function code throws an error when called. What is the problem?

export default async function handler(req) {
  const data = await fetch('https://api.example.com/data');
  return data.json();
}

medium

A. fetch URL is invalid syntax

B. Missing 'await' before data.json() causing a Promise to be returned

C. Function must not be async

D. Response must be a string, not JSON

Solution

1. Step 1: Identify async handling of fetch response

   fetch returns a Response object; calling data.json() returns a Promise that must be awaited.

2. Step 2: Spot missing 'await' before data.json()

   Without 'await', the function returns a Promise instead of resolved JSON, causing errors in response handling.

3. Final Answer:

   Missing 'await' before data.json() causing a Promise to be returned -> Option B

4. Quick Check:

   Await all async calls to get resolved data [OK]

Hint: Always await data.json() after fetch [OK]

Common Mistakes:

• Not awaiting JSON parsing
• Assuming fetch URL syntax error
• Thinking async keyword is wrong here

5. You want to keep user authentication logic secure and fast in your Supabase app. Why should you use Edge Functions for this instead of client-side code?

hard

A. Client-side code runs faster and is more secure than Edge Functions

B. Edge Functions store user passwords on the client device

C. Edge Functions run server-side, protecting secrets and reducing client load

D. Client-side code can access database directly without restrictions

Solution

1. Step 1: Understand security needs for authentication

   Authentication requires secret keys and sensitive logic that must not be exposed to users.

2. Step 2: Explain why Edge Functions are suitable

   Edge Functions run on the server close to users, keeping secrets safe and off the client, while improving response speed.

3. Step 3: Contrast with client-side code risks

   Client-side code is visible to users and cannot securely handle secrets or sensitive operations.

4. Final Answer:

   Edge Functions run server-side, protecting secrets and reducing client load -> Option C

5. Quick Check:

   Server-side = secure + fast auth logic [OK]

Hint: Keep secrets server-side with Edge Functions [OK]

Common Mistakes:

• Thinking client-side is more secure
• Believing Edge Functions expose passwords
• Assuming client code can safely access DB secrets