net/http

Modern HTTP/1.1 client and routed server for Nyra — inspired by Go’s net/http, built on native TCP + selectable TLS backends.

import "stdlib/net/http/mod.ny"

import "stdlib/net/http/mod.ny"

Architecture

Application
      │
stdlib/net/http  (get / post / …)
      │
stdlib/tls.ny    (stable rt_tls_* ABI)
      │
 ┌────┴────┬──────────┐
rustls   native    openssl
(default) (OS TLS) (optional)
      │
     TCP

HTTPS works out of the box with the bundled rustls client — no OpenSSL install required. Choose a backend in nyra.mod; nyra.lock pins the resolved choice under features.tls.

TLS backends — what Nyra supports today

# nyra.mod — optional; rustls is already the default
module example.local
tls rustls

// nyra.lock pins the resolved backend
{
  "features": { "tls": "rustls" },
  "require": []
}

How to choose in practice: prefer rustls (default, portable). Use tls native when you want the platform TLS stack (enterprise CA / OS policy). Use openssl when you already depend on OpenSSL or need server helpers.

Resolve order: value in nyra.mod → else features.tls in nyra.lock → else rustls. If mod and lock disagree, Nyra reports a mismatch. Full nyra.mod syntax: packages → nyra.mod syntax.

CI covers all three backends in make test-conformance (pass/tls for rustls defaults; fixtures tls_native / tls_openssl for the others).

Application code is identical for every backend:

fn main() {
    print(get("https://example.com/"))
}

fn main() -> void {
    print(get("https://example.com/"))
}

On failure, tls_last_error() describes the real connect/handshake problem (network reset, cert error, …) — it does not ask you to install OpenSSL when using rustls or native on macOS/Windows.

Module layout

stdlib/net/http/
  mod.ny         — public entry (Router, listen_and_serve_handlers, client verbs)
  types.ny       — HttpRequest, HttpResponse, Server, Client, Router
  client.ny      — GET, POST, PUT, PATCH, DELETE, HEAD
  server.ny      — listen, keep-alive, dispatch, CORS helpers
  request.ny     — parse incoming requests
  response.ny    — status lines, JSON helpers

Routing and middleware helpers live in mod.ny / server.ny (no separate router.ny file).

HTTP client

Preferred (JS-like): one entry — fetch(url) returns HttpResponse. Put options on req(), then call the method with the URL (.get / .post / …). Body-only convenience remains get(url) -> string.

let resp = fetch("https://example.com/")
print(resp.status, resp.text())

let posted = req()
    .header("Authorization", "Bearer tok")
    .timeout(10000)
    .json("{\"name\":\"Nyra\"}")
    .post("https://example.com/api")

let form_post = req()
    .form(form().append("a", "1").append("b", "2"))
    .post(url)

let resp = fetch("https://example.com/")
print(resp.status, resp.text())

let posted = req()
    .header("Authorization", "Bearer tok")
    .timeout(10000)
    .json("{\"name\":\"Nyra\"}")
    .post("https://example.com/api")

let form_post = req()
    .form(form().append("a", "1").append("b", "2"))
    .post(url)

Long names like http_post_form still work as aliases — prefer the short path above.

RequestInit · headers · forms · abort · redirects

Client example

import "stdlib/net/http/mod.ny"

fn main() {
    let client = Client_default()
    let resp = client.do_post("https://example.com/api", "{\"name\":\"Nyra\"}")
    if resp.status == 201 {
        print(resp.body)
    }
}

import "stdlib/net/http/mod.ny"

fn main() -> void {
    let client = Client_default()
    let resp = client.do_post("https://example.com/api", "{\"name\":\"Nyra\"}")
    if resp.status == 201 {
        print(resp.body)
    }
}

HttpResponse

Router

Routes are keyed by METHOD:path (e.g. GET:/health). Register handlers with free functions:

let router = Router_new()
let r = Router_add_get(router, "/health", "{\"status\":\"ok\"}")
let r2 = Router_add_post(r, "/users", "{\"created\":true}")
let r3 = Router_add_put(r2, "/users/1", "{\"updated\":true}")

let router = Router_new()
let r = Router_add_get(router, "/health", "{\"status\":\"ok\"}")
let r2 = Router_add_post(r, "/users", "{\"created\":true}")
let r3 = Router_add_put(r2, "/users/1", "{\"updated\":true}")

Server

let server = Server_with_router("127.0.0.1", 8080, router)
let s2 = Server_enable_cors(server)
Server_listen(s2, router)

let server = Server_with_router("127.0.0.1", 8080, router)
let s2 = Server_enable_cors(server)
Server_listen(s2, router)

Handler dispatch

Register integer slots and pass a Nyra function fn(i32, RequestContext) -> HttpResponse. Use for dynamic logic instead of static response bodies.

fn health_slot(slot, ctx) {
    return response_ok_json("{\"status\":\"ok\"}")
}

fn main() {
    let router = Router_new()
    let r = Router_add_slot_get(router, "/health", 0)
    listen_and_serve_handlers("127.0.0.1", 8080, r, health_slot)
}

fn health_slot(slot: i32, ctx: RequestContext) -> i32 {
    return response_ok_json("{\"status\":\"ok\"}")
}

fn main() -> void {
    let router = Router_new()
    let r = Router_add_slot_get(router, "/health", 0)
    listen_and_serve_handlers("127.0.0.1", 8080, r, health_slot)
}

Arrow handler alternative (Extended): (ctx: RequestContext) => response_ok_json("{\"status\":\"ok\"}") when compiled with arrow support.

Response helpers

Request lifecycle

1. TCP accept on host:port
2. Read raw HTTP/1.1 request (headers + body)
3. Parse into RequestContext (method, path, query, body)
4. Log request line (middleware_log)
5. Match route in router → build HttpResponse
6. Apply CORS headers if enabled
7. Write response; repeat on keep-alive until close or 100 requests

Method constants

METHOD_GET, METHOD_POST, METHOD_PUT, METHOD_DELETE, METHOD_PATCH, METHOD_HEAD, METHOD_OPTIONS

Other networking (stdlib)

Beyond HTTP/1.1, the stdlib ships:

Full inventory: stdlib → Net, HTTP, WebSocket

Legacy imports

stdlib/http/mod.ny and stdlib/http.ny re-export this module. HttpServer wraps Server_listen for older examples.

Production APIs

Build services with handler slots (examples/net_http_smoke.ny), stdlib/db/*, and NyraPkg drivers (ny-postgres, ny-redis). See Standard library → net/http and NyraPkg.