JsonEntitiesFromSchemasTestApi

Extension methods for Endpoint.

Extension methods for values of type F[A] for which there is an implicit InvariantFunctor[F] instance.

Documentation related methods for annotating schemas. Encoder and decoder interpreters ignore this information.

Implicit methods for values of type JsonSchema

Convenient methods for Paths.

Extension methods on QueryString.

Implicit methods for values of type Record

Extension methods for Request.

Extension methods for Response.

Callbacks indexed by URL pattern

Information carried by an HTTP endpoint

Values of type Endpoint can be constructed by using the operation endpoint.

A more specific type of JSON schema for enumerations, i.e. types that have a specific set of valid values

Values of type Enum[A] can be constructed by the operations:

• enumeration
• stringEnumeration
• intEnumeration

The JSON schema of a type A

JSON schemas can be interpreted as encoders serializing values of type A into JSON, decoders de-serializing JSON documents into values of type A, or documentation rendering the underlying JSON schema.

The JsonSchemas trait provides implicit definitions of JsonSchema[A] for basic types (Int, Double, String, etc.), and operations such as field, optField, or enumeration, which construct more complex JSON schemas.

HTTP Method

An URL path carrying an A information

Values of type Path[A] can be constructed by the operations path, segment, and remainingSegments.

 path / "user" / segment[UUID]("id")

• Server interpreters raise an error if they can’t parse the incoming request path as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

A query string carrying an A information

QueryString values can be created with the qs operation, and can be combined with the & operation:

 val queryPageAndLang: QueryString[(Int, Option[String])] =
   qs[Int]("page") & qs[Option[String]]("lang")

• Server interpreters raise an error if they can’t parse the incoming request query string parameters as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

A query string parameter codec for type A.

The trait Urls provides implicit instances of type QueryStringParam[A] for basic types (e.g., Int, String, etc.). You can create additional instances by transforming or refining the existing instances with xmap and xmapPartial.

A more specific type of JSON schema for record types (case classes)

Values of type Record[A] can be constructed with the operations field and optField.

Information carried by a whole request (headers and entity)

Values of type Request[A] can be constructed by using the operations request, get, post, put, or delete.

• Server interpreters raise an error if they can’t parse the incoming request as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

Information carried by request entity

Values of type RequestEntity[A] can be constructed by using the operations emptyRequest or textRequest. Additional types of request entities are provided by other algebra modules, such as JsonEntities or ChunkedEntities.

• Server interpreters raise an error if they can’t parse the incoming request entity as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

Information carried by requests’ headers.

You can construct values of type RequestHeaders by using the operations requestHeader, optRequestHeader, or emptyRequestHeaders.

• Server interpreters raise an error if they can’t parse the incoming request headers as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

An HTTP response (status, headers, and entity) carrying an information of type A

Values of type Response[A] can be constructed by using the operations ok, badRequest, internalServerError, or the more general operation response.

An HTTP response entity carrying an information of type A

Values of type ResponseEntity can be constructed by using the operations emptyResponse or textResponse. Additional types of response entities are provided by other algebra modules, such as JsonEntities or ChunkedEntities.

Information carried by responses’ headers.

You can construct values of type ResponseHeaders by using the operations responseHeader, optResponseHeader, or emptyResponseHeaders.

An URL path segment codec for type A.

The trait Urls provides implicit instances of Segment[A] for basic types (e.g., Int, String, etc.). You can create additional instances by transforming or refining the existing instances with xmap and xmapPartial.

HTTP Status Code

A more specific type of JSON schema for sum types (sealed traits)

“Tagged” schemas include the name of the type A as an additional discriminator field. By default, the name of the discriminator field is defined by the operation defaultDiscriminatorName but it can be customized by calling the operation withDiscriminator.

Values of type Tagged[A] can be constructed by calling the operation tagged on a Record[A].

An URL carrying an A information

Values of type URL[A] are typically constructed by first using the path constructor and then chaining it with segments and query parameters.

 path / "users" / segment[UUID]("id") /? qs[String]("apiKey")

• Server interpreters raise an error if they can’t parse the incoming request URL as a value of type A. By default, they produce a Bad Request (400) response with a list of error messages in a JSON array. Refer to the documentation of your server interpreter to customize this behavior.

This type is necessary to express different perspectives of servers and clients on optional query string parameters with default value:

• Client interpreters should define it as Option[A] and omit query string parameters with default value that are empty
• Server interpreters should define it as A and accept incoming requests whose query string parameters with default value are missing, while providing the defined default value
• Documentation interpreters should mark the parameter as optional and document the provided default value

Add the provided headers to the request.

Add the provided queryString to the request.

Add the provided headers to the response.

Note that if the response describes a choice of several possible responses (resulting from the orElse operation), the headers will be added to all the possible responses.

Bad Request (400) response, with an entity of type ClientErrors.

A JSON schema for type BigDecimal where certain properties, such as minimum, maximum, etc. are set.

Chains the two paths

Alternative between two possible request entities, differentiated by the Content-Type header

Alternative between two possible choices of responses.

Server interpreters construct either one or the other response. Client interpreters accept either one or the other response. Documentation interpreters list all the possible responses.

The JSON schema of a coproduct made of the given alternative tagged records

Response entity format for Invalid values

Concatenates two QueryStrings

Default discriminator field name for sum types.

It defaults to "type", but you can override it twofold:

• by overriding this field you can change default discriminator name algebra-wide
• by using withDiscriminator you can specify discriminator field name for specific sum type

Helper method to perform DELETE request

A JSON schema for type Double where certain properties, such as minimum, maximum, etc. are set.

Empty request -- request without a body. Use description of endpoints4s.algebra.Endpoints#endpoint to document an empty body.

Ignore headers

• Server interpreters don’t try to parse any information from the request headers,
• Client interpreters supply no specific headers

Use description of endpoints4s.algebra.Endpoints#endpoint to document empty headers.

Empty response entity

• Server interpreters produce no response entity,
• Client interpreters ignore the response entity.

No particular response header.

• Client interpreters should ignore information carried by response headers.

Define an HTTP endpoint

Promotes a schema to an enumeration.

• Decoder interpreters fail if the input value does not match the encoded values of any of the possible values,
• Encoder interpreters never fail, even if the value is not contained in the set of possible values,
• Documentation interpreters enrich the JSON schema with an enum property listing the possible values.

The JSON schema of a record with a single field name of type A

• Encoder interpreters produce a JSON object with one property of the given name,
• Decoder interpreters fail if the JSON value is not a JSON object, or if it doesn’t contain the name property, or if the property has an invalid value (according to its tpe),
• Documentation interpreters produce the JSON schema of a JSON object schema with one required property of the given name.

A JSON schema for type BigDecimal where certain properties, such as minimum, maximum, etc. are set.

Helper method to perform GET request

Convenient constructor for enumerations represented by int values.

A JSON schema for type Int where certain properties, such as minimum, maximum, etc. are set.

Internal Server Error (500) response, with an entity of type ServerError.

Request with a JSON body, given an implicit JsonRequest[A]

• Server interpreters accept requests with content-type application/json and reject requests with an incorrect content-type.
• Client interpreters supply content-type application/json

Defines a Response[A] given an implicit JsonResponse[A]

Captures a lazy reference to a JSON schema currently being defined:

 case class Recursive(next: Option[Recursive])
 val recursiveSchema: Record[Recursive] =
   lazyRecord("Rec") {
     optField("next")(recursiveSchema)
   }.xmap(Recursive(_))(_.next)

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

A lazy JSON schema that can references schemas currently being defined:

 case class Recursive(next: Option[Recursive])
 val recursiveSchema: JsonSchema[Recursive] = lazySchema("Rec")(
   optField("next")(recursiveSchema)
 ).xmap(Recursive)(_.next)

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

Captures a lazy reference to a JSON schema currently being defined.

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

A schema for a statically known value.

• Decoder interpreters first try to decode incoming values with the given tpe schema, and then check that it is equal to the given value,
• Encoder interpreters always produce the given value, encoded according to tpe,
• Documentation interpreters enrich the JSON schema with a const property documenting its only possible value (or an enum property with a single item).

This is useful to model schemas of objects containing extra fields that are absent from their Scala representation. For example, here is a schema for a GeoJSON point:

 case class Point(lon: Double, lat: Double)
 val pointSchema = (
   field("type")(literal("Point")) zip
   field[(Double, Double)]("coordinates")
 ).xmap(Point.tupled)(p => (p.lon, p.lat))

A JSON schema for type Long where certain properties, such as minimum, maximum, etc. are set.

Map the inner documentation of the endpoint to new documentation.

Map the inner request of the endpoint to a new request. This is for example useful to add Auth headers to an existing endpoint.

Map the inner response of the endpoint to a new response. This is for example useful so you can add error handling to an existing endpoint.

Annotates the enumeration JSON schema with a name

Annotates the record JSON schema with a name

Annotates the tagged JSON schema with a name

OK (200) Response with the given entity

The JSON schema of a record with a single optional field name of type A

• Encoder interpreters can omit the field or emit a field with a null value,
• Decoder interpreters successfully decode None if the field is absent or if it is present but has the value null. They fail if the field is present but contains an invalid value,
• Documentation interpreters produce the JSON schema of a JSON object with an optional property of the given name.

The JSON schema of a record with a single optional field with the given name

• Decoders fallback to the defaultValue if the field is absent from the decoded JSON object. They fail if the field is present but has an invalid value,
• Encoders must emit the field if it is not defaultValue, but can choose to omit it when it has the defaultValue
• Documentation interpreters produce the JSON schema of a JSON object with an optional property of the given name.

Builds a QueryString with one optional parameter, which has a default value.

Examples:

 optQsWithDefault[Int]("page", 1) // optional `page` parameter, with default value 1

An optional request header

Response headers optionally containing a header with the given name.

• Client interpreters should model the header value as Some[String], or None if the response header is missing.
• Server interpreters should produce such a response header.
• Documentation interpreters should document this header.

The JSON schema of a coproduct that share the same parent type and thus can be widened to that parent type

A schema that can be either schemaA or schemaB.

Documentation interpreter produce a oneOf JSON schema. Encoder interpreters forward to either schemaA or schemaB. Decoder interpreters first try to decode with schemaA, and fallback to schemaB in case of failure.

The difference between this operation and the operation orElse on “tagged” schemas is that this operation does not rely on a discriminator field between the alternative schemas. As a consequence, decoding is slower than with “tagged” schemas and provides less precise error messages.

Helper method to perform PATCH request

Helper method to perform POST request

Helper method to perform PUT request

Builds a QueryString with one parameter.

Examples:

 qs[Int]("page")            // mandatory `page` parameter
 qs[Option[String]]("lang") // optional `lang` parameter
 qs[List[Long]]("id")       // repeated `id` parameter

The remaining segments of the path. The String value carried by this Path is still URL-encoded.

Request for given parameters

A required request header

Define an HTTP response

• Server interpreters construct a response with the given status and entity.
• Client interpreters accept a response only if it has a corresponding status code.

Response headers containing a header with the given name.

• Client interpreters should model the header value as String, or fail if the response header is missing.
• Server interpreters should produce such a response header.
• Documentation interpreters should document this header.

Example:

 val versionedResource: Endpoint[Unit, (SomeResource, String)] =
   endpoint(
     get(path / "versioned-resource"),
     ok(
       jsonResponse[SomeResource],
       headers = responseHeader("ETag")
     )
   )

A path segment carrying an A information

Response entity format for Throwable values

A path segment whose value is the given segment

Convenient constructor for enumerations represented by string values.

A JSON schema for type String.

Tags a schema for type A with the given tag name

Request with a String body.

• Server interpreters accept requests with content-type text/plain and reject requests with an incorrect content-type.
• Server interpreters will use the character encoding set in the content-type header to determine how the text is decoded.
• Client interpreters supply content-type text/plain with an explicit character encoding

Text response entity

• Server interpreters produce an HTTP response with a text/plain content type.

Builds an URL from the given path and query string

Turns a Response[A] into a Response[Option[A]].

Interpreters represent None with an empty HTTP response whose status code is 404 (Not Found).

Add a description to the given enumeration JSON schema

Add a description to the given JSON schema

Add a description to the given record JSON schema

Add a description to the given tagged JSON schema

Allows to specify name of discriminator field for sum type

Include an example value within the given enumeration JSON schema

Include an example value within the given JSON schema

Include an example value within the given record JSON schema

Include an example value within the given tagged JSON schema

Add a title to the given enumeration JSON schema

Add a title to the given schema

Add a title to the given record JSON schema

Add a title to the given tagged JSON schema

The JSON schema of a record merging the fields of the two given records

Captures a lazy reference to a JSON schema currently being defined:

 case class Recursive(next: Option[Recursive])
 val recursiveSchema: Record[Recursive] = (
   optField("next")(lazyRecord(recursiveSchema, "Rec"))
 ).xmap(Recursive)(_.next)

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

Captures a lazy reference to a JSON schema currently being defined.

Interpreters should return a JsonSchema value that does not evaluate the given schema unless it is effectively used.

Response used by endpoints4s when decoding a request fails.

The provided implementation forwards to badRequest.

An empty path.

Useful to begin a path definition:

 path / "foo" / segment[Int] /? qs[String]("bar")

Response used by endpoints4s when the business logic of an endpoint fails.

The provided implementation forwards to internalServerError

Extension methods for Endpoint.