Add API endpoint using netlify edge function 🪄

Author: 01100100

.gitignore

@@ -1,2 +1,5 @@
 app/node_modules
 .vscode
+
+# Local Netlify folder
+.netlify

README.md

@@ -68,6 +68,98 @@ npm install
 npm run build
 ```
 
+## API 🚀
+
+WhereRoulette provides a simple API using Netlify Edge Functions to retrieve POIs within a specified region. Mix some randomness into your apps or get details about specific locations! ✨
+
+### POI Endpoint ⚡
+
+```bash
+GET https://whereroulette.com/api
+```
+
+#### Query Parameters 🔍
+
+| Parameter | Description | Required | Default |
+|-----------|-------------|----------|---------|
+| region    | OpenStreetMap region ID | Yes | - |
+| type      | POI category (drinks, cafe, food, park, climb) | No | drinks |
+| id        | Specific OSM node ID (e.g., "node/11967421222" or just "11967421222") | No | - |
+
+#### Usage Examples 📝
+
+**Random POI:**
+
+```bash
+https://whereroulette.com/api?region=62422&type=climb
+```
+
+**Specific POI by ID:**
+
+```bash
+https://whereroulette.com/api?region=62422&type=climb&id=node%2F11967421222
+```
+
+#### Response Example 💾
+
+```json
+{
+  "osm_node": "11967421222",
+  "name": "Bouldergarten",
+  "type": "climb",
+  "emoji": "🧗",
+  "opening_hours": "Mo-Fr 10:00-23:00, Sa,Su 10:00-22:00",
+  "url": "https://whereroulette.com/?region=62422&type=climb&id=node%2F11967421222",
+  "coordinates": [13.4567, 52.4890]
+}
+```
+
+#### Error Responses ⚠️
+
+**Missing Region:**
+
+```json
+{
+  "error": "Missing required parameter: region"
+}
+```
+
+**Invalid Category:**
+
+```json
+{
+  "error": "Invalid type. Must be one of: drinks, cafe, food, park, climb"
+}
+```
+
+**No POIs Found:**
+
+```json
+{
+  "error": "No climb found in region 62422"
+}
+```
+
+**Node Not Found:**
+
+```json
+{
+  "error": "Node with ID node/12345678 not found"
+}
+```
+
+### Technical Implementation 🛠️
+
+The API is implemented as a Netlify Edge Function, which provides fast, globally distributed response times. It directly queries the Overpass API to fetch OpenStreetMap data and converts it to a simplified format optimized for POI information.
+
+The configuration in `netlify.toml` maps the `/api` path to the Edge Function:
+
+```toml
+[[edge_functions]]
+function = "json"
+path = "/api"
+```
+
 ## Deployment
 
 ### Frontend - GitHub Pages

app/netlify/edge-functions/choose/choose.ts

@@ -0,0 +1,229 @@
+import type { Context } from 'https://edge.netlify.com'
+
+// Define categories (copied from main.ts)
+enum Category {
+  Drinks = "drinks",
+  Cafe = "cafe",
+  Food = "food",
+  Park = "park",
+  Climb = "climb",
+}
+
+// Define category details (copied from main.ts)
+const categories = {
+  [Category.Drinks]: { tag: 'amenity~"^(pub|bar|biergarten)$"', emoji: "🍺" },
+  [Category.Cafe]: { tag: 'amenity~"^(cafe)$"', emoji: "☕" },
+  [Category.Food]: { tag: 'amenity~"^(restaurant|fast_food|food_court|ice_cream)$"', emoji: "🍴" },
+  [Category.Park]: { tag: 'leisure~"^(park|garden)$"', emoji: "🌳" },
+  [Category.Climb]: { tag: 'sport~"^(climbing|bouldering)$"', emoji: "🧗" },
+};
+
+// Define response type
+type ApiResponse = {
+  osm_node: string;
+  name: string;
+  type: string;
+  emoji: string;
+  opening_hours?: string;
+  url: string;
+  coordinates?: [number, number];
+  error?: string;
+};
+
+// Helper function to fetch data from Overpass API
+async function fetchOverpassData(overpassQuery: string) {
+  const response = await fetch("https://www.overpass-api.de/api/interpreter", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body: overpassQuery,
+  });
+  
+  if (response.ok) {
+    return await response.json();
+  } else {
+    throw new Error(`Overpass API error: ${response.statusText}`);
+  }
+}
+
+// Function to generate query for POIs in a relation
+function poisInRelationQuery(relationID: number, category: Category): string {
+  return `[out:json];node(area:${relationID + 3600000000})[${categories[category].tag}];out geom;`;
+}
+
+// Function to generate query for a specific node
+function specificNodeQuery(nodeId: string): string {
+  return `[out:json];node(${nodeId});out geom;`;
+}
+
+// Simplified implementation of osmtogeojson for node elements only
+function simplifiedOsmToGeoJson(osmData: any) {
+  const features = [];
+  
+  // Process nodes from OSM data
+  if (osmData.elements) {
+    for (const element of osmData.elements) {
+      if (element.type === 'node') {
+        const properties: any = {};
+        
+        // Copy all tags to properties
+        if (element.tags) {
+          Object.assign(properties, element.tags);
+        }
+        
+        // Add ID to properties
+        properties.id = `node/${element.id}`;
+        
+        // Create feature
+        features.push({
+          type: 'Feature',
+          id: `node/${element.id}`,
+          properties: properties,
+          geometry: {
+            type: 'Point',
+            coordinates: [element.lon, element.lat]
+          }
+        });
+      }
+    }
+  }
+  
+  return {
+    type: 'FeatureCollection',
+    features: features
+  };
+}
+
+// Function to fetch POIs in a relation
+async function fetchPoisInRelation(relationID: string, category: Category) {
+  const query = poisInRelationQuery(parseInt(relationID), category);
+  const osmData = await fetchOverpassData(query);
+  return simplifiedOsmToGeoJson(osmData);
+}
+
+// Function to fetch a specific node by ID
+async function fetchSpecificNode(nodeId: string) {
+  // Extract the numeric ID if it's in the format "node/123456"
+  const numericId = nodeId.includes('/') ? nodeId.split('/')[1] : nodeId;
+  const query = specificNodeQuery(numericId);
+  const osmData = await fetchOverpassData(query);
+  return simplifiedOsmToGeoJson(osmData);
+}
+
+export default async (request: Request, context: Context) => {
+  // Set CORS headers
+  const headers = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type",
+    "Content-Type": "application/json",
+  };
+
+  // Handle preflight requests
+  if (request.method === "OPTIONS") {
+    return new Response("", {
+      status: 204,
+      headers,
+    });
+  }
+
+  try {
+    // Parse query parameters from URL
+    const url = new URL(request.url);
+    const regionId = url.searchParams.get('region');
+    const categoryName = url.searchParams.get('type') || 'drinks'; // Default to drinks
+    const specificId = url.searchParams.get('id');
+
+    // Validate parameters
+    if (!regionId) {
+      return Response.json({ 
+        error: "Missing required parameter: region" 
+      }, { 
+        status: 400,
+        headers 
+      });
+    }
+
+    // Validate category
+    if (!Object.values(Category).includes(categoryName as Category)) {
+      return Response.json({ 
+        error: `Invalid type. Must be one of: ${Object.values(Category).join(", ")}` 
+      }, { 
+        status: 400,
+        headers 
+      });
+    }
+
+    const category = categoryName as Category;
+    
+    let selectedFeature;
+    let properties;
+    
+    // If specific ID is provided, fetch that specific node
+    if (specificId) {
+      // Check if it's a full OSM ID (e.g., "node/123456") or just a numeric ID
+      const nodeData = await fetchSpecificNode(specificId);
+      
+      if (nodeData.features && nodeData.features.length > 0) {
+        selectedFeature = nodeData.features[0];
+        properties = selectedFeature.properties || {};
+      } else {
+        return Response.json({ 
+          error: `Node with ID ${specificId} not found` 
+        }, { 
+          status: 404,
+          headers 
+        });
+      }
+    } else {
+      // Otherwise, fetch POIs for the region and category and select randomly
+      const pois = await fetchPoisInRelation(regionId, category);
+
+      // Check if any POIs were found
+      if (!pois.features || pois.features.length === 0) {
+        return Response.json({ 
+          error: `No ${category} found in region ${regionId}` 
+        }, { 
+          status: 404,
+          headers 
+        });
+      }
+
+      // Randomly select a POI
+      const randomIndex = Math.floor(Math.random() * pois.features.length);
+      selectedFeature = pois.features[randomIndex];
+      properties = selectedFeature.properties || {};
+    }
+
+    // Get the OSM ID
+    const osmId = properties.id || "";
+    const idParts = osmId.split("/");
+    const osmNodeType = idParts[0] || "node";
+    const osmNodeId = idParts[1] || "";
+
+    // Create response
+    const response: ApiResponse = {
+      osm_node: osmNodeId,
+      name: properties.name || "Unnamed location",
+      type: category,
+      emoji: categories[category].emoji,
+      opening_hours: properties.opening_hours,
+      url: `https://whereroulette.com/?region=${regionId}&type=${category}&id=${encodeURIComponent(osmId)}`,
+    };
+
+    // Add coordinates if it's a point
+    if (selectedFeature.geometry.type === "Point") {
+      response.coordinates = selectedFeature.geometry.coordinates as [number, number];
+    }
+
+    return Response.json(response, { headers });
+  } catch (error) {
+    console.error("Error processing request:", error);
+    return Response.json({ 
+      error: "Internal server error" 
+    }, { 
+      status: 500,
+      headers 
+    });
+  }
+}