Cycle Node Http Server

Driver and router component for manage HTTP/HTTPS services with Cycle.js

Installation with NPM

npm i cycle-node-http-serve --save

HTTP/HTTPS Driver

`makeHttpServerDriver(config)`

Create the driver

Arguments

config with specifics options
- middlewares : Array : array of express compatible middlewares like serveStatic or bodyParser
- render: (template) => template : a template engine renderer, call with req.response.render(template)

Basic usage

const {run} = require('@cycle/run');
const {makeHttpServerDriver} = require('cycle-node-http-server');

function main(sources){

  const {httpServer} = sources;

  const sinks = {
    
  }
  return sinks;
}

const drivers = {
  httpServer: makeHttpServerDriver()
}

run(main,drivers)

Create a HTTP Server Instance

To create a server instance, we need to send a config stream to the httpServer output. Like this :

   const httpCreate$ = xs.of({
        id: 'http',
        action: 'create',
        port: 1983
    });
    
    const sinks = {
       httpServer: httpCreate$
    }

create action config:

id : the instance reference name. Needed to select the server stream on input.
action:'create' : the action name
port : see server.listen([port][, hostname][, backlog][, callback]) on NodeJS Api
hostname : see server.listen([port][, hostname][, backlog][, callback]) on NodeJS Api
backlog : see server.listen([port][, hostname][, backlog][, callback]) on NodeJS Api
handle : see server.listen(handle[, callback]) on NodeJS Api
path : see server.listen(path[, callback]) on NodeJS Api
secured : set at true to create a HTTPS server.
securedOptions : Needed if securedis true see Node HTTPS createServer options
middlewares : Array : array of express compatible middlewares like serveStatic or bodyParser

Basic example with HTTPS

     const securedOptions = {
          key: fs.readFileSync(`${__dirname}/certs/key.pem`),
          cert: fs.readFileSync(`${__dirname}/certs/cert.pem`)
     };
     
     const httpsCreate$ = xs.of({
        id: 'https',
        action: 'create',
        port: 1984,
        secured: true,
        securedOptions
    });

Close server instance

To close a server instance we need to send a config stream to the httpServer output.

   const httpClose$ = xs.of({
        id: 'http',
        action: 'close'
    });
    
    const sinks = {
       httpServer: httpClose$
    }

create action config:

id : the instance reference name. Needed to select the server stream on input.
action:'close' : the action name

Select a server stream with `select(id)`

Select the server width this specific id

Return Object

   const http = httpServer.select('http');

Get events with `event(name)`

Get event with name stream from a httpobject.

   const http = httpServer.select('http');
   const httpReady$ = http.events('ready');
   const httpRequest$ = http.events('request');

Return Stream

Event `ready`

Dispatched when the server is ready to listen.

Returned values :

event : 'ready'
instanceId : The instance id
instance : the original Node.js server object

Event `request`

Dispatched when the server received a request. See Request object above.

`Request` object

Properties

event : 'request',
instanceId : The instance id
original : original NodeJS request object,
url : request's url,
method : request's method (POST,GET,PUT, etc...),
headers : request's headers,
body : the body request. undefinedby default. See BodyParser middleware
response : the response object

`Response`object

Methods

`send()`

Format response for driver output.

Arguments

content : the body response
options :
statusCode : default 200
headers : default null
statusMessage : default null

Return formatted object for driver output

`json()`

Format response in json. See send()

`text()`

Format response in plain text. See send()

`html()`

Format response in html. See send()

`render()`

Format response with the render engine defined in makeHttpServerDriver() options.

`redirect()`

Format response redirection for driver output.

Arguments

path : path to redirect
options :
statusCode : default 302
headers : default null
statusMessage : default null

Return formatted object for driver output

Basic Usage

const {run} = require('@cycle/run');
const {makeHttpServerDriver} = require('cycle-node-http-server');

function main(sources){

  const {httpServer} = sources;

  // get http source
  const http = httpServer.select('http');
  // get requests
  const serverRequest$ = http.events('request');

  const httpCreate$ = xs.of({
      id: 'http',
      action: 'create',
      port: 1983
  });
  
  // response formated with a helper response object
  // Response in text format : 'covfefe'
  const response$ = serverRequest$.map( req => req.response.text('covfefe') );

  const sinks = {
    httpServer: xs.merge(httpCreate$,response$)
  }
  return sinks;
}

const drivers = {
  httpServer: makeHttpServerDriver()
}

run(main,drivers)

Routing

A Router component using switch-path

Arguments

Router(sources,routes)

sources : Cycle.js sources object with a specific source request$, a stream of http(s) requests.
routes : a collection of routes. See switch-path

Return stream

Example

 const {makeHttpServerDriver, Router} = require('cycle-node-http-server');

 function main(sources) {

    const { httpServer } = sources;

    // get http source
    const http = httpServer.select('http');
    // get requests
    const serverRequest$ = http.events('request');

    const router$ = Router({ request$: serverRequest$ }, {
        '/': sources => Page({ props$: xs.of({ desc: 'home' }) }),
        '/user/:id': id => sources => Page({ props$: xs.of({ desc: `user/${id}` }) }),
    })

    const sinks = {
        httpServer: router$.map(c => c.httpServer).flatten(),
    }
    return sinks;
}

 function Page(sources) {
    // request$ is add by the Router to the `sources` object
    const { props$, request$ } = sources;
    const sinks = {
        httpServer: xs.combine(props$, request$).map(([props, req]) => req.response.text(props.desc))
    }
    return sinks;
}

Cooking with middlewares

Here are discribed two usefull express middlewares.

serveStatic

It is used to serve static files ( images, css, etc... )

Basic usage

const serveStatic = require('serve-static');
const {makeHttpServerDriver} = require('cycle-node-http-server');

const drivers = {
  httpServer: makeHttpServerDriver({middlewares:[serveStatic('./public')]})
}

bodyParser

It is used to parse request body and return a full formated body.

Basic usage

const bodyParser = require('body-parser');
const {makeHttpServerDriver} = require('cycle-node-http-server');

const drivers = {
  httpServer: makeHttpServerDriver({
      middlewares: [
          // two parsers used to format body POST request in json
          bodyParser.urlencoded({ extended: true }),
          bodyParser.json()
      ]
  })
}

Using Snabbdom

Snabbdom is the Virtual DOM using by @cycle/dom. It's possible to use it in server side with snabbdom-to-html.

A small helper to use snabbdom with cycle-node-http-server

  const snabbdomInit = require('snabbdom-to-html/init');
  const snabbdomModules = require('snabbdom-to-html/modules');
  const {makeHttpServerDriver} = require('cycle-node-http-server');
    
  export default function vdom(modules=[
          snabbdomModules.class,
          snabbdomModules.props,
          snabbdomModules.attributes,
          snabbdomModules.style
      ]){
      return snabbdomInit(modules);
  }
  
  const drivers = {
    httpServer: makeHttpServerDriver({
        render: vdom()
    })
  }

In main function, snabbdom used with JSX

  const response$ = request$.map( req => req.response.render(
    <div>
      Pouet
    </div>
  ))

License

MIT

fabienjuif / cycle-node-http-server Goto Github PK