What should a rest api return for an empty guid?

Question

I have a .net api backend for mobile apps and the question came up (in conversation with the iOS develper) if a JSON response for an empty GUID should return:

• 00000000-0000-0000-0000-000000000000
• or null (by having the return type nullable Guid type (Guid?)

If the first one, the mobile developer needs to create a parse method for that and not use his regular generic null check function.

In C# you would just do

if (guid == Guid.Empty)

But the iOS developer talks about creating a parsing method (so not build in I guess).

But I can´t find any discussion on what is considered "best practice" or even how native apps are dealing with empty/null Guid's.

I know what I like to do but what do you think I should do?

Answer 1

An 'empty' guid is still a valid guid, so parsing it shouldn't require any extra logic.

The question is why are you using it at all? It seems like a mistake to me to assign special meaning to a particular guid, making it a magic number.

It's a bit like saying I'll return an int id, but if it's negative then it's an error code. Don't do it!

..The reason being that in every call to your function, the user will have to remember to check for a negative return value. If they forget, disaster occurs.

Similarly, if you assign guid.empty a special meaning, everyone who calls your API has to write a special check after every call.

It's better to return null (if appropriate) or throw an exception (via an HTTP error code, assuming a REST service).

Answer 2

I'm an iOS developer and I have no idea why your guy thinks he needs to create "a parsing method." UUID(uuidString: valueFromServer) is all he needs to do. He can create your magic UUID by simply:

extension UUID {
    static var zero: UUID { return UUID(uuidString: "00000000-0000-0000-0000-000000000000")! }
}

Then he can compare any GUID to this magic GUID.

That said, for all values that come from the server, the frontend developer must first check to see if the value is there, then check to see if it's well formed (of the right type.) If you are returning a magic value, then he must also check to see if the correctly typed value is magic. By including the magic value, you are forcing him to make an additional if check.

As a frontend developer, I have to ask: For what reason are you forcing me to increase the complexity of my app?

If you can make an argument that the frontend should treat a missing GUID differently than the magic GUID, then you have an argument for returning it. Otherwise you are adding unnecessary complexity to the frontend app.

---

(Addition in response to @RubberDuck's comment.)

Here's the thing. The JSON standard has one way of dealing with null values and the GUID standard has a different way of dealing with null values. Since you are sending a GUID through JSON, the latter is the overarching concern (because the GUID is being wrapped in JSON,) it is the standard you should conform to... Because even if you decide to send a null GUID by actually sending a GUID full of zeros, the frontend still has to check for the JSON null.

Don't force the front end to deal with two different concepts of null.

Answer 3

Do what you like (as far as MacOS and iOS are concerned).

The iOS or MacOS developer will write a parsing method that checks if your JSON data contains a string and turn it into a GUID object or somehow indicate failure. If you send a JSON null to indicate a non-existing guid they will also check whether the JSON data contains an NSNull() value. That's assuming the developer isn't totally incompetent. In addition, depending on their preference they will either use optional GUIDs and check for nil, or non-optional GUIDs and have a property that checks if a GUID is all zeroes. That's totally independent of what you do.

So seriously, you can do what you like (just keep it consistent). Any not totally incompetent developer will be just fine. "Creating a parsing method" is something that is done very easily. As mostly iOS developer, this isn't even worth discussing. Document what you are sending. I'll create a parsing method quicker than our discussion would take.

Answer 4

Since in .NET Guid is a value type it cannot be assigned the value null.

If we need to store nulls in value types the normal solution is to use Nullable or as a shorthand use the ? syntax like in Guid? int? long? etc.

This will also work with standard serializers so the value will be either missing or have the literal null value.