PricingLoginStart free
Node.js Backend Development Bootcamp · レッスン

tsx、ホットリロード、ソースマップによる高速イテレーション

オンザフライ変換、ウォッチモード、正確なスタックトレースによるスムーズな開発ループを設定します。

レッスン 4/413 ステップ

「tsx、ホットリロード、ソースマップによる高速イテレーション」はCoddyKit上の無料Node.js Backend Development Bootcampレッスンです。 これはレッスン4/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはNode.js Backend Development Bootcamp学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Node.js Backend Development Bootcampコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

The Slow Dev Loop Problem

When you write a Node.js backend in TypeScript, the naive workflow is painful: edit a file, run tsc to compile to JavaScript, then run node dist/index.js, then repeat on every change.

This adds friction in three places:

  • Transpile step — you wait for the whole project to build before anything runs.
  • Restart step — you manually kill and relaunch the process.
  • Debugging — errors point to compiled dist/*.js line numbers, not your real source.

In this lesson we wire up a frictionless loop: on-the-fly transpilation with tsx, automatic restarts with watch mode, and accurate stack traces with source maps.

What tsx Actually Does

tsx ("TypeScript Execute") is a CLI that runs TypeScript and ESM files directly, with no separate build step. Under the hood it uses esbuild to transpile each module in memory as Node loads it.

Key facts to remember:

  • It does not type-check — esbuild only strips types and emits JS. You keep tsc --noEmit for type safety in CI.
  • It handles both .ts and modern ESM import syntax transparently.
  • It is meant for development and scripts, not as your production runtime.

Install it as a dev dependency:

// package.json (dev dependency install)
// npm install --save-dev tsx

// Then run any TypeScript file directly:
// npx tsx src/index.ts

// No tsconfig 'outDir', no dist/ folder needed during dev.

Running a File Directly

The simplest use of tsx is replacing node with tsx. Given a TypeScript entry point, you run it directly and tsx transpiles on the fly.

Here is a tiny standalone script. The logic itself is plain JavaScript you can run anywhere; with tsx you would write the same thing in a .ts file using types, and tsx would strip them before executing.

function greet(name) {
  return `Hello, ${name}! Server starting...`;
}

const port = process.env.PORT || 3000;
console.log(greet('developer'));
console.log(`Would listen on port ${port}`);

Watch Mode: Automatic Restarts

The biggest time-saver is tsx watch. It launches your program, watches every file in the dependency graph, and restarts the process automatically whenever a source file changes.

This replaces older tools like nodemon + ts-node with a single fast command. You no longer hit Ctrl+C and re-run after every edit.

Add it to your package.json scripts so the whole team uses the same command:

{
  "name": "my-api",
  "type": "module",
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "start": "node dist/index.js",
    "typecheck": "tsc --noEmit",
    "build": "tsc"
  }
}

A Watchable Server Entry Point

Here is a minimal HTTP server entry point you would run with tsx watch. Edit any handler and tsx restarts the process in milliseconds, so the new code is live almost instantly.

Notice this uses only Node's built-in http module — no Express, no framework. tsx works the same regardless of what libraries you import.

import { createServer } from 'node:http';

const server = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ message: 'Edit me and tsx restarts!' }));
});

server.listen(3000, () => {
  console.log('Listening on http://localhost:3000');
});

Why You Still Need Type Checking

Because tsx (via esbuild) only strips types, it will happily run code that has type errors. That speed is great for iteration but dangerous if it is your only safety net.

The standard pattern is a two-track setup:

  • Fast loop: tsx watch for instant feedback while coding.
  • Correctness gate: tsc --noEmit in a separate terminal or in CI to catch real type errors.

You can even run the type-checker in watch mode alongside tsx:

// Terminal 1 — run + restart on change (no type errors caught)
// npm run dev        ->  tsx watch src/index.ts

// Terminal 2 — continuous type checking
// npx tsc --noEmit --watch

// CI pipeline step
// npm run typecheck   ->  tsc --noEmit

Hot Reload vs Restart

It is worth being precise: tsx watch does a full process restart, not in-place hot module replacement (HMR). The whole Node process exits and a fresh one starts.

For backend APIs this is almost always what you want:

  • State is rebuilt cleanly, avoiding stale modules or leaked listeners.
  • Restarts are fast because only changed modules are re-transpiled.

True HMR (keeping connections and in-memory state alive across edits) exists in some frameworks but adds complexity and subtle bugs. For most Node backends, a fast clean restart is simpler and safer.

Graceful Shutdown for Clean Restarts

Because watch mode kills and relaunches the process, your server should shut down cleanly so ports and resources are released before the next start. Listen for the SIGTERM / SIGINT signals tsx sends.

Without this, a slow-closing server can leave the port in use and the restarted process crashes with EADDRINUSE.

import { createServer } from 'node:http';

const server = createServer((req, res) => res.end('ok'));
server.listen(3000);

function shutdown() {
  console.log('Closing server before restart...');
  server.close(() => process.exit(0));
}

process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);

Source Maps: Accurate Stack Traces

When code is transpiled, an error's line and column refer to the generated JavaScript, not your TypeScript. Source maps are mapping files that translate generated positions back to your original source.

Good news for tsx: it generates and applies source maps automatically, so thrown errors already point at your real .ts lines.

For a tsc-built production bundle you must opt in via tsconfig.json:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "dist",
    "sourceMap": true,
    "strict": true
  }
}

Enabling Source Maps at Runtime

Generating .map files is only half the story. Node must be told to use them when formatting stack traces. Modern Node supports the --enable-source-maps flag.

With it, a crash in dist/index.js shows the original src/index.ts filename and line in the stack trace. Add it to your production start script:

{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "start": "node --enable-source-maps dist/index.js"
  }
}

Seeing a Source-Mapped Trace

To feel why source maps matter, here is a complete program that throws from inside a nested call. When run, the stack trace lists each function and the line it failed on.

In a transpiled project without source maps, those line numbers would belong to the compiled output and be useless. With tsx (or --enable-source-maps), they map back to your original source.

function loadConfig() {
  throw new Error('Missing DATABASE_URL');
}

function startServer() {
  return loadConfig();
}

try {
  startServer();
} catch (err) {
  console.error('Startup failed:', err.message);
  console.error(err.stack);
}

Quick Check

You are setting up the development and production workflow for a TypeScript Node.js API. Answer based on what each tool does.

対話的なレッスンで答える

Recap

You built a frictionless TypeScript dev loop for Node.js backends:

  • tsx runs .ts and ESM directly with esbuild — no separate build step, but no type checking either.
  • tsx watch auto-restarts the process on every file change, replacing nodemon + ts-node with one fast command.
  • Watch mode does a clean full restart, so add graceful shutdown (SIGTERM/SIGINT) to avoid EADDRINUSE.
  • Keep correctness with tsc --noEmit in CI, and build production with tsc.
  • Source maps map errors back to your real source: tsx applies them automatically, and production needs sourceMap: true plus node --enable-source-maps.

Result: edit, save, and see correct behavior and accurate stack traces almost instantly.

無料で開始

AI チューターと学ぶ JavaScript — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース
22
レッスン
92
無料で学習を始めるコース全体を表示

よくある質問

「tsx、ホットリロード、ソースマップによる高速イテレーション」レッスンは無料ですか？

はい。「tsx、ホットリロード、ソースマップによる高速イテレーション」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Node.js Backend Development Bootcampコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Node.js Backend Development Bootcampコースには全4レッスンが含まれています。

「tsx、ホットリロード、ソースマップによる高速イテレーション」で何を学びますか？

オンザフライ変換、ウォッチモード、正確なスタックトレースによるスムーズな開発ループを設定します。 ブラウザで直接実行するハンズオンコードでNode.js Backend Development Bootcampを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Node.js Backend Development Bootcampを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのNode.js Backend Development Bootcampは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン4/4です。

「tsx、ホットリロード、ソースマップによる高速イテレーション」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このNode.js Backend Development Bootcampレッスンでコードを書いて実行できますか？

はい。すべてのNode.js Backend Development Bootcampレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. CommonJSからネイティブES Modulesへの移行
  2. Nodeバックエンドプロジェクト向けtsconfigの設定
  3. 型安全な環境設定とランタイム検証
  4. tsx、ホットリロード、ソースマップによる高速イテレーション
← Node.js Backend Development Bootcampに戻る