# Health Check

> Service health check with status, individual checks, and duration.

- Name: `health-check`
- Categories: infrastructure
- Detail page: https://open-types.dev/types/health-check

## Install

```bash
# Types only
npx shadcn add @open-types/health-check

# Types + Zod v4 validators
npx shadcn add @open-types/health-check-zod

# Types + real-world examples
npx shadcn add @open-types/health-check-examples
```

## Types

```typescript
export type HealthCheckStatus = "healthy" | "unhealthy" | "starting" | "none";

export interface HealthCheckEntry {
  name: string;
  status: HealthCheckStatus;
  duration_ms?: number;
  output?: string;
}

export interface HealthCheckResult {
  status: HealthCheckStatus;
  checks?: HealthCheckEntry[];
  timestamp?: string;
}
```

## Zod validator

```typescript
import * as z from "zod";
import type {
  HealthCheckEntry,
  HealthCheckResult,
  HealthCheckStatus,
} from "../types/health-check";

export const healthCheckStatusSchema = z.enum([
  "healthy",
  "unhealthy",
  "starting",
  "none",
]) satisfies z.ZodType<HealthCheckStatus>;

export const healthCheckEntrySchema = z.object({
  name: z.string().min(1, { error: "Check name is required" }),
  status: healthCheckStatusSchema,
  duration_ms: z
    .number()
    .int()
    .min(0, { error: "Duration must be greater than or equal to 0" })
    .optional(),
  output: z.string().optional(),
}) satisfies z.ZodType<HealthCheckEntry>;

export const healthCheckResultSchema = z.object({
  status: healthCheckStatusSchema,
  checks: z.array(healthCheckEntrySchema).optional(),
  timestamp: z.iso.datetime({ error: "Invalid timestamp" }).optional(),
}) satisfies z.ZodType<HealthCheckResult>;

export type {
  HealthCheckEntry,
  HealthCheckResult,
  HealthCheckStatus,
} from "../types/health-check";
```

## Examples

```typescript
// Source: hand-crafted; modeled after Kubernetes liveness/readiness conventions
import type {
  HealthCheckStatus,
  HealthCheckEntry,
  HealthCheckResult,
} from "../types/health-check";

export const healthCheckStatusExamples = {
  healthy: "healthy",
  unhealthy: "unhealthy",
  starting: "starting",
  none: "none",
} as const satisfies Record<string, HealthCheckStatus>;

const dbHealthy = {
  name: "database",
  status: "healthy",
  duration_ms: 12,
  output: "SELECT 1 returned in 12ms",
} as const satisfies HealthCheckEntry;

const cacheHealthy = {
  name: "cache",
  status: "healthy",
  duration_ms: 3,
} as const satisfies HealthCheckEntry;

const queueDown = {
  name: "queue",
  status: "unhealthy",
  duration_ms: 5_001,
  output: "Connection refused after 5000ms",
} as const satisfies HealthCheckEntry;

export const healthCheckEntryExamples = {
  databaseHealthy: dbHealthy,
  cacheHealthy,
  queueDown,
  minimal: { name: "self", status: "healthy" } satisfies HealthCheckEntry,
  starting: { name: "migrator", status: "starting" } satisfies HealthCheckEntry,
} as const;

export const healthCheckResultExamples = {
  allHealthy: {
    status: "healthy",
    checks: [dbHealthy, cacheHealthy],
    timestamp: "2026-05-16T18:30:00Z",
  } satisfies HealthCheckResult,
  oneDegraded: {
    status: "unhealthy",
    checks: [dbHealthy, queueDown],
    timestamp: "2026-05-16T18:30:00Z",
  } satisfies HealthCheckResult,
  starting: {
    status: "starting",
    checks: [{ name: "migrator", status: "starting" }],
    timestamp: "2026-05-16T18:30:00Z",
  } satisfies HealthCheckResult,
  topLevelOnly: { status: "healthy" } satisfies HealthCheckResult,
} as const;
```