Routing patterns in Deno - Mini Project: Build & Apply

Routing patterns

📖 Scenario: You are building a simple web server using Deno that responds differently based on the URL path requested by the user.

🎯 Goal: Create a Deno server that uses routing patterns to handle requests for the home page, about page, and a user profile page with a dynamic username.

📋 What You'll Learn

Create a basic HTTP server using Deno's standard library

Define routes for /, /about, and /user/:username

Use routing patterns to extract the username from the URL

Send appropriate text responses for each route

💡 Why This Matters

🌍 Real World

Web servers often need to respond differently based on the URL path. This project shows how to handle simple routing in Deno.

💼 Career

Understanding routing is essential for backend developers and full-stack engineers building web applications and APIs.

1

Set up the basic HTTP server

Write code to import serve from https://deno.land/std@0.177.0/http/server.ts and create a server that listens on port 8000. Define an async function called handler that takes a Request object and returns a simple Response with the text "Server is running".

Deno

import { serve } from "https://deno.land/std@0.177.0/http/server.ts"

// Your code here

Hint

Use Deno's serve function to start the server and define a handler function that returns a Response.

2

Add route matching setup

Create a variable called url inside the handler function by constructing a new URL object from request.url. This will help to check the request path.

Deno

import { serve } from "https://deno.land/std@0.177.0/http/server.ts"

async function handler(request: Request): Promise {
  const url = new URL(request.url)
  // Your code here
}

serve(handler, { port: 8000 })

Hint

Use new URL(request.url) to get the full URL and access its pathname.

3

Implement routing logic for static paths

Inside the handler function, use if statements to check if url.pathname is exactly "/" or "/about". Return a Response with the text "Welcome to the Home Page" for / and "About Us Page" for /about.

Deno

import { serve } from "https://deno.land/std@0.177.0/http/server.ts"

async function handler(request: Request): Promise {
  const url = new URL(request.url)
  if (url.pathname === "/") {
    // Your code here
  } else if (url.pathname === "/about") {
    // Your code here
  }
}

serve(handler, { port: 8000 })

Hint

Use if and else if to check the path and return different responses.

4

Add dynamic routing for user profiles

Add code inside the handler function to check if url.pathname starts with "/user/". Extract the username by slicing url.pathname after "/user/". Return a Response with the text "User Profile for: " followed by the extracted username. If no route matches, return a 404 response with text "Not Found".

Deno

import { serve } from "https://deno.land/std@0.177.0/http/server.ts"

async function handler(request: Request): Promise {
  const url = new URL(request.url)
  if (url.pathname === "/") {
    return new Response("Welcome to the Home Page", { status: 200 })
  } else if (url.pathname === "/about") {
    return new Response("About Us Page", { status: 200 })
  } else if (url.pathname.startsWith("/user/")) {
    // Your code here
  }
  return new Response("Not Found", { status: 404 })
}

serve(handler, { port: 8000 })

Hint

Use startsWith to detect the user route and slice to get the username part.

Practice

1. What is the main purpose of routing patterns in a Deno web application?

easy

A. To store data in a database

B. To style the webpage with colors and fonts

C. To connect URLs to specific code that runs when those URLs are visited

D. To manage user authentication only

Solution

1. Step 1: Understand routing role

   Routing connects web addresses (URLs) to the code that should run when those addresses are accessed.

2. Step 2: Compare options

   Only To connect URLs to specific code that runs when those URLs are visited describes this connection. Other options describe unrelated tasks like styling or data storage.

3. Final Answer:

   To connect URLs to specific code that runs when those URLs are visited -> Option C

4. Quick Check:

   Routing = URL to code connection [OK]

Hint: Routing links URLs to code that runs on visit [OK]

Common Mistakes:

• Confusing routing with styling or database tasks
• Thinking routing only manages user login
• Believing routing changes page colors

2. Which of the following is the correct way to define a static route using Oak in Deno?

easy

A. router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; });

B. router.route('/home', (ctx) => { ctx.body = 'Welcome'; });

C. router.add('/home', (ctx) => { ctx.response.body = 'Welcome'; });

D. router.get('/home', (ctx) => { return 'Welcome'; });

Solution

1. Step 1: Recall Oak routing syntax

   Oak uses router.get(path, handler) to define GET routes. The handler sets ctx.response.body for response content.

2. Step 2: Check each option

   router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; }); matches correct syntax. router.route('/home', (ctx) => { ctx.body = 'Welcome'; }); uses non-existent method 'route'. router.add('/home', (ctx) => { ctx.response.body = 'Welcome'; }); uses 'add' which is invalid. router.get('/home', (ctx) => { return 'Welcome'; }); returns string instead of setting ctx.response.body.

3. Final Answer:

   router.get('/home', (ctx) => { ctx.response.body = 'Welcome'; }); -> Option A

4. Quick Check:

   Oak static route uses router.get and ctx.response.body [OK]

Hint: Use router.get and set ctx.response.body for static routes [OK]

Common Mistakes:

• Using wrong router method like route or add
• Returning string instead of setting ctx.response.body
• Forgetting to set response body

3. Given this Oak route code in Deno:

router.get('/user/:id', (ctx) => {
  const id = ctx.params.id;
  ctx.response.body = `User ID is ${id}`;
});

// Request URL: /user/42

What will be the response body when visiting /user/42?

medium

A. "User ID is :id"

B. "User ID is 42"

C. "User ID is undefined"

D. "User ID is /user/42"

Solution

1. Step 1: Understand dynamic route parameter

   The route uses ':id' as a placeholder. When URL is '/user/42', ctx.params.id becomes '42'.

2. Step 2: Check response body construction

   The response body uses template string to insert id value, so it becomes 'User ID is 42'.

3. Final Answer:

   "User ID is 42" -> Option B

4. Quick Check:

   Dynamic param ':id' = '42' in response [OK]

Hint: Dynamic params fill ctx.params with URL parts [OK]

Common Mistakes:

• Using literal ':id' instead of param value
• Forgetting to access ctx.params.id
• Assuming undefined if param missing

4. Identify the error in this Oak routing code snippet:

router.get('/post/:postId', (ctx) => {
  const postId = ctx.request.params.postId;
  ctx.response.body = `Post: ${postId}`;
});

medium

A. ctx.response.body cannot be a template string

B. Missing async keyword in handler

C. Route path should not have colon before postId

D. ctx.request.params is undefined; should use ctx.params

Solution

1. Step 1: Check how to access route params in Oak

   Route parameters are accessed via ctx.params, not ctx.request.params.

2. Step 2: Verify other parts

   Async is not required here. Colon before postId is correct for dynamic routes. Template strings are valid for response body.

3. Final Answer:

   ctx.request.params is undefined; should use ctx.params -> Option D

4. Quick Check:

   Use ctx.params for route parameters [OK]

Hint: Use ctx.params, not ctx.request.params for route params [OK]

Common Mistakes:

• Accessing params from ctx.request instead of ctx
• Thinking async is mandatory for all handlers
• Removing colon from dynamic route path

5. You want to create a Deno Oak route that matches URLs like /product/123/review/456 where 123 is the product ID and 456 is the review ID. Which route pattern correctly captures both IDs as parameters?

hard

A. router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ });

B. router.get('/product/:productId/:reviewId/review', (ctx) => { /* ... */ });

C. router.get('/product/review/:productId/:reviewId', (ctx) => { /* ... */ });

D. router.get('/product/:productId/review', (ctx) => { /* ... */ });

Solution

1. Step 1: Analyze URL structure

   The URL has 'product', then product ID, then 'review', then review ID in order.

2. Step 2: Match route pattern to URL

   router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ }); matches this pattern exactly with dynamic segments ':productId' and ':reviewId' in correct places.

3. Step 3: Check other options

   router.get('/product/:productId/:reviewId/review', (ctx) => { /* ... */ }); misplaces ':reviewId' before 'review' segment. router.get('/product/review/:productId/:reviewId', (ctx) => { /* ... */ }); swaps order. router.get('/product/:productId/review', (ctx) => { /* ... */ }); misses review ID parameter.

4. Final Answer:

   router.get('/product/:productId/review/:reviewId', (ctx) => { /* ... */ }); -> Option A

5. Quick Check:

   Dynamic segments match URL parts in order [OK]

Hint: Match URL parts exactly; use :param for dynamic segments [OK]

Common Mistakes:

• Swapping order of dynamic segments and static parts
• Omitting one of the dynamic parameters
• Placing parameters in wrong URL positions