This article is about fixing ES Module error: Cannot use import statement outside a module in wclr ts-node-dev
  • 20-Feb-2023
Lightrun Team
Author Lightrun Team
This article is about fixing ES Module error: Cannot use import statement outside a module in wclr ts-node-dev

ES Module error: Cannot use import statement outside a module in wclr ts-node-dev

Lightrun Team
Lightrun Team

Explanation of the problem

When attempting to port some projects to ESM (ECMAScript modules) an error is encountered. The error message indicates that to load an ES module, they need to set “type”: “module” in the package.json file or use the .mjs extension. However, when attempting to import the ‘crypto-random-string’ module, they receive a SyntaxError indicating that import statements cannot be used outside a module. The error message also includes a stack trace showing where the warning was created.

The user has provided some context about their system, including that they are running on Windows 10 Home, using Node version 16.2.0 and ts-node-dev version. They have tried running their code with ts-node, but encountered a TypeError indicating that the file extension “.ts” is unknown. They also attempted running their code with the “–loader ts-node/esm” option, which worked. The user has provided a git repo with a reproducible example.

To summarize, the user is encountering a SyntaxError when attempting to import an ES module and has already tried various options to run their code, including ts-node and the –loader option. They have provided a reproducible example in a git repo for further investigation.

Troubleshooting with the Lightrun Developer Observability Platform

Getting a sense of what’s actually happening inside a live application is a frustrating experience, one that relies mostly on querying and observing whatever logs were written during development.
Lightrun is a Developer Observability Platform, allowing developers to add telemetry to live applications in real-time, on-demand, and right from the IDE.

  • Instantly add logs to, set metrics in, and take snapshots of live applications
  • Insights delivered straight to your IDE or CLI
  • Works where you do: dev, QA, staging, CI/CD, and production

Start for free today

Problem solution for ES Module error: Cannot use import statement outside a module in wclr ts-node-dev

One workaround for this issue is to change the “module” option in tsconfig.json to “commonjs”. However, this might not always be possible, as it might not be desirable to change the module system being used for the entire project. Another workaround is to override the “module” option for ts-node within the tsconfig.json file. This involves specifying the “compilerOptions” within the “ts-node” object and setting the “module” option to “commonjs”. This way, when ts-node compiles the TypeScript file, it will use the “commonjs” module system, which is recognized by Node.js.

To implement the workaround, you will need to have ts-node and typescript installed as devDependencies in your project. Then, you can add a “ts-node” object to your tsconfig.json file and specify the “compilerOptions” for ts-node within it. Specifically, you will need to set the “module” option to “commonjs”. For example:

// tsconfig.json

  "compilerOptions": {
    "module": "esnext",
    // ... rest of config
  "ts-node": {
    "compilerOptions": {
      "module": "commonjs"

This solution has been tested with ts-node-dev ver. 1.1.8, ts-node ver. 9.1.1, and typescript ver. 4.4.2, but it should work with other versions as well. It is important to note that this workaround is specific to ts-node, and it will not affect the module system used by the rest of your project. It is a viable solution if you need to use “esnext” or another non-“commonjs” module system for your TypeScript files, but you still want to be able to run them with Node.js.

Other popular problems with wclr ts-node-dev

Problem: “Error: Cannot use import statement outside a module”

The “Error: Cannot use import statement outside a module” is a common issue faced by developers using TypeScript with ts-node-dev. This error occurs when a TypeScript file that uses the “import” statement is executed by Node.js directly, rather than through a TypeScript compiler. This problem arises because Node.js does not natively support the ES6 module syntax used by TypeScript, and instead expects CommonJS modules.


To solve this problem, we need to ensure that TypeScript files are compiled into CommonJS modules before being executed by Node.js. We can do this by setting the “module” option in the tsconfig.json file to “commonjs”. This will instruct the TypeScript compiler to generate CommonJS modules instead of ES6 modules. Alternatively, we can use a tool like babel to transpile the TypeScript code to ES5, which is compatible with Node.js.

Problem: “UnhandledPromiseRejectionWarning: TypeError: Cannot read property ‘apply’ of undefined”

Another common issue with ts-node-dev is the “UnhandledPromiseRejectionWarning: TypeError: Cannot read property ‘apply’ of undefined” error. This error occurs when a Promise is rejected and there is no catch handler to handle the rejection. This can happen when using async/await syntax and not properly handling the Promise rejections.


The solution to this problem is to add a catch handler to all Promises to handle any possible rejections. We can also use a Promise library like Bluebird that provides global rejection handling and makes it easier to handle Promise rejections.

Problem: “Error: ts-node-dev is not recognized as an internal or external command”

The “Error: ts-node-dev is not recognized as an internal or external command” error occurs when ts-node-dev is not installed or configured properly. This can happen when installing ts-node-dev globally and not including it in the project’s dependencies, or when running ts-node-dev from an incorrect directory.


To solve this issue, we need to ensure that ts-node-dev is installed and configured properly. We can install ts-node-dev as a project dependency using npm or yarn, or globally using the -g flag. We also need to ensure that we are running ts-node-dev from the correct directory, which is the root directory of the project. Additionally, we can check the system environment variables and ensure that the path to ts-node-dev is included.

A brief introduction to in wclr ts-node-dev

ts-node-dev is a development tool for Node.js applications that allows developers to write and run TypeScript code directly in their local environment without the need to compile it to JavaScript first. It is built on top of ts-node, a popular TypeScript execution environment for Node.js, and provides additional features like file-watching and automatic reloading when code changes are detected. ts-node-dev is easy to set up and use, making it a popular choice for developers working on Node.js projects in TypeScript.

One of the key benefits of ts-node-dev is that it speeds up the development process by allowing developers to see the changes they make to their code almost instantly. By automatically reloading the application when changes are made to the codebase, ts-node-dev eliminates the need for developers to manually restart the application every time they make a change. This saves time and increases productivity, making it an essential tool for developers working on Node.js applications. Additionally, ts-node-dev provides a simple and intuitive command-line interface that allows developers to customize the tool to suit their specific needs, making it a flexible and powerful tool for any Node.js project.

Most popular use cases for wclr ts-node-dev

  1. Development with TypeScript and Node.js: wclr ts-node-dev is a popular tool for developing applications using TypeScript with Node.js. It provides automatic compilation of TypeScript code to JavaScript and automatic reloading of the application whenever a file changes, which helps to streamline the development process.


$ ts-node-dev app.ts

This command starts the application and monitors any changes to the TypeScript files. Whenever a file is changed, it recompiles the TypeScript code and restarts the application automatically.

  1. Debugging TypeScript Applications: wclr ts-node-dev can be used to debug TypeScript applications. It allows you to set breakpoints in your TypeScript code, which can be very helpful in troubleshooting issues during development. When the application is started with the –inspect-brk flag, it will start in debug mode, and you can use a debugger like VSCode to debug the application.


$ ts-node-dev --inspect-brk app.ts

This command starts the application in debug mode and waits for a debugger to connect. You can then use a debugger like VSCode to attach to the process and start debugging.

  1. Running TypeScript Scripts: wclr ts-node-dev can also be used to run TypeScript scripts directly from the command line. This can be useful for running scripts that perform certain tasks, such as generating code or running tests.


$ ts-node-dev script.ts

This command runs the TypeScript script and monitors any changes to the file. Whenever the file changes, it recompiles the code and reruns the script. This can be a helpful way to streamline the development process and avoid the need to manually re-run the script after each change.


It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications. It’s a registration form away.

Get Lightrun

Lets Talk!

Looking for more information about Lightrun and debugging?
We’d love to hear from you!
Drop us a line and we’ll get back to you shortly.

By submitting this form, I agree to Lightrun’s Privacy Policy and Terms of Use.