@senrijs/senri 0.0.0-stage → 0.2.0

package/dist/src/dev/stack.js

@@ -0,0 +1,93 @@
+// err.stack(文字列)を、ページで扱いやすい { fn, file, line, col } の配列にする
+//
+// 3ランタイムとも "    at 関数名 (場所)" か "    at 場所" という V8 風の書式だが、「場所」の書き方が違う
+// - Bun:  C:\Users\me\app.ts:6:15            (Windows の生のパス)
+// - Node: file:///C:/Users/SHO%20T/app.ts:6:11 (エンコードされた file:// URL)
+// - Deno: file:///C:/Users/SHO T/app.ts:6:11   (エンコードされていない file:// URL も混ざる)
+// そこで、場所を「末尾の :行:列」から逆に読み、パスはスラッシュ区切りの絶対パスにそろえる
+// このファイルは src/dev/stack.ts(ビルド後は dist/src/dev/stack.js)にある
+// そこから2つ上がパッケージのルートで、その下の src / adapters / dist が Senri 本体
+// Cloudflare Workers のように1つのファイルにまとめられていると import.meta.url がない(またはファイルの URL でない)。
+// そのときは Senri の場所が分からないので、区別しない(どのフレームも利用者のコードとして扱う)
+function defaultSenriDirs() {
+    const here = import.meta.url;
+    // data: URL のように、相対パスを解決できない URL のこともある
+    if (typeof here !== "string" || !URL.canParse("../..", here))
+        return [];
+    const root = toPath(new URL("../..", here).href).replace(/\/$/, "");
+    // ビルド後は root が .../dist になっている
+    const pkg = root.endsWith("/dist") ? root.slice(0, -"/dist".length) : root;
+    return [`${pkg}/src`, `${pkg}/adapters`, `${pkg}/dist`];
+}
+// "file:///C:/a%20b/x.ts" や "C:\a b\x.ts" を "C:/a b/x.ts" にする
+function toPath(location) {
+    if (location.startsWith("file://")) {
+        // new URL は空白をエンコードし直すので、エンコードあり・なしのどちらでも同じ結果になる
+        const pathname = decodeURIComponent(new URL(location).pathname);
+        // Windows: "/C:/Users/..." の先頭の "/" を取る
+        return /^\/[A-Za-z]:\//.test(pathname) ? pathname.slice(1) : pathname;
+    }
+    return location.replaceAll("\\", "/");
+}
+function isRuntime(location) {
+    return /^(node|ext|bun|deno):/.test(location) || location === "native" || !location.includes("/");
+}
+// Windows はドライブ文字やフォルダ名の大文字小文字を区別しないので、そろえて比べる
+function sameOrInside(path, dir) {
+    const norm = (p) => (/^[A-Za-z]:\//.test(p) ? p.toLowerCase() : p);
+    const p = norm(path);
+    const d = norm(dir).replace(/\/$/, "");
+    return p === d || p.startsWith(`${d}/`);
+}
+function classify(file, senriDirs) {
+    if (isRuntime(file))
+        return "runtime";
+    // node_modules/senri は Senri 本体として扱いたいので、node_modules より先に見る
+    if (senriDirs.some((dir) => sameOrInside(file, dir)))
+        return "senri";
+    if (file.includes("/node_modules/"))
+        return "node_modules";
+    return "user";
+}
+// "Object.auth [as mw]" → "auth"、"async getUser" → "getUser"
+function cleanName(fn) {
+    const name = fn
+        .replace(/^async /, "")
+        .replace(/ \[as [^\]]+\]$/, "")
+        .replace(/^Object\./, "");
+    return name === "" ? "<anonymous>" : name;
+}
+// "場所" を { file, line, col } に。末尾が :行:列 でなければ行も列も 0
+function splitLocation(location) {
+    const m = /^(.*):(\d+):(\d+)$/.exec(location);
+    if (!m)
+        return { file: location, line: 0, col: 0 };
+    return { file: toPath(m[1]), line: Number(m[2]), col: Number(m[3]) };
+}
+function parseLine(line, senriDirs) {
+    const m = /^\s*at (.*)$/.exec(line);
+    if (!m)
+        return null;
+    const rest = m[1];
+    // "関数名 (場所)" の形。パスにも "(" が入りうる("Program Files (x86)")ので、
+    // 最初の " (" で切り、末尾が ")" で閉じているものだけを採用する
+    const open = rest.indexOf(" (");
+    let fn = "<anonymous>";
+    let location = rest;
+    if (open !== -1 && rest.endsWith(")")) {
+        fn = cleanName(rest.slice(0, open));
+        location = rest.slice(open + 2, -1);
+    }
+    const { file, line: lineNo, col } = splitLocation(location);
+    return { fn, file, line: lineNo, col, kind: classify(file, senriDirs) };
+}
+export function parseStack(stack, options = {}) {
+    const senriDirs = (options.senriDirs ?? defaultSenriDirs()).map((d) => d.replaceAll("\\", "/"));
+    const frames = [];
+    for (const line of stack.split("\n")) {
+        const frame = parseLine(line, senriDirs);
+        if (frame)
+            frames.push(frame);
+    }
+    return frames;
+}

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

@@ -0,0 +1,12 @@
+export declare function distance(a: string, b: string): number;
+export type Difference = {
+    parts: {
+        text: string;
+        mark: boolean;
+    }[];
+    note: string;
+};
+export declare function explainDifference(requested: string, suggested: string): Difference;
+export declare function suggest<R extends {
+    path: string;
+}>(routes: R[], path: string): R | null;

package/dist/src/dev/suggest.js

@@ -0,0 +1,95 @@
+// dp[i][j] = a の先頭 i 文字と b の先頭 j 文字が、何回の「追加・削除・置き換え」で同じになるか
+function table(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp;
+}
+// 2つの文字列が、何回の「追加・削除・置き換え」で同じになるかを数える
+export function distance(a, b) {
+    return table(a, b)[a.length][b.length];
+}
+// リクエストされたパスと候補のパスの、どこが違うかを調べる
+// DP の表を右下(両方の最後)から左上へたどると、1文字ずつ「同じ / 足りない / 多い / 違う」が分かる
+export function explainDifference(requested, suggested) {
+    const dp = table(requested, suggested);
+    const ops = [];
+    let i = requested.length;
+    let j = suggested.length;
+    while (i > 0 || j > 0) {
+        const here = dp[i][j];
+        // 「足りない」を先に試すと、"/helo" → "/hello" で後ろの l に印が付く("/hel" + "l" + "o")
+        if (j > 0 && here === dp[i][j - 1] + 1) {
+            ops.push({ kind: "missing", ch: suggested[j - 1] });
+            j--;
+        }
+        else if (i > 0 && j > 0 && requested[i - 1] === suggested[j - 1] && here === dp[i - 1][j - 1]) {
+            ops.push({ kind: "same", ch: suggested[j - 1] });
+            i--;
+            j--;
+        }
+        else if (i > 0 && j > 0 && here === dp[i - 1][j - 1] + 1) {
+            ops.push({ kind: "changed", ch: suggested[j - 1], was: requested[i - 1] });
+            i--;
+            j--;
+        }
+        else {
+            ops.push({ kind: "extra", ch: requested[i - 1] });
+            i--;
+        }
+    }
+    ops.reverse();
+    // 候補のパスを、印あり・なしのかたまりに分ける(「多い」文字は候補にないので出てこない)
+    const parts = [];
+    for (const op of ops) {
+        if (op.kind === "extra")
+            continue;
+        const mark = op.kind !== "same";
+        const last = parts.at(-1);
+        if (last && last.mark === mark)
+            last.text += op.ch;
+        else
+            parts.push({ text: op.ch, mark });
+    }
+    const diffs = ops.filter((op) => op.kind !== "same");
+    const chars = diffs.map((op) => op.ch).join("");
+    let note;
+    if (diffs.every((op) => op.kind === "missing")) {
+        note = `"${chars}" が${diffs.length}文字足りません`;
+    }
+    else if (diffs.every((op) => op.kind === "extra")) {
+        note = `"${chars}" が${diffs.length}文字多いです`;
+    }
+    else if (diffs.length === 1 && diffs[0].kind === "changed") {
+        note = `"${diffs[0].ch}" のところが "${diffs[0].was}" になっています`;
+    }
+    else {
+        note = `${diffs.length}か所違います`;
+    }
+    return { parts, note };
+}
+const MAX_DISTANCE = 3;
+// これより長いパスはタイプミスではないと見なして計算しない(長いほど計算が重くなるので)
+const MAX_PATH_LENGTH = 200;
+// いちばん近いルートを探す(距離が3より大きければ null)
+export function suggest(routes, path) {
+    if (path.length > MAX_PATH_LENGTH)
+        return null;
+    let closest = null;
+    let best = Infinity;
+    for (const r of routes) {
+        // 長さの差がそのまま距離の下限になるので、差が大きければ計算するまでもない
+        if (Math.abs(r.path.length - path.length) > MAX_DISTANCE)
+            continue;
+        const d = distance(r.path, path);
+        if (d < best) {
+            closest = r;
+            best = d;
+        }
+    }
+    return closest && best <= MAX_DISTANCE ? closest : null;
+}

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

@@ -0,0 +1,3 @@
+import type { RouteSchemas, ValidationError } from "../validate.ts";
+export declare function describeValidation(err: ValidationError): string;
+export declare function checkSchemas(path: string, schemas: RouteSchemas): void;

package/dist/src/dev/validation.js

@@ -0,0 +1,47 @@
+// バリデーションの、開発モードだけの部分(本体を小さくするため、本体の src/validate.ts から分けている)
+// - 登録した時点で、スキーマの書き間違いに気づけるようにする
+// - 通らなかったとき、どこが違うかを一覧にする
+import { senriError } from "../errors.js";
+const LABEL = {
+    params: "パスパラメーター",
+    query: "クエリ",
+    body: "ボディ",
+};
+// ["user", 0, "name"] → "user[0].name"
+function issuePath(issue) {
+    let out = "";
+    for (const part of issue.path ?? []) {
+        const key = typeof part === "object" ? part.key : part;
+        if (typeof key === "number")
+            out += `[${key}]`;
+        else
+            out += out ? `.${String(key)}` : String(key);
+    }
+    return out;
+}
+// 開発モードで返す、どこが違うかの一覧
+export function describeValidation(err) {
+    const lines = err.issues.map((issue) => {
+        const path = issuePath(issue);
+        return `- ${path ? `${path}: ` : ""}${issue.message}`;
+    });
+    return [`400 Bad Request: ${LABEL[err.target]}が、スキーマに合いません`, ...lines].join("\n");
+}
+// ArkType のスキーマは関数なので、オブジェクトでも関数でもよい
+function isSchema(value) {
+    return (typeof value === "object" || typeof value === "function") && value !== null && "~standard" in value;
+}
+// スキーマを確かめておく(書き間違いに、登録した時点で気づけるように)
+export function checkSchemas(path, schemas) {
+    if (typeof schemas !== "object" || schemas === null) {
+        throw senriError("schema_shape", new TypeError(`${path}: 2つ目の引数には { params, query, body } のスキーマかハンドラーを渡してください`));
+    }
+    for (const [key, schema] of Object.entries(schemas)) {
+        if (key !== "params" && key !== "query" && key !== "body") {
+            throw senriError("schema_key", new TypeError(`${path}: スキーマに渡せるのは params / query / body だけです("${key}" は使えません)`));
+        }
+        if (schema !== undefined && !isSchema(schema)) {
+            throw senriError("schema_type", new TypeError(`${path}: ${key} が Standard Schema のスキーマではありません(Zod・Valibot・ArkType などのスキーマを渡してください)`));
+        }
+    }
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,25 @@
+import type { Context, HandlerResult } from "./context.ts";
+export declare class HttpError extends Error {
+    status: number;
+    headers: Headers;
+    constructor(status: number, message?: string, options?: {
+        headers?: HeadersInit;
+        cause?: unknown;
+    });
+}
+export type ConversionOrigin = {
+    kind: "handler" | "middleware";
+    name: string;
+};
+export declare function markConversionError(err: unknown, origin: ConversionOrigin): unknown;
+export declare function conversionOriginOf(err: unknown): ConversionOrigin | null;
+export type ErrorHandler<V extends object = any> = (err: unknown, c: Context<V>) => HandlerResult | Promise<HandlerResult>;
+export type NotFoundHandler<V extends object = any> = (c: Context<V>) => HandlerResult | Promise<HandlerResult>;
+export declare function handleError(err: unknown, c: Context, onError: ErrorHandler): Promise<Response>;
+export declare function senriError<E extends Error>(code: string, error: E): E;
+export declare function senriError(code: string, message: string): Error;
+export declare function errorCode(err: unknown): string | undefined;
+export declare const defaultOnError: ErrorHandler;
+export declare const defaultNotFound: NotFoundHandler;
+export declare function methodNotAllowed(methods: string): HttpError;
+export declare function checkQueryRequest(c: Context): Promise<HttpError | null>;

package/dist/src/errors.js

@@ -0,0 +1,97 @@
+// status 付きで投げられるエラー。message はそのままクライアントに見せる前提のもの
+export class HttpError extends Error {
+    status;
+    headers;
+    constructor(status, message, options = {}) {
+        super(message ?? `HTTP ${status}`, { cause: options.cause });
+        this.name = "HttpError";
+        this.status = status;
+        this.headers = new Headers(options.headers);
+    }
+}
+const conversionOrigins = new WeakMap();
+export function markConversionError(err, origin) {
+    if (typeof err === "object" && err !== null)
+        conversionOrigins.set(err, origin);
+    return err;
+}
+export function conversionOriginOf(err) {
+    return typeof err === "object" && err !== null ? (conversionOrigins.get(err) ?? null) : null;
+}
+// onError を通して、例外をレスポンスに変える
+// HttpError なら status と headers を先に c に入れておくので、onError が文字列を返すだけでも正しい status になる
+export async function handleError(err, c, onError) {
+    if (err instanceof HttpError) {
+        c.status(err.status);
+        err.headers.forEach((value, key) => c.header(key, value));
+    }
+    else {
+        c.status(500);
+    }
+    // ログに出すべき「本当のエラー」だけ c.error に入れる(404 や 403 はふつうの応答)
+    if (!(err instanceof HttpError) || err.status >= 500) {
+        c.error = err;
+    }
+    try {
+        return c.toResponse(await onError(err, c));
+    }
+    catch (onErrorFailed) {
+        // onError 自体が壊れていたら、もう頼れるものがないので固定の 500 を返す
+        c.error = onErrorFailed;
+        return new Response("500 Internal Server Error", { status: 500 });
+    }
+}
+export function senriError(code, error) {
+    return Object.assign(typeof error === "string" ? new Error(error) : error, { code });
+}
+// Senri が投げたエラーの code(なければ undefined)
+export function errorCode(err) {
+    const code = err?.code;
+    return typeof code === "string" ? code : undefined;
+}
+// 本番の既定。エラーの中身(DB のパスワードなど)がもれないよう、固定の文言だけ返す
+// (開発モードの詳しい文言とエラーページは @senrijs/senri/dev が差し替える)
+export const defaultOnError = (err, c) => c.text(err instanceof HttpError ? err.message : "500 Internal Server Error");
+export const defaultNotFound = (c) => c.text("404 Not Found");
+export function methodNotAllowed(methods) {
+    return senriError("method_not_allowed", new HttpError(405, "405 Method Not Allowed", { headers: { allow: methods } }));
+}
+// QUERY(RFC 10008)は、検索の条件をボディに入れて送るメソッド。ボディと、その形式(Content-Type)が必須
+// ハンドラーを呼ぶ前に確かめる。どちらも問題なければ null
+export async function checkQueryRequest(c) {
+    if (await isEmptyBody(c))
+        return senriError("query_no_body", new HttpError(400, "400 Bad Request"));
+    if (!c.req.headers.get("content-type")) {
+        return senriError("query_no_type", new HttpError(415, "415 Unsupported Media Type"));
+    }
+    return null;
+}
+// ボディが空か。Content-Length があればそれで決める
+// ないとき(Deno はボディがなくても空のストリームを渡す。チャンク転送のこともある)は、
+// 複製(clone)のほうを中身のあるチャンクが来るまで読んで確かめる。元の c.req はそのまま読める
+async function isEmptyBody(c) {
+    const req = c.req;
+    if (req.body === null)
+        return true;
+    const length = req.headers.get("content-length");
+    if (length !== null)
+        return length.trim() === "0";
+    // ミドルウェアが読み済みなら clone() は例外になる。読めたということは、ボディはあった
+    if (req.bodyUsed)
+        return false;
+    const reader = req.clone().body.getReader();
+    try {
+        // 長さ 0 のチャンクが来ることもある(Deno)
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return true;
+            if (value.byteLength > 0)
+                return false;
+        }
+    }
+    finally {
+        // 複製のほうはもう読まない(元のほうに、読んだ分ため込まれ続けないようにする)
+        reader.cancel().catch(() => { });
+    }
+}

package/dist/src/group.d.ts

@@ -0,0 +1,37 @@
+import type { Handler, Middleware } from "./context.ts";
+import { type ExtractParams, type Simplify } from "./router.ts";
+import { type RouteSchemas, type Validated, type ValidatedParams } from "./validate.ts";
+type GroupParams<Prefix extends string, Path extends string> = Simplify<ExtractParams<`${Prefix}/${Path}`>>;
+type GroupMethod<Prefix extends string, V extends object> = {
+    <Path extends string>(path: Path, handler: Handler<GroupParams<Prefix, Path>, V>): void;
+    <Path extends string, S extends RouteSchemas>(path: Path, schemas: S, handler: Handler<ValidatedParams<S, GroupParams<Prefix, Path>>, V, Validated<S>>): void;
+};
+export type Router<Prefix extends string = string, V extends object = any> = {
+    readonly prefix: Prefix;
+    use(pathOrMw: string | Middleware<V>, mw?: Middleware<V>): void;
+    get: GroupMethod<Prefix, V>;
+    post: GroupMethod<Prefix, V>;
+    put: GroupMethod<Prefix, V>;
+    patch: GroupMethod<Prefix, V>;
+    delete: GroupMethod<Prefix, V>;
+    all: GroupMethod<Prefix, V>;
+    head: GroupMethod<Prefix, V>;
+    options: GroupMethod<Prefix, V>;
+    on<Path extends string>(method: string | readonly string[], path: Path, handler: Handler<GroupParams<Prefix, Path>, V>): void;
+    on<Path extends string, S extends RouteSchemas>(method: string | readonly string[], path: Path, schemas: S, handler: Handler<ValidatedParams<S, GroupParams<Prefix, Path>>, V, Validated<S>>): void;
+    route(router: Router<string, V>): void;
+};
+export type GroupEntry = {
+    kind: "route";
+    method: string;
+    path: string;
+    handler: Handler;
+} | {
+    kind: "use";
+    path: string;
+    mw: Middleware;
+};
+export declare function joinPath(...parts: string[]): string;
+export declare function groupEntries(router: Router): GroupEntry[];
+export declare function createRouter<Prefix extends string, V extends object = Record<string, unknown>>(prefix: Prefix): Router<Prefix, V>;
+export {};

package/dist/src/group.js

@@ -0,0 +1,75 @@
+import { normalizeMethod, splitPattern } from "./router.js";
+import { routeHandler } from "./validate.js";
+import { senriError } from "./errors.js";
+const entries = new WeakMap();
+export function joinPath(...parts) {
+    return "/" + parts.flatMap(splitPattern).join("/");
+}
+// ルーターに登録されたものを、プレフィックスを付けたパスで返す
+export function groupEntries(router) {
+    const list = entries.get(router);
+    if (!list)
+        throw senriError("not_router", new TypeError("Not a router from createRouter()"));
+    return list("");
+}
+// V は c.set / c.get で使う変数の型。アプリと同じものを指定する: createRouter<"/admin", Vars>("/admin")
+export function createRouter(prefix) {
+    // 子のルーターは、つなげた時点ではなく app.route の時点で中身を読む(あとから足したルートも入る)
+    const items = [];
+    const push = (name, path, handler) => {
+        items.push({ kind: "entry", entry: { kind: "route", method: name, path, handler } });
+    };
+    const method = (name) => ((path, a, b) => push(name, path, routeHandler(path, a, b)));
+    const router = {
+        prefix,
+        use(pathOrMw, mw) {
+            const path = typeof pathOrMw === "string" ? pathOrMw : "/";
+            const fn = typeof pathOrMw === "string" ? mw : pathOrMw;
+            if (!fn)
+                throw senriError("no_middleware", `Missing middleware: ${path}`);
+            items.push({ kind: "entry", entry: { kind: "use", path, mw: fn } });
+        },
+        get: method("GET"),
+        post: method("POST"),
+        put: method("PUT"),
+        patch: method("PATCH"),
+        delete: method("DELETE"),
+        all: method("ALL"),
+        head: method("HEAD"),
+        options: method("OPTIONS"),
+        on: ((methods, path, a, b) => {
+            const list = typeof methods === "string" ? [methods] : methods;
+            if (list.length === 0)
+                throw senriError("no_method", `Missing method: ${path}`);
+            const handler = routeHandler(path, a, b);
+            for (const m of list) {
+                if (m.toUpperCase() === "ALL")
+                    throw senriError("on_all", "Use all() for every method");
+                // 名前の確認(CONNECT などの拒否)は、ここで先にしておく(app.route まで待たない)
+                push(normalizeMethod(m), path, handler);
+            }
+        }),
+        route(child) {
+            if (!entries.has(child))
+                throw senriError("not_router", new TypeError("Not a router from createRouter()"));
+            items.push({ kind: "router", router: child });
+        },
+    };
+    const seen = new Set();
+    entries.set(router, (base) => {
+        // ルーターが自分自身を(間接的にでも)含んでいると終わらないので止める
+        if (seen.has(router))
+            throw senriError("router_cycle", `Router ${prefix} contains itself`);
+        seen.add(router);
+        try {
+            const here = joinPath(base, prefix);
+            return items.flatMap((item) => item.kind === "router"
+                ? entries.get(item.router)(here)
+                : [{ ...item.entry, path: joinPath(here, item.entry.path) }]);
+        }
+        finally {
+            seen.delete(router);
+        }
+    });
+    return router;
+}

package/dist/src/health.d.ts

@@ -0,0 +1,9 @@
+import type { Middleware } from "./context.ts";
+export type HealthOptions = {
+    path?: string | false;
+    readyPath?: string | false;
+    ready?: () => boolean | Promise<boolean>;
+};
+export declare function setDraining(value: boolean): void;
+export declare function isDraining(): boolean;
+export declare function health(options?: HealthOptions): Middleware;

package/dist/src/health.js

@@ -0,0 +1,40 @@
+// serve() が止まり始めた(SIGTERM などを受けた)か。プロセス全体で1つ
+let draining = false;
+export function setDraining(value) {
+    draining = value;
+}
+export function isDraining() {
+    return draining;
+}
+const plain = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" } });
+export function health(options = {}) {
+    const live = options.path === undefined ? "/healthz" : options.path;
+    const ready = options.readyPath === undefined ? "/readyz" : options.readyPath;
+    return async function health(c, next) {
+        const method = c.req.method;
+        if (method !== "GET" && method !== "HEAD")
+            return next();
+        let path;
+        try {
+            path = c.path;
+        }
+        catch {
+            return next();
+        }
+        if (path === live)
+            return plain("ok", 200);
+        if (path !== ready)
+            return next();
+        if (draining)
+            return plain("shutting down", 503);
+        try {
+            if (options.ready && !(await options.ready()))
+                return plain("not ready", 503);
+        }
+        catch {
+            // 確かめる処理が失敗したなら、受けられるとは言えない(中身は外に出さない)
+            return plain("not ready", 503);
+        }
+        return plain("ready", 200);
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+export { createApp, type App, type AppCore, type AppOptions, type DevHooks, type DevInstalled, type MountableApp, type Resolved, } from "./app.ts";
+export { createRouter, type Router } from "./group.ts";
+export { Context, type BindingsOf, type ExecutionContext, type Handler, type HandlerResult, type Middleware, type Next, type VariablesOf, } from "./context.ts";
+export { HttpError, type ErrorHandler, type NotFoundHandler } from "./errors.ts";
+export { ValidationError, type InferOutput, type RouteSchemas, type StandardIssue, type StandardSchemaV1, type ValidationTarget, } from "./validate.ts";
+export type { CookieOptions } from "./cookie.ts";
+export type { FormBody, FormValue } from "./body.ts";
+export type { Layer, Timing, Trace } from "./compose.ts";
+export { logger, showRoutes } from "./logger.ts";
+export { health, type HealthOptions } from "./health.ts";
+export { cors, type CorsOptions } from "./middleware/cors.ts";
+export { secureHeaders, type SecureHeadersOptions } from "./middleware/secure-headers.ts";
+export { bodyLimit, type BodyLimitOptions } from "./middleware/body-limit.ts";

package/dist/src/index.js

@@ -0,0 +1,12 @@
+// @senrijs/senri の入口
+// 開発モード(エラーページ・ダッシュボードなど)は @senrijs/senri/dev、Cookie は @senrijs/senri/cookie、接続元の IP は @senrijs/senri/ip
+export { createApp, } from "./app.js";
+export { createRouter } from "./group.js";
+export { Context, } from "./context.js";
+export { HttpError } from "./errors.js";
+export { ValidationError, } from "./validate.js";
+export { logger, showRoutes } from "./logger.js";
+export { health } from "./health.js";
+export { cors } from "./middleware/cors.js";
+export { secureHeaders } from "./middleware/secure-headers.js";
+export { bodyLimit } from "./middleware/body-limit.js";

package/dist/src/ip.d.ts

@@ -0,0 +1,2 @@
+import { type Context } from "./context.ts";
+export declare function getIp(c: Context): string | null;

package/dist/src/ip.js

@@ -0,0 +1,12 @@
+// @senrijs/senri/ip の入口
+// Context のメソッドにしないのは、使わないアプリのバンドルに入れないため(0.1 の c.ip)
+import { connectionOf } from "./context.js";
+import { clientIp } from "./connection.js";
+// 接続元の IP アドレス。分からなければ null(app.fetch を直接呼んだときなど)
+// - Bun / Deno / Node(senri/node): ランタイムが渡す接続元
+// - Cloudflare Workers: Cloudflare が付ける CF-Connecting-IP
+// X-Forwarded-For などのヘッダーは偽装できるので読まない。プロキシの後ろでは、プロキシが付けるヘッダーを自分で読む
+export function getIp(c) {
+    const { req, info } = connectionOf(c);
+    return clientIp(req, info);
+}

package/dist/src/logger.d.ts

@@ -0,0 +1,18 @@
+import type { Middleware } from "./context.ts";
+type LoggerOptions = {
+    format?: "pretty" | "json";
+    color?: boolean;
+    slow?: number;
+};
+export declare function logger(options?: LoggerOptions): Middleware;
+type RouteInfo = {
+    method: string;
+    path: string;
+};
+export declare function showRoutes(app: {
+    routeList(): RouteInfo[];
+}, url: string, options?: {
+    color?: boolean;
+    note?: string;
+}): void;
+export {};