import webservice from 'web-service'

const service = webservice({ routing: true })

// REST API routes
service.get ('/items/:id', async ({ id }) => ({ color : 'black' }))
service.post('/save/:id',  async ({ id, name, description }) => ({ result : true }))

service.listen(3000)

{
    // Incoming HTTP request IP address
    // (Trusts `X-Forwarded-For` header)
    ip,

    // Cookie helpers
    get_cookie,
    set_cookie,
    destroy_cookie,

    // If a Json Web Token was supplied in an HTTP request
    // (`Authorization: Bearer {token}` HTTP header),
    // then these three properties are set.
    //
    // The `user` object is gonna have 
    // a user `id` extracted from the token
    // along with all the extra fields 
    // extracted by `authentication` function 
    // (see "Json Web Token" section)
    user,
    //
    // Raw Json Web Token (can be used for additional HTTP requests)
    authentication_token,
    //
    // Json Web Token id (can be used for token expiration checks)
    authentication_token_id,

    // The secret keys passed to webservice
    keys,

    // A handy HTTP client for making "internal" HTTP requests
    // (`.get('/data', parameters).then(result => ...)`,
    //  `.post('/data', data).then(result => ...)`,
    //  etc)
    // 
    // If Json Web Token authentication is enabled
    // then this "internal" HTTP client utility will send HTTP requests
    // with "Authorization" HTTP header set appropriately.
    //
    // Therefore this `internal_http` utility should only be used
    // for sending HTTP requests to your own servers
    // (hence the word "internal")
    // to prevent leaking JWT token to a third party.
    //
    internal_http
}

import { api, errors } from 'web-service'

// Supports Web 1.0 Mode (for DarkNet: Tor, etc)

const service = api
({
    api:
    [
        function(api)
        {
            // web 2.0 mode (ajax)
            api.get('/get/:id', async ({ id }) =>
            {
                if (id <= 0)
                {
                    throw new errors.Input_rejected(`Invalid id: ${id}`)
                }

                return await database.get(id)
            })

            // web 1.0 mode (redirects to a URL when finished)
            api.legacy.post('/save/:id', async (input) =>
            {
                if (input.id <= 0)
                {
                    throw new errors.Input_rejected(`Invalid id: ${input.id}`)
                }

                await database.save(input)

                return { redirect: '/done' }
            },
            (error) => '/error')
        },
        ...
    ]
})

// // `api` array can be used with `require()` 
// // to split a large code base into modules
// const service = api
// ({
//     api:
//     [
//         require('./api/items'),
//         require('./api/users'),
//         require('./api/utility')
//     ]
// })

service.listen(3000)

import webservice from 'web-service'

const service = webservice()

// Performs an HTTP redirect (301 Moved Permanently)
service.redirect('/old', { to: '/new' })

// Serve static files from a folder on disk
service.files('/static', path.join(__dirname, '../static'))

// Proxy '/proxied' path to another server
// (make sure you proxy only to your own servers
//  so that you don't leak JWT token to a third party).
//
// Additional options may be passed as a third parameter.
// https://github.com/nodejitsu/node-http-proxy#options
//
service.proxy('/proxied', 'http://localhost:8080/api')

// Handle file uploads
service.upload('/upload', path.join(__dirname, '../uploads'),
{
   // (optional)
   // Will process each file being uploaded.
   // The returned value is gonna be sent back in HTTP response.
   process: async function({ path })
   {
      const contents = await fs.readFileAsync(path, 'utf-8')
      const stats = await analyze(contents)
      return { stats }

      // // Or maybe something like this
      // const converted_file_name = await convert(path)
      // return { filename: converted_file_name }
   }

   // // (optional)
   // // Instead of first writing files to disk
   // // and then `process`ing them,
   // // the uploaded files may be `stream`ed directly.
   // // `fields` are the `<form/>` fields.
   // stream: async function(file, fields, response)
   // {
   //    // To stream HTTP response manually
   //    file.pipe(analyzer).pipe(response)
   //    
   //    // // Without streaming HTTP response manually
   //    // return new Promise((resolve, reject) =>
   //    // {
   //    //    analyzer.on('end', result => resolve(result))
   //    //    analyzer.on('error', reject)
   //    //    file.pipe(analyzer)
   //    // })
   // },
   //
   // // `respond: false` tells the library that
   // // no response data should be sent to `response`
   // // (which means the user of the library
   // //  chose to send HTTP response manually)
   // respond: false
})

service.listen(3000)

const service = webservice
({
    keys: ['secret'],
    authentication: payload => ({ role: payload.role })
})

import { jwt, errors } from 'web-service'

export default function(api)
{	
    api.post('/login', async ({ name, password }, { set_cookie }) =>
    {
        const user = await database.users.get({ name })

        if (!user)
        {
            throw new errors.Not_found()
        }

        if (password !== user.password)
        {
            throw new errors.Input_rejected(`Wrong password`)
        }

        const jwt_id = '...' // a randomly generated unique id of some kind
        const payload = { role: 'admin' }
        const token = jwt(payload, keys, user_id, jwt_id)

        // The cookie is "HttpOnly" by default
        // (that means it can only be read on the server-side)
        set_cookie('authentication', token, { signed: false })
    }

    api.get('/restricted-data', async ({ parameter }, { user }) =>
    {
        if (!user)
        {
            throw new errors.Unauthenticated()
        }

        if (user.role !== 'admin')
        {
            throw new errors.Access_denied(`Must be an adminstrator to view the data`)
        }

        return await database.query(parameter)
    })
}