feat: use URNs as outputs

[cmdoret]

Context:

Uniform Resource Name (URNs) are URIs that use the urn scheme without any prefix.

Currently we hash the whole URI, and replace the fragment with the hash, retaining the original prefix. This poses 2 issues:

• we need to extract the prefix, which fails when urns are in the input
• sensitive data may be present in the prefix. This should be removed

Proposed solution

Using URNs (format: <urn:hash>) as output would provide a solution to both issues as the pseudonymized data would not have a namespace.

Objective: original domain is absent from pseudonymized URIs.

Requirements:

• Implement Hash for rdf types -> urn:
• (optional?) additional method to hash with optional domain

[cmdoret]

Possible formats:
urn:<hash>
urn:tripsu:<hash>
urn:uuid:<uuid>

[rmfranken]

I like urn:tripsu: but I want to see if there are best practices for crafting URN's. Maybe there is implicit meaning in the 'argument positions'. (like namespace:format in the case of urn:uuid or something). Don't want to accidentally introduce implicit meaning that we don't want.

[cmdoret]

This would be a good opportunity to implement Hash on the individual RDF types

[supermaxiste]

According to Wikipedia the syntax should go as follows:

urn:NID:NSS

Where NID is the Namespace IDentifier and formally it should be an officially registered one. uuid would be best in our case.

The Namespace Specific String (NSS) is not bound to any formal registered domain it's a sequence of letters, numbers and or special characters that:

may contain ASCII letters and digits, and many punctuation and special characters. Disallowed ASCII and Unicode characters may be included if percent-encoded.

When going more in depth into how UUIDs should be used, I found a specific guide about hashing. Here's the juice:

The requirements for name-based [note: meaning hashed] UUIDs are as follows:

1. UUIDs generated at different times from the same name (using the same canonical format) in the same namespace MUST be equal.
2. UUIDs generated from two different names (same or differing canonical format) in the same namespace should be different (with very high probability).
3. UUIDs generated from the same name (same or differing canonical format) in two different namespaces should be different (with very high probability).
4. If two UUIDs that were generated from names (using the same canonical format) are equal, then they were generated from the same name in the same namespace (with very high probability).

As far as I understand we do all of the points above.

TL;DR: we should use urn:uuid:<uuid>