Calling the catalog

catalog := httpclient.DefaultSettings()
catalog.BaseURL = r.Get(env("CATALOG_URL").Parse(url.Parse).Validate(checkCatalogURL))
catalog.TLS = &tls.Config{
	RootCAs: r.Get(file("CATALOG_CA_FILE").Parse(certPool)),
	GetClientCertificate: r.Get(env("CATALOG_CLIENT_CERT_FILE").Validate(holdsCertificate(s.Host.FS)).FlatMap(func(certFile string) config.Value[clientCertificate] {
		return env("CATALOG_CLIENT_KEY_FILE").Parse(func(keyFile string) (clientCertificate, error) {
			cfg, err := certfile.Config(s.Host.FS, certFile, keyFile)
			if err != nil {
				return nil, err
			}
			return cfg.GetClientCertificate, nil
		})
	})),
}
catalog.Timeout = r.Get(env("CATALOG_TIMEOUT").Parse(time.ParseDuration).Default(catalog.Timeout).Validate(httpclient.CheckTimeout))
catalog.AttemptTimeout = r.Get(env("CATALOG_ATTEMPT_TIMEOUT").Parse(time.ParseDuration).Default(catalog.AttemptTimeout).Validate(httpclient.CheckAttemptTimeout))
catalog.MaxAttempts = r.Get(env("CATALOG_MAX_ATTEMPTS").Parse(strconv.Atoi).Default(catalog.MaxAttempts).Validate(httpclient.CheckMaxAttempts))
catalog.ForwardScenario = true

type clientCertificate = func(*tls.CertificateRequestInfo) (*tls.Certificate, error)

func checkCatalogURL(u *url.URL) error {
	if err := httpclient.CheckBaseURL(u); err != nil {
		return err
	}
	if u.Scheme != "https" {
		return errors.New("must be an https URL")
	}
	return nil
}

func openCatalog(s *humus.Setup, settings httpclient.Settings) (endpoint.Catalog, func(context.Context) error, error) {
	client, err := httpclient.NewClient(s, settings)
	if err != nil {
		return nil, nil, err
	}
	return catalogclient.New(client, settings.BaseURL), readiness(client, settings.BaseURL.JoinPath("health", "readiness")), nil
}

type Client struct {
	http *http.Client
	base *url.URL
}

func New(client *http.Client, baseURL *url.URL) *Client {
	return &Client{http: client, base: baseURL}
}

type product struct {
	UnitPrice *float64 `json:"unitPrice"`
}

const maxBody = 64 << 10

func (c *Client) Price(ctx context.Context, productID string) (float64, error) {
	u := c.base.JoinPath("products")
	u.RawPath = u.EscapedPath() + "/" + url.PathEscape(productID)
	u.Path += "/" + productID

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
	if err != nil {
		return 0, fmt.Errorf("getting product %s: %w", productID, err)
	}
	req.Header.Set("Accept", "application/json")
	resp, err := c.http.Do(req)
	if err != nil {
		return 0, fmt.Errorf("getting product %s: %w: %w", productID, endpoint.ErrCatalogUnavailable, err)
	}
	defer func() {
		_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, maxBody))
		_ = resp.Body.Close()
	}()

switch resp.StatusCode {
case http.StatusOK:
case http.StatusNotFound:
	return 0, fmt.Errorf("getting product %s: %w", productID, endpoint.ErrProductNotFound)
case http.StatusBadGateway, http.StatusServiceUnavailable, http.StatusGatewayTimeout:
	return 0, fmt.Errorf("getting product %s: %w: the catalog answered %d", productID, endpoint.ErrCatalogUnavailable, resp.StatusCode)
default:
	return 0, fmt.Errorf("getting product %s: the catalog answered %d", productID, resp.StatusCode)
}

var p product
if err := json.NewDecoder(io.LimitReader(resp.Body, maxBody)).Decode(&p); err != nil {
	return 0, fmt.Errorf("getting product %s: decoding the catalog's answer: %w", productID, err)
}
switch {
case p.UnitPrice == nil:
	return 0, fmt.Errorf("getting product %s: the catalog answered with no unitPrice", productID)
case *p.UnitPrice < 0:
	return 0, fmt.Errorf("getting product %s: the catalog answered with a negative unitPrice", productID)
}
return *p.UnitPrice, nil

case errors.Is(err, ErrCatalogUnavailable) && errors.Is(err, circuit.ErrRejected):
	return unavailable("The cart isn't calling the catalog right now, since it has been failing. Try again later.")
case errors.Is(err, ErrCatalogUnavailable):
	return unavailable("The cart can't reach the catalog right now. Try again later.")

func readiness(client *http.Client, u *url.URL) func(context.Context) error {
	return func(ctx context.Context) error {
		req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
		if err != nil {
			return err
		}
		resp, err := client.Do(req)
		if err != nil {
			return err
		}
		defer func() {
			_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, maxBodyBytes))
			_ = resp.Body.Close()
		}()
		if resp.StatusCode != http.StatusOK {
			return fmt.Errorf("the catalog's readiness answered %d", resp.StatusCode)
		}
		return nil
	}
}