npm  i  -S  bliz
or
yarn  add  bliz

// if youre using es6 modules
import  Bliz  from  'bliz'
or
// if youre not using es2016 modules
const  Bliz  =  require('bliz').default
const  app  =  Bliz()

// path.js
export  default  function  examplePath (app) {
    app
        // creates a new http path
        .createPath('/example/path')
        // creates a handler for the path
        .handler((req, res) => {
            res.json({message:  "This is so cool and simple!"})
        })
        // path middleware like in express
        .middleware((req, res, next)=>{
            console.log('hit /example/path!')
            next()
        })
        .errHandler((req, res, err)=>{
            console.log('my own custom error handler, so cool!!')
            // do some path specific error handling!
            res.json({error:  err.message})
        })
}

 
// router.js
import  examplePath  from  './path.js'
export  default  function  router(app) {
    app
        .createRouter('/api')
        .get(examplePath(app))
        .middleware((req, res, next)=>{
            console.log('hit /api router and attached a path to it with very few lines of code!')
            next()
        })
        .errHandler((req, res, err)=>{
            console.log('router err handler, for when you do no have a path error handler'  +
            'but want a router to have all routes under it with special error handling !')
            // do some path specific router error handling!
            res.json({error:  err.message})
        })
}

// index.js
import  Bliz  from  'bliz'
import  router  from  './router.js'
const  app  =  Bliz()
app
.registerRouters(router(app))
.middleware((req, res, next)=> {// global middleware})
.listen(4000)

// event.js
export  default  function  exampleEvent(app) {
    app
        // creates a new socket listener
        .createSocketListener('event')
        // creates a handler for the event
        .handler((io, socket, msg, cb) => {
        // if emit fired you can cb to it immidietly
        // receive the msg and do something
        })
        // yes, yes, events have middlewares as well, because why not ???
        // abstraction usually helps readability
        .middleware((io, socket, msg, cb, next)=>{
            console.log('hit event')
            next()
        })
}

// events-router.js
import  exampleEventfrom  './event.js'
export  default  function  router(app) {
app
    .createSocketRouter('router')
    .event(exampleEvent(app))
    .middleware((io, socket, msg, cb, next)=>{
        console.log('hit router !')
        next()
    })
}
 

// index.js
import  Bliz  from  'bliz'
import  router  from  './events-router.js'
const  app  =  Bliz()
app
.sockets({useSockets:  true, delimiter:  ':'})
.registerSocketRouters(router(app))
.listen(4000)

// schema.js
const  schema  =  `
type Post {
    name: String!
    id: Int!
    data: String
}
 
input newPost {
    name: String!
    id: Int!
    data: String
}
`
export  default  schema

 
// resolver.js
const  resolver  = {
    Query:{
        Post(obj, args, context, info){
            return {name:'some name', id:args.id}
        }
    },
    Post:{
        name(post, args, context, info){
        return  post.name
    },
    id(post, args, context, info){
        return  post.id
    },
    data(post, args, context, info){
        return  post.data
    }
    },
    Subscription:(pubsub)=> ({
        postAdded: {
            subscribe:()=>{
                return  pubsub.asyncIterator('POST_ADDED')
            }
        }
    }),
    Mutation:(pubsub)=>({
        Post(obj, args, context, info){
            pubsub.publish('POST_ADDED', {postAdded:  args.input});
            return {...args.input}
        }
    })
}
export  default  resolver

 
app.graphql({pubsub:  new  yourOwnPubSub()})

import  postSchema  from  './schema'
import  postResolver  from  './resolver'
// create a graphql schema with our schema and resolver, define query
// subscription and mutation
export  default  function  PostSchema (app) {
    return  app
    .createGraphQlSchema(postSchema)
    .resolver(postResolver)
    .query(`Post(id: Int!): Post`)
    .mutation(`Post(input: newPost): Post`)
    .subscription(`postAdded: Post`)
}

import  Bliz  from  'bliz'
import  PostSchema  from  './Post'
app
.graphql({useGraphql:  true, useGraphiql:  true, tracing:  true})
.registerGraphQlSchemas(PostSchema(app))
.listen(4000)

import  Bliz  from  'bliz'
const  app  =  Bliz()
app
.graphql({useGraphql:  true, useGraphiql:  true})
.registerRemoteGraphQlSchemas({
    url:'http://localhost:4000/graphql',
    ws:  'ws://localhost:4000/subscriptions'
},{
    url:'http://localhost:5000/graphql',
    ws:  'ws://localhost:5000/subscriptions'
})
.listen(6000)