https://github.com/npm/redsess
Yet another redis session thing for node.
https://github.com/npm/redsess
Last synced: 10 months ago
JSON representation
Yet another redis session thing for node.
- Host: GitHub
- URL: https://github.com/npm/redsess
- Owner: npm
- License: isc
- Archived: true
- Created: 2012-04-25T04:51:02.000Z (about 14 years ago)
- Default Branch: master
- Last Pushed: 2014-04-22T22:25:06.000Z (over 12 years ago)
- Last Synced: 2025-09-28T16:46:17.726Z (10 months ago)
- Language: JavaScript
- Size: 382 KB
- Stars: 30
- Watchers: 30
- Forks: 13
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
Awesome Lists containing this project
README
# redsess
Yet another redis session thing for node.
This is built on top of [jed/cookies](https://github.com/jed/cookies).
You can optionally pass in a KeyGrip instance, or an array of keys to
use to sign cookies.
## Breaking Changes in 1.0.0
Sessions are now stored as stringified JSON objects using `set` and `get`.
This means that *all sessions that were created using previous versions of
redsess will need to be cleared out/nuked/obliterated*. Before upgrading
to 1.0.0, let your users know that their sessions will be removed!
## Example
```javascript
var RedSess = require('redsess')
, http = require('http')
, Cookies = require('cookies')
, Keygrip = require('keygrip')
, keys = new Keygrip(['some secret keys here'])
// Create a client with the options that you'd pass to node_redis
RedSess.createClient(redisOptions)
http.createServer(function (req, res) {
var session = new RedSess(req, res, {
keys: keys, // if keys are provided, they'll be used
cookieName: 's',
expire: expirationInSeconds, // default = 2 weeks
client: redisClient, // defaults to RedSess.client
keys: [ "this is a string key" ], // will be made into a keygrip obj
keys: new KeyGrip(keys), // this way also works
})
// you can decorate like this if you chose
req.session = session
res.session = session
// .. and then some time later ..
req.session.get('auth', function (er, auth) {
if (!auth) {
// redirect to login page
} else {
// do authorized login things
}
})
// .. on the login page, if there's a post ..
validateLogin(postedData, function (er, isValid) {
if (isValid)
req.session.set('auth', postedData)
})
// .. on the logout page ..
req.session.del('auth', function (er) {
// user is now logged out
})
}).listen(1337)
```
## Constructor Options
* `expire` {Number} Time in seconds that sessions last Default=2 weeks
* `cookieName` {String} Cookie name to use for session id's. Default = 's'
* `keys` A [Keygrip](https://github.com/jed/keygrip) instance to use
to sign the session token cookie. (If an array is passed in, then
RedSess will make a KeyGrip obj out of it.)
* `client` If you have another redis client you'd like to use, then
you can do so.
* `cookies` If you already have a Cookies object, you may pass that
in. If not specified, then it'll make a new one for you.
* `cookieOptions` an object that extends the options object that is passed to
`cookies.set` and `cookies.get`
## Methods
Callbacks are all the standard `cb(er, result)` style.
Deep objects are supported, but cycles in data objects will cause
terrible explosively bad awful undefined behavior, so DON'T DO THAT.
* RedSess.createClient(opts)
Calls `redis.createClient` with the supplied options. See
[node_redis](https://github.com/mranney/node_redis) for more details.
(opts.host and opts.port are passed to redis.createClient as positional
arguments, not on the configuration object.)
If there's an `opts.auth` member, then it will use that string as a
password to redis.
* session.set(k, v, cb)
Sets a key on the session.
* session.set(object, cb)
Sets a hash of keys and values on the session.
* session.get(k, cb)
Fetches the key from the session.
* session.get(cb)
Fetches all keys from the session. If there is no data in the
session, then it'll return `null`.
* session.del(k, cb)
Deletes a key from the session.
* session.del(cb)
Deletes the entire session.