Essential TypeScript Utility Packages for 2026

import { z } from 'zod';

const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
});

type User = z.infer<typeof UserSchema>; // TypeScript type auto-generated

const result = UserSchema.safeParse(input);
if (result.success) {
  console.log(result.data); // Fully typed
}

import * as v from 'valibot';

const UserSchema = v.object({
  name: v.pipe(v.string(), v.minLength(2)),
  email: v.pipe(v.string(), v.email()),
  age: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
});

type User = v.InferOutput<typeof UserSchema>;

// Before ts-reset
const filtered = [1, undefined, 2].filter(Boolean);
// Type: (number | undefined)[] — still includes undefined!

// After ts-reset
const filtered = [1, undefined, 2].filter(Boolean);
// Type: number[] — correct!

// Before ts-reset
const data = JSON.parse(input);
// Type: any

// After ts-reset
const data = JSON.parse(input);
// Type: unknown — forces you to validate

import type { PartialDeep, CamelCase, SetRequired } from 'type-fest';

// Make all nested properties optional
type DeepPartialUser = PartialDeep<User>;

// Convert string to camelCase type
type Key = CamelCase<'user-profile-settings'>; // 'userProfileSettings'

// Make specific optional fields required
type UserWithEmail = SetRequired<User, 'email'>;

import { match, P } from 'ts-pattern';

type Shape =
  | { type: 'circle'; radius: number }
  | { type: 'rect'; width: number; height: number };

const area = match(shape)
  .with({ type: 'circle' }, ({ radius }) => Math.PI * radius ** 2)
  .with({ type: 'rect' }, ({ width, height }) => width * height)
  .exhaustive(); // Compile error if a case is missing

import { format, addDays, differenceInDays } from 'date-fns';

format(new Date(), 'yyyy-MM-dd'); // '2026-03-04'
addDays(new Date(), 7); // Next week
differenceInDays(endDate, startDate); // Days between

import dayjs from 'dayjs';

dayjs().format('YYYY-MM-DD');
dayjs().add(7, 'day');
dayjs(endDate).diff(startDate, 'day');

import { createEnv } from '@t3-oss/env-nextjs';
import { z } from 'zod';

export const env = createEnv({
  server: {
    DATABASE_URL: z.string().url(),
    STRIPE_SECRET_KEY: z.string().startsWith('sk_'),
  },
  client: {
    NEXT_PUBLIC_APP_URL: z.string().url(),
  },
  runtimeEnv: {
    DATABASE_URL: process.env.DATABASE_URL,
    STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY,
    NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
  },
});

// env.DATABASE_URL is guaranteed to be a valid URL string

import { nanoid } from 'nanoid';

nanoid(); // "V1StGXR8_Z5jdHi6B-myT" (21 chars, URL-safe)
nanoid(10); // "IRFa-VaY2b" (custom length)

import { createId } from '@paralleldrive/cuid2';

createId(); // "tz4a98xxat96iws9zmbrgj3a"

import ky from 'ky';

const data = await ky.get('https://api.example.com/data').json<User[]>();
// Automatic JSON parsing, typed response

import { ofetch } from 'ofetch';

const data = await ofetch<User[]>('/api/users', {
  retry: 3,
  retryDelay: 1000,
});

import slugify from 'slugify';
slugify('Hello World!', { lower: true }); // 'hello-world'

import superjson from 'superjson';

const data = { date: new Date(), set: new Set([1, 2, 3]) };
const json = superjson.stringify(data);
const parsed = superjson.parse(json); // Dates and Sets restored

// ❌ Common: only validate API inputs
app.post('/users', async (req, res) => {
  const user = UserSchema.parse(req.body); // Good
});

// But then trust data from other sources without validation:
const config = JSON.parse(fs.readFileSync('config.json', 'utf-8')); // ❌ unvalidated

// ✅ Better: validate ALL external data
const ConfigSchema = z.object({
  port: z.number().int().min(1024).max(65535),
  dbUrl: z.string().url(),
});
const config = ConfigSchema.parse(JSON.parse(fs.readFileSync('config.json', 'utf-8')));

// ❌ ts-reset installed but not referenced
// Nothing changes — TypeScript doesn't know about it

// ✅ Add to your tsconfig.json
{
  "compilerOptions": {
    "types": ["@total-typescript/ts-reset"]
  }
}

// OR: import it once in your project's global types file
// types/global.d.ts
import "@total-typescript/ts-reset";

// ❌ Using type-fest when built-ins work
import type { Except } from 'type-fest';
type UserWithoutPassword = Except<User, 'password'>;

// ✅ Use built-in Omit
type UserWithoutPassword = Omit<User, 'password'>;

// ✅ Reach for type-fest when built-ins fall short
import type { PartialDeep } from 'type-fest';
type PatchPayload = PartialDeep<User>; // Deep partial — no built-in equivalent

// schemas/base.ts — reusable primitives
const Timestamp = z.object({
  createdAt: z.string().datetime(),
  updatedAt: z.string().datetime(),
});

const PaginatedResponse = <T extends z.ZodTypeAny>(itemSchema: T) =>
  z.object({
    items: z.array(itemSchema),
    total: z.number().int().nonnegative(),
    page: z.number().int().positive(),
    pageSize: z.number().int().positive(),
  });

// schemas/user.ts
const UserBase = z.object({
  id: z.string().cuid2(),
  name: z.string().min(2).max(100),
  email: z.string().email(),
});

export const User = UserBase.merge(Timestamp);
export const UserList = PaginatedResponse(UserBase);
export const CreateUserInput = UserBase.omit({ id: true }).merge(
  z.object({ password: z.string().min(8) })
);

// Type inference flows through
type User = z.infer<typeof User>;
type UserList = z.infer<typeof UserList>;

import { match, P } from 'ts-pattern';

type ApiResponse<T> =
  | { status: 'success'; data: T }
  | { status: 'error'; code: number; message: string }
  | { status: 'loading' }
  | { status: 'idle' };

function renderUserProfile(response: ApiResponse<User>) {
  return match(response)
    .with({ status: 'idle' }, () => <EmptyState />)
    .with({ status: 'loading' }, () => <Skeleton />)
    .with({ status: 'error', code: 401 }, () => <LoginPrompt />)
    .with({ status: 'error', code: P.number }, ({ message }) => <ErrorBanner message={message} />)
    .with({ status: 'success' }, ({ data }) => <UserCard user={data} />)
    .exhaustive(); // TypeScript ensures all cases are handled
}

// server/trpc.ts
import { initTRPC } from '@trpc/server';
import superjson from 'superjson';

const t = initTRPC.create({
  transformer: superjson, // Dates flow through automatically
});

// Now returning a Date from a procedure works end-to-end
const userRouter = t.router({
  getUser: t.procedure
    .input(z.object({ id: z.string() }))
    .query(async ({ input }) => {
      const user = await db.user.findUnique({ where: { id: input.id } });
      return user; // createdAt (Date) is preserved through superjson
    }),
});

┌──────────────────────────────────────────────────────┐
│                   Frontend (Client)                  │
│                                                      │
│  ofetch / ky → tRPC client → Zod-validated response │
│  nanoid for optimistic update IDs                    │
│  ts-pattern for UI state machine rendering           │
│  superjson as tRPC transformer (dates preserved)     │
└──────────────────────────────────────────────────────┘
                        │
                        ▼
┌──────────────────────────────────────────────────────┐
│              tRPC Router (Server)                    │
│                                                      │
│  @t3-oss/env-nextjs validates env at startup         │
│  Zod validates all procedure inputs                  │
│  type-fest utility types on shared interfaces        │
│  ts-reset applied globally (JSON.parse → unknown)    │
│  date-fns for date formatting in responses           │
└──────────────────────────────────────────────────────┘
                        │
                        ▼
┌──────────────────────────────────────────────────────┐
│                    Database Layer                    │
│                                                      │
│  superjson serializes complex types to/from JSON     │
│  nanoid / cuid2 for ID generation                    │
└──────────────────────────────────────────────────────┘