The Carrier language, grounded in what compiles today.

service App {
  openapi { title: "Hello Carrier API" version: "0.1.0" }
  server  { host: env("HOST", "0.0.0.0") port: env_int("PORT", 3000) }
}
 
auth jwt Auth {
  issuer:   env("JWT_ISSUER", "carrier")
  audience: env("JWT_AUDIENCE", "carrier-users")
  secret:   env("JWT_SECRET", "local-dev-secret")
}
 
type RegisterRequest {
  email: String     @email
  name: String      @length(min: 2, max: 100)
  password: String  @length(min: 8)
}
 
type AuthTokens { access_token: String  refresh_token: String }
 
route POST "/auth/register" public -> AuthTokens {
  input: RegisterRequest
  handler {
    let user = auth.register(
      email: input.email, name: input.name, password: input.password
    )
    return auth.issue_tokens(user.id)
  }
}
 
route GET "/me" protect Auth -> MeResponse {
  handler { return auth.current_user() }
}

crud Doctor at "/doctors" {
  create: protect AdminAuth roles [admin]
  list:   public
  get:    public
  update: protect AdminAuth roles [admin]
  delete: soft using deleted_at protect AdminAuth roles [admin]
  restore: true protect AdminAuth roles [admin]
 
  list_defaults {
    page_size: 20
    sort: "rating"
    direction: desc
    scope: active          // active · all · deleted
  }
 
  filters {
    specialty: exact
    city:      exact
    language:  contains
    rating:    min
  }
 
  searchable { full_name  specialty  city  bio }
}

route GET "/doctors/{id}" public -> Doctor {
  params { id: UUID }
  handler { return Doctor.get(id: params.id) }
}
 
route POST "/admin/doctors/{id}/lock"
  protect AdminAuth roles [admin] idempotent -> Doctor
{
  params { id: UUID }
  handler { return audit_locked_doctor(params.id) }
}

/// Transaction-safe admin action with row locking
action audit_locked_doctor(id: UUID) -> Doctor {
  let actor = auth.current_user()
 
  transaction {
    let locked = Doctor.get_for_update(id: id, scope: "all")
    logs.info("doctor lock audit", {
      action_name: "audit_locked_doctor"
      doctor_id: locked.id
      actor_email: actor.email
    })
  }
 
  return Doctor.get(id: id, scope: "all")
}
 
/// Idempotent admin route; retries return the stored response
route POST "/admin/doctors/{id}/lock"
  protect AdminAuth roles [admin] idempotent -> Doctor
{
  params { id: UUID }
  handler { return audit_locked_doctor(params.id) }
}

policy AppointmentSlot {
  tenant_field: org_id
  read:  roles [viewer, scheduler]
  write: roles [scheduler]
  deleted: roles [scheduler]
}
 
model AppointmentSlot {
  id: UUID
  org_id: String  @index
  clinician_name: String  @length(min: 3, max: 120)
  starts_at: Time
  status: SlotStatus = open
  version: Int  @version
  deleted_at: Time?
  created_at: Time
  updated_at: Time
}

event SlotReminderQueued {
  slot_id: UUID
  trigger: String
}
 
job send_slot_reminder(payload: Json) -> Void {
  logs.info("slot reminder job", { job_name: "send_slot_reminder", payload: payload })
  audit.record("send_slot_reminder", "AppointmentSlot", "scheduled", payload)
}
 
schedule "*/15 * * * *" run send_slot_reminder
 
route POST "/slots/{id}/notify"
  protect StaffAuth roles [scheduler] idempotent -> Json
{
  params { id: UUID }
  handler {
    let job_id = jobs.enqueue("send_slot_reminder", { slot_id: params.id }, delay_seconds: 5)
    emit SlotReminderQueued { slot_id: params.id, trigger: "manual" }
    return { job_id: job_id }
  }
}

client WeatherApi {
  base_url: env("WEATHER_API_URL", "https://api.example.com")
  header "x-api-key": env("WEATHER_API_KEY", "")
  timeout_ms: 3000
}
 
type WeatherResponse {
  city: String
  temperature_c: Float
  condition: String
}
 
route GET "/weather/{city}" public -> WeatherResponse {
  handler {
    return WeatherApi.get("/forecast", query: { city: params.city })
  }
}

/// Admin reporting endpoint using raw SQL mapped into a typed result list
route GET "/reports/doctors/by-city" protect AdminAuth roles [admin]
  -> DoctorCityReportRow[]
{
  handler {
    return sql.list_as(
      "DoctorCityReportRow",
      "select city, count(*)::bigint as total
         from doctors
         where deleted_at is null
         group by city
         order by total desc, city asc"
    )
  }
}