" + h("html", [
8 | h("head", [
9 | h("title", "Express"),
10 | // to expose state to the client
11 | // we create a script tag with JSONGlobals version
12 | // of the data. This will just expose a single
13 | // global variable called `__JSON_GLOBALS_`
14 | h("script", JSONGlobals(clientData))
15 | ]),
16 | h("body", [
17 | h("h1", "Expose client data"),
18 | h("p", "The following was exposed to the client:"),
19 | h("pre",
20 | h("script", [
21 | "document.write(JSON.stringify(__JSON_GLOBALS_, null, 2))"
22 | ]))
23 | ])
24 | ]).outerHTML
25 | }
26 |
--------------------------------------------------------------------------------
/documents/send-html.md:
--------------------------------------------------------------------------------
1 | # [`send-html`](https://github.com/Raynos/send-data)
2 |
3 | > I want to send a HTML payload to my user
4 |
5 | ```js
6 | var http = require("http")
7 | var fs = require("fs")
8 | var sendHtml = require("send-data/html")
9 |
10 | var page = fs.readFileSync(__dirname + "/static/index.html")
11 |
12 | http.createServer(function (req, res) {
13 | sendHtml(req, res, page)
14 | }).listen(8080)
15 | ```
16 |
17 | ## Alternatively by hand:
18 |
19 | ```js
20 | var http = require("http")
21 | var fs = require("fs")
22 |
23 | // note that fs.readFileSync returns a buffer
24 | var page = fs.readFileSync(__dirname + "/static/index.html")
25 |
26 | http.createServer(function (req, res) {
27 | res.statusCode = 200
28 | res.setHeader("Content-Type", "text/html")
29 | // ensure Content-Length is number of bytes, not number of characters
30 | res.setHeader("Content-Length", page.length)
31 | res.end(page)
32 | }).listen(8080)
33 | ```
34 |
--------------------------------------------------------------------------------
/examples/mvc/features/user/views/edit.js:
--------------------------------------------------------------------------------
1 | var h = require("hyperscript")
2 |
3 | module.exports = edit
4 |
5 | function edit(user, options) {
6 | return options.layout("Edit User", [
7 | h("h1", user.name),
8 | h("form", {
9 | action: options.urlMap.user({ userId: user.id }),
10 | method: "post"
11 | }, [
12 | h("label", [
13 | "Name: ",
14 | h("input", { type: "text", name: "name", value: user.name })
15 | ]),
16 | h("input", { type: "submit", value: "Update" })
17 | ]),
18 | h("form", {
19 | action: options.urlMap.userPet({ userId: user.id }),
20 | method: "post"
21 | }, [
22 | h("label", [
23 | "Pet: ",
24 | h("input", { type: "text", name: "name", placeholder: "name" })
25 | ]),
26 | h("input", { type: "submit", value: "Add" })
27 | ])
28 | ])
29 | }
30 |
--------------------------------------------------------------------------------
/examples/error/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/error/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 |
5 | var app = Router({
6 | // you can define your own error handler. If you call the cb
7 | // in (req, res, opts, cb) in your routes then this error
8 | // handler gets called
9 | errorHandler: function (req, res, err) {
10 | res.statusCode = 500
11 | res.end(err.message || "Internal server error")
12 | }
13 | })
14 |
15 | app.addRoute("/", function (req, res, opts, cb) {
16 | // try catch is slow. do not throw. pass them to cb
17 | cb(new Error("something broke!"))
18 | })
19 |
20 | app.addRoute("/next", function (req, res, opts, cb) {
21 | // you can pass asynchronous exceptions to the cb
22 | process.nextTick(function () {
23 | cb(new Error("oh no!"))
24 | })
25 | })
26 |
27 | var server = http.createServer(app)
28 | server.listen(3000)
29 | console.log("error server listening on port 3000")
30 |
--------------------------------------------------------------------------------
/LICENCE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2013 Raynos.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 |
--------------------------------------------------------------------------------
/examples/basic-auth/admin.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/senchalabs/connect/blob/master/examples/basicAuth.js
2 | var basic = require("basic")
3 | var Router = require("routes-router")
4 | var http = require("http")
5 |
6 | function sendBasicError(req, res) {
7 | res.statusCode = 401
8 | res.setHeader("WWW-Authenticate", "Basic realm=\"Secure Area\"")
9 | res.end("Unauthorized")
10 | }
11 |
12 | var auth = basic(function (user, pass, callback) {
13 | if (user === "tj" && pass === "tobi") {
14 | return callback(null)
15 | }
16 |
17 | callback(new Error("Access Denied"))
18 | })
19 |
20 | var app = Router()
21 |
22 | app.addRoute("/admin", function (req, res) {
23 | auth(req, res, function (err) {
24 | if (err) {
25 | return sendBasicError(req, res)
26 | }
27 |
28 | res.end("authorized!")
29 | })
30 | })
31 |
32 |
33 | app.addRoute("*", function (req, res) {
34 | res.end("hello! try /admin")
35 | })
36 |
37 | var adminServer = http.createServer(app)
38 | adminServer.listen(3000)
39 | console.log("basic authed admin server listening on port 3001")
40 |
--------------------------------------------------------------------------------
/examples/cors/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/tree/master/examples/cors
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var filed = require("filed")
5 | var Corsify = require("corsify")
6 | var jsonBody = require("body/json")
7 | var sendJson = require("send-data/json")
8 |
9 | var app = Router()
10 | var api = Router()
11 |
12 | app.addRoute("/", function (req, res) {
13 | filed(__dirname + "/static/index.html").pipe(res)
14 | })
15 |
16 | var cors = Corsify({
17 | "Access-Control-Allow-Origin": "http://localhost:3000"
18 | })
19 |
20 | api.addRoute("/user", cors(function (req, res, opts, cb) {
21 | jsonBody(req, res, function (err, body) {
22 | if (err) {
23 | return cb(err)
24 | }
25 |
26 | console.log("body", body)
27 | sendJson(req, res, body)
28 | })
29 | }))
30 |
31 | var appServer = http.createServer(app)
32 | appServer.listen(3000)
33 | console.log("cors app server listening on port 3000")
34 |
35 | var apiServer = http.createServer(api)
36 | apiServer.listen(3001)
37 | console.log("cors api server listening on port 3001")
38 |
--------------------------------------------------------------------------------
/examples/vhost/server.js:
--------------------------------------------------------------------------------
1 | // inspired by https://github.com/visionmedia/express/blob/master/examples/vhost/index.js
2 |
3 | /*
4 | edit /etc/hosts:
5 |
6 | 127.0.0.1 foo.example.com
7 | 127.0.0.1 bar.example.com
8 | 127.0.0.1 example.com
9 | */
10 |
11 | var http = require("http")
12 | var redirecter = require("redirecter")
13 | var Router = require("routes-router")
14 |
15 | var vhost = require("./vhost.js")
16 |
17 | var main = Router()
18 |
19 | main.addRoute("/", function (req, res) {
20 | res.end("Hello from main app!")
21 | })
22 | main.addRoute("/:sub", function (req, res, opts) {
23 | res.end("you requested " + opts.sub)
24 | })
25 |
26 | // redirect router
27 |
28 | var redirect = Router()
29 |
30 | redirect.addRoute("*", function (req, res) {
31 | var subdomains = (req.headers.host || "").split(".")
32 |
33 | redirecter(req, res, "http://example.com:3000/" + subdomains[0])
34 | })
35 |
36 | var app = Router()
37 | app.addRoute("*", vhost({
38 | "*.example.com": redirect,
39 | "example.com": main
40 | }))
41 |
42 | var server = http.createServer(app)
43 | server.listen(3000)
44 | console.log("vhost server started on port 3000")
45 |
--------------------------------------------------------------------------------
/examples/content-negotiation/server.js:
--------------------------------------------------------------------------------
1 | // https://github.com/visionmedia/express/blob/master/examples/content-negotiation/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var mediaTypes = require("media-types")
5 | var sendText = require("send-data")
6 | var sendJson = require("send-data/json")
7 | var sendHtml = require("send-data/html")
8 |
9 | var users = [
10 | { name: "Tobi" },
11 | { name: "Loki" },
12 | { name: "Jane" }
13 | ]
14 |
15 | var app = Router()
16 |
17 | app.addRoute("/", mediaTypes({
18 | "text/html": function (req, res) {
19 | sendHtml(req, res, "" + users.map(function (user) {
20 | return "" + user.name + " "
21 | }).join("") + " ")
22 | },
23 | "application/json": function (req, res) {
24 | sendJson(req, res, users)
25 | },
26 | "default": function (req, res) {
27 | sendText(req, res, users.map(function (user) {
28 | return " - " + user.name + "\n"
29 | }).join(""))
30 | }
31 | }))
32 |
33 | var server = http.createServer(app)
34 | server.listen(3000)
35 | console.log("content negotiation server listening on port 3000")
36 |
--------------------------------------------------------------------------------
/examples/route-seperation/routes/user/edit.js:
--------------------------------------------------------------------------------
1 | var sendHtml = require("send-data/html")
2 | var formBody = require("body/form")
3 | var redirecter = require("redirecter")
4 |
5 | var userPage = require("../../templates/users/edit.js")
6 | var loadUser = require("./load-user.js")
7 | var users = require("./user-db.js")
8 |
9 | module.exports = {
10 | GET: renderPage,
11 | POST: updateUser
12 | }
13 |
14 | function renderPage(req, res, opts, callback) {
15 | loadUser(opts.id, function (err, user) {
16 | if (err) {
17 | return callback(err)
18 | }
19 |
20 | sendHtml(req, res, userPage({
21 | title: "Editing user " + user.name,
22 | name: user.name,
23 | email: user.email
24 | }))
25 | })
26 | }
27 |
28 | // normally you would handle validation logic and asynchronously
29 | // save back to the database
30 | function updateUser(req, res, opts, callback) {
31 | var userId = opts.id
32 | formBody(req, res, function (err, body) {
33 | if (err) {
34 | return callback(err)
35 | }
36 |
37 | users[userId] = body
38 |
39 | redirecter(req, res, "/users/" + userId + "/edit")
40 | })
41 | }
42 |
--------------------------------------------------------------------------------
/examples/vhost/vhost.js:
--------------------------------------------------------------------------------
1 | // heavily based on https://github.com/senchalabs/connect/blob/master/lib/middleware/vhost.js
2 | module.exports = vhost
3 |
4 | // this should be a module on npm!
5 | function vhost(hosts) {
6 | var pairs = Object.keys(hosts).map(function (hostName) {
7 | var handler = hosts[hostName]
8 | var regexp = new RegExp("^" + hostName
9 | .replace(/[^*\w]/g, "\\$&")
10 | .replace(/[*]/g, "(?:.*?)") + "$", "i")
11 |
12 | return [regexp, handler]
13 | })
14 |
15 | return function (req, res, opts, cb) {
16 | if (!req.headers.host) {
17 | return cb(new Error("no host header found"))
18 | }
19 |
20 | var host = req.headers.host.split(":")[0]
21 | var handled = pairs.some(function (pair) {
22 | var regexp = pair[0]
23 | var handler = pair[1]
24 |
25 | var match = regexp.test(host)
26 | if (!match) {
27 | return false
28 | }
29 |
30 | handler(req, res)
31 | return true
32 | })
33 |
34 | if (!handled) {
35 | return cb(new Error("could not find a vhost redirect match"))
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/examples/online/server.js:
--------------------------------------------------------------------------------
1 | // https://github.com/visionmedia/express/blob/master/examples/online/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var redis = require("redis")
5 | var Online = require("online")
6 | var sendHtml = require("send-data/html")
7 |
8 | var db = redis.createClient()
9 | var online = Online(db)
10 | var app = Router()
11 |
12 | function lists(ids) {
13 | return "" + ids.map(function (id) {
14 | return "" + id + " "
15 | }).join("") + " "
16 | }
17 |
18 | // GET users online
19 | app.addRoute("/", function (req, res, opts, cb) {
20 | online.last(5, function (err, ids) {
21 | if (err) {
22 | return cb(err)
23 | }
24 |
25 | sendHtml(req, res, "Users online: " + ids.length +
26 | "
" + lists(ids))
27 | })
28 | })
29 |
30 | // if you want to do something globally you should put it in
31 | // your server request response handler
32 | var server = http.createServer(function (req, res) {
33 | // activity tracking, in this case the UA string
34 | // normally you would get it from the session
35 | online.add(req.headers["user-agent"])
36 | app(req, res)
37 | })
38 | server.listen(3000)
39 | console.log("online server listening on port 3000")
40 |
--------------------------------------------------------------------------------
/examples/search/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/search/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var redis = require("redis")
5 | var filed = require("filed")
6 | var sendJson = require("send-data/json")
7 |
8 | // create and instantiate a redis db connection
9 | var db = redis.createClient()
10 | var app = Router()
11 |
12 | // initialize db
13 | db.sadd("ferret", "tobi")
14 | db.sadd("ferret", "loki")
15 | db.sadd("ferret", "jane")
16 | db.sadd("cat", "manny")
17 | db.sadd("cat", "luna")
18 |
19 | // GET the search page
20 | app.addRoute("/", function (req, res) {
21 | filed(__dirname + "/page.html").pipe(res)
22 | })
23 |
24 | // GET search for :query
25 | app.addRoute("/search/:query?", function (req, res, opts, cb) {
26 | var query = opts.query
27 | db.smembers(query, function (err, vals) {
28 | if (err) {
29 | return cb(err)
30 | }
31 |
32 | sendJson(req, res, vals)
33 | })
34 | })
35 |
36 | // serve the javascript client seperately.
37 | app.addRoute("/client.js", function (req, res) {
38 | filed(__dirname + "/client.js").pipe(res)
39 | })
40 |
41 | var server = http.createServer(app)
42 | server.listen(3000)
43 | console.log("search app listening on port 3000")
44 |
--------------------------------------------------------------------------------
/examples/route-map/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/route-map/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var sendText = require("send-data")
5 |
6 | var map = require("./map.js")
7 |
8 | var app = Router()
9 |
10 | var users = {
11 | list: function (req, res) {
12 | sendText(req, res, "user list")
13 | },
14 | get: function (req, res, opts) {
15 | sendText(req, res, "user " + opts.uid)
16 | },
17 | del: function (req, res) {
18 | sendText(req, res, "delete users")
19 | }
20 | }
21 | var pets = {
22 | list: function (req, res, opts) {
23 | sendText(req, res, "user " + opts.uid + "'s pets")
24 | },
25 | del: function (req, res, opts) {
26 | sendText(req, res, "delete " + opts.uid + "'s pet " + opts.pid)
27 | }
28 | }
29 |
30 | map(app, {
31 | "/users": {
32 | GET: users.list,
33 | DELETE: users.del,
34 | "/:uid": {
35 | GET: users.get,
36 | "/pets": {
37 | GET: pets.list,
38 | "/:pid": {
39 | DELETE: pets.del
40 | }
41 | }
42 | }
43 | }
44 | })
45 |
46 | var server = http.createServer(app)
47 | server.listen(3000)
48 | console.log("map example server is listening on port 3000")
49 |
--------------------------------------------------------------------------------
/examples/mvc/db.js:
--------------------------------------------------------------------------------
1 | var level = require("level")
2 | var SubLevel = require("level-sublevel")
3 |
4 | module.exports = Db
5 |
6 | // Create a database based on our configuration
7 | // we keep the production & local database seperate
8 | // also set encoding to json so we can just store objects
9 | function Db(config) {
10 | var db = level(config.dbPath, {
11 | valueEncoding: "json",
12 | keyEncoding: "json"
13 | })
14 |
15 | initializeDb(db)
16 |
17 | return db
18 | }
19 |
20 | // put fake data in the database!
21 | function initializeDb(db) {
22 | var pets = []
23 |
24 | pets.push({ name: "Tobi", id: "0" })
25 | pets.push({ name: "Loki", id: "1" })
26 | pets.push({ name: "Jane", id: "2" })
27 | pets.push({ name: "Raul", id: "3" })
28 |
29 | var users = []
30 |
31 | users.push({ name: "TJ", pets: [pets[0], pets[1], pets[2]], id: "0" })
32 | users.push({ name: "Guillermo", pets: [pets[3]], id: "1" })
33 | users.push({ name: "Nathan", pets: [], id: "2" })
34 |
35 | db = SubLevel(db)
36 |
37 | var usersDb = db.sublevel("users")
38 | var petsDb = db.sublevel("pets")
39 |
40 | petsDb.put(pets[0].id, pets[0])
41 | petsDb.put(pets[1].id, pets[1])
42 | petsDb.put(pets[2].id, pets[2])
43 | petsDb.put(pets[3].id, pets[3])
44 |
45 | usersDb.put(users[0].id, users[0])
46 | usersDb.put(users[1].id, users[1])
47 | usersDb.put(users[2].id, users[2])
48 | }
49 |
--------------------------------------------------------------------------------
/examples/auth/template.js:
--------------------------------------------------------------------------------
1 | var h = require("hyperscript")
2 |
3 | var styleContent = [
4 | "body {",
5 | " padding: 50px;",
6 | " font: 13px Helvetica, Arial, sans-serif;",
7 | "}",
8 | ".error {",
9 | " color: red;",
10 | "}",
11 | ".success {",
12 | " color: green;",
13 | "}"
14 | ].join("\n")
15 |
16 | module.exports = template
17 |
18 | function template(opts) {
19 | return layout("Authentication Example", [
20 | h("h1", "Login"),
21 | h("div", { innerHTML: opts.message }),
22 | "Try accessing ",
23 | h("a", { href: "/restricted" }, "/restricted"),
24 | ", then authenticate with tj and foobar",
25 | h("form", { method: "post", action: "/login" }, [
26 | h("p", [
27 | h("label", "Username:"),
28 | h("input", { type: "text", name: "username" })
29 | ]),
30 | h("p", [
31 | h("label", "Password:"),
32 | h("input", { type: "text", name: "password" })
33 | ]),
34 | h("p",
35 | h("input", { type: "submit", value: "Login" }))
36 | ])
37 | ])
38 | }
39 |
40 | function layout(title, content) {
41 | return "" +
42 | h("html",
43 | h("head", [
44 | h("title", title),
45 | h("style", styleContent)
46 | ]),
47 | h("body", content)
48 | ).outerHTML
49 | }
50 |
--------------------------------------------------------------------------------
/examples/session/redis.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/session/redis.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var Session = require("redsess")
5 | var Redis = require("redis")
6 | var sendHtml = require("send-data/html")
7 |
8 | // create a single redis connection. This is shared among all
9 | // req/res pairs in your server
10 | var client = Redis.createClient()
11 |
12 | var app = Router()
13 |
14 | app.addRoute("/", function (req, res, opts, cb) {
15 | var session = Session(req, res, { client: client })
16 |
17 | // get a value of the session is a database read is async
18 | session.get("views", function (err, views) {
19 | if (err) {
20 | return cb(err)
21 | }
22 |
23 | views = views || 0
24 | views++
25 |
26 | // setting a value in the session is a database write and
27 | // is async
28 | session.set("views", views, function (err) {
29 | if (err) {
30 | return cb(err)
31 | }
32 |
33 | var html = ""
34 |
35 | if (views === 1) {
36 | html += "First time visiting?" +
37 | " view this page in several browsers :)
"
38 | }
39 |
40 | sendHtml(req, res, html + "viewed " +
41 | views + " times.
")
42 | })
43 | })
44 | })
45 |
46 | var server = http.createServer(app)
47 | server.listen(3000)
48 | console.log("redis session server on port 3000")
49 |
50 |
--------------------------------------------------------------------------------
/documents/filed.md:
--------------------------------------------------------------------------------
1 | # [`filed`](https://github.com/mikeal/filed)
2 |
3 | > I want to send a file down a response
4 |
5 | Using `filed` you will stream a file down the `HttpResponse`. The usage
6 | of streaming the payload is nice for efficiency and memory usage.
7 |
8 | ```js
9 | var http = require("http")
10 | var filed = require("filed")
11 |
12 | http.createServer(function (req, res) {
13 | filed(__dirname + "/static/index.html").pipe(res)
14 | }).listen(8080)
15 | ```
16 |
17 | ## Alternatively by hand:
18 |
19 | ```js
20 | var http = require("http")
21 | var fs = require("fs")
22 |
23 | http.createServer(function (req, res) {
24 | var filePath = __dirname + "/static/index.html"
25 | // optionally stat the file your streaming. This allows you
26 | // to set the Content-Length header.
27 | fs.stat(filePath, function (err, stat) {
28 | if (err) {
29 | // the ENOENT code means no such file or directory
30 | if (err.code === "ENOENT") {
31 | res.statusCode = 404
32 | return res.end("Not Found")
33 | }
34 |
35 | res.statusCode = 500
36 | return res.end(err.message)
37 | }
38 |
39 | // you can skip the fs.stat call and just stream the content directly
40 | var stream = fs.createReadStream(__dirname + "/static/index.html")
41 | res.statusCode = 200
42 | res.setHeader("Content-Type", "text/html")
43 | res.setHeader("Content-Length", stat.size)
44 | stream.pipe(res)
45 | })
46 | }).listen(8080)
47 | ```
48 |
--------------------------------------------------------------------------------
/examples/session/memory.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/session/redis.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var Session = require("generic-session")
5 | var MemoryStore = require("generic-session").MemoryStore
6 | var sendHtml = require("send-data/html")
7 |
8 | // create a single memory store for session data is used by
9 | // all req/res pairs in the http server
10 | var store = MemoryStore()
11 |
12 | var app = Router()
13 |
14 | app.addRoute("/", function (req, res, opts, cb) {
15 | var session = Session(req, res, store)
16 |
17 | // get a value of the session is a database read is async
18 | session.get("views", function (err, views) {
19 | if (err) {
20 | return cb(err)
21 | }
22 |
23 | views = views || 0
24 | views++
25 |
26 | // setting a value in the session is a database write and
27 | // is async
28 | session.set("views", views, function (err) {
29 | if (err) {
30 | return cb(err)
31 | }
32 |
33 | var html = ""
34 |
35 | if (views === 1) {
36 | html += "First time visiting?" +
37 | " view this page in several browsers :)
"
38 | }
39 |
40 | sendHtml(req, res, html + "viewed " +
41 | views + " times.
")
42 | })
43 | })
44 | })
45 |
46 | var server = http.createServer(app)
47 | server.listen(3000)
48 | console.log("memory session server on port 3000")
49 |
50 |
--------------------------------------------------------------------------------
/examples/expose-data-to-client/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/blob/master/examples/expose-data-to-client/index.js
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var redirect = require("redirecter")
5 | var sendHtml = require("send-data/html")
6 |
7 | var template = require("./template.js")
8 |
9 | function User(name) {
10 | this.private = "heyyyy"
11 | this.secret = "something"
12 | this.name = name
13 | this.id = 123
14 | }
15 |
16 | // you want to serialize the user without 'secret' stuff
17 | User.prototype.toJSON = function () {
18 | return { id: this.id, name: this.name }
19 | }
20 |
21 | // dummy user loading function
22 | function getUser(req, res, callback) {
23 | process.nextTick(function () {
24 | callback(null, new User("Tobi"))
25 | })
26 | }
27 |
28 | var app = Router()
29 |
30 | app.addRoute("/", function (req, res) {
31 | redirect(req, res, "/user")
32 | })
33 |
34 | app.addRoute("/user", function (req, res, opts, cb) {
35 | getUser(req, res, function (err, user) {
36 | if (err) {
37 | return cb(err)
38 | }
39 |
40 | var clientData = { user: user }
41 | // we expose the clientData by passing it to the template
42 | // the template will expose this properly.
43 | // you can pass the data to your layout instead to avoid
44 | // passing it to every template
45 | sendHtml(req, res, template(clientData))
46 | })
47 | })
48 |
49 | var server = http.createServer(app)
50 | server.listen(3000)
51 | console.log("expose data to client server listening on port 3000")
52 |
--------------------------------------------------------------------------------
/documents/cookies.md:
--------------------------------------------------------------------------------
1 | # [`cookies`](https://github.com/mikeal/cookies)
2 |
3 | > I want to persist data between req/res pairs from the same client
4 |
5 | Using `cookies` you cam `get()` and `set()` HTTP cookies on a req / res
6 | pair. `cookies` also allows you to handle options like signed cookies
7 | and setting the domain / http only flag. Cookies will stick in the
8 | http client and will be send again with the next request by that
9 | client.
10 |
11 | ```js
12 | var http = require("http")
13 | var cookies = require("cookies")
14 |
15 | http.createServer(function (req, res) {
16 | var cookies = Cookies(req, res)
17 |
18 | // fetch value out of cookie
19 | var count = Number(cookies.get("count")) || 0
20 | count++
21 | // store value in cookie
22 | cookies.set("count", String(count))
23 |
24 | res.end("you have watched this page " + count + " times")
25 | }).listen(8080)
26 | ```
27 |
28 | ## Alternatively by hand:
29 |
30 | ```js
31 | var http = require("http")
32 |
33 | http.createServer(function (req, res) {
34 | var cookie = req.headers.cookie || ""
35 |
36 | // parse cookie out
37 | var pairs = cookie.split(";")
38 | var obj = {}
39 | pairs.forEach(function (pair) {
40 | var parts = pair.split("=")
41 | obj[parts[0].trim()] = parts[1].trim()
42 | })
43 |
44 | var count = Number(obj.count) || 0
45 | count++
46 |
47 | // serialize cookie
48 | res.setHeader("Set-Cookie", "count=" + count)
49 |
50 | res.end("you have watched this page " + count + " times")
51 | }).listen(8080)
52 | ```
53 |
54 | Note that using `cookies` gives you a more forgiving parser &
55 | serializer as well as it handling all options & signed
56 | cookies.
57 |
--------------------------------------------------------------------------------
/examples/cookies/server.js:
--------------------------------------------------------------------------------
1 | // based on https://github.com/visionmedia/express/tree/master/examples/cookies
2 | var http = require("http")
3 | var Router = require("routes-router")
4 | var redirect = require("redirecter")
5 | var sendHtml = require("send-data/html")
6 | var formBody = require("body/form")
7 | var Cookies = require("cookies")
8 |
9 | var SECOND = 1000
10 | var MINUTE = 60 * SECOND
11 |
12 | var app = Router()
13 |
14 | app.addRoute("/", {
15 | GET: function (req, res) {
16 | var cookies = new Cookies(req, res)
17 |
18 | if (cookies.get("remember")) {
19 | sendHtml(req, res, "Remembered :). Click to " +
20 | "forget ")
21 | } else {
22 | sendHtml(req, res, "")
26 | }
27 | },
28 | POST: function (req, res, opts, cb) {
29 | formBody(req, res, function (err, body) {
30 | if (err) {
31 | return cb(err)
32 | }
33 |
34 | var cookies = new Cookies(req, res)
35 | if (body.remember) {
36 | cookies.set("remember", 1, { maxage: MINUTE })
37 | }
38 |
39 | redirect(req, res, "back")
40 | })
41 | }
42 | })
43 |
44 | app.addRoute("/forget", function (req, res) {
45 | var cookies = new Cookies(req, res)
46 | cookies.set("remember", "", { expires: new Date(0) })
47 | redirect(req, res, "back")
48 | })
49 |
50 | var server = http.createServer(app)
51 | server.listen(3000)
52 | console.log("cookies server is listening on port 3000")
53 |
--------------------------------------------------------------------------------
/examples/mvc/features/pet/model.js:
--------------------------------------------------------------------------------
1 | var SubLevel = require("level-sublevel")
2 |
3 | module.exports = PetModel
4 |
5 | function PetModel(db) {
6 | db = SubLevel(db)
7 |
8 | var users = db.sublevel("users")
9 | var pets = db.sublevel("pets")
10 |
11 | return {
12 | get: get,
13 | create: create,
14 | getAll: getAll,
15 | setName: setName
16 | }
17 |
18 | function get(id, callback) {
19 | pets.get(id, function (err, result) {
20 | if (err && err.notFound) {
21 | return callback(null, null)
22 | }
23 |
24 | callback(err, result)
25 | })
26 | }
27 |
28 | function getAll(callback) {
29 | var list = []
30 | var stream = pets.createReadStream()
31 |
32 | stream
33 | .on("data", onData)
34 | .once("error", callback)
35 | .once("end", function onEnd() {
36 | stream.removeListener("data", onData)
37 |
38 | callback(null, list)
39 | })
40 |
41 | function onData(chunk) {
42 | list.push(chunk.value)
43 | }
44 | }
45 |
46 | function setName(id, name, callback) {
47 | pets.get(id, function (err, pet) {
48 | if (err) {
49 | return callback(err)
50 | }
51 |
52 | pet.name = name
53 |
54 | pets.put(id, pet, function (err) {
55 | if (err) {
56 | return callback(err)
57 | }
58 |
59 | //TODO. Fix the user records we denormalized
60 | callback(null, pet)
61 | })
62 | })
63 | }
64 |
65 | function create(pet, callback) {
66 | pets.put(pet.id, pet, callback)
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "http-framework",
3 | "version": "1.2.0",
4 | "description": "A web framework based purely on `require('http')`",
5 | "keywords": [],
6 | "author": "Raynos ",
7 | "repository": "git://github.com/Raynos/http-framework.git",
8 | "main": "index",
9 | "homepage": "https://github.com/Raynos/http-framework",
10 | "contributors": [
11 | {
12 | "name": "Raynos"
13 | },
14 | {
15 | "name": "Matt-Esch"
16 | },
17 | {
18 | "name": "maxogden"
19 | }
20 | ],
21 | "bugs": {
22 | "url": "https://github.com/Raynos/http-framework/issues",
23 | "email": "raynos2@gmail.com"
24 | },
25 | "dependencies": {
26 | "redirecter": "~0.2.1",
27 | "routes-router": "~1.5.3",
28 | "error": "~2.0.3",
29 | "send-data": "~3.1.2",
30 | "st": "~0.2.3",
31 | "generic-session": "0.0.2",
32 | "redsess": "~0.3.2",
33 | "filed": "~0.1.0",
34 | "hyperscript": "~1.3.2",
35 | "process": "~0.5.1",
36 | "body": "~2.0.1",
37 | "pwd": "0.0.2",
38 | "media-types": "~1.0.3",
39 | "cookies": "~0.3.8",
40 | "corsify": "~1.0.2",
41 | "json-globals": "~0.2.1",
42 | "multiparty": "~3.1.0",
43 | "config-chain": "~1.1.8",
44 | "string-template": "~0.1.3",
45 | "basic": "~0.0.1",
46 | "csrf-lite": "~0.1.0",
47 | "serve-favicon":"~2.0.0",
48 | "serve-file-download":"~0.0.1"
49 | },
50 | "devDependencies": {
51 | "redis": "~0.9.0",
52 | "online": "0.0.1",
53 | "level": "~0.18.0",
54 | "level-sublevel": "~5.1.1",
55 | "uuid": "~1.4.1",
56 | "joi": "~2.0.3",
57 | "tape":"~2.13.0"
58 | },
59 | "licenses": [
60 | {
61 | "type": "MIT",
62 | "url": "http://github.com/Raynos/http-framework/raw/master/LICENSE"
63 | }
64 | ],
65 | "scripts": {
66 | "test": "echo 'no tests'"
67 | }
68 | }
69 |
--------------------------------------------------------------------------------
/examples/multipart/multiparty-form.js:
--------------------------------------------------------------------------------
1 | var Form = require("multiparty").Form
2 |
3 | module.exports = MultipartyForm
4 |
5 | // This should be a module on npm
6 | function MultipartyForm(req, res, opts, cb) {
7 | var form = new Form()
8 | var fields = {}
9 | var files = {}
10 | var result = { fields: fields, files: files }
11 | var counter = 1
12 | form.parse(req)
13 |
14 | // any normal non file form input is considered a field
15 | // if you had logout ")
91 | }))
92 |
93 | app.addRoute("/logout", function (req, res, opts, callback) {
94 | var session = Session(req, res, store)
95 | // destroy(cb) will delete the entire session for this user.
96 | // this means a new one will be created next time
97 | session.destroy(function (err) {
98 | if (err) {
99 | return callback(err)
100 | }
101 |
102 | redirect(req, res, "/")
103 | })
104 | })
105 |
106 | app.addRoute("/login", {
107 | GET: function (req, res, opts, callback) {
108 | var session = Session(req, res, store)
109 | // fetch the message out of the session. if a previous
110 | // POST failed or succeeded we will generate a message
111 | session.get("message", function (err, doc) {
112 | if (err) {
113 | return callback(err)
114 | }
115 |
116 | var message = ""
117 | if (doc && doc.type === "error") {
118 | message = "" + doc.text + "
"
119 | }
120 | if (doc && doc.type === "success") {
121 | message = "" + doc.text + "
"
122 | }
123 |
124 | // we are rendering the message so make sure to remove it
125 | // from the session otherwise it will be seen twice
126 | session.del("message", function (err) {
127 | if (err) {
128 | return callback(err)
129 | }
130 |
131 | sendHtml(req, res, template({ message: message }))
132 | })
133 | })
134 | },
135 | POST: function (req, res, opts, callback) {
136 | formBody(req, res, function (err, body) {
137 | if (err) {
138 | return callback(err)
139 | }
140 |
141 | authenticate(body.username, body.password, function (err, user) {
142 | var session = Session(req, res, store)
143 |
144 | // if no user matches authentication then set error message
145 | // for next GET to login
146 | if (err || !user) {
147 | return session.set("message", {
148 | type: "error",
149 | text: "Authentication failed, pleace check your " +
150 | " username and password." +
151 | " (user 'tj' and 'foobar')"
152 | }, function (err) {
153 | if (err) {
154 | return callback(err)
155 | }
156 |
157 | redirect(req, res, "/login")
158 | })
159 | }
160 |
161 | // succesfull user authentication. we should delete any
162 | // existing session
163 | session.del(function (err) {
164 | if (err) {
165 | return callback(err)
166 | }
167 |
168 | // then set the user
169 | session.set("user", user, function (err) {
170 | if (err) {
171 | return callback(err)
172 | }
173 |
174 | // and a success message
175 | session.set("message", {
176 | type: "success",
177 | text: "Authenticated as " + user.name +
178 | " click to logout . " +
179 | " You may now access " +
180 | "/restricted "
181 | }, function (err) {
182 | if (err) {
183 | return callback(err)
184 | }
185 |
186 | redirect(req, res, "/login")
187 | })
188 | })
189 | })
190 | })
191 | })
192 | }
193 | })
194 |
195 | // really should use https for security
196 | var server = http.createServer(app)
197 | server.listen(3000)
198 | console.log("example auth server listening on port 3000")
199 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # http-framework
2 |
3 | A web framework based purely on `require('http')`
4 |
5 |
6 |
7 | **Table of Contents** *generated with [DocToc](http://doctoc.herokuapp.com/)*
8 |
9 | - [http-framework](#http-framework)
10 | - [Motivation](#motivation)
11 | - [[Modules][20]](#modules20)
12 | - [For a complete list of [Modules check out the wiki][20]](#for-a-complete-list-of-modules-check-out-the-wiki20)
13 | - [[Documentation][26]](#documentation26)
14 | - [[HTTP workshop][27]](#http-workshop27)
15 | - [module docs](#module-docs)
16 | - [rest of the modules](#rest-of-the-modules)
17 | - [[Examples][17]](#examples17)
18 | - [[`express`][18] inspired examples](#express18-inspired-examples)
19 | - [[`hapi`][24] inspired examples](#hapi24-inspired-examples)
20 | - [[`connect`][25] inspired examples](#connect25-inspired-examples)
21 | - [Todo](#todo)
22 | - [Installation](#installation)
23 | - [Contributors](#contributors)
24 | - [MIT Licenced](#mit-licenced)
25 |
26 |
27 |
28 |
29 | ## Motivation
30 |
31 | `require('http')` is a web framework. All you need are a few
32 | small modules that do one thing well when you are building your
33 | web application route handlers.
34 |
35 | This module aggregates and documents (with examples) a selection
36 | of small modules that can be used to achieve this goal.
37 |
38 | It's recommended you check out the:
39 |
40 | - [the wiki of modules][23]
41 | - [the documentation][22]
42 | - [the examples][21]
43 |
44 | I do not recommend you use this "framework". You should check
45 | out the small modules and use them directly. Use the list of
46 | examples here for inspiration.
47 |
48 | http-framework is an OPEN Open Source Project, see the Contributing
49 | section to find out what this means.
50 |
51 | ## [Modules][20]
52 |
53 | Check out the [modules folder](modules) for an example of small
54 | modules you can combine to build your own custom "framework"
55 |
56 | See the [`package.json`][19] dependencies hash for an example of
57 | many small modules used in the examples folder of this project.
58 |
59 | ### For a complete list of [Modules check out the wiki][20]
60 |
61 | ## [Documentation][26]
62 |
63 | ### [HTTP workshop][27]
64 |
65 | For a tutorial / workshop see [http-works][27]
66 |
67 | ### module docs
68 |
69 | - [config-chain](documents/config-chain.md)
70 | - [cookies](documents/cookies.md)
71 | - [corsify](documents/corsify.md)
72 | - [csrf-lite](documents/csrf-lite.md)
73 | - [filed](documents/filed.md)
74 | - [form-body](documents/form-body.md)
75 | - [send-json](documents/send-json.md)
76 | - [send-html](documents/send-html.md)
77 |
78 | ### rest of the modules
79 |
80 | ```js
81 | // TODO
82 | ```
83 |
84 | For now see the [examples folder][17]
85 |
86 | ## [Examples][17]
87 |
88 | ### [`express`][18] inspired examples
89 |
90 | These examples are clones of [`express`][18] examples demonstrating
91 | how to author web apps without frameworks.
92 |
93 | - [**auth**](examples/auth)
94 | An example demonstrating how to login and authenticate users
95 | - [**auth-helpers**](examples/auth-helpers)
96 | An example demonstrating how you can restrict certain routes in your
97 | apps to only be accessed by certain types of users
98 | - [**content-negotiation**](examples/content-negotiation)
99 | An example demonstrating how you can return different types of
100 | content based on what the user asks for in his Accept header.
101 | - [**cookie-sessions**](examples/cookie-sessions)
102 | An example of storing session information in a users cookie
103 | - [**cookies**](examples/cookies)
104 | An example of setting a cookie to track a user
105 | - [**cors**](examples/cors)
106 | An example of adding cors support to your HTTP server
107 | - [**downloads**](examples/downloads)
108 | An example of allowing users to download files from your server
109 | - [**error**](examples/error)
110 | An example of handling errors in your HTTP server
111 | - [**error-pages**](examples/error-pages)
112 | An example of rendering custom 500 and 404 pages in your web
113 | server
114 | - [**expose-data-to-client**](examples/expose-data-to-client)
115 | An example of putting server side state into your template
116 | so that it can be accessed from browser javascript
117 | - [**hello-world**](examples/hello-world)
118 | A simple hello world example
119 | - [**multipart**](examples/multipart)
120 | An example demonstrating file uploads and saving them to
121 | disk temporarily.
122 | - [**mvc**](examples/mvc)
123 | An over engineered example of how to structure a slightly
124 | larger web application. Includes configuration, modularity
125 | and databases. Take ideas from it, please do not copy paste it
126 | - [**online**](examples/online)
127 | An example of using redis and the `online` module to track
128 | user presence
129 | - [**route-map**](examples/route-map)
130 | An example of a `map` utility function that can be used to
131 | structure your routes differently. This demonstrates you can
132 | do whatever you want, if you like it, do it.
133 | - [**route-seperation**](examples/route-seperation)
134 | An example of spreading your route handlers over multiple
135 | files.
136 | - [**search**](examples/search)
137 | An example of doing a database query over XHR with a web
138 | server backed by redis
139 | - [**session**](examples/session)
140 | An example of storing information in a session. The session
141 | is either backed by redis or memory.
142 | - [**static-files**](examples/static-files)
143 | An example of serving static files for your web server
144 | - [**vhost**](examples/vhost)
145 | An example of handling multiple sub domains as seperate
146 | applications in a singlue web server
147 | - [**web-service**](examples/web-service)
148 | An example JSON REST api web server. Contains API key
149 | authentication and error handling
150 |
151 | Credit for the applications goes to
152 |
153 | - @tj & express maintainers
154 |
155 | ### [`hapi`][24] inspired examples
156 |
157 | These examples are clones of [`hapi`][24] examples demonstrating
158 | how to author web apps without frameworks.
159 |
160 | - [**tail**](examples/tail)
161 | An example of handling async errors in your applications
162 | after you have ended the HTTP response
163 | - [**validate-api**](examples/validate-api)
164 | An example of how to add validation logic to your HTTP
165 | route handlers. Both validating query params & the HTTP body
166 |
167 | Credit for the application's goes to
168 |
169 | - @hapijs & hapi maintainers
170 |
171 | ### [`connect`][25] inspired examples
172 |
173 | These examples are clones of [`connect`][25] examples demonstrating
174 | how to author web apps without frameworks.
175 |
176 | - [**basic-auth**](examples/basic-auth)
177 | An example of handling basic authorization style authentication
178 | of a web server.
179 | - [**csrf**](examples/csrf)
180 | An example of adding csrf security to a form in a web application
181 |
182 | Credit for the applications goes to
183 |
184 | - @tj & connect maintainers
185 |
186 | ## Todo
187 |
188 | - [x] Finish porting express examples
189 | - [ ] continue porting hapi examples
190 | - [ ] continue connect examples
191 | - [ ] Port koajs examples
192 | - [ ] Port restify examples
193 | - [ ] Port partial.js examples
194 | - [ ] Finish documentation
195 | - [ ] Get community feedback
196 | - [ ] Author new fresh examples
197 |
198 |
199 | ## Installation
200 |
201 | `npm install http-framework`
202 |
203 | ## Contributors
204 |
205 | - Raynos
206 | - Matt-Esch
207 | - maxogden
208 |
209 | ## MIT Licenced
210 |
211 | [17]: https://github.com/Raynos/http-framework/tree/master/examples
212 | [18]: https://github.com/visionmedia/express
213 | [19]: https://github.com/Raynos/http-framework/blob/master/package.json#L19
214 | [20]: https://github.com/Raynos/http-framework/wiki/Modules
215 | [21]: https://github.com/Raynos/http-framework#examples
216 | [22]: https://github.com/Raynos/http-framework#documentation
217 | [23]: https://github.com/Raynos/http-framework#modules
218 | [24]: https://github.com/spumko/hapi
219 | [25]: https://github.com/senchalabs/connect
220 | [26]: https://github.com/Raynos/http-framework/tree/master/documents
221 | [27]: https://github.com/Raynos/http-works
222 |
--------------------------------------------------------------------------------