TypeScript 5.9: Features That Actually Change Your Workflow

// TypeScript 5.8: Inference fails, requires annotation
function pipe<A, B, C>(
  value: A,
  fn1: (a: A) => B,
  fn2: (b: B) => C
): C {
  return fn2(fn1(value));
}

// Had to annotate explicitly
const result: string = pipe(
  { id: 1, name: "Alice" },
  (user) => user.name,
  (name) => name.toUpperCase()
);

// TypeScript 5.9: Infers correctly without annotation
const result = pipe(
  { id: 1, name: "Alice" },
  (user) => user.name,           // TypeScript infers: (user: {id: number, name: string}) => string
  (name) => name.toUpperCase()   // TypeScript infers: (name: string) => string
);
// result is correctly typed as string, no annotation needed

// TypeScript 5.9: Narrows correctly on template literal patterns
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
type SafeMethod = "GET";
type MutatingMethod = Exclude<HttpMethod, SafeMethod>;

function handleRequest(method: HttpMethod, body: unknown) {
  if (method === "GET") {
    // TypeScript now correctly knows method is SafeMethod here
    // No body parameter processing needed
    return processReadRequest();
  }
  
  // TypeScript 5.9 correctly infers method is MutatingMethod here
  if (!body) {
    throw new Error(`Method ${method} requires a body`);
  }
  
  return processMutatingRequest(method, body);
}

type ApiResponse<T> =
  | { status: "success"; data: T; timestamp: number }
  | { status: "error"; error: string; code: number }
  | { status: "loading" };

function processResponse<T>(response: ApiResponse<T>): T | null {
  // TypeScript 5.9 narrows these correctly including the timestamp/error/code fields
  switch (response.status) {
    case "success":
      // TypeScript knows: response.data exists, response.timestamp exists
      console.log(`Success at ${response.timestamp}`);
      return response.data;
    case "error":
      // TypeScript knows: response.error and response.code exist
      console.error(`Error ${response.code}: ${response.error}`);
      return null;
    case "loading":
      return null;
    default:
      // This satisfies the exhaustive check
      const _exhaustive: never = response;
      return _exhaustive;
  }
}

// Without using: manual cleanup is error-prone
async function fetchWithConnection(url: string) {
  const conn = await database.connect();
  try {
    const result = await conn.query(url);
    return result;
  } finally {
    // This runs, but it's easy to forget
    await conn.disconnect();
  }
}

// With using: automatic cleanup is guaranteed
class DatabaseConnection implements AsyncDisposable {
  private conn: Connection;

  constructor(conn: Connection) {
    this.conn = conn;
  }

  async query(sql: string) {
    return this.conn.execute(sql);
  }

  async [Symbol.asyncDispose]() {
    await this.conn.disconnect();
    console.log("Connection closed");
  }
}

async function fetchWithUsing(url: string) {
  await using conn = new DatabaseConnection(await database.connect());
  // conn.disconnect() is guaranteed to run when scope exits
  // whether through normal return OR exception
  return await conn.query(url);
}

// Real-world example: file handles
class FileHandle implements Disposable {
  private handle: fs.FileHandle;

  constructor(handle: fs.FileHandle) {
    this.handle = handle;
  }

  readLine() {
    return this.handle.readLine();
  }

  [Symbol.dispose]() {
    this.handle.close();
  }
}

async function processFile(path: string) {
  using file = new FileHandle(await fs.open(path, "r"));
  // File is automatically closed when function exits
  const content = await file.readLine();
  return content;
}

// Without const type parameter: TypeScript widens literals
function createConfig<T>(config: T): T {
  return config;
}

// TypeScript infers: { theme: string, variant: string }
// Not what we want
const config = createConfig({ theme: "dark", variant: "primary" });

// TypeScript 5.9 const type parameter: preserves literal types
function createTypedConfig<const T>(config: T): T {
  return config;
}

// TypeScript infers: { theme: "dark", variant: "primary" }
// Exact literal types preserved
const strictConfig = createTypedConfig({ theme: "dark", variant: "primary" });

// This enables powerful patterns like type-safe route definitions
const routes = createTypedConfig([
  { path: "/", component: "Home" },
  { path: "/about", component: "About" },
  { path: "/blog/:slug", component: "BlogPost" },
] as const);

// TypeScript knows exactly which paths exist
type AppRoute = typeof routes[number]["path"];
// Type: "/" | "/about" | "/blog/:slug"

// Type-safe pipeline with variadic tuples
type Pipeline<T extends unknown[]> = {
  [K in keyof T]: K extends "0"
    ? (input: T[K]) => T[1 extends keyof T ? 1 : never]
    : (input: T[K extends keyof T ? K : never]) => T[number];
};

// Simpler practical example: typed middleware
type Middleware<Ctx extends object = object> = (
  ctx: Ctx,
  next: () => Promise<void>
) => Promise<void>;

function compose<Ctx extends object>(
  ...middlewares: Middleware<Ctx>[]
): Middleware<Ctx> {
  return async (ctx, next) => {
    const execute = async (i: number): Promise<void> => {
      if (i < middlewares.length) {
        await middlewares[i](ctx, () => execute(i + 1));
      } else {
        await next();
      }
    };
    await execute(0);
  };
}

// Type-safe API route building
type RouteContext = {
  request: Request;
  response: Response;
  params: Record<string, string>;
  user?: { id: string; role: "admin" | "user" };
};

const authMiddleware: Middleware<RouteContext> = async (ctx, next) => {
  const token = ctx.request.headers.get("Authorization");
  if (!token) throw new Error("Unauthorized");
  ctx.user = await verifyToken(token);
  await next();
};

const rateLimitMiddleware: Middleware<RouteContext> = async (ctx, next) => {
  await enforceRateLimit(ctx.request);
  await next();
};

const handler = compose(authMiddleware, rateLimitMiddleware);

// env.ts - Type-safe environment configuration
import { z } from "zod";

const envSchema = z.object({
  DATABASE_URL: z.string().url(),
  OPENAI_API_KEY: z.string().min(1),
  PORT: z.string().transform(Number).pipe(z.number().min(1).max(65535)),
  NODE_ENV: z.enum(["development", "production", "test"]),
  FEATURE_AI_ENABLED: z
    .string()
    .transform((v) => v === "true")
    .default("false"),
});

// Validates at startup, throws descriptive errors if misconfigured
export const env = envSchema.parse(process.env);

// Now env is fully typed:
// env.DATABASE_URL: string (valid URL guaranteed)
// env.OPENAI_API_KEY: string
// env.PORT: number
// env.NODE_ENV: "development" | "production" | "test"
// env.FEATURE_AI_ENABLED: boolean

// TypeScript 5.9 integrates better with Zod's inference
// for complex schemas like this one

// Method decorator for automatic error boundary
function withRetry(maxAttempts: number = 3) {
  return function <This, Args extends unknown[], Return>(
    target: (this: This, ...args: Args) => Promise<Return>,
    context: ClassMethodDecoratorContext
  ) {
    return async function (this: This, ...args: Args): Promise<Return> {
      let lastError: Error;
      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
        try {
          return await target.call(this, ...args);
        } catch (error) {
          lastError = error instanceof Error ? error : new Error(String(error));
          if (attempt < maxAttempts) {
            await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
          }
        }
      }
      throw lastError!;
    };
  };
}

// Property decorator for validated assignment
function validate<T>(schema: { parse: (val: unknown) => T }) {
  return function <This>(
    _target: undefined,
    context: ClassFieldDecoratorContext<This, T>
  ) {
    return function (this: This, value: T) {
      return schema.parse(value);
    };
  };
}

class AIService {
  @validate(z.string().url())
  endpoint: string = "";

  @withRetry(3)
  async generateText(prompt: string): Promise<string> {
    const response = await fetch(this.endpoint, {
      method: "POST",
      body: JSON.stringify({ prompt }),
    });
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    const data = await response.json();
    return data.text;
  }
}

// Usage - automatically retries up to 3 times on failure
const service = new AIService();
service.endpoint = "https://api.example.com/v1/generate";
const text = await service.generateText("Hello");

// tsconfig.json - Recommended configuration for 5.9
{
  "compilerOptions": {
    "target": "ES2022",
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "moduleResolution": "Bundler",
    "strict": true,
    "exactOptionalPropertyTypes": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true,
    "useDefineForClassFields": true,
    // New in 5.9: more accurate auto-imports
    "moduleDetection": "force"
  }
}