Skip to content
Dynamic version of require() - loads fresh copy of the module every time the module file is changed
JavaScript
Find file
Latest commit 7801bfe Feb 6, 2013 @yuryb Update example/drex.js
Failed to load latest commit information.
example Update example/drex.js Feb 6, 2013
.DS_Store update Jan 30, 2013
.gitignore Update .gitignore Jan 30, 2013
README.md Update README.md Feb 2, 2013
drex.js Update drex.js Feb 6, 2013
package.json Update package.json Jan 31, 2013

README.md

drex

drex - "dynamic require() extension". Dynamic version of Node's require() - loads fresh copy of the module every time the module file is changed.

Insanely simple, and/but astonishingly useful grab of bits, which has been brought to this world out of severe necessity.

Here is why:

  • all re-loaders I was able to find reload the whole node process, which means that the context of the process is gone;
  • but, sometimes, you don't want that! You want your process to continue running intact, at least for those clients who already deep in it, and would choke if process forgets about them;
  • sometime you have a little (or BIG) piece of code which you constantly change and, for G-d sake, do not want to sacrifice the whole your Node process for, but
  • you don't want to loose the benefits of CommonJS/require supported modularity of your code.

Here comes drex, and it comes like this:

var drex = require('drex');

... node code node code node code ...

// here goes my frea[ky/quently updated] piece of code, which lives in a js file called mucode.js:
drex.require('./mucode.js', function(mucode)
{
  // at this point my mucode.js has been require()d, just like this: 
  // var mucode = require('./mucode.js');
  // the code of the required module is the LATEST UPDATE TO mucode.js
  mucode.muNewFunc();  
});

Here is an example (and the reason I had to comeup with drex) from the real life when drex is irreplaceable:

frequently updated/added socket.io event handlers:

io.sockets.on('connection', function (socket) {
  // I need to do many things here, and these things change all the time!
  // If I use something like "forever", or "supervisor" to re-start my Node process every time 
  // when things here should change, all active sessions will be killed!
  // Oh, no, no, no!
  // All I want to do here, most of the time, is to put new event handler, which existing sessions 
  // do not even know about!

  drex.require('./my_module_with_event_handlers_which_I_always_change.js', function(mymod) {
      // here I can start calling methods from my module like there is no tomorrow!
      // and I'm guaranteed that every time I update my module, sessions which will come here after the update
      // will get the new code, but sessions which were opened before the update will still be working with the
      // code which existed in my module when these sessions were created. That's fair!
  });

API

drex.require(<module reference>, <callBack>);

where:

  • <module reference> resolvable Node module reference, such as './module.js'
  • <callBack> function which is being called when the module has been require()d.

    callBack signature: callBack(module, filepath)

    where:

    • module: reference to the require()d module, and
    • filepath: full path to the module's file

Installation using NPM

npm install drex

Even more simple installation

Just copy drex.js to the place where Node can find it, i.e. for require('./drex.js') - to the root of your Node project.

tl;dr

drex is watching a module for updates and cleanly re-requires the module after the update. New code is being require()d as if the new code is a totally different module, so require.cache is not a problem.

License

GPL

Enjoy

Something went wrong with that request. Please try again.