Unique Email Addresses

Handling Constraint Errors

If we take a look at RegisterAsync() method, it had been hardcoded to throw a new ValidationException if the email address is anything other than graphacademy@neo4j.com.

public async Task<Dictionary<string, object>> RegisterAsync(string email, string plainPassword, string name)
{
    var rounds = Config.UnpackPasswordConfig();
    var encrypted = BCryptNet.HashPassword(plainPassword, rounds);
    // TODO: Handle Unique constraints in the database
    if (email != "graphacademy@neo4j.com")
        throw new ValidationException($"An account already exists with the email address", email);
    
    // TODO: Save user
    var exampleUser = new Dictionary<string, object>
    {
        ["identity"] = 1,
        ["properties"] = new Dictionary<string, object>
        {
            ["userId"] = 1,
            ["email"] = "graphacademy@neo4j.com",
            ["name"] = "Graph Academy"
        }
    };

    var safeProperties = SafeProperties(exampleUser["properties"] as Dictionary<string, object>);
    safeProperties.Add("token", JwtHelper.CreateToken(GetUserClaims(safeProperties)));

    return safeProperties;
}

The code we added had no explicit error handling.

Any errors will be sent back up the stack and will result in a 500 Bad Request error.

Instead, this error should be caught and reformatted in such a way that the server would return a 422 Unprocessable Entity error. This way, the error can be better handled by the UI.

To do this, you will need to rearrange the code into try/catch blocks.

If we take a look at a generic try/catch, it can be broken down into three parts; try, catch, and an optional finally.

try (/* allocate resources */) {
  // Attempt the code inside the block
}
catch (Exception e) {
  // If anything goes wrong in the try block,
  // deal with the error here
}
finally {
  // Run this statement regardless of whether an error
  // is thrown or not
}

When a user tries to register with an email address that has already been taken, the database will throw an Neo.ClientError.Schema.ConstraintViolation error.

Instead of this being treated as an internal server error, it should instead be treated as a 422 Unprocessable Entity. This will allow the front end to render an appropriate error page.

Completing the Challenge

To complete this challenge, you will first create a new constraint in your Sandbox database and modify the code to add a try/catch block

CREATE CONSTRAINT UserEmailUnique
IF NOT EXISTS
FOR (user:User)
REQUIRE user.email IS UNIQUE;

try
{
    await using var session = _driver.AsyncSession();

    var user = await session.ExecuteWriteAsync(async tx =>
    {
        var query = @"
        CREATE (u:User {
            userId: randomUuid(),
            email: $email,
            password: $encrypted,
            name: $name
        })
        RETURN u { .userId, .name, .email } as u";
        var cursor = await tx.RunAsync(query, new {email, encrypted, name});

        var record = await cursor.SingleAsync();
        // Extract safe properties from the user node (`u`) in the first row
        return record["u"].As<Dictionary<string, object>>();
    });
   
    var safeProperties = SafeProperties(user);
    safeProperties.Add("token", JwtHelper.CreateToken(GetUserClaims(safeProperties)));

    return safeProperties;
}
catch (ClientException exception) when (exception.Code == "Neo.ClientError.Schema.ConstraintValidationFailed")
{
    throw new ValidationException(exception.Message, email);
}

Working Solution

public async Task<Dictionary<string, object>> RegisterAsync(string email, string plainPassword, string name)
{
    var rounds = Config.UnpackPasswordConfig();
    var encrypted = BCryptNet.HashPassword(plainPassword, rounds);

    try
    {
        await using var session = _driver.AsyncSession();

        var user = await session.ExecuteWriteAsync(async tx =>
        {
            var query = @"
            CREATE (u:User {
                userId: randomUuid(),
                email: $email,
                password: $encrypted,
                name: $name
            })
            RETURN u { .userId, .name, .email } as u";
            var cursor = await tx.RunAsync(query, new {email, encrypted, name});

            var record = await cursor.SingleAsync();
            // Extract safe properties from the user node (`u`) in the first row
            return record["u"].As<Dictionary<string, object>>();
        });
       
        var safeProperties = SafeProperties(user);
        safeProperties.Add("token", JwtHelper.CreateToken(GetUserClaims(safeProperties)));

        return safeProperties;
    }
    catch (ClientException exception) when (exception.Code == "Neo.ClientError.Schema.ConstraintValidationFailed")
    {
        throw new ValidationException(exception.Message, email);
    }
}

Testing

To test that this functionality has been correctly implemented, run the following code in a new terminal session:

dotnet test --logger "console;verbosity=detailed" --filter "Neoflix.Challenges._04_HandleConstraintErrors"

The test file is located at Neoflix.Challenges/04_HandleConstraintErrors.cs.

git checkout 04-handling-constraint-errors