server_auth_endpoints.hpp

Go to the documentation of this file.

// Copyright (c) 2025 [caomengxuan666]
 
#pragma once
 
#include <chrono>
#include <functional>
#include <optional>
#include <string>
#include <vector>
 
#include "cxxmcp/auth/metadata.hpp"
#include "cxxmcp/auth/registration.hpp"
#include "cxxmcp/auth/token.hpp"
#include "cxxmcp/auth/types.hpp"
#include "cxxmcp/core/result.hpp"
 
 
namespace mcp::auth {
 
struct AuthorizationRequestParams {
  std::string response_type;
  std::string client_id;
  std::string redirect_uri;
  std::string state;
  std::optional<std::string> scope;
  std::optional<std::string> code_challenge;
  std::optional<std::string> code_challenge_method;
  std::optional<std::string> resource;
  std::optional<std::string> nonce;
};
 
struct AuthorizationDecision {
  std::string authorization_code;
  std::string state;
  std::string redirect_uri;
};
 
class AuthorizationEndpointHandler {
 public:
  virtual ~AuthorizationEndpointHandler() = default;
 
  virtual core::Result<AuthorizationDecision> authorize(
      const AuthorizationRequestParams& params) = 0;
};
 
struct TokenRequestParams {
  std::string grant_type;
  std::optional<std::string> code;
  std::optional<std::string> redirect_uri;
  std::optional<std::string> client_id;
  std::optional<std::string> client_secret;
  std::optional<std::string> code_verifier;
  std::optional<std::string> refresh_token;
  std::optional<std::string> scope;
  std::optional<std::string> resource;
};
 
class TokenEndpointHandler {
 public:
  virtual ~TokenEndpointHandler() = default;
 
  virtual core::Result<TokenSet> issue_token(
      const TokenRequestParams& params) = 0;
};
 
class ClientRegistrationEndpointHandler {
 public:
  virtual ~ClientRegistrationEndpointHandler() = default;
 
  virtual core::Result<ClientRegistrationResponse> register_client(
      const ClientRegistrationRequest& request) = 0;
};
 
struct TokenRevocationParams {
  std::string token;
  std::optional<std::string> token_type_hint;
  std::optional<std::string> client_id;
  std::optional<std::string> client_secret;
};
 
class TokenRevocationEndpointHandler {
 public:
  virtual ~TokenRevocationEndpointHandler() = default;
 
  virtual core::Result<core::Unit> revoke_token(
      const TokenRevocationParams& params) = 0;
};
 
struct TokenEndpointResponse {
  std::string access_token;
  std::string token_type = "Bearer";
  std::optional<std::string> refresh_token;
  std::optional<std::chrono::seconds> expires_in;
  std::optional<std::string> scope;
  MetadataMap metadata;
};
 
using AuthorizationEndpointCallback =
    std::function<core::Result<AuthorizationDecision>(
        const AuthorizationRequestParams&)>;
 
using TokenEndpointCallback = std::function<core::Result<TokenEndpointResponse>(
    const TokenRequestParams&)>;
 
using ClientRegistrationEndpointCallback =
    std::function<core::Result<ClientRegistrationResponse>(
        const ClientRegistrationRequest&)>;
 
using TokenRevocationEndpointCallback =
    std::function<core::Result<core::Unit>(const TokenRevocationParams&)>;
 
struct AuthorizationServerConfig {
  std::string issuer;
  std::string authorize_path = "/authorize";
  std::string token_path = "/token";
  std::string registration_path = "/register";
  std::string revocation_path = "/revoke";
  ScopeList scopes_supported;
  StringList grant_types_supported = {"authorization_code", "refresh_token"};
  StringList response_types_supported = {"code"};
  StringList code_challenge_methods_supported = {"S256"};
  StringList token_endpoint_auth_methods_supported = {"none"};
  std::optional<std::string> jwks_uri;
  std::optional<std::string> service_documentation;
  AuthorizationEndpointCallback authorization_handler;
  TokenEndpointCallback token_handler;
  ClientRegistrationEndpointCallback registration_handler;
  TokenRevocationEndpointCallback revocation_handler;
  MetadataMap metadata;
};
 
}  // namespace mcp::auth