Nsryjdtyk

__dirname isn't a global; it's local to the current module so each file has its own local, different value.

If you want the root directory of the running process, you probably do want to use process.cwd().

If you want predictability and reliability, then you probably need to make it a requirement of your application that a certain environment variable is set. Your app looks for MY_APP_HOME (Or whatever) and if it's there, and the application exists in that directory then all is well. If it is undefined or the directory doesn't contain your application then it should exit with an error prompting the user to create the variable. It could be set as a part of an install process.

You can read environment variables in node with something like process.env.MY_ENV_VARIABLE.

1- create a file in the project root call it settings.js

2- inside this file add this code

module.exports = {

    POST_MAX_SIZE : 40 , //MB

    UPLOAD_MAX_FILE_SIZE: 40, //MB

    PROJECT_DIR : __dirname

};

3- inside node_modules create a new module name it "settings" and inside the module index.js write this code:

module.exports = require("../../settings");

4- and any time you want your project directory just use

var settings = require("settings");

settings.PROJECT_DIR; 

in this way you will have all project directories relative to this file ;)

the easiest way to get the global root (assuming you use NPM to run your node.js app 'npm start', etc)

var appRoot = process.env.PWD;

If you want to cross-verify the above

Say you want to cross-check process.env.PWD with the settings of you node.js application. if you want some runtime tests to check the validity of process.env.PWD, you can cross-check it with this code (that I wrote which seems to work well). You can cross-check the name of the last folder in appRoot with the npm_package_name in your package.json file, for example:

    var path = require('path');



    var globalRoot = __dirname; //(you may have to do some substring processing if the first script you run is not in the project root, since __dirname refers to the directory that the file is in for which __dirname is called in.)



    //compare the last directory in the globalRoot path to the name of the project in your package.json file

    var folders = globalRoot.split(path.sep);

    var packageName = folders[folders.length-1];

    var pwd = process.env.PWD;

    var npmPackageName = process.env.npm_package_name;

    if(packageName !== npmPackageName){

        throw new Error('Failed check for runtime string equality between globalRoot-bottommost directory and npm_package_name.');

    }

    if(globalRoot !== pwd){

        throw new Error('Failed check for runtime string equality between globalRoot and process.env.PWD.');

    }

you can also use this NPM module: require('app-root-path') which works very well for this purpose

I've found this works consistently for me, even when the application is invoked from a sub-folder, as it can be with some test frameworks, like Mocha:

process.mainModule.paths[0].split('node_modules')[0].slice(0, -1);

Why it works:

At runtime node creates a registry of the full paths of all loaded files. The modules are loaded first, and thus at the top of this registry. By selecting the first element of the registry and returning the path before the 'node_modules' directory we are able to determine the root of the application.

It's just one line of code, but for simplicity's sake (my sake), I black boxed it into an NPM module:

https://www.npmjs.com/package/node-root.pddivine

Enjoy!

All these "root dirs" mostly need to resolve some virtual path to a real pile path, so may be you should look at path.resolve?

var path= require('path');

var filePath = path.resolve('our/virtual/path.ext");

Maybe you can try traversing upwards from __filename until you find a package.json, and decide that's the main directory your current file belongs to.

Actually, i find the perhaps trivial solution also to most robust:
you simply place the following file at the root directory of your project: root-path.js which has the following code:

import * as path from 'path'

const projectRootPath = path.resolve(__dirname)

export const rootPath = projectRootPath

A technique that I've found useful when using express is to add the following to app.js before any of your other routes are set

// set rootPath

app.use(function(req, res, next) {

  req.rootPath = __dirname;

  next();

});



app.use('/myroute', myRoute);

No need to use globals and you have the path of the root directory as a property of the request object.

This works if your app.js is in the root of your project which, by default, it is.

I use this.

For my module named mymodule

var BASE_DIR = __dirname.replace(/^(.*/mymodule)(.*)$/, '$1')

I know this one is already too late.
But we can fetch root URL by two methods

1st method

var path = require('path');

path.dirname(require.main.filename);

2nd method

var path = require('path');

path.dirname(process.mainModule.filename);

Reference Link:- https://gist.github.com/geekiam/e2e3e0325abd9023d3a3

Create a function in app.js

/*Function to get the app root folder*/

var appRootFolder = function(dir,level){

    var arr = dir.split('\');

    arr.splice(arr.length - level,level);

    var rootFolder = arr.join('\');

    return rootFolder;

}



// view engine setup

app.set('views', path.join(appRootFolder(__dirname,1),'views'));

At top of main file add:

mainDir = __dirname;

Then use it in any file you need:

console.log('mainDir ' + mainDir);

• 
  mainDir is defined globally, if you need it only in current file - use __dirname instead.


• main file is usually in root folder of the project and is named like main.js, index.js, gulpfile.js.

Make it sexy 💃🏻.

const users = require('../../../database/users'); // 👎 what you have

// OR

const users = require('$db/users'); // 👍 no matter how deep you are

const products = require('/database/products'); // 👍 alias or pathing from root directory

Three simple steps to solve the issue of ugly path.

1. Install the package: npm install sexy-require --save
   
   


2. 
   

   Include require('sexy-require') once on the top of your main application file.

   
   
   

   require('sexy-require');
   
   const routers = require('/routers');
   
   const api = require('$api');
   
   ...
   
   

   
   


3. 
   

   Optional step. Path configuration can be defined in .paths file on root directory of your project.

   
   
   

   $db = /server/database
   
   $api-v1 = /server/api/legacy
   
   $api-v2 = /server/api/v2
   
   

   
   

process.mainModule.paths

  .filter(p => !p.includes('node_modules'))

  .shift()

Get all paths in main modules and filter out those with "node_modules",
then get the first of remaining path list. Unexpected behavior will not throw error, just an undefined.

Works well for me, even when calling ie $ mocha.

You can simply add the root directory path in the express app variable and get this path from the app. For this add app.set('rootDirectory', __dirname); in your index.js or app.js file. And use req.app.get('rootDirectory') for getting the root directory path in your code.

Old question, I know, however no question mention to use progress.argv. The argv array includes a full pathname and filename (with or without .js extension) that was used as parameter to be executed by node. Because this also can contain flags, you must filter this.

This is not an example you can directly use (because of using my own framework) but I think it gives you some idea how to do it. I also use a cache method to avoid that calling this function stress the system too much, especially when no extension is specified (and a file exist check is required), for example:

node myfile

or

node myfile.js

That's the reason I cache it, see also code below.

function getRootFilePath()

{

        if( !isDefined( oData.SU_ROOT_FILE_PATH ) )

        {

            var sExt = false;



            each( process.argv, function( i, v )

            {

                 // Skip invalid and provided command line options

                if( !!v && isValidString( v ) && v[0] !== '-' )

                {

                    sExt = getFileExt( v );



                    if( ( sExt === 'js' ) || ( sExt === '' && fileExists( v+'.js' )) )

                    {



                        var a = uniformPath( v ).split("/"); 



                         // Chop off last string, filename

                        a[a.length-1]='';



                         // Cache it so we don't have to do it again.

                        oData.SU_ROOT_FILE_PATH=a.join("/"); 



                         // Found, skip loop

                        return true;

                    }

                }

            }, true ); // <-- true is: each in reverse order

        }



        return oData.SU_ROOT_FILE_PATH || '';

    }

}; 

As simple as add this line to your module in root, usually it is app.js

global.__basedir = __dirname;

Then _basedir will be accessiable to all your modules.

Finding the root path of an electron app could get tricky. Because the root path is different for the main process and renderer under different conditions such as production, development and packaged conditions.

I have written a npm package electron-root-path to capture the root path of an electron app.

$ npm install electron-root-path



or 



$ yarn add electron-root-path





// Import ES6 way

import { rootPath } from 'electron-root-path';



// Import ES2015 way

const rootPath = require('electron-root-path').rootPath;



// e.g:

// read a file in the root

const location = path.join(rootPath, 'package.json');

const pkgInfo = fs.readFileSync(location, { encoding: 'utf8' });

Try path._makeLong('some_filename_on_root.js');

example:

cons path = require('path');

console.log(path._makeLong('some_filename_on_root.js');

That will return full path from root of your node application (same position of package.json)

Add this somewhere towards the start of your main app file (e.g. app.js):

global.__basedir = __dirname;

This sets a global variable that will always be equivalent to your app's base dir. Use it just like any other variable:

const yourModule = require(__basedir + '/path/to/module.js');

Simple...

to get current file's pathname:


define in that file:

    var get_stack = function() {

        var orig = Error.prepareStackTrace;

        Error.prepareStackTrace = function(_, stack) {

            return stack;

        };

        var err = new Error;

        Error.captureStackTrace(err, arguments.callee);

        var stack = err.stack;

        Error.prepareStackTrace = orig;

        return stack;

    };

usage in that file:

    console.log(get_stack()[0].getFileName());

API:
StackTrace

Just use:

 path.resolve("./") ... output is your project root directory