Oak

mkdir oak-tasks
cd oak-tasks
deno init
deno add jsr:@oak/oak jsr:@std/assert

import { Application, Router } from "@oak/oak";

type AppState = {
  requestId: string;
};

type TaskInput = {
  title: string;
};

function parseTaskInput(value: unknown): TaskInput {
  if (
    typeof value !== "object" ||
    value === null ||
    typeof (value as { title?: unknown }).title !== "string"
  ) {
    throw new TypeError("title must be a string");
  }

  const title = (value as { title: string }).title.trim();
  if (!title || title.length > 120) {
    throw new TypeError("title must contain 1–120 characters");
  }

  return { title };
}

export const app = new Application<AppState>();
const router = new Router<AppState>({ prefix: "/api" });

app.use(async (ctx, next) => {
  ctx.state.requestId = crypto.randomUUID();

  try {
    await next();
  } catch (error) {
    ctx.response.status = error instanceof TypeError ? 422 : 500;
    ctx.response.body = {
      error: error instanceof TypeError
        ? error.message
        : "Internal server error",
      requestId: ctx.state.requestId,
    };
  }
});

router.get("/health", (ctx) => {
  ctx.response.body = { status: "ok" };
});

router.post("/tasks", async (ctx) => {
  const input = parseTaskInput(await ctx.request.body.json());

  ctx.response.status = 201;
  ctx.response.body = {
    id: crypto.randomUUID(),
    title: input.title,
    completed: false,
  };
});

app.use(router.routes());
app.use(router.allowedMethods());

import { app } from "./app.ts";

app.addEventListener("error", (event) => {
  console.error("Unhandled Oak error", event.error);
});

const controller = new AbortController();

Deno.addSignalListener("SIGINT", () => {
  controller.abort();
});

await app.listen({
  hostname: "127.0.0.1",
  port: 8000,
  signal: controller.signal,
});

import {
  assertEquals,
  assertExists,
} from "@std/assert";
import { app } from "./app.ts";

Deno.test("creates a task", async () => {
  const response = await app.handle(
    new Request("http://localhost/api/tasks", {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({ title: "学习 Oak" }),
    }),
  );

  assertExists(response);
  assertEquals(response.status, 201);

  const task = await response.json();
  assertEquals(task.title, "学习 Oak");
  assertEquals(task.completed, false);
});

import { Application, Router } from "@oak/oak";

const router = new Router();
router.get("/health", (ctx) => {
  ctx.response.body = { status: "ok" };
});

const app = new Application();
app.use(router.routes());
app.use(router.allowedMethods());

export default { fetch: app.fetch };