hook.hpp

#pragma once
 
#include <launchdarkly/context.hpp>
#include <launchdarkly/data/evaluation_detail.hpp>
#include <launchdarkly/value.hpp>
 
#include <any>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace launchdarkly::server_side::hooks {
 
class HookContext {
   public:
    HookContext() = default;
 
    HookContext& Set(std::string key, std::shared_ptr<std::any> value);
 
    [[nodiscard]] std::optional<std::shared_ptr<std::any>> Get(
        std::string const& key) const;
 
    [[nodiscard]] bool Has(std::string const& key) const;
 
   private:
    std::map<std::string, std::shared_ptr<std::any>> data_;
};
 
class HookMetadata {
   public:
    explicit HookMetadata(std::string name);
 
    [[nodiscard]] std::string_view Name() const;
 
   private:
    std::string name_;
};
 
class EvaluationSeriesData {
   public:
    EvaluationSeriesData();
 
    [[nodiscard]] std::optional<std::reference_wrapper<Value const>> Get(std::string const& key) const;
 
    [[nodiscard]] std::optional<std::shared_ptr<std::any>> GetShared(
        std::string const& key) const;
 
    [[nodiscard]] bool Has(std::string const& key) const;
 
    [[nodiscard]] std::vector<std::string> Keys() const;
 
   private:
    friend class EvaluationSeriesDataBuilder;
 
    struct DataEntry {
        std::optional<Value> value;
        std::optional<std::shared_ptr<std::any>> shared;
    };
 
    explicit EvaluationSeriesData(std::map<std::string, DataEntry> data);
 
    std::map<std::string, DataEntry> data_;
};
 
class EvaluationSeriesDataBuilder {
   public:
    explicit EvaluationSeriesDataBuilder(EvaluationSeriesData const& data);
 
    EvaluationSeriesDataBuilder();
 
    EvaluationSeriesDataBuilder& Set(std::string key, Value value);
 
    EvaluationSeriesDataBuilder& SetShared(std::string key,
                                           std::shared_ptr<std::any> value);
 
    [[nodiscard]] EvaluationSeriesData Build() const;
 
   private:
    std::map<std::string, EvaluationSeriesData::DataEntry> data_;
};
 
class EvaluationSeriesContext {
   public:
    EvaluationSeriesContext(std::string flag_key,
                            Context const& context,
                            Value default_value,
                            std::string method,
                            HookContext const& hook_context,
                            std::optional<std::string> environment_id);
 
    [[nodiscard]] std::string_view FlagKey() const;
 
    [[nodiscard]] Context const& EvaluationContext() const;
 
    [[nodiscard]] Value const& DefaultValue() const;
 
    [[nodiscard]] std::string_view Method() const;
 
    [[nodiscard]] std::optional<std::string_view> EnvironmentId() const;
 
    [[nodiscard]] HookContext const& HookCtx() const;
 
   private:
    std::string flag_key_;
    Context const& context_;
    Value default_value_;
    std::string method_;
    HookContext const& hook_context_;
    std::optional<std::string> environment_id_;
};
 
class TrackSeriesContext {
   public:
    TrackSeriesContext(Context const& context,
                       std::string key,
                       std::optional<double> metric_value,
                       std::optional<std::reference_wrapper<Value const>> data,
                       HookContext const& hook_context,
                       std::optional<std::string> environment_id);
 
    [[nodiscard]] Context const& TrackContext() const;
 
    [[nodiscard]] std::string_view Key() const;
 
    [[nodiscard]] std::optional<double> MetricValue() const;
 
    [[nodiscard]] std::optional<std::reference_wrapper<Value const>> Data() const;
 
    [[nodiscard]] std::optional<std::string_view> EnvironmentId() const;
 
    [[nodiscard]] HookContext const& HookCtx() const;
 
   private:
    Context const& context_;
    std::string key_;
    std::optional<double> metric_value_;
    std::optional<std::reference_wrapper<Value const>> data_;
    HookContext const& hook_context_;
    std::optional<std::string> environment_id_;
};
 
class Hook {
   public:
    virtual ~Hook() = default;
 
    [[nodiscard]] virtual HookMetadata const& Metadata() const = 0;
 
    virtual EvaluationSeriesData BeforeEvaluation(
        EvaluationSeriesContext const& series_context,
        EvaluationSeriesData data);
 
    virtual EvaluationSeriesData AfterEvaluation(
        EvaluationSeriesContext const& series_context,
        EvaluationSeriesData data,
        EvaluationDetail<Value> const& detail);
 
    virtual void AfterTrack(TrackSeriesContext const& series_context);
 
   protected:
    Hook() = default;
};
 
}  // namespace launchdarkly::server_side::hooks