HTTPure

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 _
• Lookup Headers String String

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

• Show Headers

  Allow a Headers to be represented as a string. This string is formatted in HTTP headers format.

• Eq Headers

  Compare two Headers objects by comparing the underlying Objects.

• Semigroup Headers

  Allow one Headers objects to be appended to another.

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 r k c. 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 r k c. 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
• Show Method

  Convert a constructor to a String.

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 :: String, headers :: Headers, httpVersion :: Version, method :: Method, path :: Path, query :: Query }

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, status :: Status, writeBody :: Response -> Aff Unit }

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

variantAlsoNegotiates' :: Headers -> ResponseM

506 with headers

variantAlsoNegotiates :: ResponseM

506

useProxy' :: forall b. Body b => Headers -> b -> ResponseM

305 with headers

useProxy :: forall b. Body b => b -> ResponseM

305

upgradeRequired' :: Headers -> ResponseM

426 with headers

upgradeRequired :: ResponseM

426

unsupportedMediaType' :: Headers -> ResponseM

415 with headers

unsupportedMediaType :: ResponseM

415

unprocessableEntity' :: Headers -> ResponseM

422 with headers

unprocessableEntity :: ResponseM

422

unavailableForLegalReasons' :: Headers -> ResponseM

451 with headers

unavailableForLegalReasons :: ResponseM

451

unauthorized' :: Headers -> ResponseM

401 with headers

unauthorized :: ResponseM

401

uRITooLong' :: Headers -> ResponseM

414 with headers

uRITooLong :: ResponseM

414

tooManyRequests' :: Headers -> ResponseM

429 with headers

tooManyRequests :: ResponseM

429

temporaryRedirect' :: forall b. Body b => Headers -> b -> ResponseM

307 with headers

temporaryRedirect :: forall b. Body b => b -> ResponseM

307

switchingProtocols' :: Headers -> ResponseM

101 with headers

switchingProtocols :: ResponseM

101

serviceUnavailable' :: Headers -> ResponseM

503 with headers

serviceUnavailable :: ResponseM

503

seeOther' :: forall b. Body b => Headers -> b -> ResponseM

303 with headers

seeOther :: forall b. Body b => b -> ResponseM

303

response' :: forall b. Body b => Status -> Headers -> b -> ResponseM

The same as response but with headers.

response :: forall b. Body b => Status -> b -> ResponseM

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

resetContent' :: Headers -> ResponseM

205 with headers

resetContent :: ResponseM

205

requestTimeout' :: Headers -> ResponseM

408 with headers

requestTimeout :: ResponseM

408

requestHeaderFieldsTooLarge' :: Headers -> ResponseM

431 with headers

requestHeaderFieldsTooLarge :: ResponseM

431

rangeNotSatisfiable' :: Headers -> ResponseM

416 with headers

rangeNotSatisfiable :: ResponseM

416

proxyAuthenticationRequired' :: Headers -> ResponseM

407 with headers

proxyAuthenticationRequired :: ResponseM

407

processing' :: Headers -> ResponseM

102 with headers

processing :: ResponseM

102

preconditionRequired' :: Headers -> ResponseM

428 with headers

preconditionRequired :: ResponseM

428

preconditionFailed' :: Headers -> ResponseM

412 with headers

preconditionFailed :: ResponseM

412

permanentRedirect' :: forall b. Body b => Headers -> b -> ResponseM

308 with headers

permanentRedirect :: forall b. Body b => b -> ResponseM

308

paymentRequired' :: Headers -> ResponseM

402 with headers

paymentRequired :: ResponseM

402

payloadTooLarge' :: Headers -> ResponseM

413 with headers

payloadTooLarge :: ResponseM

413

partialContent' :: forall b. Body b => Headers -> b -> ResponseM

206 with headers

partialContent :: forall b. Body b => b -> ResponseM

206

ok' :: forall b. Body b => Headers -> b -> ResponseM

200 with headers

ok :: forall b. Body b => b -> ResponseM

200

notModified' :: Headers -> ResponseM

304 with headers

notModified :: ResponseM

304

notImplemented' :: Headers -> ResponseM

501 with headers

notImplemented :: ResponseM

501

notFound' :: Headers -> ResponseM

404 with headers

notFound :: ResponseM

404

notExtended' :: Headers -> ResponseM

510 with headers

notExtended :: ResponseM

510

notAcceptable' :: Headers -> ResponseM

406 with headers

notAcceptable :: ResponseM

406

nonAuthoritativeInformation' :: forall b. Body b => Headers -> b -> ResponseM

203 with headers

nonAuthoritativeInformation :: forall b. Body b => b -> ResponseM

203

noContent' :: Headers -> ResponseM

204 with headers

noContent :: ResponseM

204

networkAuthenticationRequired' :: Headers -> ResponseM

511 with headers

networkAuthenticationRequired :: ResponseM

511

multipleChoices' :: forall b. Body b => Headers -> b -> ResponseM

300 with headers

multipleChoices :: forall b. Body b => b -> ResponseM

300

multiStatus' :: forall b. Body b => Headers -> b -> ResponseM

207 with headers

multiStatus :: forall b. Body b => b -> ResponseM

207

movedPermanently' :: forall b. Body b => Headers -> b -> ResponseM

301 with headers

movedPermanently :: forall b. Body b => b -> ResponseM

301

misdirectedRequest' :: Headers -> ResponseM

421 with headers

misdirectedRequest :: ResponseM

421

methodNotAllowed' :: Headers -> ResponseM

405 with headers

methodNotAllowed :: ResponseM

405

loopDetected' :: Headers -> ResponseM

508 with headers

loopDetected :: ResponseM

508

locked' :: Headers -> ResponseM

423 with headers

locked :: ResponseM

423

lengthRequired' :: Headers -> ResponseM

411 with headers

lengthRequired :: ResponseM

411

internalServerError' :: forall b. Body b => Headers -> b -> ResponseM

500 with headers

internalServerError :: forall b. Body b => b -> ResponseM

500

insufficientStorage' :: Headers -> ResponseM

507 with headers

insufficientStorage :: ResponseM

507

imATeapot' :: Headers -> ResponseM

418 with headers

imATeapot :: ResponseM

418

iMUsed' :: forall b. Body b => Headers -> b -> ResponseM

226 with headers

iMUsed :: forall b. Body b => b -> ResponseM

226

hTTPVersionNotSupported' :: Headers -> ResponseM

505 with headers

hTTPVersionNotSupported :: ResponseM

505

gone' :: Headers -> ResponseM

410 with headers

gone :: ResponseM

410

gatewayTimeout' :: Headers -> ResponseM

504 with headers

gatewayTimeout :: ResponseM

504

found' :: forall b. Body b => Headers -> b -> ResponseM

302 with headers

found :: forall b. Body b => b -> ResponseM

302

forbidden' :: Headers -> ResponseM

403 with headers

forbidden :: ResponseM

403

failedDependency' :: Headers -> ResponseM

424 with headers

failedDependency :: ResponseM

424

expectationFailed' :: Headers -> ResponseM

417 with headers

expectationFailed :: ResponseM

417

emptyResponse' :: Status -> Headers -> ResponseM

The same as emptyResponse but with headers.

emptyResponse :: Status -> ResponseM

The same as response but without a body.

created' :: Headers -> ResponseM

201 with headers

created :: ResponseM

201

continue' :: Headers -> ResponseM

100 with headers

continue :: ResponseM

100

conflict' :: forall b. Body b => Headers -> b -> ResponseM

409 with headers

conflict :: forall b. Body b => b -> ResponseM

409

badRequest' :: forall b. Body b => Headers -> b -> ResponseM

400 with headers

badRequest :: forall b. Body b => b -> ResponseM

400

badGateway' :: Headers -> ResponseM

502 with headers

badGateway :: ResponseM

502

alreadyReported' :: Headers -> ResponseM

208 with headers

alreadyReported :: ResponseM

208

accepted' :: Headers -> ResponseM

202 with headers

accepted :: ResponseM

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.