Anatomy of a Simple Backend

package main

import (
	"fmt"
	"strings"
)

const alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// --- store: the only part that remembers (a database in real life) ---
type link struct {
	url    string
	clicks int
}

var (
	links  = map[string]*link{}
	nextID = 100000 // a counter; real systems get unique ids from the database
)

// --- service: the business rules ---

// base62 turns a number into a short code: 100000 -> "q0U".
func base62(n int) string {
	code := ""
	for ; n > 0; n /= 62 {
		code = string(alphabet[n%62]) + code
	}
	return code
}

func shorten(url string) (int, string) {
	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
		return 400, "only http(s) links"
	}
	code := base62(nextID)
	nextID++
	links[code] = &link{url: url}
	return 201, "short link: /" + code
}

func follow(code string) (int, string) {
	l, ok := links[code]
	if !ok {
		return 404, "no such link"
	}
	l.clicks++
	return 302, "Location: " + l.url
}

func stats(code string) (int, string) {
	l, ok := links[code]
	if !ok {
		return 404, "no such link"
	}
	return 200, fmt.Sprintf("%d clicks", l.clicks)
}

// --- router: turns a request into a call to the right handler ---
func handle(method, path, body string) (int, string) {
	switch {
	case method == "POST" && path == "/shorten":
		return shorten(body)
	case method == "GET" && strings.HasSuffix(path, "/stats"):
		return stats(strings.TrimSuffix(strings.TrimPrefix(path, "/"), "/stats"))
	case method == "GET":
		return follow(strings.TrimPrefix(path, "/"))
	}
	return 405, "method not allowed"
}

func main() {
	requests := [][3]string{
		{"POST", "/shorten", "https://codingfoding.com/learn"},
		{"POST", "/shorten", "ftp://files.example.com"},
		{"POST", "/shorten", "https://example.com"},
		{"GET", "/q0U", ""},
		{"GET", "/q0U", ""},
		{"GET", "/zzz", ""},
		{"GET", "/q0U/stats", ""},
		{"DELETE", "/q0U", ""},
	}
	for _, r := range requests {
		status, out := handle(r[0], r[1], r[2])
		req := strings.TrimSpace(r[0] + " " + r[1] + " " + r[2])
		fmt.Printf("%-46s -> %d %s\n", req, status, out)
	}
}

const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

// --- store: the only part that remembers (a database in real life) ---
const links = new Map(); // code -> { url, clicks }
let nextId = 100000; // a counter; real systems get unique ids from the database

// --- service: the business rules ---

// base62 turns a number into a short code: 100000 -> "q0U".
function base62(n) {
  let code = "";
  for (; n > 0; n = Math.floor(n / 62)) code = ALPHABET[n % 62] + code;
  return code;
}

function shorten(url) {
  if (!url.startsWith("http://") && !url.startsWith("https://")) return [400, "only http(s) links"];
  const code = base62(nextId++);
  links.set(code, { url, clicks: 0 });
  return [201, `short link: /${code}`];
}

function follow(code) {
  const link = links.get(code);
  if (!link) return [404, "no such link"];
  link.clicks++;
  return [302, `Location: ${link.url}`];
}

function stats(code) {
  const link = links.get(code);
  if (!link) return [404, "no such link"];
  return [200, `${link.clicks} clicks`];
}

// --- router: turns a request into a call to the right handler ---
function handle(method, path, body) {
  if (method === "POST" && path === "/shorten") return shorten(body);
  if (method === "GET" && path.endsWith("/stats")) return stats(path.slice(1, -"/stats".length));
  if (method === "GET") return follow(path.slice(1));
  return [405, "method not allowed"];
}

const requests = [
  ["POST", "/shorten", "https://codingfoding.com/learn"],
  ["POST", "/shorten", "ftp://files.example.com"],
  ["POST", "/shorten", "https://example.com"],
  ["GET", "/q0U", ""],
  ["GET", "/q0U", ""],
  ["GET", "/zzz", ""],
  ["GET", "/q0U/stats", ""],
  ["DELETE", "/q0U", ""],
];
for (const [method, path, body] of requests) {
  const [status, out] = handle(method, path, body);
  console.log(`${`${method} ${path} ${body}`.trim().padEnd(46)} -> ${status} ${out}`);
}

use std::collections::HashMap;

const ALPHABET: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

// --- store: the only part that remembers (a database in real life) ---
struct Link {
    url: String,
    clicks: u32,
}

struct Shortener {
    links: HashMap<String, Link>,
    next_id: u64, // a counter; real systems get unique ids from the database
}

// --- service: the business rules ---

// base62 turns a number into a short code: 100000 -> "q0U".
fn base62(mut n: u64) -> String {
    let mut code = Vec::new();
    while n > 0 {
        code.insert(0, ALPHABET[(n % 62) as usize]);
        n /= 62;
    }
    String::from_utf8(code).unwrap()
}

impl Shortener {
    fn shorten(&mut self, url: &str) -> (u16, String) {
        if !url.starts_with("http://") && !url.starts_with("https://") {
            return (400, "only http(s) links".into());
        }
        let code = base62(self.next_id);
        self.next_id += 1;
        self.links.insert(code.clone(), Link { url: url.into(), clicks: 0 });
        (201, format!("short link: /{code}"))
    }

    fn follow(&mut self, code: &str) -> (u16, String) {
        match self.links.get_mut(code) {
            None => (404, "no such link".into()),
            Some(link) => {
                link.clicks += 1;
                (302, format!("Location: {}", link.url))
            }
        }
    }

    fn stats(&self, code: &str) -> (u16, String) {
        match self.links.get(code) {
            None => (404, "no such link".into()),
            Some(link) => (200, format!("{} clicks", link.clicks)),
        }
    }

    // --- router: turns a request into a call to the right handler ---
    fn handle(&mut self, method: &str, path: &str, body: &str) -> (u16, String) {
        match method {
            "POST" if path == "/shorten" => self.shorten(body),
            "GET" if path.ends_with("/stats") => self.stats(&path[1..path.len() - "/stats".len()]),
            "GET" => self.follow(&path[1..]),
            _ => (405, "method not allowed".into()),
        }
    }
}

fn main() {
    let mut app = Shortener { links: HashMap::new(), next_id: 100000 };
    let requests = [
        ("POST", "/shorten", "https://codingfoding.com/learn"),
        ("POST", "/shorten", "ftp://files.example.com"),
        ("POST", "/shorten", "https://example.com"),
        ("GET", "/q0U", ""),
        ("GET", "/q0U", ""),
        ("GET", "/zzz", ""),
        ("GET", "/q0U/stats", ""),
        ("DELETE", "/q0U", ""),
    ];
    for (method, path, body) in requests {
        let (status, out) = app.handle(method, path, body);
        let req = format!("{method} {path} {body}");
        println!("{:<46} -> {} {}", req.trim(), status, out);
    }
}

ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

# --- store: the only part that remembers (a database in real life) ---
links = {}  # code -> {"url": ..., "clicks": ...}
next_id = 100000  # a counter; real systems get unique ids from the database


# --- service: the business rules ---


def base62(n):
    """Turns a number into a short code: 100000 -> "q0U"."""
    code = ""
    while n > 0:
        code = ALPHABET[n % 62] + code
        n //= 62
    return code


def shorten(url):
    global next_id
    if not url.startswith(("http://", "https://")):
        return 400, "only http(s) links"
    code = base62(next_id)
    next_id += 1
    links[code] = {"url": url, "clicks": 0}
    return 201, f"short link: /{code}"


def follow(code):
    link = links.get(code)
    if link is None:
        return 404, "no such link"
    link["clicks"] += 1
    return 302, f"Location: {link['url']}"


def stats(code):
    link = links.get(code)
    if link is None:
        return 404, "no such link"
    return 200, f"{link['clicks']} clicks"


# --- router: turns a request into a call to the right handler ---
def handle(method, path, body):
    if method == "POST" and path == "/shorten":
        return shorten(body)
    if method == "GET" and path.endswith("/stats"):
        return stats(path[1 : -len("/stats")])
    if method == "GET":
        return follow(path[1:])
    return 405, "method not allowed"


requests = [
    ("POST", "/shorten", "https://codingfoding.com/learn"),
    ("POST", "/shorten", "ftp://files.example.com"),
    ("POST", "/shorten", "https://example.com"),
    ("GET", "/q0U", ""),
    ("GET", "/q0U", ""),
    ("GET", "/zzz", ""),
    ("GET", "/q0U/stats", ""),
    ("DELETE", "/q0U", ""),
]
for method, path, body in requests:
    status, out = handle(method, path, body)
    req = f"{method} {path} {body}".strip()
    print(f"{req:<46} -> {status} {out}")

import java.util.HashMap;
import java.util.Map;

public class Main {
    static final String ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

    // --- store: the only part that remembers (a database in real life) ---
    static class Link {
        final String url;
        int clicks;
        Link(String url) { this.url = url; }
    }

    static final Map<String, Link> LINKS = new HashMap<>();
    static long nextId = 100000; // a counter; real systems get unique ids from the database

    record Response(int status, String out) {}

    // --- service: the business rules ---

    // base62 turns a number into a short code: 100000 -> "q0U".
    static String base62(long n) {
        StringBuilder code = new StringBuilder();
        for (; n > 0; n /= 62) code.insert(0, ALPHABET.charAt((int) (n % 62)));
        return code.toString();
    }

    static Response shorten(String url) {
        if (!url.startsWith("http://") && !url.startsWith("https://")) return new Response(400, "only http(s) links");
        String code = base62(nextId++);
        LINKS.put(code, new Link(url));
        return new Response(201, "short link: /" + code);
    }

    static Response follow(String code) {
        Link link = LINKS.get(code);
        if (link == null) return new Response(404, "no such link");
        link.clicks++;
        return new Response(302, "Location: " + link.url);
    }

    static Response stats(String code) {
        Link link = LINKS.get(code);
        if (link == null) return new Response(404, "no such link");
        return new Response(200, link.clicks + " clicks");
    }

    // --- router: turns a request into a call to the right handler ---
    static Response handle(String method, String path, String body) {
        if (method.equals("POST") && path.equals("/shorten")) return shorten(body);
        if (method.equals("GET") && path.endsWith("/stats")) return stats(path.substring(1, path.length() - "/stats".length()));
        if (method.equals("GET")) return follow(path.substring(1));
        return new Response(405, "method not allowed");
    }

    public static void main(String[] args) {
        String[][] requests = {
            {"POST", "/shorten", "https://codingfoding.com/learn"},
            {"POST", "/shorten", "ftp://files.example.com"},
            {"POST", "/shorten", "https://example.com"},
            {"GET", "/q0U", ""},
            {"GET", "/q0U", ""},
            {"GET", "/zzz", ""},
            {"GET", "/q0U/stats", ""},
            {"DELETE", "/q0U", ""},
        };
        for (String[] r : requests) {
            Response res = handle(r[0], r[1], r[2]);
            String req = (r[0] + " " + r[1] + " " + r[2]).trim();
            System.out.printf("%-46s -> %d %s%n", req, res.status(), res.out());
        }
    }
}