Error cannot find module как исправить

When you are working in Node, you will sometimes encounter the error Cannot find module 'module-name' with the error code MODULE_NOT_FOUND.

The error looks like this:

	internal/modules/cjs/loader.js:796
    throw err;
    ^

Error: Cannot find module 'module'
    at Function.Module._resolveFilename (internal/modules/cjs/loader.js:793:17)
    at Function.Module._load (internal/modules/cjs/loader.js:686:27)
    at Function.Module.runMain (internal/modules/cjs/loader.js:1043:10)
    at internal/main/run_main_module.js:17:11 {
        code: 'MODULE_NOT_FOUND',
        requireStack: []
    }

In this post, we’ll learn how to resolve this error.

What is the problem?

The issue is that Node is unable to find the module that you are trying to import into your Node application.

The most common reason for this is that you simply haven’t installed the project’s dependencies yet.

The project’s dependencies are listed in the package.json file at the root of the project.

The Solution

To fix the Cannot find module error, simply install the missing modules using npm.

To so, you can use the following command:

	npm install

If you are using the yarn package manager, you can use the following command:

	yarn install

This will install the project’s dependencies into your project so that you can use them.

Sometimes, this might still not resolve it for you. In this case, you’ll want to just delete your node_modules folder and lock file (package-lock.json or yarn.lock) and try again.

This is how you can delete the node_modules folder and lock files:

	rm -rf node_modules

rm package-lock.json
rm yarn.lock

Local files

If your module is not coming from a remote source, you are seeing the error because the path to the local file is not correct.

Try to confirm that the path pointing to the local module is correct and your error should be resolved.

Conclusion

The Cannot find module error is a common error that usually happens when dependencies are not installed. Once you install your dependencies and ensure that the paths are correct, you can resolve the error and run your application successfully.

Hopefully, this resolved the issue for you.

Thanks for reading!

• Support Us

• Join

• Share

• Tweet

• Share

Sometimes, when developing a TypeScript project and importing a new package, you get a «cannot find module» error. Luckily, this error is easy to fix.

There are many reasons why the «cannot find module» error can happen in TypeScript:

1. The package is not installed.
2. Something is wrong with the node_modules folder.
3. The package import contains a spelling mistake.
4. Something is wrong with your tsconfig.json file.

This article will analyze those four potential causes and show how to fix this error for each one of them.

Let’s get to it 😎.

Here is how this error can look in your console:

bashCould not find a declaration file for module 'package/x'.

To fix this error, try those solutions one by one.

One of them will solve your error.

Solution #1 — Install the package

The first thing to fix the «cannot find module» error in TypeScript is to ensure that the package is installed on your system.

Run this command to install the package:

bashnpm install package-name

Also, some packages have a separate package with TypeScript types.

You need to install it as well, like so:

bashnpm install --save-dev @types/package-name

Solution #2 — Re-install your dependencies

Another potential fix for the «cannot find module» error is re-installing your dependencies. Indeed, something may be wrong with the project’s node_modules folder.

Here’s how to do it:

1. Remove the node_modules folder and the package-lock.json file, like so:

bashrm -rf node_modules package-lock.json

2. Install the dependencies like so:

bashnpm install

Solution #3 — Verify the import’s name

This error can occur when you try building your project on a different OS than originally built. Indeed, various case sensitivity errors can occur.

You must verify the import in question and match it to the file path.

If your file path is: path/File.ts

Your import should be the same: path/File.ts

It should NOT be: path/file.ts

Note: Set forceConsistentCasingInFileNames to true, inside the tsconfig.json file, for this not to happen.

Solution #4 — Fix the tsconfig.json file

Maybe this error occurs because something is wrong with the tsconfig.json file.

You can try to set the moduleResolution to node, like so:

json{
  "compilerOptions": {
    "moduleResolution": "node",
    // Rest
  }
}

If it doesn’t help, verify that your TypeScript file path is inside the include array AND is not inside the exclude array, like so:

json{
  "include": ["src/**/*.ts", "tests/**/*.ts"],
  "exclude": ["node_modules", ".vscode"],
  // Rest
}

Or try adding a baseUrl, like so:

json{
  "compilerOptions": {
    "baseUrl": ".",
    // Rest
  }
}

Note: Sometimes, you must also add a valid paths entry for this solution to work.

Final Thoughts

As you can see, solving the «cannot find module» error in TypeScript is simple.

If it is a new dependency, it is usually a problem with the tsconfig.json file.

Otherwise, re-installing the dependencies will solve this error most of the time.

Here are some other TypeScript tutorials for you to enjoy:

• Define a singleton in TypeScript
• Export a function in TypeScript
• Use instanceOf on an interface in TypeScript

Introduction

A common error that can come up when working with Node applications is the error of:

ERR_MODULE_NOT_FOUND]: Cannot find module

This generally means that whatever module you are trying to import is not being found.

A more descriptive error from the terminal looks like the below:

> node dist/app.js

node:internal/errors:465
    ErrorCaptureStackTrace(err);
    ^

Error [ERR_MODULE_NOT_FOUND]: Cannot find module 'redacted/dist/config/datadog' imported from /redacted/dist/app.js
    at new NodeError (node:internal/errors:372:5)
    at finalizeResolution (node:internal/modules/esm/resolve:405:11)
    at moduleResolve (node:internal/modules/esm/resolve:966:10)
    at defaultResolve (node:internal/modules/esm/resolve:1176:11)
    at ESMLoader.resolve (node:internal/modules/esm/loader:605:30)
    at ESMLoader.getModuleJob (node:internal/modules/esm/loader:318:18)
    at ModuleWrap.<anonymous> (node:internal/modules/esm/module_job:80:40)
    at link (node:internal/modules/esm/module_job:78:36) {
  code: 'ERR_MODULE_NOT_FOUND'
}

Node.js v18.0.0

Process finished with exit code 1

So in the above error message, our app.js is importing the datadog module. The erro comes up because the app.js code cannot find the datadog module.

To fix this error, there are few things we can do:

1. Check that you are using the import/ export syntax correctly
2. Make sure to have the file extension .js when you import
3. Make sure that the module exists and you have supplied the correct path.
4. You are not mixing and matching with CommonJs — eg using the require() function

1. Check that you are using the import/ export syntax correctly

Firstly, if we want to make sure that we do not get this error, check that we are using the import and export syntax correctly.

As an example, lets say you have a file called helloModule.js which exports a function:

export function sayHello() {
  console.log("Hello World!");
}

You can then import this function into another file — app.js using the import statement:

import { sayHello } from './helloModule.js';

sayHello(); // Output: Hello World!

In the above example, we are importing the helloModule.js to be used in our app.js file — the sayHello() function.

Node will consider a file as ECMAScript modules when it satisfies the following:

• Files ending in .js if there is a top-level field “type” with a value of “module” in the nearest parent package.json file
• Files ending in .mjs
• Strings passed in as an argument to –eval or –print, or piped to node via STDIN, with the flag –input-type=module.

2. Make sure to have the file extension .js when you import

One thing to keep in mind when doing import is that the file MUST have an extension.

As specified in the Node docs — it is mandatory to have file extensions when working with import keyword (https://nodejs.org/api/esm.html#mandatory-file-extensions)

Consider the following code:

import { sayHello } from './helloModule'; ❌ /* Will give you error - need .js extension */

import { sayHello } from './helloModule.js'; ✔️ /* This will work!*/

The first import will not work and will give you “ERR_MODULE_NOT_FOUND” since there is no extension (.js)

Note: The behavior tries to match how import behaves in browser environments

In the browser, imports still require file extensions (eg .js), but we can get around it using bundlers/ transpilers such as Webpack!

3. Make sure that the module exists and you have supplied the correct path.

One thing to keep in mind is that you are providing the correct path.

.
└── My project/
    ├── node_modules
    ├── common/
    │   └── helloModule.js
    ├── app.js
    ├── db/
    │   └── index.js
    └── package.json

Now if we want to use helloModule.js in our app.js file, we have to make sure that the path is correct.

import { sayHello } from './helloModule.js'; ❌ /* Will give you error - wrong path */

import { sayHello } from './common/helloModule.js'; ✔️ /* This will work!*/

In the above, our helloModule.js is in the common folder and we need to specify it relative to app.js

4. Check that not mixing and matching with CommonJs — eg using the require() function

As specified in the Node docs (https://nodejs.org/api/esm.html) — Node comes with two module systems.

The old way to import javascript libraries or common code is to use CommonJS.

This uses the require() function to load libraries that you want to use with your code.

Since Node version 14, ESM modules are introduced — which lets us use the import/ export keywords.

You should NOT mix and match ES6 modules and CommonJS syntax together!

You can only pick one module system — for example the below code will not work:

❌ /* will not work since mixing and matching require and import */

const { sayHello } = require('./helloModule.js'); 
import { sayHello } from './common/helloModule.js'; 

Convert to use ESM modules

If you already have require() methods to load your JS files and want to use the new ES6 module syntax with import and export, we can do the following:

1. Replace require(), with the import keyword.

So instead of doing this:

const express = require('express');

We can convert to the new ES6 syntax with import/export.
(Note: keep in mind that you still have the “type” value as “module”)

import express from 'express';

1. In the package.json, make sure the “type” attribute is “module”.

For example:

{
  "name": "TestApp",
  "main": "server.js",
  "type": "module", ✔️
  ...
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.19.0",
    "chalk": "^4.0.0",
    "dotenv": "^8.2.0",
    "express": "^4.17.1"
  },
  "devDependencies": {
    "sequelize-cli": "^5.5.1"
  }
}

Convert to use CommonJS

The other option is to revert and keep using CommonJS.

To this this issue, we can do the following:

1. Change the “type” value from “module” to “commonjs”

1. Change all import to require()

import express from 'express';

Becomes

const express = require('express');