@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/adapters/serve/index.js

@@ -0,0 +1,137 @@
+import { showRoutes } from "../../src/index.js";
+import { setDraining } from "../../src/health.js";
+import * as runtime from "../../src/runtime.js";
+// よく使われる 3000 や 8080 とぶつかりにくい番号にしている
+export const DEFAULT_PORT = 3927;
+function isPort(n) {
+    return Number.isInteger(n) && n >= 0 && n <= 65535;
+}
+// 使うポートを決める: 明示した port → 環境変数 PORT → DEFAULT_PORT
+// 環境変数は runtime.env で読むので、Deno で --allow-env がなければ聞き返さずにデフォルトになる
+export function resolvePort(explicit, env = runtime.env) {
+    if (explicit !== undefined) {
+        if (!isPort(explicit))
+            throw new RangeError(`port が正しいポート番号(0〜65535)ではありません: ${explicit}`);
+        return { port: explicit, source: "option" };
+    }
+    const raw = env("PORT")?.trim();
+    if (raw) {
+        // 黙ってデフォルトで待ち受けると、デプロイ先で「つながらない」原因が分かりにくいので、エラーにする
+        const port = /^\d+$/.test(raw) ? Number(raw) : NaN;
+        if (!isPort(port))
+            throw new RangeError(`環境変数 PORT が正しいポート番号(0〜65535)ではありません: ${raw}`);
+        return { port, source: "env" };
+    }
+    return { port: DEFAULT_PORT, source: "default" };
+}
+const SOURCE_NOTE = {
+    option: "port オプション",
+    env: "環境変数 PORT",
+    default: "デフォルト。環境変数 PORT で変えられます",
+};
+const SIGNALS = ["SIGTERM", "SIGINT"];
+// 上限つきで待つ。時間内に終われば true
+function within(promise, ms) {
+    let timer;
+    const timeout = new Promise((resolve) => (timer = setTimeout(() => resolve(false), ms)));
+    return Promise.race([promise.then(() => true), timeout]).finally(() => clearTimeout(timer));
+}
+export async function serve(app, options = {}) {
+    const { port, source } = resolvePort(options.port);
+    const hostname = options.hostname;
+    const g = globalThis;
+    const timeout = options.shutdownTimeout ?? 10_000;
+    if (!Number.isFinite(timeout) || timeout < 0) {
+        throw new RangeError(`shutdownTimeout には 0 以上のミリ秒を指定してください: ${timeout}`);
+    }
+    // 実際に待ち受けたポート(port: 0 なら、ランタイムが選んだ番号)と、止め方
+    // - drain: 新しい接続を受けるのをやめ、処理中のものが終わったら resolve
+    // - force: 残っている接続を切る(drain が時間内に終わらなかったとき)
+    let actualPort;
+    let drain;
+    let force;
+    if (g.Bun) {
+        const s = g.Bun.serve({ port, hostname, fetch: app.fetch });
+        actualPort = s.port;
+        drain = async () => s.stop(false);
+        force = () => void s.stop(true);
+    }
+    else if (g.Deno) {
+        // onListen を空にして、Deno が勝手に出す "Listening on ..." を消す(バナーと二重になるので)
+        const s = g.Deno.serve({ port, hostname, onListen() { } }, app.fetch);
+        actualPort = s.addr.port;
+        drain = () => s.shutdown();
+        // Deno には、shutdown() のあとに残りの接続を切る方法がない(signal で abort すると Deno の中で例外になる)
+        // なので待つのをやめるだけ。シグナルで止めたときは、このあとプロセスごと終わるので接続も切れる
+        force = () => { };
+    }
+    else {
+        // Node のときだけ node:http を読み込む
+        const node = await import("../node/index.js");
+        const s = node.serve(app, { port });
+        // Node は待ち受けが非同期。使用中のポートなどは error イベントで来るので、ここで reject にする
+        // (受け取らないとプロセスごと落ちる)
+        await new Promise((resolve, reject) => {
+            s.once("listening", resolve);
+            s.once("error", reject);
+        });
+        const address = s.address();
+        actualPort = typeof address === "object" && address ? address.port : port;
+        drain = () => new Promise((resolve) => {
+            s.close(() => resolve());
+            // close() は、使っていない keep-alive の接続が切れるまで待ってしまうので、それは先に切る
+            s.closeIdleConnections();
+        });
+        force = () => s.closeAllConnections();
+    }
+    let stopping = null;
+    // シグナルのリスナーを外すもの(止めたあとまで残さない)
+    const detach = [];
+    const stop = () => {
+        stopping ??= (async () => {
+            for (const off of detach)
+                off();
+            // まず /readyz を 503 にする(ロードバランサーが、新しいリクエストを送ってこないように)
+            setDraining(true);
+            if (!(await within(drain(), timeout)))
+                force();
+        })();
+        return stopping;
+    };
+    // シグナルを受けたら、止めてから終わる。2回目を受けたら待たずに終わる
+    if (options.gracefulShutdown ?? true) {
+        const proc = globalThis.process;
+        const exit = (code) => (g.Deno ? g.Deno.exit(code) : proc?.exit(code));
+        const onSignal = () => {
+            if (stopping)
+                return exit(1);
+            console.log("\n止めています(処理中のリクエストが終わるのを待ちます)…");
+            stop()
+                .then(() => options.onShutdown?.())
+                .then(() => exit(0), (err) => {
+                console.error(err);
+                exit(1);
+            });
+        };
+        for (const signal of SIGNALS) {
+            try {
+                if (g.Deno) {
+                    g.Deno.addSignalListener(signal, onSignal);
+                    detach.push(() => g.Deno.removeSignalListener(signal, onSignal));
+                }
+                else if (proc) {
+                    proc.on(signal, onSignal);
+                    detach.push(() => proc.off(signal, onSignal));
+                }
+            }
+            catch {
+                // Windows の Deno は SIGTERM を受けられない(SIGINT だけ使う)
+            }
+        }
+    }
+    const url = `http://${hostname ?? "localhost"}:${actualPort}`;
+    if (options.banner ?? true) {
+        showRoutes(app, url, { note: SOURCE_NOTE[source] });
+    }
+    return { port: actualPort, url, stop };
+}

package/dist/adapters/static/index.d.ts

@@ -0,0 +1,9 @@
+import type { Middleware } from "../../src/index.ts";
+export type ServeStaticOptions = {
+    root: string;
+    prefix?: string;
+    index?: string | false;
+    dotfiles?: boolean;
+    cacheControl?: string;
+};
+export declare function serveStatic(options: ServeStaticOptions): Middleware;

package/dist/adapters/static/index.js

@@ -0,0 +1,120 @@
+// 静的ファイル配信(senri/static)。node:fs を使うので本体とは別の入口にしている
+// Bun / Deno / Node で動く。Cloudflare Workers ではファイルを読めないので、wrangler の Static Assets を使う
+import { createReadStream } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { extname, join, relative, resolve, sep } from "node:path";
+import { Readable } from "node:stream";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".htm": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".json": "application/json",
+    ".map": "application/json",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/markdown; charset=utf-8",
+    ".csv": "text/csv; charset=utf-8",
+    ".xml": "application/xml",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".wasm": "application/wasm",
+    ".pdf": "application/pdf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".zip": "application/zip",
+    ".webmanifest": "application/manifest+json",
+};
+function isWorkers() {
+    return globalThis.navigator?.userAgent === "Cloudflare-Workers";
+}
+// If-None-Match に、この ETag が入っているか(W/ は比べない = 弱い比較)
+function matchesEtag(header, etag) {
+    const bare = etag.replace(/^W\//, "");
+    return header.split(",").some((t) => {
+        const tag = t.trim();
+        return tag === "*" || tag.replace(/^W\//, "") === bare;
+    });
+}
+// ファイルの場所として使ってはいけないセグメント
+// (ルーターが "." / ".." / %2F は 400 にしている。ここでは Windows の区切りやドライブ、NUL を防ぐ)
+function unsafeSegment(segment) {
+    return segment.includes("\\") || segment.includes(":") || segment.includes("\0");
+}
+export function serveStatic(options) {
+    if (isWorkers()) {
+        throw new Error("serveStatic() は Cloudflare Workers では使えません(ファイルを読めないため)。\n" +
+            "wrangler.jsonc の assets(Static Assets)で配ってください: https://developers.cloudflare.com/workers/static-assets/");
+    }
+    const root = resolve(options.root);
+    const prefix = (options.prefix ?? "/").split("/").filter(Boolean);
+    const index = options.index ?? "index.html";
+    // シンボリックリンクで外に出ていないかを、実体のパスで確かめる(root 自体がリンクでもよいように、root も実体にする)
+    const realRoot = realpath(root).catch(() => root);
+    return async function serveStatic(c, next) {
+        const method = c.req.method;
+        if (method !== "GET" && method !== "HEAD")
+            return next();
+        const segments = c.segments;
+        if (segments.length < prefix.length || prefix.some((p, i) => p !== segments[i]))
+            return next();
+        const rest = segments.slice(prefix.length);
+        if (rest.some(unsafeSegment))
+            return next();
+        if (!options.dotfiles && rest.some((s) => s.startsWith(".")))
+            return next();
+        let file = join(root, ...rest);
+        // 念のため、つないだ結果が root の外になっていないか
+        const rel = relative(root, file);
+        if (rel.startsWith("..") || resolve(root, rel) !== file)
+            return next();
+        let info = await stat(file).catch(() => null);
+        if (info?.isDirectory()) {
+            if (index === false)
+                return next();
+            file = join(file, index);
+            info = await stat(file).catch(() => null);
+        }
+        if (!info?.isFile())
+            return next();
+        const real = await realpath(file).catch(() => null);
+        const base = await realRoot;
+        if (real === null || (real !== base && !real.startsWith(base.endsWith(sep) ? base : base + sep)))
+            return next();
+        // root の中のシンボリックリンクが .env などを指していることもあるので、実体のパスでもドットファイルを確かめる
+        if (!options.dotfiles && relative(base, real).split(sep).some((s) => s.startsWith(".")))
+            return next();
+        const etag = `W/"${info.size.toString(16)}-${Math.floor(info.mtimeMs).toString(16)}"`;
+        const lastModified = info.mtime.toUTCString();
+        const headers = new Headers({ etag, "last-modified": lastModified });
+        if (options.cacheControl)
+            headers.set("cache-control", options.cacheControl);
+        // 変わっていなければ 304(If-None-Match があれば、If-Modified-Since より優先する)
+        const ifNoneMatch = c.req.headers.get("if-none-match");
+        const ifModifiedSince = c.req.headers.get("if-modified-since");
+        const notModified = ifNoneMatch !== null
+            ? matchesEtag(ifNoneMatch, etag)
+            : ifModifiedSince !== null && Math.floor(info.mtimeMs / 1000) <= Date.parse(ifModifiedSince) / 1000;
+        if (notModified)
+            return new Response(null, { status: 304, headers });
+        headers.set("content-type", MIME[extname(file).toLowerCase()] ?? "application/octet-stream");
+        headers.set("content-length", String(info.size));
+        if (method === "HEAD")
+            return new Response(null, { status: 200, headers });
+        const body = Readable.toWeb(createReadStream(file));
+        return new Response(body, { status: 200, headers });
+    };
+}

package/dist/src/app.d.ts

@@ -0,0 +1,86 @@
+import { Context, type ExecutionContext, type Handler, type Middleware } from "./context.ts";
+import { type ExtractParams, type RouteTable, type Route, type Simplify } from "./router.ts";
+import { type Layer } from "./compose.ts";
+import { type RouteSchemas, type Validated, type ValidatedParams } from "./validate.ts";
+import { type Router } from "./group.ts";
+import { type ErrorHandler, type NotFoundHandler } from "./errors.ts";
+export type Resolved = {
+    kind: "route";
+    route: Route;
+    params: Record<string, string>;
+} | {
+    kind: "options";
+    allow: string;
+} | {
+    kind: "methodNotAllowed";
+    allow: string;
+} | {
+    kind: "notFound";
+} | {
+    kind: "notImplemented";
+} | {
+    kind: "badRequest";
+    error: unknown;
+};
+export type RouteMethod<V extends object> = {
+    <Path extends string>(path: Path, handler: Handler<Simplify<ExtractParams<Path>>, V>): void;
+    <Path extends string, S extends RouteSchemas>(path: Path, schemas: S, handler: Handler<ValidatedParams<S, Simplify<ExtractParams<Path>>>, V, Validated<S>>): void;
+};
+export type OnMethod<V extends object> = {
+    <Path extends string>(method: string | readonly string[], path: Path, handler: Handler<Simplify<ExtractParams<Path>>, V>): void;
+    <Path extends string, S extends RouteSchemas>(method: string | readonly string[], path: Path, schemas: S, handler: Handler<ValidatedParams<S, Simplify<ExtractParams<Path>>>, V, Validated<S>>): void;
+};
+export type MountableApp = {
+    routeList(): {
+        method: string;
+        path: string;
+    }[];
+};
+export type App<V extends object = Record<string, unknown>> = {
+    use(pathOrMw: string | Middleware<V>, mw?: Middleware<V>): void;
+    onError(handler: ErrorHandler<V>): void;
+    notFound(handler: NotFoundHandler<V>): void;
+    get: RouteMethod<V>;
+    post: RouteMethod<V>;
+    put: RouteMethod<V>;
+    patch: RouteMethod<V>;
+    delete: RouteMethod<V>;
+    head: RouteMethod<V>;
+    options: RouteMethod<V>;
+    all: RouteMethod<V>;
+    on: OnMethod<V>;
+    routes<K extends string>(table: RouteTable<K, V>): void;
+    route(routerOrPrefix: Router<string, V> | string, child?: MountableApp): void;
+    middlewareList(): {
+        name: string;
+        path: string | null;
+        anonymous: boolean;
+    }[];
+    routeList(): {
+        method: string;
+        path: string;
+    }[];
+    fetch(req: Request, info?: unknown, ctx?: ExecutionContext): Promise<Response>;
+};
+export type AppOptions = {
+    dev?: DevHooks | undefined;
+};
+export type DevHooks = {
+    install(core: AppCore): DevInstalled;
+};
+export type AppCore = {
+    app: App<any>;
+    resolve(c: Context): Resolved;
+    layers(c: Context): Layer[];
+    inner(c: Context, resolved: Resolved): Response | Promise<Response>;
+    fail(err: unknown, c: Context): Promise<Response>;
+    routes(): readonly Route[];
+};
+export type DevInstalled = {
+    fetch(req: Request, info?: unknown, ctx?: ExecutionContext): Promise<Response>;
+    onError: ErrorHandler;
+    notFound: NotFoundHandler;
+    checkRoute(method: string, path: string, schemas: RouteSchemas | undefined): void;
+    explain(err: unknown): unknown;
+};
+export declare function createApp<V extends object = Record<string, unknown>>(options?: AppOptions): App<V>;