SyntaxError: Cannot use import statement outside a module
  • 02-May-2023
Lightrun Team
Author Lightrun Team
SyntaxError: Cannot use import statement outside a module

SyntaxError: Cannot use import statement outside a module

Lightrun Team
Lightrun Team

Explanation of the problem

A user has cloned and forked a project and is attempting to verify its functionality. To accomplish this, they are running a code block with the help of the tem.js file. The code block imports all from the src/index.js file and subsequently logs the output of a function named isUrl that is a member of the imported object.

import all from'./src/index.js';

const {isUrl}=all


However, the user is encountering an error that reads as follows: SyntaxError: Cannot use import statement outside a module.

The user has attempted to resolve the issue by setting “type”: “module” in the package.json file. This did not work as it necessitated the inclusion of “.js” at the end of each import statement.


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 SyntaxError: Cannot use import statement outside a module

The problem described in the question is related to the usage of ES6 modules, specifically the import statement used to import functions from the validator library. The error message suggests that the code is not being run as an ES module, and therefore the import statement cannot be used outside of a module. The recommended solution is to enable ES modules by adding “type”: “module” to the package.json file or the tsconfig file if using TypeScript. By enabling ES modules, the code can use the import statement to import functions from external libraries.

However, it is important to note that ES modules are a relatively new feature and are not yet supported in all environments. Therefore, using transpilers like Babel or tsc can be a viable solution to convert ES6 code to an older format, such as CommonJS modules. This approach allows developers to use modern syntax like import and export while ensuring compatibility with older environments. It is worth noting that transpilers require additional configuration and setup, and therefore may add complexity to the project.

Regarding the import of specific functions from the validator library, the answers provide different approaches. One solution is to import each function separately, which allows developers to selectively import only the required functions. Another solution is to import the entire library and selectively use the required functions. However, it is worth noting that importing each function separately can lead to verbose code if multiple functions are required, whereas importing the entire library can lead to unnecessary imports and increased file size. Therefore, the choice between these two approaches may depend on the specific needs of the project.


Other popular problems with Validator.js

Problem: Validator.js not working with conditional rules

Another common issue when using Validator.js is related to conditional rules not working as expected. For example, when using the sometimes rule, which specifies that a field is required only under certain conditions, the validation may fail even when the condition is met. This can happen because the sometimes rule is not fully compatible with all other validation rules, and may cause unexpected behavior.


To solve this issue, you can use the when rule instead of sometimes. The when rule allows you to specify a callback function that returns true or false based on the current field value, and then apply any validation rules conditionally. For example:

const rules = {
  email: 'required|email',
  password: 'required|min:6',
  password_confirmation: 'required|same:password',
  name: 'required|when:role,admin',
  role: 'required'

const data = {
  email: '',
  password: 'password',
  password_confirmation: 'password',
  name: 'John Doe',
  role: 'admin'

const validation = new Validator(data, rules);

if (validation.fails()) {

Problem: Validator.js not validating arrays correctly

Another common issue when using Validator.js is related to the validation of arrays. When using the array rule to validate an array of values, the validation may fail even when all elements in the array are valid. This is because the array rule only checks if the value is an array, but does not validate each element individually.


To validate each element in the array individually, you can use the each rule. The each rule allows you to apply validation rules to each element in the array separately. For example:

const rules = {
  emails: 'required|array',
  'emails.*': 'required|email'

const data = {

A brief introduction to Validator.js

Validator.js is a JavaScript library that provides a set of methods for validating and sanitizing user input data in both the frontend and backend of web applications. The library offers a variety of validation rules for checking data types, formats, lengths, and other constraints. Validator.js is available as a standalone library or as part of popular web development frameworks such as Express and Laravel. The library supports both synchronous and asynchronous validation, and its API is designed to be user-friendly and easy to use.

One of the strengths of Validator.js is its flexibility and customizability. Users can define their own validation rules and error messages, and the library allows for easy integration with third-party libraries and tools. Validator.js also offers a variety of sanitization methods for cleaning up user input, such as removing whitespace, converting data types, and formatting strings. With its extensive set of features and easy integration with popular frameworks, Validator.js is a powerful tool for ensuring the integrity and security of web applications.

Most popular use cases for Validator.js

  1. Validating user input: Validator.js can be used for validating user input in web applications. When a user enters data into a form, the data needs to be validated to ensure that it meets the required format and criteria. Validator.js provides a set of validation rules that can be used to validate user input, such as checking for required fields, validating email addresses, validating dates, and more. Here is an example of how Validator.js can be used to validate an email address:
    const { isEmail } = require('validator');
    const email = '';
    if (isEmail(email)) {
      console.log('Email is valid');
    } else {
      console.log('Email is invalid');
    1. Data validation in APIs: Validator.js can also be used for validating data in APIs. APIs often receive data in JSON format, and this data needs to be validated to ensure that it meets the required format and criteria. Validator.js provides a set of validation rules that can be used to validate JSON data, such as checking for required fields, validating email addresses, validating dates, and more.
    2. Custom validation: Validator.js allows developers to create custom validation rules that can be used to validate data that is specific to their application. This is done by extending the Validator class and adding custom validation methods. Here is an example of how to create a custom validation rule for checking if a string is a palindrome:

      const { Validator } = require('validator');
      class CustomValidator extends Validator {
        isPalindrome(str) {
          return str === str.split('').reverse().join('');
      const customValidator = new CustomValidator();
      const str = 'racecar';
      if (customValidator.isPalindrome(str)) {
        console.log(`${str} is a palindrome`);
      } else {
        console.log(`${str} is not a palindrome`);

It’s Really not that Complicated.

You can actually understand what’s going on inside your live applications.

Try Lightrun’s Playground

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.