parent-require

What is parent-require?

The 'parent-require' npm package allows you to require modules relative to the parent module, rather than the current module. This can be particularly useful in scenarios where you have nested modules and you want to ensure that you are requiring a module relative to the top-level parent module.

What are parent-require's main functionalities?

Require a module relative to the parent module

This feature allows you to require a module as if you were doing so from the parent module's context. This can help avoid issues with relative paths in deeply nested modules.

const parentRequire = require('parent-require');
const someModule = parentRequire('some-module');

Fallback to current module if parent module not found

This feature allows you to specify a fallback to the current module's context if the parent module is not found. The second argument is a boolean that, when set to true, enables this fallback behavior.

const parentRequire = require('parent-require');
const someModule = parentRequire('some-module', true);

Other packages similar to parent-require

resolve

The 'resolve' package provides a synchronous and asynchronous module resolution similar to Node's require.resolve. It allows you to resolve the path of a module relative to a given directory. Unlike 'parent-require', it does not automatically resolve relative to the parent module but offers more flexibility in specifying the base directory.

app-root-path

The 'app-root-path' package helps you to resolve modules relative to the application's root directory. This is useful for avoiding complex relative paths in your require statements. Unlike 'parent-require', it focuses on the application's root rather than the parent module.

require-relative

The 'require-relative' package allows you to require modules relative to a specific path. It provides a similar functionality to 'parent-require' but requires you to explicitly specify the base path for resolution.

README

parent-require

Require modules from parent (i.e. loading) module.

Install

$ npm install parent-require

Usage

parent-require addresses an annoying error condition that arises when developing plugins, which have peer dependencies, that are npm link'd into an application.

The problem is best illustrated by example. We'll use a shared package of Mongoose schemas, but the concept applies equally well to any module you plugin to a larger framework.

Develop a Plugin for a Framework

Let's develop a set of shared Mongoose schemas for a user database, packaged as mongoose-schemas-users for reuse by any application that needs to query the database.

var mongoose = require('mongoose');

var UserSchema = new mongoose.Schema(...);

module.exports = UserSchema;

The important bit here is that mongoose is a peer dependency of this package.

Require a Plugin from an App

Now, let's install this package...

npm install mongoose-schemas-users

..and require it within our application:

var mongoose = require('mongoose')
  , schemas = require('mongoose-schemas-users')
  
mongoose.model('User', schemas.UserSchema);

So far, so good.

npm link Plugin for Development

During the course of developing the application, we discover that we need to tweak the schemas we've defined. This is usually easy:

npm link mongoose-schemas-users

We've made some edits, and run the application:

Error: Cannot find module 'mongoose'

WTF?!? This issue arises because mongoose is a peer dependency. Now that it has been npm link'd to a directory that resides outside of the application itself, Node's typical resolution algorithm fails to find it.

Fallback to Parent Require

This is where parent-require comes into play. It provides a fallback to require modules from the loading (aka parent) module. Because the loading module exists within the application itself, Node's resolution algorithm will correctly find our peer dependency.

try {
  var mongoose = require('mongoose');
} catch (_) {
  // workaround when `npm link`'ed for development
  var prequire = require('parent-require')
    , mongoose = prequire('mongoose');
}

var UserSchema = new mongoose.Schema(...);

module.exports = UserSchema;

With the fallback in place, we can both npm install and npm link this plugin, correctly resolving peer dependencies in both cases.

Tests

$ npm install
$ npm test

Credits

• Jared Hanson

License

The MIT License

Copyright (c) 2013 Jared Hanson <http://jaredhanson.net/>