I have made the switch from using nodemon and ts-node to a more superior alternative, ts-node-dev. https://github.com/whitecolor/ts-node-dev

Simply execute ts-node-dev src/index.ts

[EDIT] I should note that since posting this answer, nodemon has significantly improved in terms of configuration and performance. I now utilize both tools on separate projects and am content with their functionality.

Summary of Best Options for Running TypeScript in Node.js

• nodemon plus ts-node: Stable but requires explicit configuration and can be slow.
• node-dev plus ts-node: Less configuration than nodemon but still slow.
• ts-node-dev: Fast but may have reliability issues.

Note: Use tsx or swc for fast transpilation without type checking, as most editors offer built-in type checking capabilities.

(Recommended) tsx

ⓘ TL;DR: fastest with minimal configuration

Tsx provides a fast and easy-to-configure solution for running TypeScript in Node.js:

1. Install tsx

   npm install --save-dev tsx
   

2. Update your package.json scripts

   "scripts": {
     "dev": "tsx watch src/index.ts",
   

3. Run the script

   npm run dev
   

   (Adjust steps for global installation if needed)

Alternative Approaches:

1. nodemon/node-dev + ts-node + swc

ⓘ TL;DR: fast but more configuration required

Combine nodemon/node-dev with ts-node and swc for improved speed:

1. Install nodemon or node-dev

2. Set up ts-node with swc integration

3. Run nodemon or node-dev

2. nodemon/node-dev + ts-node transpileOnly

ⓘ TL;DR: reliable with standard TypeScript transpiler

A faster alternative using standard Ts-node transpiler without swc:

1. Install nodemon/node-dev

2. Install ts-node

3. Enable transpileOnly in tsconfig.json

4. Start nodemon/node-dev

3. nodemon + tsc --incremental

ⓘ TL;DR: reliable with type checking, more complex

This approach includes type checking but requires more setup:

1. Install nodemon

2. Configure tsconfig.json for incremental transpilation

3. Setup nodemon to run the TypeScript compiler on file changes

Instead of using HeberLZ's solution, you can try a different approach that involves npm scripts.

Below is an example from my own package.json:

  "scripts": {
    "watch": "nodemon -e ts -w ./src -x npm run watch:serve",
    "watch:serve": "ts-node --inspect src/index.ts"
  },

• The -e flag specifies the extensions to be watched,
• The -w flag sets the directory to watch,
• The -x flag executes the specified script.

The --inspect option in the watch:serve script is related to node.js and enables debugging protocol.

I've found success using the following command:

nodemon src/index.ts

It seems that this method has been effective since the implementation of this pull request: https://github.com/remy/nodemon/pull/1552

If you're looking to streamline your development process, consider utilizing ts-node-dev

With ts-node-dev, the target node process is restarted every time a required file changes (similar to standard node-dev), but it also shares the Typescript compilation process between restarts.

Get Started

yarn add ts-node-dev --dev

Your package.json file can be configured like this:

"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "tsc": "tsc",
  "dev": "ts-node-dev --respawn --transpileOnly ./src/index.ts",
  "prod": "tsc && node ./build/index.js"
}

If you're dealing with this particular problem, I have developed the tsc-watch library specifically for it. You can easily access it on npm.

An obvious scenario where you could use it is:

tsc-watch server.ts --outDir ./dist --onSuccess "node ./dist/server.js"

To include the command

"watch": "nodemon --exec ts-node -- ./src/index.ts"

in the scripts part of your package.json.

I believe it's best to avoid using ts-node and instead always run from the dist folder.

To achieve this, simply configure your package.json with the following settings:

....
"main": "dist/server.js",
"scripts": {
  "build": "tsc",
  "prestart": "npm run build",
  "start": "node .",
  "dev": "nodemon"
},
....

Next, include a nodemon.json configuration file:

{
  "watch": ["src"],
  "ext": "ts",
  "ignore": ["src/**/*.spec.ts"],
  "exec": "npm restart"
}

In this setup, I utilize "exec": "npm restart"
This ensures that all ts files will be recompiled to js files before restarting the server.

To run in a development environment, use the command:

npm run dev

By following this configuration, you can always run the application from the distributed files without relying on ts-node.

i tried using the following script:

"start": "nodemon --watch 'src/**/*.ts' --ignore 'src/**/*.spec.ts' --exec ts-node src/index.ts"

when I ran 'yarn start', an error occurred with the message stating that it did not recognize 'ts-node'

Standard Solution

Starting from Node.js version v16.19.0, the CLI introduces a convenient --watch option, eliminating the need for external dependencies such as nodemon.

To run TypeScript code, leverage the popular package ts-node. Below is an example of how to configure it:

// package.json
{
    "scripts": {
        "dev": "node --watch --loader=ts-node/esm ./src/app.ts"
    },
    "devDependencies": {
        "ts-node": "~10.9.0"
    }
}

Alternative Approach

If you're open to exploring other options, consider checking out tsx, although it may not be as mature as ts-node.

Please note that tsx does not currently support emitDecoratorMetadata, which is essential for projects utilizing decorators. Despite this limitation, tsx offers quicker compilation (powered by esbuild backend):

// package.json
{
    "scripts": {
        "dev": "tsx watch ./src/app.ts"
    },
    "devDependencies": {
        "tsx": "~4.6.0"
    }
}

An alternative approach is to start by compiling the code in watch mode using tsc -w and then running nodemon on the generated JavaScript files. This technique offers a comparable speed to ts-node-dev while providing a more production-ready environment.

 "scripts": {
    "watch": "tsc -w",
    "dev": "nodemon dist/index.js"
  },

Step one - Start by installing the packages listed below in your project dependencies

npm i -D @types/express @types/node nodemon ts-node tsc typescript

You can also use yarn:

yarn add -D @types/express @types/node nodemon ts-node tsc typescript

Step two - Add the following configuration to your tsconfig.json file

{
  "compilerOptions": {
    "target": "es6" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */,
    "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
    "lib": [
      "DOM",
      "ES2017"
    ] /* Specify library files to be included in the compilation. */,
    "sourceMap": true /* Generates corresponding '.map' file. */,
    "outDir": "./dist" /* Redirect output structure to the directory. */,
    "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,

    "strict": true /* Enable all strict type-checking options. */,
    "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
    "skipLibCheck": true /* Skip type checking of declaration files. */,
    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
  },
  "exclude": ["node_modules"],
  "include": ["./src"]
}

Step three - Implement the following scripts in your package.json file

"scripts": {
    "start": "node ./dist/server.js",
    "dev": "nodemon -L ./src/server.ts && tsc -w"
},

Include the following code in your package.json file:

scripts {
"dev": "nodemon --watch '**/*.ts' --exec 'ts-node' index.ts"
}

In order for this to work, you must also install ts-node as a dev-dependency

yarn add ts-node -D

To start the development server, run yarn dev

STEP 1: To get started, you need to install nodemon and ts-node. If you have already installed them, you can skip this step.

npm install --save-dev nodemon ts-node

STEP 2: Next, configure the start script in your package.json file.

"start": "nodemon ./src/app.ts"

Nodemon now automatically detects TypeScript files in your project and uses the ts-node command. Simply run npm start to compile, watch, and reload your application.

If you encounter errors regarding TypeScript modules not being found in your project, simply run the following command in your project folder.

npm link typescript

Encountered an error with code: 'ERR_UNKNOWN_FILE_EXTENSION'. I required esm support, so to enable ES6 functionality, you can use the following commands:

npm i -D ts-node nodemon

Add the script below to your package.json file:

"dev": "nodemon --exec ts-node-esm ./src/index.ts"

To resolve the issue, simply update these 3 packages:

nodemon, ts-node, typescript
yarn global add nodemon ts-node typescript

Alternatively, you can use npm:

npm install -g nodemon ts-node typescript

Once updated, execute the following command to solve the problem:

nodemon <filename>.ts

Refresh console logs after making changes

Javascript:

"start": "nodemon -x \"clear && node\" index.js",

Typescript:

"start": "nodemon -x \"clear && ts-node\" index.ts",

The simplest solution would be to download Nodemon and execute the following command: "nodemon --exec npx ts-node --esm test.ts"

If you encounter any issues while using

"type": "module"

in your package.json file (as detailed in this GitHub issue), you can resolve them by applying the following configuration:

{
  "watch": ["src"],
  "ext": "ts,json",
  "ignore": ["src/**/*.spec.ts"],
  "exec": "node --loader ts-node/esm --experimental-specifier-resolution ./src/index.ts"
}

You can also use the following command line options:

nodemon --watch "src/**" --ext "ts,json" --ignore "src/**/*.spec.ts" --exec "node --loader ts-node/esm --experimental-specifier-resolution src/index.ts"

To activate the --poll feature on your package.json file, simply add the option within your scripts section. The --poll flag instructs ts-node-dev to actively monitor source code files for changes by intermittently scanning them, rather than relying on the file system's change notifications. This ensures that any modifications made to the files are promptly detected, even in cases where the file system may not reliably report changes.

   "start": "ts-node-dev --poll src/index.ts"

Utilize ts-node-dev version 2.0.0+ with the following command:

ts-node-dev --respawn ./src/index.ts

*Note: In case of an error stating "command not found", you can execute it directly from node-modules as follows:

./node_modules/.bin/ts-node-dev --respawn ./src/index.ts

If you're looking to integrate tsc and the payload more tightly without resorting to running them in parallel, there's an alternative approach that involves incorporating them together. You can achieve this by creating a Node.js script that waits for the TypeScript compiler to finish building before initiating your process.

For one of my projects, I devised the following solution (note: this requires the installation of the tree-kill package):

#!/usr/bin/env node

import { spawn } from 'node:child_process';
import { join } from 'node:path';
import { createInterface } from 'node:readline';
import process from 'node:process';
import kill from 'tree-kill';

const cwd = process.cwd();
const tscConfigPath = join(cwd, 'tsconfig.build.json');
const tscArgs = ['tsc', '--build', '--watch', '--pretty', tscConfigPath];
const command = process.argv.slice(2);

// adjust params above as necessary

const tsc = spawn('yarn', tscArgs, { // change if not using yarn
  stdio: ['ignore', 'pipe', 'inherit'],
  cwd,
});

let proc;

const startCommand = () => {
  proc && kill(proc.pid);
  proc = spawn(command[0], command.slice(1), { stdio: 'inherit', cwd });
};

const rl = createInterface({
  input: tsc.stdout,
  terminal: false,
});

rl.on('line', (line) => {
  console.log(line);
  if (line.includes('Found 0 errors. Watching for file changes.')) {
    startCommand();
  }
});

tsc.on('exit', (code) => {
  console.log('tsc exited with code', code);
  proc && kill(proc.pid);
  process.exit(code);
});

process.on('SIGINT', () => {
  kill(tsc.pid);
  proc && kill(proc.pid);
  process.exit(0);
});

process.on('exit', () => {
  kill(tsc.pid);
  proc && kill(proc.pid);
});

I implement it in other packages within my monorepo like so in the package.json configuration:

"scripts": {
  "start:dev": "run-on-tsc-build yarn node dist/main.js"
}

This method functions by waiting for the message "Found 0 errors. Watching for file changes." from TypeScript before executing the specified command.