HTTPure

toString :: RequestBody -> Aff String

Turn RequestBody into a String

This drains the Readable stream in RequestBody for the first time and returns cached result from then on.

toStream :: RequestBody -> Readable ()

Return the Readable stream directly from RequestBody

toBuffer :: RequestBody -> Aff Buffer

Turn RequestBody into a Buffer

This drains the Readable stream in RequestBody for the first time and returns cached result from then on.

newtype Headers

The Headers type is just sugar for a Object of Strings that represents the set of headers in an HTTP request or response.

Instances

• Newtype Headers _
• Generic Headers _
• Lookup Headers String String

  Given a string, return a Maybe containing the value of the matching header, if there is any.

• Show Headers
• Eq Headers

  Compare two Headers objects by comparing the underlying Objects.

• Semigroup Headers

  Allow one Headers objects to be appended to another.

• Monoid Headers

headers :: Array (Tuple String String) -> Headers

Convert an Array of Tuples of 2 Strings to a Headers object.

header :: String -> String -> Headers

Create a singleton header from a key-value pair.

empty :: Headers

Return a Headers containing nothing.

lookup :: forall c k r. Lookup c k r => c -> k -> Maybe r

Given some type and a key on that type, extract some value that corresponds to that key.

has :: forall c k r. Lookup (c r) k r => c r -> k -> Boolean

This simple helper works on any Lookup instance, where the container set has a single type variable, and returns a Boolean indicating if the given key matches any value in the given container.

at :: forall c k r. Monoid r => Lookup c k r => c -> k -> r

This simple helper works on any Lookup instance where the return type is a Monoid, and is the same as lookup except that it returns a t instead of a Maybe t. If lookup would return Nothing, then at returns mempty.

Operator alias for HTTPure.Lookup.at (left-associative / precedence 8)

Expose at as the infix operator !@

Operator alias for HTTPure.Lookup.has (left-associative / precedence 8)

Expose has as the infix operator !?

Operator alias for HTTPure.Lookup.lookup (left-associative / precedence 8)

!! is inspired by !! in Data.Array, but note that it differs from !! in Data.Array in that you can use !! for any other instance of Lookup.

data Method

These are the HTTP methods that HTTPure understands.

Constructors

• Get
• Post
• Put
• Delete
• Head
• Connect
• Options
• Trace
• Patch

Instances

• Eq Method

  If two Methods are the same constructor, they are equal.

• Show Method

  Convert a constructor to a String.

newtype MultiHeaders

The MultiHeaders type represets the set of headers in a HTTP request or response read in a way such that every header name maps to a non-empty list of header values. This is useful for headers that may have multiple values, such as "Set-Cookie".

Instances

• Newtype MultiHeaders _
• Generic MultiHeaders _
• Lookup MultiHeaders String (NonEmptyArray String)

  Given a string, return a Maybe containing the values of the matching header, if there is any.

• Show MultiHeaders
• Eq MultiHeaders

  Compare two MultiHeaders objects by comparing the underlying Objects.

• Semigroup MultiHeaders

  Allow one MultiHeaders objects to be appended to another.

• Monoid MultiHeaders

type Path = Array String

The Path type is just sugar for an Array of String segments that are sent in a request and indicates the path of the resource being requested. Note that this type has an implementation of Lookup for Int keys defined by lookupArray in Lookup.purs because lookupArray is defined for any Array of Monoids. So you can do something like path !! 2 to get the path segment at index 2.

type Query = Object String

The Query type is a Object of Strings, with one entry per query parameter in the request. For any query parameters that don't have values (/some/path?query or /some/path?query=), the value in the Object for that parameter will be the an empty string. Note that this type has an implementation of Lookup for String keys defined by lookupObject in Lookup.purs because lookupObject is defined for any Object of Monoids. So you can do something like query !! "foo" to get the value of the query parameter "foo".

type Request = { body :: RequestBody, headers :: Headers, httpVersion :: Version, method :: Method, multiHeaders :: MultiHeaders, path :: Path, query :: Query, url :: String }

The Request type is a Record type that includes fields for accessing the different parts of the HTTP request.

fullPath :: Request -> String

Return the full resolved path, including query parameters. This may not match the requested path--for instance, if there are empty path segments in the request--but it is equivalent.

type ResponseM = Aff Response

The ResponseM type simply conveniently wraps up an HTTPure monad that returns a response. This type is the return type of all router/route methods.

type Response = { headers :: Headers, multiHeaders :: MultiHeaders, status :: Status, writeBody :: Response -> Aff Unit }

A Response is a status code, headers, and a body.

variantAlsoNegotiates' :: forall m. MonadAff m => Headers -> m Response

506 with headers

variantAlsoNegotiates :: forall m. MonadAff m => m Response

506

useProxy' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

305 with headers

useProxy :: forall m b. MonadAff m => Body b => b -> m Response

305

upgradeRequired' :: forall m. MonadAff m => Headers -> m Response

426 with headers

upgradeRequired :: forall m. MonadAff m => m Response

426

unsupportedMediaType' :: forall m. MonadAff m => Headers -> m Response

415 with headers

unsupportedMediaType :: forall m. MonadAff m => m Response

415

unprocessableEntity' :: forall m. MonadAff m => Headers -> m Response

422 with headers

unprocessableEntity :: forall m. MonadAff m => m Response

422

unavailableForLegalReasons' :: forall m. MonadAff m => Headers -> m Response

451 with headers

unavailableForLegalReasons :: forall m. MonadAff m => m Response

451

unauthorized' :: forall m. MonadAff m => Headers -> m Response

401 with headers

unauthorized :: forall m. MonadAff m => m Response

401

uRITooLong' :: forall m. MonadAff m => Headers -> m Response

414 with headers

uRITooLong :: forall m. MonadAff m => m Response

414

tooManyRequests' :: forall m. MonadAff m => Headers -> m Response

429 with headers

tooManyRequests :: forall m. MonadAff m => m Response

429

temporaryRedirect' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

307 with headers

temporaryRedirect :: forall m b. MonadAff m => Body b => b -> m Response

307

switchingProtocols' :: forall m. MonadAff m => Headers -> m Response

101 with headers

switchingProtocols :: forall m. MonadAff m => m Response

101

serviceUnavailable' :: forall m. MonadAff m => Headers -> m Response

503 with headers

serviceUnavailable :: forall m. MonadAff m => m Response

503

seeOther' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

303 with headers

seeOther :: forall m b. MonadAff m => Body b => b -> m Response

303

response' :: forall m b. MonadAff m => Body b => Status -> Headers -> b -> m Response

The same as response but with headers.

response :: forall m b. MonadAff m => Body b => Status -> b -> m Response

For custom response statuses or providing a body for response codes that don't typically send one.

resetContent' :: forall m. MonadAff m => Headers -> m Response

205 with headers

resetContent :: forall m. MonadAff m => m Response

205

requestTimeout' :: forall m. MonadAff m => Headers -> m Response

408 with headers

requestTimeout :: forall m. MonadAff m => m Response

408

requestHeaderFieldsTooLarge' :: forall m. MonadAff m => Headers -> m Response

431 with headers

requestHeaderFieldsTooLarge :: forall m. MonadAff m => m Response

431

rangeNotSatisfiable' :: forall m. MonadAff m => Headers -> m Response

416 with headers

rangeNotSatisfiable :: forall m. MonadAff m => m Response

416

proxyAuthenticationRequired' :: forall m. MonadAff m => Headers -> m Response

407 with headers

proxyAuthenticationRequired :: forall m. MonadAff m => m Response

407

processing' :: forall m. MonadAff m => Headers -> m Response

102 with headers

processing :: forall m. MonadAff m => m Response

102

preconditionRequired' :: forall m. MonadAff m => Headers -> m Response

428 with headers

preconditionRequired :: forall m. MonadAff m => m Response

428

preconditionFailed' :: forall m. MonadAff m => Headers -> m Response

412 with headers

preconditionFailed :: forall m. MonadAff m => m Response

412

permanentRedirect' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

308 with headers

permanentRedirect :: forall m b. MonadAff m => Body b => b -> m Response

308

paymentRequired' :: forall m. MonadAff m => Headers -> m Response

402 with headers

paymentRequired :: forall m. MonadAff m => m Response

402

payloadTooLarge' :: forall m. MonadAff m => Headers -> m Response

413 with headers

payloadTooLarge :: forall m. MonadAff m => m Response

413

partialContent' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

206 with headers

partialContent :: forall m b. MonadAff m => Body b => b -> m Response

206

ok' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

200 with headers

ok :: forall m b. MonadAff m => Body b => b -> m Response

200

notModified' :: forall m. MonadAff m => Headers -> m Response

304 with headers

notModified :: forall m. MonadAff m => m Response

304

notImplemented' :: forall m. MonadAff m => Headers -> m Response

501 with headers

notImplemented :: forall m. MonadAff m => m Response

501

notFound' :: forall m. MonadAff m => Headers -> m Response

404 with headers

notFound :: forall m. MonadAff m => m Response

404

notExtended' :: forall m. MonadAff m => Headers -> m Response

510 with headers

notExtended :: forall m. MonadAff m => m Response

510

notAcceptable' :: forall m. MonadAff m => Headers -> m Response

406 with headers

notAcceptable :: forall m. MonadAff m => m Response

406

nonAuthoritativeInformation' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

203 with headers

nonAuthoritativeInformation :: forall m b. MonadAff m => Body b => b -> m Response

203

noContent' :: forall m. MonadAff m => Headers -> m Response

204 with headers

noContent :: forall m. MonadAff m => m Response

204

networkAuthenticationRequired' :: forall m. MonadAff m => Headers -> m Response

511 with headers

networkAuthenticationRequired :: forall m. MonadAff m => m Response

511

multipleChoices' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

300 with headers

multipleChoices :: forall m b. MonadAff m => Body b => b -> m Response

300

multiStatus' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

207 with headers

multiStatus :: forall m b. MonadAff m => Body b => b -> m Response

207

movedPermanently' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

301 with headers

movedPermanently :: forall m b. MonadAff m => Body b => b -> m Response

301

misdirectedRequest' :: forall m. MonadAff m => Headers -> m Response

421 with headers

misdirectedRequest :: forall m. MonadAff m => m Response

421

methodNotAllowed' :: forall m. MonadAff m => Headers -> m Response

405 with headers

methodNotAllowed :: forall m. MonadAff m => m Response

405

loopDetected' :: forall m. MonadAff m => Headers -> m Response

508 with headers

loopDetected :: forall m. MonadAff m => m Response

508

locked' :: forall m. MonadAff m => Headers -> m Response

423 with headers

locked :: forall m. MonadAff m => m Response

423

lengthRequired' :: forall m. MonadAff m => Headers -> m Response

411 with headers

lengthRequired :: forall m. MonadAff m => m Response

411

internalServerError' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

500 with headers

internalServerError :: forall m b. MonadAff m => Body b => b -> m Response

500

insufficientStorage' :: forall m. MonadAff m => Headers -> m Response

507 with headers

insufficientStorage :: forall m. MonadAff m => m Response

507

imATeapot' :: forall m. MonadAff m => Headers -> m Response

418 with headers

imATeapot :: forall m. MonadAff m => m Response

418

iMUsed' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

226 with headers

iMUsed :: forall m b. MonadAff m => Body b => b -> m Response

226

hTTPVersionNotSupported' :: forall m. MonadAff m => Headers -> m Response

505 with headers

hTTPVersionNotSupported :: forall m. MonadAff m => m Response

505

gone' :: forall m. MonadAff m => Headers -> m Response

410 with headers

gone :: forall m. MonadAff m => m Response

410

gatewayTimeout' :: forall m. MonadAff m => Headers -> m Response

504 with headers

gatewayTimeout :: forall m. MonadAff m => m Response

504

found' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

302 with headers

found :: forall m b. MonadAff m => Body b => b -> m Response

302

forbidden' :: forall m. MonadAff m => Headers -> m Response

403 with headers

forbidden :: forall m. MonadAff m => m Response

403

failedDependency' :: forall m. MonadAff m => Headers -> m Response

424 with headers

failedDependency :: forall m. MonadAff m => m Response

424

expectationFailed' :: forall m. MonadAff m => Headers -> m Response

417 with headers

expectationFailed :: forall m. MonadAff m => m Response

417

emptyResponse' :: forall m. MonadAff m => Status -> Headers -> m Response

The same as emptyResponse but with headers.

emptyResponse :: forall m. MonadAff m => Status -> m Response

The same as response but without a body.

created' :: forall m. MonadAff m => Headers -> m Response

201 with headers

created :: forall m. MonadAff m => m Response

201

continue' :: forall m. MonadAff m => Headers -> m Response

100 with headers

continue :: forall m. MonadAff m => m Response

100

conflict' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

409 with headers

conflict :: forall m b. MonadAff m => Body b => b -> m Response

409

badRequest' :: forall m b. MonadAff m => Body b => Headers -> b -> m Response

400 with headers

badRequest :: forall m b. MonadAff m => Body b => b -> m Response

400

badGateway' :: forall m. MonadAff m => Headers -> m Response

502 with headers

badGateway :: forall m. MonadAff m => m Response

502

alreadyReported' :: forall m. MonadAff m => Headers -> m Response

208 with headers

alreadyReported :: forall m. MonadAff m => m Response

208

accepted' :: forall m. MonadAff m => Headers -> m Response

202 with headers

accepted :: forall m. MonadAff m => m Response

202

type ServerM = Effect (Effect Unit -> Effect Unit)

The ServerM is just an Effect containing a callback to close the server. This type is the return type of the HTTPure serve and related methods.

serveSecure' :: Options SSLOptions -> ListenOptions -> (Request -> ResponseM) -> Effect Unit -> ServerM

Given a Options HTTPS.SSLOptions object and a HTTP.ListenOptions object, a function mapping Request to ResponseM, and a ServerM containing effects to run on boot, creates and runs a HTTPure server with SSL.

serveSecure :: Int -> String -> String -> (Request -> ResponseM) -> Effect Unit -> ServerM

Create and start an SSL server. This method is the same as serve, but takes additional SSL arguments. The arguments in order are:

1. A port number
2. A path to a cert file
3. A path to a private key file
4. A handler method which maps Request to ResponseM
5. A callback to call when the server is up

serve' :: ListenOptions -> (Request -> ResponseM) -> Effect Unit -> ServerM

Given a ListenOptions object, a function mapping Request to ResponseM, and a ServerM containing effects to run on boot, creates and runs a HTTPure server without SSL.

serve :: Int -> (Request -> ResponseM) -> Effect Unit -> ServerM

Create and start a server. This is the main entry point for HTTPure. Takes a port number on which to listen, a function mapping Request to ResponseM, and a ServerM containing effects to run after the server has booted (usually logging). Returns an ServerM containing the server's effects.

type Status = Int

The Status type enumerates all valid HTTP response status codes.