[nodejs] find path of module require()ing

guess there is no other way. but the whole task smells like hell to me. why
does your module need to know who required it?

Am Samstag, 10. November 2012 15:02:50 UTC+1 schrieb boden:

doesn't *have* to, but does for ease of use -- it defaults some paths
relative to the caller's (the module require()ing) module location...
obviously there are other approaches such as forcing the require()er to
pass in those paths rather than defaulting them.

i'm not all that seasoned in the node space, but i haven't gotten a whiff
of hell yet... anything in particular that drums up the smell of hell for
you that I should be aware of?

If you're making assumptions about your caller, you're likely asking for
trouble, now or in the future. For an example, see:

https://github.com/joyent/node/issues/4233#issuecomment-10046241

You'll have to disable caching and it will work, this saved would print the
directory that required the module;

delete require.cache[__filename];

module.exports = function() {
var path = require('path');

console.log(path.dirname(module.parent.filename));
};

You can look at module.parent.filename, but that's just the first
module to require() you, not necessarily the most recent, due to
caching.

Deleting yourself out of the cache is likely pretty stupid. Don't do that.

But what you're probably more interested in is require.main.filename
or process.cwd() anyway.


On Sun, Nov 18, 2012 at 11:34 AM, Jason Brumwell
wrote:

Other then the obvious speed implications, there shouldn't be any other
downsides to removing the cache? Although not the best case scenario, I
believe its the only way to know the file that is requiring the module, as
module.parent.filename will update to be the latest file.

If the module uses some form of internal storage (for caching, module level
object registration, etc.) it would be duplicated and then you could see
some interesting cache mismatch bugs.

For example in the following module 2 registries would exist rather than
the expected one if completely reloaded:

```javascript
var registeredHandlers = {};
exports.register = function (event, fn) {registeredHandlers[event] = fn;}
exports.fire = function (event) {registeredHandlers[event]();}
```

Soo... if you setup a "prestart" function, then it gets reloaded, and
someone attempts to fire "prestart" on the reloaded module; it would not
contain the function originally registered as "prestart" and be a cache
mismatch, which would be very hard to debug.

Don't introduce side effects into other authors' modules, so never ever do
this without knowing you can cause cache mismatches.

Definitely you would need to develop your module with the understanding
that it will be loaded more then once, but it should not effect 3rd party
libraries as they would still be cached correct?

Its the only approach that I can see to solve the users scenario, another
possible solution would be to utilize something like
http://www.npmjs.org/package/traceback if your collecting the information
via a function call.

Other then that the only other way I can see is to edit module.js and
inject the actual parent into the module. Seems kind of an odd api for the
module when the parent isn't actually the current parent for the module. I
can see where knowing the actual parent would be very useful, if it were
possible to inject the current parent into the cache to make it retrievable
could be beneficial.

Depends, if a module holds a reference to the module being reloaded and
there is a shared cache being used by that module. You would still end up
with 2 references to different things. I would need to know way more about
whats trying to be done / API to make any sane comment on if it looks like
there is a reference leak and shared cache situation.

Looks you want separate behaviour for every module require()ing you. Why
not force every caller to instantiate an object of your custom class type,
passing in a directory location? This has the added side effect of allowing
a single module to instantiate multiple objects with potentially different
arguments (something you might need later - it at least smells like it).

If you mess with the require() cache, it's very possible to create a
situation where you cause infinite loops by require() cycles
re-reading the same files repeatedly and synchronously, and these are
difficult to debug.

It's much better to just export a function, and have your consumer
call that function, rather than re-run your module on every load.

module.exports = function(arg) {
// do stuff
}

// the consumer
var blarg = require('blahrg');
var myBlarg = blarg(__filename);