HTTP Routing

/**
 * HTTP routing. This routing is capable of handling any HTTP version.
 */
interface HttpRouting extends Routing, Prototype.Api {
    /**
     * Creates new instance of HttpRouting builder.
     * @return a new instance
     */
    static Builder builder();
    
    /**
     * Create a default router.
     * @return new default router
     */
    static HttpRouting create();
    
    /**
     * Empty routing (all requests will return 404).
     * @return empty routing
     */
    static HttpRouting empty();
    
    /**
     * Route a request.
     * @param ctx the underlying connection context
     * @param request the request to route
     * @param response the response for the request
     */
    void route(ConnectionContext ctx, RoutingRequest request, RoutingResponse response);
    
    /**
     * Security associated with this routing.
     * @return security
     */
    HttpSecurity security();
    
    @Override
    default Class<? extends Routing> routingType() {
        return HttpRouting.class;
    }
}

import io.helidon.webserver.http.HttpRouting;
import io.helidon.http.Method;

// Create simple routing
HttpRouting routing = HttpRouting.builder()
    .get("/hello", (req, res) -> res.send("Hello World!"))
    .post("/users", (req, res) -> {
        // Handle user creation
        res.status(201).send("User created");
    })
    .build();

// Create default routing (returns "Helidon WebServer works!")
HttpRouting defaultRouting = HttpRouting.create();

// Create empty routing (returns 404 for all requests)
HttpRouting emptyRouting = HttpRouting.empty();

/**
 * Fluent API builder for HttpRouting.
 */
interface HttpRouting.Builder extends HttpRules, io.helidon.common.Builder<Builder, HttpRouting> {
    /**
     * Register HTTP services.
     * @param service services to register
     * @return updated builder
     */
    Builder register(HttpService... service);
    
    /**
     * Register HTTP services with path prefix.
     * @param path path prefix for services
     * @param service services to register
     * @return updated builder
     */
    Builder register(String path, HttpService... service);
    
    /**
     * Add HTTP route.
     * @param route route to add
     * @return updated builder
     */
    Builder route(HttpRoute route);
    
    /**
     * Add HTTP route with supplier.
     * @param route route supplier
     * @return updated builder
     */
    default Builder route(Supplier<? extends HttpRoute> route);
    
    /**
     * Add route for specific method and path.
     * @param method HTTP method
     * @param pathPattern path pattern
     * @param handler request handler
     * @return updated builder
     */
    default Builder route(Method method, String pathPattern, Handler handler);
    
    /**
     * Add route for specific method and path matcher.
     * @param method HTTP method
     * @param pathMatcher path matcher
     * @param handler request handler
     * @return updated builder
     */
    default Builder route(Method method, PathMatcher pathMatcher, Handler handler);
    
    /**
     * Add route with method predicate.
     * @param methodPredicate method predicate
     * @param pathMatcher path matcher
     * @param handler request handler
     * @return updated builder
     */
    default Builder route(Predicate<Method> methodPredicate, PathMatcher pathMatcher, Handler handler);
    
    /**
     * Add route for specific method without path restriction.
     * @param method HTTP method
     * @param handler request handler
     * @return updated builder
     */
    default Builder route(Method method, Handler handler);
}

/**
 * HTTP method shortcut methods in HttpRouting.Builder
 */
interface Builder {
    /**
     * Add GET route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder get(String pathPattern, Handler... handlers);
    
    /**
     * Add GET route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder get(Handler... handlers);
    
    /**
     * Add POST route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder post(String pathPattern, Handler... handlers);
    
    /**
     * Add POST route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder post(Handler... handlers);
    
    /**
     * Add PUT route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder put(String pathPattern, Handler... handlers);
    
    /**
     * Add PUT route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder put(Handler... handlers);
    
    /**
     * Add DELETE route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder delete(String pathPattern, Handler... handlers);
    
    /**
     * Add DELETE route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder delete(Handler... handlers);
    
    /**
     * Add HEAD route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder head(String pathPattern, Handler... handlers);
    
    /**
     * Add HEAD route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder head(Handler... handlers);
    
    /**
     * Add OPTIONS route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder options(String pathPattern, Handler... handlers);
    
    /**
     * Add OPTIONS route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder options(Handler... handlers);
    
    /**
     * Add TRACE route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder trace(String pathPattern, Handler... handlers);
    
    /**
     * Add TRACE route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder trace(Handler... handlers);
    
    /**
     * Add PATCH route with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder patch(String pathPattern, Handler... handlers);
    
    /**
     * Add PATCH route without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder patch(Handler... handlers);
    
    /**
     * Add route for any HTTP method with path pattern.
     * @param pathPattern path pattern
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder any(String pathPattern, Handler... handlers);
    
    /**
     * Add route for any HTTP method without path restriction.
     * @param handlers request handlers
     * @return updated builder
     */
    default Builder any(Handler... handlers);
}

import io.helidon.webserver.http.HttpRouting;
import io.helidon.http.Method;

HttpRouting routing = HttpRouting.builder()
    // Basic HTTP method routes
    .get("/users", (req, res) -> res.send("Get all users"))
    .get("/users/{id}", (req, res) -> {
        String id = req.path().pathParameters().get("id");
        res.send("Get user: " + id);
    })
    .post("/users", (req, res) -> {
        // Create user logic
        res.status(201).send("User created");
    })
    .put("/users/{id}", (req, res) -> {
        String id = req.path().pathParameters().get("id");
        res.send("Updated user: " + id);
    })
    .delete("/users/{id}", (req, res) -> {
        String id = req.path().pathParameters().get("id");
        res.status(204).send();
    })
    
    // Advanced routing patterns
    .route(Method.GET, "/admin/*", (req, res) -> {
        // Admin routes
    })
    .any("/health", (req, res) -> res.send("OK"))
    
    .build();

/**
 * Filter and feature methods in HttpRouting.Builder
 */
interface Builder {
    /**
     * Add a new filter.
     * @param filter filter to add
     * @return updated builder
     */
    Builder addFilter(Filter filter);
    
    /**
     * Add a new feature.
     * @param feature feature to add
     * @return updated builder
     */
    default Builder addFeature(HttpFeature feature);
    
    /**
     * Add a new feature with supplier.
     * @param feature feature supplier
     * @return updated builder
     */
    Builder addFeature(Supplier<? extends HttpFeature> feature);
    
    /**
     * Register error handler for specific exception type.
     * @param exceptionClass the type of exception to handle
     * @param handler the error handler
     * @param <T> exception type
     * @return updated builder
     */
    <T extends Throwable> Builder error(Class<T> exceptionClass, ErrorHandler<? super T> handler);
    
    /**
     * Maximal number of allowed re-routes within routing.
     * @param maxReRouteCount maximum number of allowed reroutes
     * @return updated builder
     */
    Builder maxReRouteCount(int maxReRouteCount);
    
    /**
     * Configure security for this routing.
     * @param security security to use
     * @return updated builder
     */
    Builder security(HttpSecurity security);
    
    /**
     * Create a copy of this builder.
     * @return builder that is a copy of this builder
     */
    Builder copy();
}

import io.helidon.webserver.http.*;

// Custom filter implementation
Filter loggingFilter = (chain, req, res) -> {
    System.out.println("Request: " + req.method() + " " + req.path());
    chain.proceed();
};

// Custom feature implementation
HttpFeature corsFeature = routing -> {
    routing.addFilter((chain, req, res) -> {
        res.header("Access-Control-Allow-Origin", "*");
        chain.proceed();
    });
};

// Error handler
ErrorHandler<IllegalArgumentException> argErrorHandler = 
    (req, res, ex) -> res.status(400).send("Bad request: " + ex.getMessage());

HttpRouting routing = HttpRouting.builder()
    // Add filters
    .addFilter(loggingFilter)
    
    // Add features
    .addFeature(corsFeature)
    
    // Add error handlers
    .error(IllegalArgumentException.class, argErrorHandler)
    .error(RuntimeException.class, (req, res, ex) -> 
        res.status(500).send("Internal error"))
    
    // Configure security
    .security(HttpSecurity.create())
    
    // Set max re-route count
    .maxReRouteCount(5)
    
    // Regular routes
    .get("/api/data", (req, res) -> {
        if (req.query().get("invalid").isPresent()) {
            throw new IllegalArgumentException("Invalid parameter");
        }
        res.send("Data response");
    })
    
    .build();

/**
 * Interface for defining HTTP routing rules.
 */
interface HttpRules {
    /**
     * Register HTTP services.
     * @param service services to register
     * @return updated rules
     */
    HttpRules register(HttpService... service);
    
    /**
     * Register HTTP services with supplier.
     * @param service service supplier
     * @return updated rules
     */
    default HttpRules register(Supplier<? extends HttpService> service);
    
    /**
     * Register HTTP services with path prefix.
     * @param pathPattern path prefix
     * @param service services to register
     * @return updated rules
     */
    HttpRules register(String pathPattern, HttpService... service);
    
    /**
     * Add HTTP route.
     * @param route route to add
     * @return updated rules
     */
    HttpRules route(HttpRoute route);
    
    /**
     * Add route with supplier.
     * @param route route supplier
     * @return updated rules
     */
    default HttpRules route(Supplier<? extends HttpRoute> route);
    
    // HTTP method shortcuts
    default HttpRules get(String pathPattern, Handler... handlers);
    default HttpRules post(String pathPattern, Handler... handlers);
    default HttpRules put(String pathPattern, Handler... handlers);
    default HttpRules delete(String pathPattern, Handler... handlers);
    default HttpRules head(String pathPattern, Handler... handlers);
    default HttpRules options(String pathPattern, Handler... handlers);
    default HttpRules trace(String pathPattern, Handler... handlers);
    default HttpRules patch(String pathPattern, Handler... handlers);
    default HttpRules any(String pathPattern, Handler... handlers);
}

/**
 * HTTP route definition.
 */
interface HttpRoute {
    /**
     * Create route builder.
     * @return route builder
     */
    static Builder builder();
    
    /**
     * Builder for HTTP routes.
     */
    interface Builder extends io.helidon.common.Builder<Builder, HttpRoute> {
        /**
         * Set HTTP methods for this route.
         * @param methods HTTP methods
         * @return updated builder
         */
        Builder methods(Method... methods);
        
        /**
         * Set method predicate for this route.
         * @param methodPredicate method predicate
         * @return updated builder
         */
        Builder methods(Predicate<Method> methodPredicate);
        
        /**
         * Set path pattern for this route.
         * @param pathPattern path pattern
         * @return updated builder
         */
        Builder path(String pathPattern);
        
        /**
         * Set path matcher for this route.
         * @param pathMatcher path matcher
         * @return updated builder
         */
        Builder path(PathMatcher pathMatcher);
        
        /**
         * Set request handler for this route.
         * @param handler request handler
         * @return updated builder
         */
        Builder handler(Handler handler);
    }
}

import io.helidon.webserver.http.HttpRoute;
import io.helidon.http.Method;

// Create custom routes
HttpRoute getUserRoute = HttpRoute.builder()
    .methods(Method.GET)
    .path("/users/{id}")
    .handler((req, res) -> {
        String userId = req.path().pathParameters().get("id");
        res.send("User: " + userId);
    })
    .build();

HttpRoute createUserRoute = HttpRoute.builder()
    .methods(Method.POST)
    .path("/users")
    .handler((req, res) -> {
        // Handle user creation
        res.status(201).send("Created");
    })
    .build();

// Use routes in routing
HttpRouting routing = HttpRouting.builder()
    .route(getUserRoute)
    .route(createUserRoute)
    .build();

HttpRouting routing = HttpRouting.builder()
    // Single path parameter
    .get("/users/{id}", (req, res) -> {
        String id = req.path().pathParameters().get("id");
        res.send("User ID: " + id);
    })
    
    // Multiple path parameters
    .get("/users/{userId}/posts/{postId}", (req, res) -> {
        Map<String, String> params = req.path().pathParameters().toMap();
        String userId = params.get("userId");
        String postId = params.get("postId");
        res.send("User: " + userId + ", Post: " + postId);
    })
    
    // Wildcard patterns
    .get("/static/*", (req, res) -> {
        String path = req.path().path();
        // Serve static files
    })
    
    // Regex patterns (advanced)
    .route(Method.GET, PathMatchers.create("/files/{filename:.+}"), 
           (req, res) -> {
               String filename = req.path().pathParameters().get("filename");
               // Handle file with any extension
           })
    
    .build();

// Create a user service
HttpService userService = rules -> {
    rules.get("/", (req, res) -> res.send("All users"))
         .get("/{id}", (req, res) -> res.send("User details"))
         .post("/", (req, res) -> res.status(201).send("User created"))
         .delete("/{id}", (req, res) -> res.status(204).send());
};

// Register with path prefix
HttpRouting routing = HttpRouting.builder()
    .register("/api/users", userService)
    .register("/admin/users", userService) // Same service, different prefix
    .build();

HttpRouting routing = HttpRouting.builder()
    // Method-based routing
    .route(method -> method.equals(Method.GET) || method.equals(Method.HEAD),
           PathMatchers.exact("/data"),
           (req, res) -> res.send("GET or HEAD data"))
    
    // Custom predicates
    .route(HttpRoute.builder()
           .methods(Method.GET)
           .path("/secure/*")
           .handler((req, res) -> {
               // Security check
               if (req.headers().contains("Authorization")) {
                   res.send("Authorized content");
               } else {
                   res.status(401).send("Unauthorized");
               }
           }))
    
    .build();

HttpRouting routing = HttpRouting.builder()
    .maxReRouteCount(3) // Prevent infinite re-routing
    
    .get("/redirect", (req, res) -> {
        res.reroute("/target"); // Internal redirect
    })
    
    .get("/target", (req, res) -> {
        res.send("Final destination");
    })
    
    // Global error handlers
    .error(IllegalArgumentException.class, 
           (req, res, ex) -> res.status(400).send("Bad request: " + ex.getMessage()))
    .error(Exception.class,
           (req, res, ex) -> res.status(500).send("Internal server error"))
    
    .build();