Module

HTTPure

Package
purescript-httpure
Repository
citizennet/purescript-httpure

Re-exports from HTTPure.Body

#toString Source

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 Source

toStream :: RequestBody -> Readable ()

Return the Readable stream directly from RequestBody

#toBuffer Source

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.

Re-exports from HTTPure.Headers

#Headers Source

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

#headers Source

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

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

#header Source

header :: String -> String -> Headers

Create a singleton header from a key-value pair.

#empty Source

empty :: Headers

Return a Headers containing nothing.

Re-exports from HTTPure.Lookup

#lookup Source

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 Source

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 Source

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.

#(!@) Source

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

Expose at as the infix operator !@

#(!?) Source

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

Expose has as the infix operator !?

#(!!) Source

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.

Re-exports from HTTPure.Method

#Method Source

data Method

These are the HTTP methods that HTTPure understands.

Constructors

Instances

  • Eq Method

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

  • Show Method

    Convert a constructor to a String.

Re-exports from HTTPure.MultiHeaders

#MultiHeaders Source

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

Re-exports from HTTPure.Path

#Path Source

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.

Re-exports from HTTPure.Query

#Query Source

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".

Re-exports from HTTPure.Request

#Request Source

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 Source

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.

Re-exports from HTTPure.Response

#ResponseM Source

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.

#Response Source

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

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

#variantAlsoNegotiates' Source

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

506 with headers

#variantAlsoNegotiates Source

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

506

#useProxy' Source

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

305 with headers

#useProxy Source

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

305

#upgradeRequired' Source

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

426 with headers

#upgradeRequired Source

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

426

#unsupportedMediaType' Source

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

415 with headers

#unsupportedMediaType Source

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

415

#unprocessableEntity' Source

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

422 with headers

#unprocessableEntity Source

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

422

#unavailableForLegalReasons' Source

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

451 with headers

#unavailableForLegalReasons Source

#unauthorized' Source

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

401 with headers

#unauthorized Source

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

401

#uRITooLong' Source

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

414 with headers

#uRITooLong Source

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

414

#tooManyRequests' Source

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

429 with headers

#tooManyRequests Source

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

429

#temporaryRedirect' Source

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

307 with headers

#temporaryRedirect Source

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

307

#switchingProtocols' Source

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

101 with headers

#switchingProtocols Source

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

101

#serviceUnavailable' Source

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

503 with headers

#serviceUnavailable Source

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

503

#seeOther' Source

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

303 with headers

#seeOther Source

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

303

#response' Source

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

The same as response but with headers.

#response Source

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' Source

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

205 with headers

#resetContent Source

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

205

#requestTimeout' Source

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

408 with headers

#requestTimeout Source

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

408

#requestHeaderFieldsTooLarge' Source

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

431 with headers

#requestHeaderFieldsTooLarge Source

#rangeNotSatisfiable' Source

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

416 with headers

#rangeNotSatisfiable Source

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

416

#proxyAuthenticationRequired' Source

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

407 with headers

#proxyAuthenticationRequired Source

#processing' Source

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

102 with headers

#processing Source

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

102

#preconditionRequired' Source

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

428 with headers

#preconditionRequired Source

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

428

#preconditionFailed' Source

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

412 with headers

#preconditionFailed Source

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

412

#permanentRedirect' Source

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

308 with headers

#permanentRedirect Source

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

308

#paymentRequired' Source

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

402 with headers

#paymentRequired Source

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

402

#payloadTooLarge' Source

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

413 with headers

#payloadTooLarge Source

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

413

#partialContent' Source

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

206 with headers

#partialContent Source

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

206

#ok' Source

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

200 with headers

#ok Source

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

200

#notModified' Source

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

304 with headers

#notModified Source

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

304

#notImplemented' Source

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

501 with headers

#notImplemented Source

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

501

#notFound' Source

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

404 with headers

#notFound Source

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

404

#notExtended' Source

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

510 with headers

#notExtended Source

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

510

#notAcceptable' Source

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

406 with headers

#notAcceptable Source

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

406

#nonAuthoritativeInformation' Source

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

203 with headers

#nonAuthoritativeInformation Source

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

203

#noContent' Source

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

204 with headers

#noContent Source

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

204

#networkAuthenticationRequired' Source

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

511 with headers

#networkAuthenticationRequired Source

#multipleChoices' Source

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

300 with headers

#multipleChoices Source

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

300

#multiStatus' Source

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

207 with headers

#multiStatus Source

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

207

#movedPermanently' Source

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

301 with headers

#movedPermanently Source

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

301

#misdirectedRequest' Source

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

421 with headers

#misdirectedRequest Source

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

421

#methodNotAllowed' Source

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

405 with headers

#methodNotAllowed Source

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

405

#loopDetected' Source

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

508 with headers

#loopDetected Source

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

508

#locked' Source

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

423 with headers

#locked Source

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

423

#lengthRequired' Source

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

411 with headers

#lengthRequired Source

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

411

#internalServerError' Source

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

500 with headers

#internalServerError Source

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

500

#insufficientStorage' Source

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

507 with headers

#insufficientStorage Source

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

507

#imATeapot' Source

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

418 with headers

#imATeapot Source

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

418

#iMUsed' Source

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

226 with headers

#iMUsed Source

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

226

#hTTPVersionNotSupported' Source

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

505 with headers

#hTTPVersionNotSupported Source

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

505

#gone' Source

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

410 with headers

#gone Source

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

410

#gatewayTimeout' Source

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

504 with headers

#gatewayTimeout Source

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

504

#found' Source

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

302 with headers

#found Source

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

302

#forbidden' Source

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

403 with headers

#forbidden Source

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

403

#failedDependency' Source

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

424 with headers

#failedDependency Source

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

424

#expectationFailed' Source

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

417 with headers

#expectationFailed Source

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

417

#emptyResponse' Source

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

The same as emptyResponse but with headers.

#emptyResponse Source

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

The same as response but without a body.

#created' Source

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

201 with headers

#created Source

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

201

#continue' Source

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

100 with headers

#continue Source

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

100

#conflict' Source

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

409 with headers

#conflict Source

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

409

#badRequest' Source

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

400 with headers

#badRequest Source

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

400

#badGateway' Source

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

502 with headers

#badGateway Source

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

502

#alreadyReported' Source

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

208 with headers

#alreadyReported Source

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

208

#accepted' Source

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

202 with headers

#accepted Source

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

202

Re-exports from HTTPure.Server

#ServerM Source

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' Source

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 Source

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' Source

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 Source

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.

Re-exports from HTTPure.Status

#Status Source

type Status = Int

The Status type enumerates all valid HTTP response status codes.