Getting a start on prototyping #347. Generally I think all the datastore functions should return a datastore error, and then it's the responsibility of the nexus wrapper (probably, could also be the endpoint) to convert it to an external error. UpdateResult is trivial to convert because there's only one query in all three examples, so I started with that.

The insight that I'm rolling with here is that if public_error_from_diesel_pool is what we call with errors everywhere, then roughly speaking the datastore error struct just needs to represent the args to public_error_from_diesel_pool:

pub struct DSError {
    error: PoolError,
    resource_type: ResourceType,
    lookup_type: LookupType,
}

And then we can make public_error_from_diesel_pool the From that converts a DSError to an external error.

impl From<DSError> for Error {
    fn from(e: DSError) -> Self {
        public_error_from_diesel_pool(e.error, e.resource_type, e.lookup_type)
    }
}

Unfortunately it's not quite that simple, because there's also public_error_from_diesel_pool_create for create errors, which would be ok, but there are methods that might return both kinds of error, for example project create: it gives a normal error if it can't find the org, but a create error if it can't create the project.

So if there's a single common datastore Error type, it probably has to be an enum of both create and non-create error info.