What if your agent
couldn't ship broken code?

import { parseBearer, jwtVerify } from "zigttp:auth";
import { schemaCompile, validateJson } from "zigttp:validate";
import { env } from "zigttp:env";

comptime(() => schemaCompile("user", JSON.stringify({
    type: "object",
    required: ["name", "email"],
    properties: {
        name:  { type: "string", minLength: 1 },
        email: { type: "string", format: "email" },
    }
})));

function handler(req: Request): Response {
    const token = parseBearer(req.headers["authorization"]);
    if (!token) return Response.json(
        { error: "unauthorized" }, { status: 401 }
    );

    const auth = jwtVerify(token, env("JWT_SECRET") ?? "");
    assert(auth.ok, Response.json(
        { error: auth.error }, { status: 401 }
    ));

    return match (req.method) {
        "POST" => {
            const result = validateJson("user", req.body ?? "");
            assert(result.ok, Response.json(
                { errors: result.errors }, { status: 400 }
            ));
            Response.json({ user: result.value }, { status: 201 });
        },
        _ => Response.json({ user: auth.value }),
    };
}

type Props = {
    name: string;
    count: number;
};

function Card(props: Props): JSX.Element {
    return (
        <div class="card">
            <h1>Hello, {props.name}</h1>
            <p>Count: {props.count}</p>
        </div>
    );
}

function handler(req: Request): Response {
    const data: Props = { name: "World", count: 42 };
    return Response.html(
        renderToString(<Card name={data.name} count={data.count} />)
    );
}

import { decodeForm } from "zigttp:decode";
import { schemaCompile } from "zigttp:validate";

comptime(() => schemaCompile("todo.create", JSON.stringify({
    type: "object",
    required: ["text"],
    properties: {
        text: { type: "string", minLength: 1 },
    }
})));

function TodoForm(): JSX.Element {
    return (
        <form hx-post="/todos" hx-target="#todo-list" hx-swap="beforeend">
            <input name="text" required="required" />
            <button type="submit">Add</button>
        </form>
    );
}

function TodoItem(text: string): JSX.Element {
    return <li class="todo">{text}</li>;
}

function handler(req: Request): Response {
    if (req.method === "GET") {
        return Response.html(renderToString(
            <main>
                <script src="https://unpkg.com/htmx.org@2.0.8"></script>
                <TodoForm />
                <ul id="todo-list"></ul>
            </main>
        ));
    }

    const todo = decodeForm("todo.create", req.body ?? "");
    assert(todo.ok, Response.text("bad request", { status: 400 }));
    return Response.html(renderToString(TodoItem(todo.value.text)));
}

import { guard } from "zigttp:compose";
import { parseBearer, jwtVerify } from "zigttp:auth";
import { env } from "zigttp:env";

distinct type Secret = string;
type Claims = { sub: string };
type AuthRequest = Request & { user?: Claims };
const jwtSecret: Secret = env("JWT_SECRET") ?? "";

const cors = (req: AuthRequest): Response | undefined =>
    match (req.method) {
        "OPTIONS" => Response.text("", {
            status: 204,
            headers: { "Access-Control-Allow-Origin": "*" }
        }),
        _ => undefined,
    };

const requireAuth = (req: AuthRequest): Response | undefined => {
    const token = parseBearer(req.headers["authorization"]);
    if (!token) return Response.json(
        { error: "unauthorized" }, { status: 401 }
    );
    const auth = jwtVerify(token, jwtSecret);
    if (!auth.ok) return Response.json(
        { error: auth.error }, { status: 403 }
    );
    req.user = auth.value;
    return undefined;
};

const dashboard = (req: AuthRequest): Response =>
    Response.json({ welcome: req.user?.sub ?? "guest" });

// Pipe: guards short-circuit, handler runs last
const handler = guard(cors) |> guard(requireAuth) |> dashboard;

import { run, step, waitSignal } from "zigttp:durable";
import { decodeJson } from "zigttp:decode";
import { schemaCompile } from "zigttp:validate";

comptime(() => schemaCompile("order", JSON.stringify({
    type: "object",
    required: ["item", "qty"],
    properties: {
        item: { type: "string" },
        qty:  { type: "number", minimum: 1 }
    }
})));

function handler(req: Request): Response {
    const body = decodeJson("order", req.body ?? "");
    assert(body.ok, Response.json(
        { errors: body.errors }, { status: 400 }
    ));

    return run(`order-${body.value.item}`, () => {
        const charge = step("charge", () =>
            fetchSync("https://pay.api/charge", {
                method: "POST",
                body: body.value
            })
        );
        // Wait for external webhook confirmation
        const confirm = waitSignal("payment-confirmed");
        return Response.json({
            status: "fulfilled",
            chargeStatus: charge.status,
            signal: confirm
        });
    });
}