catacumba.http — updcon/catacumba 2.2.2

accepted clj

(accepted body)

(accepted body headers)

HTTP 202 Accepted Must be used to indicate successful start of an asynchronous action.

A 202 response indicates that the client's request will be handled asynchronously. This response status code tells the client that the request appears valid, but it still may have problems once it's finally processed. A 202 response is typically used for actions that take a long while to process.

bad-request clj

(bad-request body)

(bad-request body headers)

HTTP 400 Bad Request May be used to indicate nonspecific failure.

400 is the generic client-side error status, used when no other 4xx error code is appropriate.

conflict clj

(conflict body)

(conflict body headers)

continue clj

(continue body)

(continue body headers)

created clj

(created location)

(created location body)

(created location body headers)

HTTP 201 Created Must be used to indicate successful resource creation.

A REST API responds with the 201 status code whenever a collection creates, or a store adds, a new resource at the client's request. There may also be times when a new resource is created as a result of some controller action, in which case 201 would also be an appropriate response.

forbidden clj

(forbidden body)

(forbidden body headers)

HTTP 403 Forbidden Should be used to forbid access regardless of authorization state.

A 403 error response indicates that the client's request is formed correctly, but the REST API refuses to honor it. A 403 response is not a case of insufficient client credentials; that would be 401 ("Unauthorized"). REST APIs use 403 to enforce application-level permissions. For example, a client may be authorized to interact with some, but not all of a REST API's resources. If the client attempts a resource interaction that is outside of its permitted scope, the REST API should respond with 403.

found clj

(found location)

(found location body)

(found location body headers)

HTTP 302 Found Should not be used.

The intended semantics of the 302 response code have been misunderstood by programmers and incorrectly implemented in programs since version 1.0 of the HTTP protocol. The confusion centers on whether it is appropriate for a client to always automatically issue a follow-up GET request to the URI in response's Location header, regardless of the original request's method. For the record, the intent of 302 is that this automatic redirect behavior only applies if the client's original request used either the GET or HEAD method.

To clear things up, HTTP 1.1 introduced status codes 303 ("See Other") and 307 ("Temporary Redirect"), either of which should be used instead of 302.

gone clj

(gone body)

(gone body headers)

internal-server-error clj

(internal-server-error body)

(internal-server-error body headers)

method-not-allowed clj

(method-not-allowed body)

(method-not-allowed body headers)

moved-permanently clj

(moved-permanently location)

(moved-permanently location body)

(moved-permanently location body headers)

301 Moved Permanently Should be used to relocate resources.

The 301 status code indicates that the REST API's resource model has been significantly redesigned and a new permanent URI has been assigned to the client's requested resource. The REST API should specify the new URI in the response's Location header.

no-content clj

(no-content)

(no-content headers)

HTTP 204 No Content Should be used when the response body is intentionally empty.

The 204 status code is usually sent out in response to a PUT, POST, or DELETE request, when the REST API declines to send back any status message or representation in the response message's body. An API may also send 204 in conjunction with a GET request to indicate that the requested resource exists, but has no state representation to include in the body.

not-acceptable clj

(not-acceptable body)

(not-acceptable body headers)

not-found clj

(not-found body)

(not-found body headers)

HTTP 404 Not Found Must be used when a client's URI cannot be mapped to a resource.

The 404 error status code indicates that the REST API can't map the client's URI to a resource.

not-implemented clj

(not-implemented body)

(not-implemented body headers)

ok clj

(ok body)

(ok body headers)

HTTP 200 OK Should be used to indicate nonspecific success. Must not be used to communicate errors in the response body.

In most cases, 200 is the code the client hopes to see. It indicates that the REST API successfully carried out whatever action the client requested, and that no more specific code in the 2xx series is appropriate. Unlike the 204 status code, a 200 response should include a response body.

precondition-failed clj

(precondition-failed body)

(precondition-failed body headers)

response clj

(response body)

(response body status)

(response body status headers)

Create a response instance.

response? clj

(response? v)

Check if the provided value is an instance of Response.

see-other clj

(see-other location)

(see-other location body)

(see-other location body headers)

HTTP 303 See Other Should be used to refer the client to a different URI.

A 303 response indicates that a controller resource has finished its work, but instead of sending a potentially unwanted response body, it sends the client the URI of a response resource. This can be the URI of a temporary status message, or the URI to some already existing, more permanent, resource. Generally speaking, the 303 status code allows a REST API to send a reference to a resource without forcing the client to download its state. Instead, the client may send a GET request to the value of the Location header.

temporary-redirect clj

(temporary-redirect location)

(temporary-redirect location body)

(temporary-redirect location body headers)

HTTP 307 Temporary Redirect Should be used to tell clients to resubmit the request to another URI.

HTTP/1.1 introduced the 307 status code to reiterate the originally intended semantics of the 302 ("Found") status code. A 307 response indicates that the REST API is not going to process the client's request. Instead, the client should resubmit the request to the URI specified by the response message's Location header.

A REST API can use this status code to assign a temporary URI to the client's requested resource. For example, a 307 response can be used to shift a client request over to another host.

too-many-requests clj

(too-many-requests body)

(too-many-requests body headers)

unauthorized clj

(unauthorized body)

(unauthorized body headers)

HTTP 401 Unauthorized Must be used when there is a problem with the client credentials.

A 401 error response indicates that the client tried to operate on a protected resource without providing the proper authorization. It may have provided the wrong credentials or none at all.

unsupported-mediatype clj

(unsupported-mediatype body)

(unsupported-mediatype body headers)