How to make node js require absolute instead of relative

Question

I would like to require my files always by the root of my project and not relative to the current module   For example if you look at https   github com visionmedia express blob 2820f2227de0229c5d7f28009aa432f9f3a7b5f9 examples downloads app js line 6 you will see  express   require             That s really bad IMO  Imagine I would like to put all my examples closer to the root only by one level  That would be impossible  because I would have to update more than 30 examples and many times within each example  To this   express   require          My solution would be to have a special case for root based  if a string starts with an   then it s relative to the root folder of the project   Any help is appreciated  thanks  Update 2  Now I m using require js which allows you to write in one way and works both on client and on server  Require js also allows you to create custom paths   Update 3  Now I moved to webpack   gulp and I use enhanced-require to handle modules on the server side  See here the rationale  http   hackhat com p 110 module-loader-webpack-vs-requirejs-vs-browserify

User · Answer

If anyone s looking for yet another way to get around this problem  here s my own contribution to the effort      https   www npmjs com package use-import   The basic idea  you create a JSON file in the root of the project that maps your filepaths to shorthand names  or get use-automapper to do it for you   You can then request your files modules using those names  Like so   var use   require  use-import    var MyClass   use  MyClass      So there s that

User · Answer

I had the same problem many times  This can be solved by using the basetag npm package  It doesn t have to be required itself  only installed as it creates a symlink inside node modules to your base path   const localFile   require    local file      instead of const localFile   require        local file     Using the       prefix will always reference files relative to your apps root directory   Source  How I created basetag to solve this problem

User · Answer

If you re using ES5 syntax you may use asapp  For ES6 you may use babel-plugin-module-resolver using a config file like this    babelrc       plugins           module-resolver            root                  alias              app      app            config      app config            schema      app db schemas            model      app db models            controller      app http controllers            middleware      app http middleware            route      app http routes            locale      app locales            log      app logs            library      app utilities libraries            helper      app utilities helpers            view      app views

User · Answer

I use process cwd   in my projects  For example   var Foo   require process cwd       common foo js      It might be worth noting that this will result in requireing an absolute path  though I have yet to run into issues with this

User · Answer

i created a node module called  rekiure   it allows you to require without the use of relative paths     https   npmjs org package rekuire   it is super easy to use

User · Answer

Whilst these answers work they do not address the problem with npm test  If  for example  I create a global variable in server js  it will not be set for my test suite execution   To set a global appRoot variable that will avoid the           problem and will be available in both npm start AND npm test see   Mocha tests with extra options or parameters  Note that this is the new official mocha solution

User · Answer

Imho the easiest way to achieve this is by creating a symbolic link on app startup at node modules app  or whatever you call it  which points to    app  Then you can just call require  app my module    Symbolic links are available on all major platforms   However  you should still split your stuff in smaller  maintainable modules which are installed via npm  You can also install your private modules via git-url  so there is no reason to have one  monolithic app-directory

User · Answer

Many good answers here already  That just shows this is a common problem without clear-cut best solution  Best would be native support in Node js of course  Here s what I use currently  const r    p   gt  require  process cwd     p   let see    r    Subs SubA someFile js     let see2   r    Subs SubB someFile2 js         I like this solution because the requires-section becomes shorter  no need to type  require  many times  The main benefit of absolute paths is you can copy them from file to file without having to adjust them like you would with relative paths  Therefore copying also the extra one-liner arrow-function  r    is not too much extra work either  And no need to import extra npm-dependencies just to accomplish this very simple task

User · Answer

I wrote this small package that lets you require packages by their relative path from project root  without introducing any global variables or overriding node defaults  https   github com Gaafar pkg-require  It works like this     create an instance that will find the nearest parent dir containing package json from your   dirname const pkgRequire   require  pkg-require     dirname       require a file relative to the your package json directory  const foo   pkgRequire  foo foo       get the absolute path for a file const absolutePathToFoo   pkgRequire resolve  foo foo       get the absolute path to your root directory const packageRootPath   pkgRequire root

User · Answer

And what about   var myModule   require main require    path to module      It requires the file as if it were required from the main js file  so it works pretty well as long as your main js file is at the root of your project    and that s something I appreciate

User · Answer

You could use a module I made  Undot  It is nothing advanced  just a helper so you can avoid those dot hell with simplicity   Example   var undot   require  undot    var User   undot  models user    var config   undot  config    var test   undot  test api user auth

User · Answer

I like to make a new node modules folder for shared code  then let node and require do what it does best    for example   - node modules      gt  these are loaded from your package json - app   - node modules      gt  add node-style modules     - helper js   - models     - user     - car - package json -  gitignore   For example  if you re in car index js you can require  helper   and node will find it   How node modules Work  node has a clever algorithm for resolving modules that is unique among rival platforms   If you require    foo js   from  beep boop bar js  node will look for   foo js in  beep boop foo js  Paths that start with a    or     are always local to the file that calls require     If however you require a non-relative name such as require  xyz   from  beep boop foo js  node searches these paths in order  stopping at the first match and raising an error if nothing is found    beep boop node modules xyz  beep node modules xyz  node modules xyz   For each xyz directory that exists  node will first look for a xyz package json to see if a  main  field exists  The  main  field defines which file should take charge if you require   the directory path   For example  if  beep node modules xyz is the first match and  beep node modules xyz package json has        name    xyz      version    1 2 3      main    lib abc js      then the exports from  beep node modules xyz lib abc js will be returned by require  xyz     If there is no package json or no  main  field  index js is assumed    beep node modules xyz index js

User · Answer

Assuming your project root is the current working directory  this should work      require built-in path module path   require  path        require file relative to current working directory config   require  path resolve      config js

User · Answer

Manual Symlinks  and Windows Junctions  Couldn t the examples directory contain a node modules with a symbolic link to the root of the project project - gt         thus allowing the examples to use require  project    although this doesn t remove the mapping  it does allow the source to use require  project   rather than require            I have tested this  and it does work with v0 6 18  Listing of project directory    ls -lR project project  drwxr-xr-x 3 user user 4096 2012-06-02 03 51 examples -rw-r--r-- 1 user user   49 2012-06-02 03 51 index js  project examples  drwxr-xr-x 2 user user 4096 2012-06-02 03 50 node modules -rw-r--r-- 1 user user   20 2012-06-02 03 51 test js  project examples node modules  lrwxrwxrwx 1 user user 6 2012-06-02 03 50 project - gt          The contents of index js assigns a value to a property of the exports object and invokes console log with a message that states it was required  The contents of test js is require  project    Automated Symlinks The problem with manually creating symlinks is that every time you npm ci  you lose the symlink  If you make the symlink process a dependency  viola  no problems  The module basetag is a postinstall script that creates a symlink  or Windows junction  named   every time npm install or npm ci is run  npm install --save basetag  node modules   - gt      With that  you don t need any special modification to your code or require system    becomes the root from which you can require  var foo   require    lib foo js     If you don t like the use of   and would prefer   or something else  except    which is a special character for npm   you could fork it and make the change  Note  Although Windows symlinks  to files  require admin permissions  Windows junctions  to directories  do not need Windows admin permissions  This is a safe  reliable  cross-platform solution

User · Answer

Just want to follow up on the great answer from Paolo Moretti and Browserify  If you are using a transpiler  e g   babel  typescript  and you have separate folders for source and transpiled code like src  and dist   you could use a variation of the solutions as  node modules  With the following directory structure   app   node modules            normal npm dependencies for app   src     node modules       app                source code   dist     node modules       app                transpiled code   you can then let babel etc to transpile src directory to dist directory   symlink  Using symlink we can get rid some levels of nesting   app   node modules            normal npm dependencies for app   src     node modules       app    symlinks to                 source code   dist     node modules       app    symlinks to                 transpiled code   A caveat with babel --copy-files The --copy-files flag of babel does not deal with symlinks well  It may keep navigating into the    symlink and recusively seeing endless files  A workaround is to use the following directory structure   app   node modules     app    symlink to     src             normal npm dependencies for app   src            source code   dist     node modules       app    symlinks to                 transpiled code   In this way  code under src will still have app resolved to src  whereas babel would not see symlinks anymore

User · Answer

Try using asapp   npm install --save asapp  https   www npmjs com package asapp  var   controller  helper  middleware  route  schema  model  APP  ROOT     require  asapp     controller  home   instead require        controllers home

User · Answer

Just came across this article which mentions app-module-path   It allows you to configure a base like this   require  app-module-path   addPath baseDir

User · Answer

I don t think you need to solve this in the manner you described  Just sed if you want to change the same string in a large amount of files  In your example   find   -name    js  -exec sed -i  s                     g         would have        changed to      Alternatively  you can require a configuration file that stores a variable containing the path to the library  If you store the following as config js in the example directory  var config       config path               and in your example file  myConfiguration   require    config    express   require config path     You ll be able to control the configuration for every example from one file   It s really just personal preference

User · Answer

There s a really interesting section in the Browserify Handbook      avoiding                           Not everything in an application properly belongs on the public npm   and the overhead of setting up a private npm or git repo is still   rather large in many cases  Here are some approaches for avoiding the                         relative paths problem       node modules      People sometimes object to putting application-specific modules into   node modules because it is not obvious how to check in your internal   modules without also checking in third-party modules from npm       The answer is quite simple  If you have a  gitignore file that   ignores node modules   node modules       You can just add an exception with   for each of your internal   application modules   node modules    node modules foo  node modules bar       Please note that you can t unignore a subdirectory  if the parent is   already ignored  So instead of ignoring node modules  you have to   ignore every directory inside node modules with the    node modules   trick  and then you can add your exceptions       Now anywhere in your application you will be able to require  foo     or require  bar   without having a very large and fragile relative   path       If you have a lot of modules and want to keep them more separate from   the third-party modules installed by npm  you can just put them all   under a directory in node modules such as node modules app   node modules app foo node modules app bar       Now you will be able to require  app foo   or require  app bar     from anywhere in your application       In your  gitignore  just add an exception for node modules app   node modules    node modules app       If your application had transforms configured in package json  you ll   need to create a separate package json with its own transform field in   your node modules foo or node modules app foo component directory   because transforms don t apply across module boundaries  This will   make your modules more robust against configuration changes in your   application and it will be easier to independently reuse the packages   outside of your application       symlink      Another handy trick if you are working on an application where you can   make symlinks and don t need to support windows is to symlink a lib    or app  folder into node modules  From the project root  do   ln -s    lib node modules app       and now from anywhere in your project you ll be able to require files   in lib  by doing require  app foo js   to get lib foo js       custom paths      You might see some places talk about using the  NODE PATH   environment variable or opts paths to add directories for node and   browserify to look in to find modules       Unlike most other platforms  using a shell-style array of path   directories with  NODE PATH is not as favorable in node compared to   making effective use of the node modules directory       This is because your application is more tightly coupled to a runtime   environment configuration so there are more moving parts and your   application will only work when your environment is setup correctly       node and browserify both support but discourage the use of    NODE PATH

User · Answer

In your own project you could modify any  js file that is used in the root directory and add its path to a property of the process env variable  For example      in index js process env root     dirname    Afterwards you can access the property everywhere      in app js express   require process env root

User · Answer

IMHO  the easiest way is to define your own function as part of GLOBAL object  Create projRequire js in the root of you project with the following contents   var projectDir     dirname   module exports   GLOBAL projRequire   function module      return require projectDir   module       In your main file before requireing any of project-specific modules      init projRequire require    projRequire      After that following works for me      main file projRequire   lib lol        index js at projectDir lib lol index js console log  Ok        Totty  I ve comed up with another solution  which could work for case you described in comments  Description gonna be tl dr  so I better show a picture with structure of my test project

User · Answer

Another answer    Imagine this folders structure     node modules   lodash  src   subdir   foo js bar js  main js  tests   test js    Then in test js  you need to require files like this    const foo   require     src subdir foo    const bar   require     src subdir bar    const main   require     src main    const     require  lodash      and in main js    const foo   require    subdir foo    const bar   require    subdir bar    const     require  lodash      Now you can use babel and the babel-plugin-module-resolver with this  babelrc file to configure 2 root folders          plugins               module-resolver                  root       src      src subdir                        Now you can require files in the same manner in tests and in src   const foo   require  foo    const bar   require  bar    const main   require  main    const     require  lodash      and if you want use the es6 module syntax          plugins               module-resolver                  root       src      src subdir                        transform-es2015-modules-commonjs            then you import files in tests and src like this    import foo from  foo  import bar from  bar  import   from  lodash

User · Answer

There s a good discussion of this issue here   I ran into the same architectural problem  wanting a way of giving my application more organization and internal namespaces  without    mixing application modules with external dependencies or bothering with private npm repos for application-specific code using relative requires  which make refactoring and comprehension harder using symlinks or changing the node path  which can obscure source locations and don t play nicely with source control   In the end  I decided to organize my code using file naming conventions rather than directories  A structure would look something like    npm-shrinkwrap json package json node modules       src  app js app config js app models bar js app models foo js app web js app web routes js        Then in code   var app config   require    app config    var app models foo   require    app models foo      or just  var config   require    app config    var foo   require    app models foo      and external dependencies are available from node modules as usual   var express   require  express      In this way  all application code is hierarchically organized into modules and available to all other code relative to the application root   The main disadvantage is of course that in a file browser  you can t expand collapse the tree as though it was actually organized into directories  But I like that it s very explicit about where all code is coming from  and it doesn t use any  magic

User · Answer

Have a look at node-rfr   It s as simple as this   var rfr   require  rfr    var myModule   rfr  projectSubDir myModule

User · Answer

Here is the actual way I m doing for more than 6 months  I use a folder named node modules as my root folder in the project  in this way it will always look for that folder from everywhere I call an absolute require    node modules   myProject   index js I can require  myProject someFolder hey js   instead of require    someFolder hey js   someFolder which contains hey js     This is more useful when you are nested into folders and it s a lot less work to change a file location if is set in absolute way  I only use 2 the relative require in my whole app

User · Answer

Some time ago I created module for loading modules relative to pre-defined paths       https   github com raaymax irequire   You can use it instead of require   irequire prefix  controllers  join path   dirname  app master     var adminUsersCtrl   irequire  controllers admin users    var net   irequire  net      Maybe it will be usefull for someone

User · Answer

I was having trouble with this same issue  so I wrote a package called include   Include handles figuring out your project s root folder by way of locating your package json file  then passes the path argument you give it to the native require   without all of the relative path mess  I imagine this not as a replacement for require    but a tool for requiring handling non-packaged   non-third-party files or libraries  Something like  var async   require  async        foo     include  lib path to foo     I hope this can be useful

User · Answer

Some of the answers is saying that the best way is to add the code to the node module as a package  i agree and its probably the best way to lose the           in require but none of them actually give a way to do so   from version 2 0 0 you can install a package from local files  which means you can create folder in your root with all the packages you want   -modules  --foo  --bar  -app js -package json   so in package json you can add the modules  or foo and bar  as a package without publishing or using external server like this         name    baz      dependencies          bar    file    modules bar        foo    file    modules foo          After that you do npm install  and you can access the code with var foo   require  foo    just like you do with all the other packages   more info can be found here    https   docs npmjs com files package json local-paths  and here how to create a package    https   docs npmjs com getting-started creating-node-modules

User · Answer

In simple lines  u can call your own folder as module    For that we need  global and app-module-path module  here  App-module-path  is the module  it enables you to add additional directories to the Node js module search path And  global  is  anything that you attach to this object will b available everywhere in your app   Now take a look at this snippet   global appBasePath     dirname   require  app-module-path   addPath appBasePath       dirname is current running directory of node You can give your own path here to search the path for module

User · Answer

We are about to try a new way to tackle this problem    Taking examples from other known projects like spring and guice  we will define a  context  object which will contain all the  require  statement    This object will then be passed to all other modules for use    For example  var context       context module1   require    module1       context    context     context module2   require    module2       context    context       This requires us to write each module as a function that receives opts  which looks to us as a best practice anyway     module exports   function context           and then you will refer to the context instead of requiring stuff    var module1Ref   context moduel1   If you want to  you can easily write a loop to do the require statements  var context       var beans     module1       module1   module2       module2      for   var i in beans        if   beans hasOwnProperty i             context i    require beans i   context              This should make life easier when you want to mock  tests  and also solves your problem along the way while making your code reusable as a package    You can also reuse the context initialization code by separating the beans declaration from it   for example  your main js file could look like so   var beans               like before var context   require  context   beans      this example assumes context is a node module since it is reused      This method also applies to external libraries  no need to hard code their names every time we require them - however it will require a special treatment as their exports are not functions that expect context      Later on we can also define beans as functions - which will allow us to require different modules according to the environment - but that it out of this thread s scope

User · Answer

You could define something like this in your app js   requireFromRoot    function root        return function resource            return require root     resource              dirname     and then anytime you want to require something from the root  no matter where you are  you just use requireFromRoot instead of the vanilla require   Works pretty well for me so far

User · Answer

What I like to do is leverage how node loads from the node module directory for this    If one tries to load the module  thing   one would do something like  require  thing      Node will then look for the  thing  directory in the  node module  directory   Since the node module is normally at the root of the project  we can leverage this consistency   If node module is not at the root  then you have other self induced headaches to deal with    If we go into the directory and then back out of it  we can get a consistent path to the root of the node project   require  thing             Then if we want to access the  happy directory  we would do this   require  thing       happy      Though it is quite a bit hacky  however I feel if the functionality of how node modules load changes  there will be bigger problems to deal with  This behavior should remain consistent   To make things clear  I do this  because the name of module does not matter   require  root       happy      I used it recently for angular2  I want to load a service from the root   import  MyService  from  root       app services http my service

User · Answer

I have tried many of these solutions  I ended up adding this to the top of my main file  e g  index js    process env NODE PATH     dirname  require  module   Module  initPaths      This adds the project root to the NODE PATH when the script is loaded  The allows me to require any file in my project by referencing its relative path from the project root such as var User   require  models user    This solution should work as long as you are running a main script in the project root before running anything else in your project

User · Answer

If your app s entry point js file  i e  the one you actually run  node  on  is in your project root directory  you can do this really easily with the rootpath npm module  Simply install it via   npm install --save rootpath      then at the very top of the entry point js file  add    require  rootpath        From that point forward all require calls are now relative to project root - e g  require           config debugging log     becomes require  config debugging log     where the config folder is in the project root

User · Answer

The big picture  It seems  really bad  but give it time  It is  in fact  really good  The explicit require  s give a total transparency and ease of understanding that is like a breath of fresh air during a project life cycle   Think of it this way  You are reading an example  dipping your toes into Node js and you ve decided it is  really bad IMO   You are second-guessing leaders of the Node js community  people who have logged more hours writing and maintaining Node js applications than anyone  What is the chance the author made such a rookie mistake   And I agree  from my Ruby and Python background  it seems at first like a disaster    There is a lot of hype and counter-hype surrounding Node js  But when the dust settles  we will acknowledge that explicit modules and  local first  packages were a major driver of adoption   The common case  Of course  node modules from the current directory  then the parent  then grandparent  great-grandparent  etc  is searched  So packages you have installed already work this way  Usually you can require  express   from anywhere in your project and it works fine   If you find yourself loading common files from the root of your project  perhaps because they are common utility functions   then that is a big clue that it s time to make a package  Packages are very simple  move your files into node modules  and put a package json there  Voila  Everything in that namespace is accessible from your entire project  Packages are the correct way to get your code into a global namespace   Other workarounds  I personally don t use these techniques  but they do answer your question  and of course you know your own situation better than I   You can set  NODE PATH to your project root  That directory will be searched when you require     Next  you could compromise and require a common  local file from all your examples  That common file simply re-exports the true file in the grandparent directory   examples downloads app js  and many others like it   var express   require    express     examples downloads express js  module exports   require             Now when you relocate those files  the worst-case is fixing the one shim module

User · Answer

I was looking for the exact same simplicity to require files from any level and I found module-alias   Just install   npm i --save module-alias   Open your package json file  here you can add aliases for your paths  for e g     moduleAliases        root                 Application s root    deep          src some very deep directory or file      my module     lib some-file js     something      src foo      Or without    Actually  it could be any string     And use your aliases by simply   require  module-alias register   const deep   require   deep   const module   require  something

User · Answer

If you are using yarn instead of npm you can use workspaces   Let s say I have a folder services I wish to require more easily      -- app js  -- node modules  -- test  -- services         -- foo         -- bar  -- package json   To create a Yarn workspace  create a package json file inside the services folder        name    myservices      version    1 0 0      In your main package json add    private   true   workspaces     myservices     Run yarn install from the root of the project   Then  anywhere in your code  you can do   const   myFunc     require  myservices foo     instead of something like   const   myFunc     require                    services foo

[node.js] How to make node.js require absolute? (instead of relative)

Examples related to node.js

Examples related to require