Creating and validating ValueObjects

[speterson-zoll]

I've figured out a few simple validations, but when I tried to use newly created custom immutable types with another class, things went off track. Here is my attempt at an immutable ValueObject using NewType:

public sealed class AlertDefinition : NewType<AlertDefinition, AlertDefinitionType>
{
    private AlertDefinition(AlertDefinitionType value) : base(value)
    {
    }

    public static Validation<Error, AlertDefinition> Create(AlertDefinitionType alertDefinitionType) =>
        (AllAlertDefinitionTypeValidator(alertDefinitionType))
            .Map(adt => new AlertDefinition(adt));
}

And the validator is:

public static Validation<Error, AlertDefinitionType> AllAlertDefinitionTypeValidator(AlertDefinitionType alertDefinitionType) =>
        Enum.IsDefined(typeof(AlertDefinitionType), alertDefinitionType)
            ? Success<Error, AlertDefinitionType>(alertDefinitionType)
            : Fail<Error, AlertDefinitionType>(Error.New($"The value {alertDefinitionType} is not a valid {nameof(AlertDefinitionType)}"));

Where AlertDefinitionType is a standard Enum with int values.

This works fine on its own. However, I have a class that makes use of the AlertDefinition class:

public class DiscreteAlert : PatientAlert
{
    public Option<MyEvent> { get; }
    public Option<DateTime> MyEventDateTime { get; }

    private DiscreteAlert(**AlertDefinition alertDefinition**, AlertLevel alertLevel, MyEvent myEvent, Option<DateTime> myEventDateTime)
    {
        **AlertDefinition = alertDefinition**;
        AlertLevel = alertLevel;
        MyEvent = myEvent;
        MyEventDateTime = myEventDateTime;
    }

    public static Validation<Error, DiscreteAlert> Create(**AlertDefinition alertDefinition**, AlertLevel alertLevel, MyEvent myEvent, Option<DateTime> myEventDateTime) =>
         new DiscreteAlert(**alertDefinition**, alertLevel, myEvent, myEventDateTime);
}

public abstract class PatientAlert
{
    public Option<AlertDefinition> AlertDefinition{ get; set; }
    public Option<AlertLevel> AlertLevel { get; set; }
}

The AlertLevel and field is similar to the AlertDefinition field in that it is a custom type with its own validation.

I am using a method in a DTO, so that if the incoming DTO data is valid, I can successfully create a valid DiscreteAlert object:

public sealed class DiscreteAlertDto : PatientAlertDto
{
    public Option<string> MyEventId { get; set; }
    public Option<string> MyEventDateTime { get; set; }

    public Validation<Error, DiscreteAlert> Validate()
    {
        var alertDefinition =
            ParseAlertDefinitionTypeId(AlertDefinitionTypeId)
                .Bind(AllAlertDefinitionTypeValidator)
                 .Match(
                    Succ: ad => AlertDefinition.Create(ad),
                    Fail: errors => Error.New(errors.ToFullString()));

        var alertLevel = ParseAlertLevelId(AlertLevelTypeId)
            .Bind(AlertLevelIdValidator)
            .Match(
                Succ: al => AlertLevel.Create(al),
                Fail: errors => Error.New(errors.ToFullString()));

        var myEvent = StringCannotBeNullOrEmpty(MyEventId, nameof(MyEventId))
            .Match(
                Succ: event => MyEvent.Create(event),
                Fail: errors => Error.New(errors.ToFullString()));

        var myEventDate = ParseNullableDateTime(MyEventDateTime);

        return (Validation<Error, DiscreteAlert>)(alertDefinition, alertLevel, myEvent, myEventDate)
            .Apply((adt, al, ev, ed) =>
                DiscreteAlert.Create(adt, al, ev, ed));
    }

    private static Validation<Error, DateTime> ParseNullableDateTime(string? dateTime) =>
        new(notnull(dateTime)
            ? parseDateTime(dateTime).ToValidation(Error.New($"{dateTime} is not a valid Date"))
            : null);

    private static Validation<Error, AlertLevelType> ParseAlertLevelId(Option<string> alertLevelId) =>
        alertLevelId.Match(
            Some: alt => parseEnum<AlertLevelType>(alt)
                .ToValidation(Error.New($"The value {alt} is not valid for an {nameof(AlertLevelType)}")),
            None: () => Error.New($"The {nameof(AlertLevelType)} input cannot be null"));
}

public abstract class PatientAlertDto
{
    public Option<string> AlertDefinitionTypeId { get; set; }
    public Option<string> AlertLevelTypeId { get; set; }
}

Note that the DiscreteAlert class Create method returns Validation<Error, DiscreteAlert>. I can create a DiscreteAlert with no problem as long as all the data is valid. However, when testing failures in a unit test (I purposely provide an invalid AlertDefinition value), I get an error: Validation is not in a Success state. This code segment in the Validate method:

var alertDefinition =
            ParseAlertDefinitionTypeId(AlertDefinitionTypeId)
                .Bind(AllAlertDefinitionTypeValidator)
                .Match(
                    Succ: ad => AlertDefinition.Create(ad),
                    Fail: errors => Error.New(errors.ToFullString()));

predictably is in a Fail state : Fail([Not a valid Discrete alert type]). However, when I hit the .Apply call:

return (Validation<Error, DiscreteAlert>)(alertDefinition, alertLevel, myEvent, myEventDate)
            .Apply((adt, al, ev, ed) =>
                DiscreteAlert.Create(adt, al, ev, ed));

I get the error mentioned above. I believe that this is happening because, while all the items in the Tuple in the .Apply have the same signature, there are Monads within that have different return types. When the .Apply method is then called, I get a message Validation is not in a Success state. When debugging, I see that the code:

 var alertDefinition =
            ParseAlertDefinitionTypeId(AlertDefinitionTypeId)
                .Bind(AllAlertDefinitionTypeValidator)
                 .Match(
                    Succ: ad => AlertDefinition.Create(ad),
                    Fail: errors => Error.New(errors.ToFullString()));

specifically, the value of alertDefinition is:

[0] = {ValidationData<Error, AlertDefinition>} ValidationData(Fail, null, [Not a valid Discrete alert type])
 Fail = {Lst<Error>} [Not a valid Discrete alert type]
 State = {Validation.StateType} Fail
 Success = {AlertDefinition} null

which is as expected since my test sends in an invalid value. As I said, running .Apply shows the error mentioned above.

One other note: I am casting the .Apply call with (Validation<Error, DiscreteAlert>) because I received an error in my IDE that Validation<Error. Validation<Error, DiscreteAlert>> cannot be converted to Validation<Error, DiscreteAlert>. I'm not certain how the return type Validation<Error. Validation<Error, DiscreteAlert>> came to be. My goal is to collect all the validation errors at the .Apply stage, but I think the ValueObject validation is causing an issue in the process.

I feel like I'm close to figuring this out, but need help. Any advice on how to accomplish this better is most welcome.

[louthy]

return (Validation<Error, DiscreteAlert>)(alertDefinition, alertLevel, myEvent, myEventDate)
            .Apply((adt, al, ev, ed) =>
                DiscreteAlert.Create(adt, al, ev, ed));

It looks like you've got a nested monad Validation<Error, Validation<DiscreetAlert>> because Apply will re-wrap the result of the lambda in a Validation, so if DiscreteAlert.Create returns a Validation then you'll have a nested result. This is evident from the cast you're doing to return (Validation<Error, DiscreteAlert>) . Casting assumes the value is in a Success state, and if not it will throw the error you've seen.

What you need to do is Flatten to result:

return (alertDefinition, alertLevel, myEvent, myEventDate)
            .Apply((adt, al, ev, ed) => DiscreteAlert.Create(adt, al, ev, ed))
            .Flatten();

This will follow the correct rules of the validation monad.