TypeScript Setup

// JavaScript: Crashes at runtime
function getUser(id) {
  return users.find(u => u.id === id);
}
getUser("123"); // Oops, id should be a number

// TypeScript: Catches at compile time
function getUser(id: number): User | undefined {
  return users.find(u => u.id === id);
}
getUser("123"); // Error: Argument of type 'string' is not assignable

npm install -D typescript @types/node

# Generate tsconfig.json
npx tsc --init

{
  "compilerOptions": {
    // Output
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "outDir": "./dist",
    "rootDir": "./src",

    // Strict mode (use all of these)
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noImplicitReturns": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,

    // Module interop
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "resolveJsonModule": true,

    // Other
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

npm install -D ts-node

{
  "scripts": {
    "dev": "ts-node src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

npm install -D tsx

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

npm install -D nodemon ts-node

{
  "scripts": {
    "dev": "nodemon --exec ts-node src/index.ts"
  }
}

// nodemon.json
{
  "watch": ["src"],
  "ext": "ts,json",
  "ignore": ["src/**/*.spec.ts"],
  "exec": "ts-node ./src/index.ts"
}

npm install -D @swc/core @swc/cli

// .swcrc
{
  "jsc": {
    "parser": {
      "syntax": "typescript",
      "decorators": true
    },
    "target": "es2022"
  },
  "module": {
    "type": "es6"
  }
}

{
  "scripts": {
    "build": "swc src -d dist",
    "dev": "swc src -d dist --watch"
  }
}

# Express types
npm install -D @types/express @types/cors @types/morgan

# Other common packages
npm install -D @types/bcryptjs @types/jsonwebtoken @types/uuid

# Search for types on DefinitelyTyped
npm search @types/package-name

// src/index.ts
import express, { Application } from 'express';
import cors from 'cors';
import { config } from './config/index.js';
import { errorHandler } from './middleware/errorHandler.js';
import userRoutes from './routes/users.js';

const app: Application = express();

app.use(cors());
app.use(express.json());

app.use('/api/users', userRoutes);

app.use(errorHandler);

app.listen(config.port, () => {
  console.log(`Server running on port ${config.port}`);
});

// src/controllers/userController.ts
import { Request, Response, NextFunction } from 'express';
import { UserService } from '../services/userService.js';

export async function getUser(
  req: Request,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    const user = await UserService.findById(req.params.id);
    res.json({ data: user });
  } catch (error) {
    next(error);
  }
}

// src/types/index.ts
import { Request } from 'express';

export interface AuthenticatedRequest extends Request {
  user: {
    id: string;
    email: string;
    role: 'user' | 'admin';
  };
}

// Usage in controller
export async function getProfile(
  req: AuthenticatedRequest,
  res: Response
): Promise<void> {
  const userId = req.user.id; // Typed!
  // ...
}

// src/routes/users.ts
import { Router, Request, Response } from 'express';

interface UserParams {
  id: string;
}

interface CreateUserBody {
  email: string;
  password: string;
  name: string;
}

const router = Router();

router.get('/:id', async (req: Request<UserParams>, res: Response) => {
  const { id } = req.params; // id is string
  // ...
});

router.post('/', async (
  req: Request<{}, {}, CreateUserBody>,
  res: Response
) => {
  const { email, password, name } = req.body; // All typed!
  // ...
});

export default router;

// src/config/index.ts
import { z } from 'zod';
import dotenv from 'dotenv';

dotenv.config();

const envSchema = z.object({
  NODE_ENV: z.enum(['development', 'production', 'test']).default('development'),
  PORT: z.string().transform(Number).default('3000'),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
  JWT_EXPIRES_IN: z.string().default('7d'),
});

const parsed = envSchema.safeParse(process.env);

if (!parsed.success) {
  console.error('Invalid environment variables:', parsed.error.format());
  process.exit(1);
}

export const config = parsed.data;
export type Config = z.infer<typeof envSchema>;

// tsconfig.json
{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"],
      "@/config": ["src/config/index.ts"],
      "@/types": ["src/types/index.ts"]
    }
  }
}

npm install -D tsconfig-paths

{
  "scripts": {
    "dev": "ts-node -r tsconfig-paths/register src/index.ts"
  }
}

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

{
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

npm install -D tsc-alias

{
  "scripts": {
    "build": "tsc && tsc-alias"
  }
}

# Build stage
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist

USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]