GLOBAL data per HTTP/Session request?

QUESTION:

Is there any way to create a variable storage in per session/http request? The variable must be globally accessible and different per HTTP request/connection/session, and need not be passed from function to function.

For example (just to illustrate):

setVariableThatCanBeAccessedByThisHTTPRequestOnly( 'a string data' );

Anything should work, but I'd prefer to stay away from passing it from function to function.

//I'm trying to get rid of passing req parameter to all custom functions.
//I'd like to store it in a variable somehow, that it can be accessed globally, but only within that session/request.
exports.functionName = function( req, res ) {

   customFunctionThatRequiresReq( req );

};

ORIGINAL QUESTIONS

I've been playing with node.js lately, and have a little concern about its GLOBAL scope. Let's say we have a server.js file:

username = ""; //Global scope

Then when a connection is established and the server receives a request, it will do the followings:

username = selectUsernameWithConditions(); //This will return a username

My question is: If 2 different computers are sending the requests to the server, will the value of username be independently different? I mean, does the username when the first request is processed different from the username when the second request is processed, or they are just one variable and will be overridden?

If they are overridden, what is the best way to store data and make them globally accessible within that requests and/or session only? For example, the following code:

username = selectUsernameWithConditions(); //This will return a username

Will assign username differently for different requests and not overriding each other.

Yes, with some caveats. You're looking for a module called continuation-local-storage.
This allows you to keep arbitrary data for the remainder of callbacks for the current request, and access it in a global fashion.
I wrote a blog post about it here. But the gist is this:

  1. Install cls: npm install --save continuation-local-storage

  2. Create a namespace for your app (at the top of the main file for your app)

    var createNamespace = require('continuation-local-storage').createNamespace, 
    namespace = createNamespace('myAppNamespace');

  3. Create a middleware that runs downstream functions in the cls (continuation-local-storage) namespace

    var getNamespace = require('continuation-local-storage').getNamespace,
    namespace = getNamespace('myAppNamespace'),

app.use(function(req, res, next) {    
  // wrap the events from request and response
  namespace.bindEmitter(req);
  namespace.bindEmitter(res);

  // run following middleware in the scope of the namespace we created
  namespace.run(function() {
    namespace.set(‘foo’, 'a string data');
    next();
  });
});

  4. Since you ran next within namespace.run, any downstream function can access data in the namespace

    var getNamespace = require('continuation-local-storage').getNamespace,
    namespace = getNamespace('myAppNamespace');

// Some downstream function that doesn't have access to req...
function doSomething() {
  var myData = namespace.get('foo');
  // myData will be 'a string data'
}

  5. There is the caveat that certain modules can "lose" the context created by cls. This means that when you go to lookup 'foo' on the namespace, it won't have it. There are a few ways to deal with this, namely using another module like cls-redis, cls-q, or binding to the namespace.

You can an unstable feature: nodejs domains

I do this on top of my head so read the docs and figure out really how it works ;)

Create a middleware high up in the hierarchy that will create a domain and run the remaining request handlers in the context of that domain:

app.use(function(req, res, next) {
  var domain = domain.create();
  domain.req = req;
  domain.run(next);
});

Then anywhere in your handlers, you can access the current request with:

var req = process.domain.req;

Again, read the docs, I'm really not sure about all this but this is one approach!

if i'm right to understood your question you can try to make global variable in node js which can stored username

you can use global array with unique id

suppose user1 hit the http request therefore you store like this in node js

if(!username)
   username = [];

if(!uniqId)
   uniqId = 0;
uniqId++;

username[uniqId] = 'xyz';

similar like this it is working

Per request, I think what you're after could be done with ordinary closures. For example, you'd define your custom functions in module that takes a req argument:

util_funcs.js:

module.exports = function( req ){
  return {
    customFunctionThatRequiresReq: function(){ console.info( req ) },
    otherFunctionThatRequiresReq:  function(){ console.log( req ) }
  };
};

Then wherever you depend on those functions (presumably some middleware elsewhere in the application), you can just require them in context:

var someMiddleWare = function( req, res, next ){

  var utils = require( 'util_funcs.js' )( req );

  utils.customFunctionThatRequiresReq();
  utils.otherFunctionThatRequiresReq();

};

This allows you to avoid littering your function args with req, and no dubious globals.