Code-MCP

# Code Examples ## TypeScript ### Express API with TypeScript ```typescript import express, { Request, Response, NextFunction } from 'express'; const app = express(); app.use(express.json()); // Typed route handler interface User { id: number; name: string; email: string; } app.get('/users/:id', async (req: Request, res: Response) => { const { id } = req.params; const user: User = { id: Number(id), name: 'John', email: 'john@example.com' }; res.json(user); }); // Error handling middleware app.use((err: Error, req: Request, res: Response, next: NextFunction) => { console.error(err.stack); res.status(500).json({ error: err.message }); }); app.listen(3000, () => console.log('Server running on port 3000')); ``` ### React Hook with TypeScript ```typescript import { useState, useEffect } from 'react'; interface FetchState<T> { data: T | null; loading: boolean; error: Error | null; } function useFetch<T>(url: string): FetchState<T> { const [state, setState] = useState<FetchState<T>>({ data: null, loading: true, error: null, }); useEffect(() => { const controller = new AbortController(); fetch(url, { signal: controller.signal }) .then(res => res.json()) .then(data => setState({ data, loading: false, error: null })) .catch(error => setState({ data: null, loading: false, error })); return () => controller.abort(); }, [url]); return state; } ``` --- ## Python ### FastAPI with Pydantic ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel, EmailStr from typing import Optional app = FastAPI() class UserCreate(BaseModel): name: str email: EmailStr age: Optional[int] = None class UserResponse(BaseModel): id: int name: str email: str class Config: from_attributes = True @app.post("/users", response_model=UserResponse) async def create_user(user: UserCreate): # Simulated database insert return {"id": 1, **user.model_dump()} @app.get("/users/{user_id}", response_model=UserResponse) async def get_user(user_id: int): if user_id <= 0: raise HTTPException(status_code=404, detail="User not found") return {"id": user_id, "name": "John", "email": "john@example.com"} ``` ### Async Python Pattern ```python import asyncio import aiohttp from typing import List async def fetch_url(session: aiohttp.ClientSession, url: str) -> dict: async with session.get(url) as response: return await response.json() async def fetch_all(urls: List[str]) -> List[dict]: async with aiohttp.ClientSession() as session: tasks = [fetch_url(session, url) for url in urls] return await asyncio.gather(*tasks) # Usage # results = asyncio.run(fetch_all(['url1', 'url2', 'url3'])) ``` --- ## Go ### HTTP Server with Middleware ```go package main import ( "encoding/json" "log" "net/http" "time" ) func loggingMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() next.ServeHTTP(w, r) log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start)) }) } type User struct { ID int `json:"id"` Name string `json:"name"` Email string `json:"email"` } func getUser(w http.ResponseWriter, r *http.Request) { user := User{ID: 1, Name: "John", Email: "john@example.com"} w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(user) } func main() { mux := http.NewServeMux() mux.HandleFunc("/user", getUser) handler := loggingMiddleware(mux) log.Fatal(http.ListenAndServe(":8080", handler)) } ``` --- ## Rust ### Axum Web Server ```rust use axum::{ routing::{get, post}, Json, Router, }; use serde::{Deserialize, Serialize}; #[derive(Serialize)] struct User { id: i32, name: String, } #[derive(Deserialize)] struct CreateUser { name: String, } async fn get_user() -> Json<User> { Json(User { id: 1, name: "John".to_string(), }) } async fn create_user(Json(payload): Json<CreateUser>) -> Json<User> { Json(User { id: 1, name: payload.name, }) } #[tokio::main] async fn main() { let app = Router::new() .route("/user", get(get_user)) .route("/user", post(create_user)); let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(); axum::serve(listener, app).await.unwrap(); } ```