@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/src/dev/index.js

@@ -0,0 +1,185 @@
+import { Context } from "../context.js";
+import { compose } from "../compose.js";
+import { defaultNotFound, defaultOnError, errorCode, HttpError } from "../errors.js";
+import { compareRoutes } from "../router.js";
+import * as runtime from "../runtime.js";
+import { ValidationError } from "../validate.js";
+import { createDashboard } from "./dashboard/index.js";
+import { registerDashboard } from "./registry.js";
+import { explain } from "./explain.js";
+import { devNotFound } from "./not-found.js";
+import { finishErrorPage, withErrorPage } from "./pages.js";
+import { serverTimingHeader, withServerTiming } from "./server-timing.js";
+import { checkSchemas, describeValidation } from "./validation.js";
+// 計測で、いちばん内側の層に付ける名前(ダッシュボードの玉ねぎタイムラインに出る)
+const INNER_NAME = {
+    route: "handler",
+    notFound: "notFound",
+    methodNotAllowed: "405",
+    options: "options",
+    badRequest: "400",
+    notImplemented: "501",
+};
+// 開発モードのフックを作る。本番(NODE_ENV=production)では undefined を返すので、開発モードにならない
+// Deno で NODE_ENV を読む許可がないときは、本番かどうか分からないので、開発モードにしない(案内を1行出す)
+export function devtools() {
+    if (!runtime.canReadEnv("NODE_ENV")) {
+        console.warn("[senri] devtools() is off: NODE_ENV is not readable. Run with --allow-env=NODE_ENV to enable it. / NODE_ENV を読めないので devtools() は無効です。--allow-env=NODE_ENV を付けると使えます");
+        return undefined;
+    }
+    if (runtime.env("NODE_ENV") === "production")
+        return undefined;
+    // Workers(nodejs_compat で process があっても、NODE_ENV はふつう入っていない)とブラウザは、本番かどうか分からない
+    const localOnly = runtime.isWorkers() || typeof globalThis.process === "undefined";
+    return { install: (core) => install(core, localOnly) };
+}
+// request.url のホスト名が localhost か(Host や X-Forwarded-Host などのヘッダーは見ない。だれでも付けられるので)
+// - Workers: Cloudflare は登録されたドメインのリクエストしか渡さないので、本番に localhost は来ない。wrangler dev は localhost
+// - ブラウザ: Service Worker が受けるリクエストの URL は、そのサイトのオリジン。開発中だけ localhost になる
+export function isLocalUrl(url) {
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return (host === "localhost" ||
+        host.endsWith(".localhost") ||
+        host === "[::1]" ||
+        /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host));
+}
+// パスが /_senri か /_senri/... なら、"_senri" より後ろのセグメント。そうでなければ null
+function underDashboard(c) {
+    try {
+        return c.segments[0] === "_senri" ? c.segments.slice(1) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// 層ごとの時間を c.timings に記録する(src/compose.ts の Trace)
+function measure(c, origin, layers, innerName) {
+    const starts = [];
+    const inner = [];
+    return {
+        enter(i) {
+            starts[i] = performance.now();
+            inner[i] = 0;
+        },
+        down(i) {
+            const start = performance.now();
+            return () => (inner[i] += performance.now() - start);
+        },
+        leave(i, failed, stopped) {
+            const total = performance.now() - starts[i];
+            c.timings[i] = {
+                name: layers[i]?.name ?? innerName,
+                total,
+                self: total - inner[i],
+                failed,
+                start: starts[i] - origin,
+                stopped,
+            };
+        },
+    };
+}
+// 開発モードの既定の onError。本番の固定の文言の代わりに、詳しい文言を返す
+// (ブラウザから開いた 5xx は、withErrorPage がエラーページにする)
+const devOnError = (err, c) => {
+    if (err instanceof ValidationError)
+        return c.text(describeValidation(err));
+    if (err instanceof HttpError) {
+        switch (errorCode(err)) {
+            case "method_not_allowed":
+                return c.text(`405 Method Not Allowed: ${c.req.method} ${c.path}\n${err.headers.get("allow")} ならあります`);
+            case "query_no_body":
+                return c.text("400 Bad Request: QUERY リクエストにボディがありません\nQUERY は、検索の条件をボディに入れて送るメソッドです");
+            case "query_no_type":
+                return c.text("415 Unsupported Media Type: QUERY リクエストに Content-Type がありません\nボディの形式を指定してください(例: Content-Type: application/json)");
+        }
+        return c.text(err.message);
+    }
+    explain(err);
+    return c.text(`500 Internal Server Error: ${err instanceof Error ? err.message : String(err)}`);
+};
+// localOnly: localhost へのリクエストのときだけ開発用の出力をする(Workers とブラウザ)
+function install(core, localOnly) {
+    const { app } = core;
+    // 本番と同じに振る舞うリクエスト(localOnly で、localhost でないもの)
+    const quiet = new WeakSet();
+    // 一覧は優先順位の順(静的なセグメントが先)。本体は登録順に持っている
+    const sortedRoutes = () => [...core.routes()].sort(compareRoutes);
+    // ダッシュボード。Cloudflare Workers では作らない(接続元が分からず localhost 制限で開けないうえ、
+    // リクエストごとに別の isolate で動くことがあり、記録が残らない)。/_senri はふつうの 404 になる
+    const dashboard = runtime.isWorkers()
+        ? null
+        : createDashboard({
+            routes: () => sortedRoutes().map((r) => ({ method: r.method, path: r.path })),
+            middlewares: () => app.middlewareList(),
+        });
+    if (dashboard)
+        registerDashboard(app, dashboard);
+    async function fetch(req, info, ctx) {
+        // 計測の基準になるリクエストの開始時刻
+        const origin = performance.now();
+        const time = Date.now();
+        const c = new Context(req, info, ctx);
+        if (localOnly && !isLocalUrl(req.url))
+            return quietFetch(c);
+        // /_senri 以下はダッシュボード。localhost から開いたときだけ、ミドルウェアを通さずに処理する
+        // (開けないときは普通の処理に回すので、/_senri はないものとして 404 になる)。どちらも記録はしない
+        const dashboardPath = underDashboard(c);
+        if (dashboard && dashboardPath && dashboard.canOpen(req, info)) {
+            return dashboard.handle(req, dashboardPath);
+        }
+        if (!dashboardPath)
+            dashboard?.begin(c, info);
+        // ミドルウェアより先にマッチして、c.route / c.params を見られるようにしておく
+        const resolved = core.resolve(c);
+        if (resolved.kind === "route") {
+            c.route = resolved.route.path;
+            c.params = resolved.params;
+        }
+        // ハンドラー・notFound・toResponse のどこで投げても、compose が onError に集める
+        const layers = core.layers(c);
+        const innerName = INNER_NAME[resolved.kind];
+        const res = await compose(layers, c, () => core.inner(c, resolved), (err) => core.fail(err, c), measure(c, origin, layers, innerName));
+        // ミドルウェアを全部通ったあとなので、ここなら「通った順番」が揃っている
+        const page = await finishErrorPage(c, res);
+        // 層ごとの時間を Server-Timing に載せる(ブラウザの開発者ツールで見られる)
+        const desc = resolved.kind === "route" ? `${resolved.route.method} ${resolved.route.path}` : innerName;
+        const final = withServerTiming(c.finalize(page), serverTimingHeader(c.timings, { name: innerName, desc }, performance.now() - origin));
+        // ダッシュボードに記録する(失敗してもレスポンスには影響しない)
+        await dashboard?.record(c, final, time, [
+            ...layers.map((l) => ({ name: l.name, order: l.order ?? null })),
+            { name: innerName, order: null },
+        ]);
+        return final;
+    }
+    // 本番の fetch と同じ流れ(計測・記録・エラーページ・Server-Timing なし。onError / notFound も本番の既定になる)
+    function quietFetch(c) {
+        quiet.add(c);
+        const resolved = core.resolve(c);
+        if (resolved.kind === "route") {
+            c.route = resolved.route.path;
+            c.params = resolved.params;
+        }
+        return compose(core.layers(c), c, () => core.inner(c, resolved), (err) => core.fail(err, c)).then((res) => c.finalize(res));
+    }
+    const pageOnError = withErrorPage(devOnError, true);
+    return {
+        fetch,
+        onError: (err, c) => (quiet.has(c) ? defaultOnError(err, c) : pageOnError(err, c)),
+        notFound: (c) => (quiet.has(c) ? defaultNotFound(c) : devNotFound(c, sortedRoutes())),
+        checkRoute(method, path, schemas) {
+            if (schemas)
+                checkSchemas(path, schemas);
+            // /_senri 以下はダッシュボードが使うので、登録しても呼ばれない。気づけるようにエラーにする
+            if (dashboard && /^\/*_senri(\/|$)/.test(path)) {
+                throw new Error(`${method} ${path}: /_senri 以下は、開発モードではダッシュボード用に予約されています`);
+            }
+        },
+        explain,
+    };
+}

package/dist/src/dev/messages.d.ts

@@ -0,0 +1,2 @@
+import type { ConversionOrigin } from "../errors.ts";
+export declare function originText(origin: ConversionOrigin): string;

package/dist/src/dev/messages.js

@@ -0,0 +1,6 @@
+// 返した値をレスポンスにできなかったときの説明(エラーの場所の代わりに出す)
+export function originText(origin) {
+    // ミドルウェア名は英数字なので、「が」との間に空白を入れて読みやすくする
+    const who = origin.kind === "handler" ? `${origin.name} のハンドラー` : `ミドルウェア ${origin.name} `;
+    return `${who}が返した値を、レスポンスにできませんでした`;
+}

package/dist/src/dev/not-found-page.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "../context.ts";
+type RouteInfo = {
+    method: string;
+    path: string;
+};
+export declare function notFoundPage(c: Context, routes: RouteInfo[]): Response;
+export {};

package/dist/src/dev/not-found-page.js

@@ -0,0 +1,33 @@
+import { dashboardLinkOf } from "./dashboard/links.js";
+import { notFoundFallback } from "./fallback.js";
+import { PAGE_HTML } from "./page.generated.js";
+import { renderPage } from "./render.js";
+import { explainDifference, suggest } from "./suggest.js";
+// ブラウザで開けるのは、パラメーターのない GET(と、どのメソッドでも動く all)だけ
+// (":id" に何を入れるかは分からないので、パラメーターのあるものはリンクにしない)
+const linkable = (r) => (r.method === "GET" || r.method === "ALL") && !r.path.includes(":");
+export function notFoundPage(c, routes) {
+    // notFound に来るのはパスをデコードできたリクエストだけなので、c.path は読める
+    const path = c.path;
+    const closest = suggest(routes, path);
+    const data = {
+        kind: "notFound",
+        method: c.req.method,
+        path,
+        suggestion: closest
+            ? {
+                method: closest.method,
+                path: closest.path,
+                link: linkable(closest),
+                ...explainDifference(path, closest.path),
+            }
+            : null,
+        // showRoutes と同じく、パスの順 → 同じパスならメソッドの順
+        routes: [...routes]
+            .sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method))
+            .map((r) => ({ method: r.method, path: r.path, link: linkable(r) })),
+        dashboardUrl: dashboardLinkOf(c),
+    };
+    const body = c.req.method === "HEAD" ? null : renderPage(PAGE_HTML, data, notFoundFallback(data));
+    return new Response(body, { status: 404, headers: { "content-type": "text/html; charset=utf-8" } });
+}

package/dist/src/dev/not-found.d.ts

@@ -0,0 +1,3 @@
+import type { Context, HandlerResult } from "../context.ts";
+import type { Route } from "../router.ts";
+export declare function devNotFound(c: Context, routes: Route[]): HandlerResult | Promise<HandlerResult>;

package/dist/src/dev/not-found.js

@@ -0,0 +1,15 @@
+import { notFoundPage } from "./not-found-page.js";
+import { wantsHtml } from "./render.js";
+import { suggest } from "./suggest.js";
+export function devNotFound(c, routes) {
+    if (wantsHtml(c.req))
+        return notFoundPage(c, routes);
+    // ルートと同じく、デコード・正規化したパスで比べる(notFound に来るのはデコードできたリクエストだけ)
+    const path = c.path;
+    let message = `404 Not Found: ${c.req.method} ${path}`;
+    const closest = suggest(routes, path);
+    if (closest) {
+        message += `\nもしかして: ${closest.method} ${closest.path} ?`;
+    }
+    return c.text(message);
+}

package/dist/src/dev/page-data.d.ts

@@ -0,0 +1,95 @@
+import type { ConversionOrigin } from "../errors.ts";
+import type { CodeFrame } from "./source.ts";
+import type { EditorGuess } from "./editor.ts";
+import type { Hint } from "./hints.ts";
+import type { FrameKind } from "./stack.ts";
+import type { Difference } from "./suggest.ts";
+export type PageFrame = {
+    fn: string;
+    file: string;
+    display: string;
+    line: number;
+    col: number;
+    kind: FrameKind;
+};
+export type ErrorPageData = {
+    kind: "error";
+    status: number;
+    statusText: string;
+    durationMs: number | null;
+    error: {
+        name: string;
+        message: string;
+    };
+    origin: ConversionOrigin | null;
+    location: PageFrame | null;
+    code: CodeFrame | null;
+    hint: Hint | null;
+    frames: PageFrame[];
+    request: {
+        method: string;
+        path: string;
+        route: string | null;
+        params: Record<string, string>;
+        userAgent: string | null;
+    };
+    layers: {
+        name: string;
+        self: number;
+        total: number;
+        failed: boolean;
+    }[];
+    editor: EditorGuess;
+    root: string | null;
+    production: string;
+    dashboardUrl: string | null;
+};
+export type NotFoundPageData = {
+    kind: "notFound";
+    method: string;
+    path: string;
+    suggestion: (Difference & {
+        method: string;
+        path: string;
+        link: boolean;
+    }) | null;
+    routes: {
+        method: string;
+        path: string;
+        link: boolean;
+    }[];
+    dashboardUrl: string | null;
+};
+export type RequestSummary = {
+    id: string;
+    time: number;
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+    hasError: boolean;
+};
+export type RouteRow = {
+    method: string;
+    path: string;
+    middlewares: {
+        name: string;
+        applies: "yes" | "no" | "maybe";
+    }[];
+};
+export type MiddlewareRow = {
+    order: number;
+    name: string;
+    anonymous: boolean;
+    path: string | null;
+    runs: number;
+    avgSelfMs: number | null;
+};
+export type DashboardPageData = {
+    kind: "dashboard";
+    max: number;
+    requests: RequestSummary[];
+    routes: RouteRow[];
+    middlewares: MiddlewareRow[];
+};
+export type PageData = ErrorPageData | NotFoundPageData | DashboardPageData;

package/dist/src/dev/page.generated.d.ts

@@ -0,0 +1 @@
+export declare const PAGE_HTML: string;