Jonatan Nilsson
8db66f416a
continuous-integration/appveyor/branch AppVeyor build failed
Details
|
||
---|---|---|
benchmark | ||
test | ||
.gitignore | ||
.npmrc | ||
LICENSE | ||
README.md | ||
appveyor.yml | ||
flaska.mjs | ||
package.json | ||
test.mjs |
README.md
Flaska
Flaska is a micro web-framework for node. It is designed to be fast, simple and lightweight, and is distributed as a single file module with no dependencies.
Heavily inspired by koa and koa-router it takes liberties of implementing most of the common functionality required for most sites without sacrificing anything. And the fact that the footprint for this is much smaller than koa while also being more powerful and faster shows the testament that is flaska.
Installation
$ npm install flaska
Hello Flaska
import { Flaska } from '../flaska.mjs'
const flaska = new Flaska()
flaska.get('/', function(ctx) {
ctx.body = 'Hello Flaska';
})
// flaska.listen(3000);
flaska.listenAsync(3000).then(function() {
console.log('listening on port 3000')
}, function(err) {
console.error('Error listening:', err)
})
Router/Handlers
Flaska supports all the common verbs out of the box:
flaska.get(url, [middlewares], handler)
flaska.post(url, [middlewares], handler)
flaska.put(url, [middlewares], handler)
flaska.delete(url, [middlewares], handler)
flaska.options(url, [middlewares], handler)
flaska.patch(url, [middlewares], handler)
Example:
flaska.get('/path/to/url', async function(ctx) {
// Perform action
})
In addition, each route can have none, one or many middlewares:
flaska.get('/handlequery', QueryHandler(), async function(ctx) {
// Perform action
})
flaska.get('/query/and/json', [QueryHandler(), JsonHandler()], async function(ctx) {
// Perform action
})
You can also run global middlewares at the start or end of every request:
import { Flaska, QueryHandler, JsonHandler } from '../flaska.mjs'
const flaska = new Flaska()
flaska.before(QueryHandler())
flaska.before(JsonHandler())
flaska.beforeAsync(MyLoadDatabase())
flaska.after(function(ctx) {
ctx.log.info('Request finished.')
})
Context, Request and Response
Each handler receives a Flaska Context
object that encapsulates an incoming
http message and the corresponding response to that message. For those familiar
with koa will be famililar with this concept. ctx
is often used as the parameter
name for the context object.
app.before(function(ctx) {
ctx.log.info('Got request')
})
app.beforeAsync(async function(ctx) {
// Do some database fetching maybe
})
The context ctx
that gets generated includes the following properties for the incoming request:
log
: Log handler.req
: The Request's IncomingMessage.res
: The Response's ServerResponse.method
: The HTTP method ('GET', 'POST', etc.).url
: The full URL path.search
: The URL search.state
: Anonymous object for user-defined data.query
: Map containing the key/value for the url search.
The following context specific variables can be specified by you the user to instruct Flaska on what to return in response:
status
: The status code to return in response (default 200).body
: The body contents to return in response (default null).type
: The content-type for the header (default null).length
: The length of the body in bytes (default null).
ctx.body
At the end of each request, flaska will read ctx.body
and determine the best course of action based on the type of content is being sent.
Javascript object
In cases where the response body is a normal object, Flaska will automatically JSON.stringify
it,
set the Content-Type
to application/json
and set the total length in Content-Length
. This
is provided for you at no expense on your behalf so you don't have to worry about it:
flaska.get('/api/test', function(ctx) {
ctx.body = {
message: 'Hello world',
}
})
pipe
In cases where the response body is a pipe object (detected from the existance of .pipe
property), flaska will automatically pipe it for you. In addition, if a file stream is used, it will read the extension of the file being streamed and automatically fill in the mime-type for you in the Content-Type
header.
flaska.get('/test.png', function(ctx) {
ctx.body = fs.createReadStream('./test/test.png')
})
Flaska will automatically close the file stream for you so you don't have to worry about that.
FileResponse
Alternatively, if you want proper file support, I recommend using FileResponse object:
import { FileResponse } from '../flaska.mjs'
flaska.get('/test.txt', function(ctx) {
return fs.stat('./test/test.txt').then(function(stat) {
ctx.body = new FileResponse('./test/test.txt', stat)
})
})
This performs a real file stream support, uses pipes and supports all the HTTP shenanigans when it comes to dealing with files, including sending proper etag header, supporting partial response and lots of other things. This is one of the few libraries that actually implements full HTTP partial and etag support in a proper way, almost all other have one or two quirks that don't follow the spec properly.
String
In other instances, Flaska will .toString()
the body and send it in response with the specified type or default to text/plain
if unspecified.
flaska.get('/file.html', function(ctx) {
ctx.body = `
<!doctype html>
<html lang="en">
<body>
<h1>Hello world</h1>
</body>
</html>
`
ctx.type = 'text/html; charset=utf-8'
})
The Context
object also provides shortcuts for methods on its request
and response
. In the prior
examples, ctx.type
can be used instead of ctx.response.type
and ctx.accepts
can be used
instead of ctx.request.accepts
.
Built-in middlewares and handlers
Flaska comes with a few middlewares out of the box.
QueryHandler()
Parse the search query and create a map with key->value in ctx.query
.
JsonHandler()
Parse incoming request body as json and store it in ctx.req.body
.
FormidableHandler()
Provides a wrapper to handle an incoming file upload using Formidable@1
.