navidrome/server/apiv1/api_gen.go

// Package apiv1 provides primitives to interact with the openapi HTTP API.
//
// Code generated by github.com/oapi-codegen/oapi-codegen/v2 version v2.8.0 DO NOT EDIT.
package apiv1

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/go-chi/chi/v5"
)

// Defines values for ProblemCode.
const (
	ProblemCodeForbidden                 ProblemCode = "forbidden"
	ProblemCodeInsufficientScope         ProblemCode = "insufficient_scope"
	ProblemCodeInternal                  ProblemCode = "internal"
	ProblemCodeMethodNotAllowed          ProblemCode = "method_not_allowed"
	ProblemCodeNotFound                  ProblemCode = "not_found"
	ProblemCodePasswordManagedExternally ProblemCode = "password_managed_externally"
	ProblemCodePayloadTooLarge           ProblemCode = "payload_too_large"
	ProblemCodeRateLimited               ProblemCode = "rate_limited"
	ProblemCodeSetupComplete             ProblemCode = "setup_complete"
	ProblemCodeTokenExpired              ProblemCode = "token_expired"
	ProblemCodeUnauthorized              ProblemCode = "unauthorized"
	ProblemCodeUnavailable               ProblemCode = "unavailable"
	ProblemCodeValidation                ProblemCode = "validation"
)

// Valid indicates whether the value is a known member of the ProblemCode enum.
func (e ProblemCode) Valid() bool {
	switch e {
	case ProblemCodeForbidden:
		return true
	case ProblemCodeInsufficientScope:
		return true
	case ProblemCodeInternal:
		return true
	case ProblemCodeMethodNotAllowed:
		return true
	case ProblemCodeNotFound:
		return true
	case ProblemCodePasswordManagedExternally:
		return true
	case ProblemCodePayloadTooLarge:
		return true
	case ProblemCodeRateLimited:
		return true
	case ProblemCodeSetupComplete:
		return true
	case ProblemCodeTokenExpired:
		return true
	case ProblemCodeUnauthorized:
		return true
	case ProblemCodeUnavailable:
		return true
	case ProblemCodeValidation:
		return true
	default:
		return false
	}
}

// Defines values for ServerInfoLoginMethods.
const (
	ServerInfoLoginMethodsPassword ServerInfoLoginMethods = "password"
)

// Valid indicates whether the value is a known member of the ServerInfoLoginMethods enum.
func (e ServerInfoLoginMethods) Valid() bool {
	switch e {
	case ServerInfoLoginMethodsPassword:
		return true
	default:
		return false
	}
}

// Problem RFC 9457 problem details, returned for every 4xx and 5xx response.
type Problem struct {
	// Code Machine-readable error code, and the value clients switch on. New codes may be added.
	Code ProblemCode `json:"code"`

	// Detail Human-readable explanation specific to this occurrence. Omitted for internal errors.
	Detail *string `json:"detail,omitempty"`

	// Errors Per-field failures. Present only when `code` is `validation`.
	Errors *[]ValidationError `json:"errors,omitempty"`

	// ReferenceId Present on internal errors. Quote it when reporting a problem; it tags the server's log lines for this request.
	ReferenceId *string `json:"referenceId,omitempty"`

	// Status HTTP status code of this response.
	Status int `json:"status"`

	// Title Short human-readable summary, the same for all occurrences of this problem type.
	Title string `json:"title"`

	// Type URI reference identifying the problem type. Omitted while the problem carries no semantics
	// beyond its HTTP status code, which RFC 9457 defines as `about:blank`. Problems with their
	// own semantics get their own URI; switch on `code` instead.
	Type *string `json:"type,omitempty"`
}

// ProblemCode Machine-readable error code, and the value clients switch on. New codes may be added.
type ProblemCode string

// ServerInfo Public server description. Everything an add-server screen needs before login.
type ServerInfo struct {
	// LoginMethods Login methods this server accepts. New methods may be added; clients ignore values they do not recognise.
	LoginMethods []ServerInfoLoginMethods `json:"loginMethods"`

	// Name Human-readable server product name.
	Name string `json:"name"`

	// ServerVersion Version of the running server build.
	ServerVersion string `json:"serverVersion"`

	// SetupRequired True until the first admin user has been created.
	SetupRequired bool `json:"setupRequired"`

	// SpecVersion Version of the OpenAPI document this server implements.
	SpecVersion string `json:"specVersion"`
}

// ServerInfoLoginMethods defines model for ServerInfo.LoginMethods.
type ServerInfoLoginMethods string

// ValidationError One field-level validation failure.
type ValidationError struct {
	// Field Name of the offending query parameter, path parameter, or body field (dotted for nested).
	Field string `json:"field"`

	// Message Why the value was rejected.
	Message string `json:"message"`
}

// InternalError RFC 9457 problem details, returned for every 4xx and 5xx response.
type InternalError = Problem

// ServerInterface represents all server handlers.
type ServerInterface interface {
	// GetServerInfo Describe the server
	// (GET /server)
	GetServerInfo(w http.ResponseWriter, r *http.Request)
}

// Unimplemented server implementation that returns http.StatusNotImplemented for each endpoint.

type Unimplemented struct{}

// GetServerInfo Describe the server
// (GET /server)
func (_ Unimplemented) GetServerInfo(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotImplemented)
}

// ServerInterfaceWrapper converts contexts to parameters.
type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type MiddlewareFunc func(http.Handler) http.Handler

// GetServerInfo operation middleware
func (siw *ServerInterfaceWrapper) GetServerInfo(w http.ResponseWriter, r *http.Request) {

	handler := http.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		siw.Handler.GetServerInfo(w, r)
	}))

	for _, middleware := range siw.HandlerMiddlewares {
		handler = middleware(handler)
	}

	handler.ServeHTTP(w, r)
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

func (e *UnescapedCookieParamError) Error() string {
	return fmt.Sprintf("error unescaping cookie parameter '%s'", e.ParamName)
}

func (e *UnescapedCookieParamError) Unwrap() error {
	return e.Err
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

func (e *UnmarshalingParamError) Error() string {
	return fmt.Sprintf("Error unmarshaling parameter %s as JSON: %s", e.ParamName, e.Err.Error())
}

func (e *UnmarshalingParamError) Unwrap() error {
	return e.Err
}

type RequiredParamError struct {
	ParamName string
}

func (e *RequiredParamError) Error() string {
	return fmt.Sprintf("Query argument %s is required, but not found", e.ParamName)
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

func (e *RequiredHeaderError) Error() string {
	return fmt.Sprintf("Header parameter %s is required, but not found", e.ParamName)
}

func (e *RequiredHeaderError) Unwrap() error {
	return e.Err
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

func (e *InvalidParamFormatError) Error() string {
	return fmt.Sprintf("Invalid format for parameter %s: %s", e.ParamName, e.Err.Error())
}

func (e *InvalidParamFormatError) Unwrap() error {
	return e.Err
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

func (e *TooManyValuesForParamError) Error() string {
	return fmt.Sprintf("Expected one value for %s, got %d", e.ParamName, e.Count)
}

// Handler creates http.Handler with routing matching OpenAPI spec.
func Handler(si ServerInterface) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{})
}

type ChiServerOptions struct {
	BaseURL          string
	BaseRouter       chi.Router
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

// HandlerFromMux creates http.Handler with routing matching OpenAPI spec based on the provided mux.
func HandlerFromMux(si ServerInterface, r chi.Router) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{
		BaseRouter: r,
	})
}

func HandlerFromMuxWithBaseURL(si ServerInterface, r chi.Router, baseURL string) http.Handler {
	return HandlerWithOptions(si, ChiServerOptions{
		BaseURL:    baseURL,
		BaseRouter: r,
	})
}

// HandlerWithOptions creates http.Handler with additional options
func HandlerWithOptions(si ServerInterface, options ChiServerOptions) http.Handler {
	r := options.BaseRouter

	if r == nil {
		r = chi.NewRouter()
	}
	if options.ErrorHandlerFunc == nil {
		options.ErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}
	wrapper := ServerInterfaceWrapper{
		Handler:            si,
		HandlerMiddlewares: options.Middlewares,
		ErrorHandlerFunc:   options.ErrorHandlerFunc,
	}

	r.Group(func(r chi.Router) {
		r.Get(options.BaseURL+"/server", wrapper.GetServerInfo)
	})

	return r
}

type InternalErrorApplicationProblemPlusJSONResponse Problem

type GetServerInfoRequestObject struct {
}

type GetServerInfoResponseObject interface {
	VisitGetServerInfoResponse(w http.ResponseWriter) error
}

type GetServerInfo200JSONResponse ServerInfo

func (response GetServerInfo200JSONResponse) VisitGetServerInfoResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	_, err := buf.WriteTo(w)
	return err
}

type GetServerInfo500ApplicationProblemPlusJSONResponse struct {
	InternalErrorApplicationProblemPlusJSONResponse
}

func (response GetServerInfo500ApplicationProblemPlusJSONResponse) VisitGetServerInfoResponse(w http.ResponseWriter) error {

	var buf bytes.Buffer
	if err := json.NewEncoder(&buf).Encode(response); err != nil {
		return err
	}
	w.Header().Set("Content-Type", "application/problem+json")
	w.WriteHeader(500)
	_, err := buf.WriteTo(w)
	return err
}

// StrictServerInterface represents all server handlers.
type StrictServerInterface interface {
	// GetServerInfo Describe the server
	// (GET /server)
	GetServerInfo(ctx context.Context, request GetServerInfoRequestObject) (GetServerInfoResponseObject, error)
}

type StrictHandlerFunc func(ctx context.Context, w http.ResponseWriter, r *http.Request, request any) (any, error)
type StrictMiddlewareFunc func(f StrictHandlerFunc, operationID string) StrictHandlerFunc

type StrictHTTPServerOptions struct {
	RequestErrorHandlerFunc  func(w http.ResponseWriter, r *http.Request, err error)
	ResponseErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

func NewStrictHandler(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc) ServerInterface {
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: StrictHTTPServerOptions{
		RequestErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		},
		ResponseErrorHandlerFunc: func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		},
	}}
}

func NewStrictHandlerWithOptions(ssi StrictServerInterface, middlewares []StrictMiddlewareFunc, options StrictHTTPServerOptions) ServerInterface {
	if options.RequestErrorHandlerFunc == nil {
		options.RequestErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusBadRequest)
		}
	}
	if options.ResponseErrorHandlerFunc == nil {
		options.ResponseErrorHandlerFunc = func(w http.ResponseWriter, r *http.Request, err error) {
			http.Error(w, err.Error(), http.StatusInternalServerError)
		}
	}
	return &strictHandler{ssi: ssi, middlewares: middlewares, options: options}
}

type strictHandler struct {
	ssi         StrictServerInterface
	middlewares []StrictMiddlewareFunc
	options     StrictHTTPServerOptions
}

// GetServerInfo operation middleware
func (sh *strictHandler) GetServerInfo(w http.ResponseWriter, r *http.Request) {
	var request GetServerInfoRequestObject

	handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, request interface{}) (interface{}, error) {
		return sh.ssi.GetServerInfo(ctx, request.(GetServerInfoRequestObject))
	}
	for _, middleware := range sh.middlewares {
		handler = middleware(handler, "GetServerInfo")
	}

	response, err := handler(r.Context(), w, r, request)

	if err != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, err)
	} else if validResponse, ok := response.(GetServerInfoResponseObject); ok {
		if err := validResponse.VisitGetServerInfoResponse(w); err != nil {
			sh.options.ResponseErrorHandlerFunc(w, r, err)
		}
	} else if response != nil {
		sh.options.ResponseErrorHandlerFunc(w, r, fmt.Errorf("unexpected response type: %T", response))
	}
}