@senrijs/senri 0.0.0-stage → 0.1.0

package/dist/src/router.d.ts

@@ -0,0 +1,30 @@
+import type { Handler } from "./context.ts";
+export type Route = {
+    path: string;
+    segments: string[];
+    paramNames: string[];
+    method: string;
+    handler: Handler;
+};
+type Segment<Path extends string> = Path extends `${infer Head}/${infer Rest}` ? Head | Segment<Rest> : Path;
+type ParamName<S extends string> = S extends `:${infer Name}` ? Name : never;
+export type ExtractParams<Path extends string> = string extends Path ? Record<string, string> : {
+    [K in ParamName<Segment<Path>>]: string;
+};
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type RouteTable<K extends string, V extends object = any> = {
+    [Key in K]: Key extends `${string} ${infer Path}` ? Handler<Simplify<ExtractParams<Path>>, V> : 'ルートの書き方が違います。"GET /hello" のように、メソッドとパスの間にスペースを入れてください';
+};
+export declare function splitPattern(pattern: string): string[];
+export declare function splitPath(pathname: string): string[];
+export declare function requestPathname(req: Request): string;
+export declare function matchPath(pattern: readonly string[], path: readonly string[]): Record<string, string> | null;
+export declare function routeShape(segments: readonly string[]): string;
+export declare function checkParamNames(path: string, segments: readonly string[]): void;
+export declare function normalizeMethod(method: string): string;
+export declare function allowedMethods(routes: readonly Route[]): string;
+export declare function startsWithSegments(path: readonly string[], prefix: readonly string[]): boolean;
+export declare function compareRoutes(a: Route, b: Route): number;
+export {};

package/dist/src/router.js

@@ -0,0 +1,177 @@
+import { HttpError } from "./errors.js";
+// ルートのパターン("/users/:id")を分割する。末尾スラッシュや連続スラッシュは無視
+export function splitPattern(pattern) {
+    return pattern.split("/").filter(Boolean);
+}
+// リクエストのパス(URL の pathname)を分割して、セグメントごとにデコードする
+// - 末尾スラッシュや連続スラッシュは無視する("/a//b/" は "/a/b" と同じ)
+// - "/" ごとに分割してからデコードするので、%2F が区切りと混ざることはないが、
+//   紛らわしいので %2F(デコードすると "/" を含む)は 400 にする
+// - デコードすると "." や ".." になるものは、パストラバーサルの元なので 400 にする
+//   (ふつうは "%2E%2E" も含めて URL の仕様で解決済みなので、ここは念のための防御)
+export function splitPath(pathname) {
+    const segments = [];
+    for (const raw of pathname.split("/")) {
+        if (raw === "")
+            continue;
+        // "%" がなければデコードしても同じなので、しない(ほとんどのリクエストはこちら)
+        // デコードしなければ "/" は含まれない(split で分けたので)
+        let segment = raw;
+        if (raw.includes("%")) {
+            try {
+                segment = decodeURIComponent(raw);
+            }
+            catch {
+                throw new HttpError(400, "400 Bad Request");
+            }
+            if (segment.includes("/"))
+                throw new HttpError(400, "400 Bad Request");
+        }
+        if (segment === "." || segment === "..") {
+            throw new HttpError(400, "400 Bad Request");
+        }
+        segments.push(segment);
+    }
+    return segments;
+}
+// URL の区切り文字や空白を含む Host は、ふつうのクライアントは送らない
+const BAD_HOST = /[\s/?#@\\]/;
+// リクエストの pathname を取り出す。おかしなリクエストは HttpError(400) にする
+// - ランタイムが Host ヘッダーをつないで URL を作ることがある(Deno)。
+//   "Host: x/admin#" だと http://x/admin#/public になり、パスが /admin にすり替わるので弾く
+// - Bun は Host が不正だと req.url を "/public" のような相対 URL にするので、new URL() が失敗する
+// - 速さのため、ふつうは new URL() を使わず req.url の文字列から切り出す。
+//   ただし Deno は req.url を正規化しない("/a/../b" のまま来る)ので、"." のセグメント・%2e・\ を含むときだけ
+//   new URL() に任せて、URL の仕様どおりに解決させる(どちらで取り出しても、同じ結果になるようにしている)
+export function requestPathname(req) {
+    const host = req.headers.get("host");
+    if (host !== null && BAD_HOST.test(host)) {
+        throw new HttpError(400, "400 Bad Request");
+    }
+    const url = req.url;
+    const scheme = url.indexOf("://");
+    if (scheme !== -1) {
+        const start = url.indexOf("/", scheme + 3);
+        if (start === -1)
+            return "/";
+        // "?" か "#" までがパス。1回の走査で、new URL() に任せるべきもの("/." と "%2e" と "\")も探す
+        let needsUrl = false;
+        let i = start;
+        for (; i < url.length; i++) {
+            const ch = url.charCodeAt(i);
+            if (ch === 63 || ch === 35)
+                break; // "?" "#"
+            if (ch === 92)
+                needsUrl = true; // "\"
+            else if (ch === 46 && url.charCodeAt(i - 1) === 47)
+                needsUrl = true; // "/."
+            else if (ch === 37 && url.charCodeAt(i + 1) === 50 && (url.charCodeAt(i + 2) | 32) === 101)
+                needsUrl = true; // "%2e" "%2E"
+        }
+        if (!needsUrl)
+            return url.slice(start, i);
+    }
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        throw new HttpError(400, "400 Bad Request");
+    }
+}
+export function matchPath(pattern, path) {
+    // 個数が違ったら一致しない
+    if (pattern.length !== path.length) {
+        return null;
+    }
+    // 1個ずつ比較する
+    const params = {};
+    for (let i = 0; i < pattern.length; i++) {
+        const p = pattern[i];
+        const actual = path[i];
+        if (p.startsWith(":")) {
+            params[p.slice(1)] = actual;
+        }
+        else if (p !== actual) {
+            return null;
+        }
+    }
+    return params;
+}
+// パターンの「形」。パラメーター名は区別しない("/users/:id" と "/users/:name" は同じ "users/:")
+export function routeShape(segments) {
+    return segments.map((s) => (s.startsWith(":") ? ":" : s)).join("/");
+}
+// パラメーター名が空だったり、1つのパターンで2回使われていたりしたらエラー
+// (2回目の値で1回目が黙って上書きされてしまうので)
+export function checkParamNames(path, segments) {
+    const seen = new Set();
+    for (const s of segments) {
+        if (!s.startsWith(":"))
+            continue;
+        const name = s.slice(1);
+        if (name === "") {
+            throw new Error(`パラメーター名が空です: "${path}"`);
+        }
+        if (seen.has(name)) {
+            throw new Error(`パラメーター名 "${name}" が2回使われています: "${path}"`);
+        }
+        seen.add(name);
+    }
+}
+// メソッド名に使える文字(RFC 9110 の token)
+const METHOD = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+// 登録するメソッド名を確かめて、大文字にする("propfind" → "PROPFIND")
+// - CONNECT はプロキシ用、TRACE / TRACK はリクエストをそのまま返すので Cookie を盗む攻撃(XST)に使われる。どれも扱わない
+// - "ALL" は app.all() の印として使っているので、app.on() からは登録させない
+export function normalizeMethod(method) {
+    if (!METHOD.test(method))
+        throw new Error(`メソッド名に使えない文字があります: ${JSON.stringify(method)}`);
+    const upper = method.toUpperCase();
+    if (upper === "CONNECT" || upper === "TRACE" || upper === "TRACK") {
+        throw new Error(`${upper} メソッドは扱いません(Senri では CONNECT / TRACE / TRACK を登録できません)`);
+    }
+    return upper;
+}
+// Allow ヘッダーに入れるメソッドの一覧("GET, HEAD, POST, OPTIONS")
+// GET があれば HEAD も使える(GET にフォールバックするので)。OPTIONS はいつでも使える
+export function allowedMethods(routes) {
+    const methods = [];
+    for (const r of routes) {
+        if (!methods.includes(r.method))
+            methods.push(r.method);
+        if (r.method === "GET" && !methods.includes("HEAD"))
+            methods.push("HEAD");
+    }
+    if (!methods.includes("OPTIONS"))
+        methods.push("OPTIONS");
+    return methods.join(", ");
+}
+// path の先頭が prefix と一致するか。セグメント単位で比べるので "/admin" は "/administrator" にはマッチしない
+// プレフィックスの ":id" のようなパラメーターは、どんなセグメントにも合う(matchPath と同じ判定)
+export function startsWithSegments(path, prefix) {
+    if (path.length < prefix.length)
+        return false;
+    return prefix.every((p, i) => p.startsWith(":") || p === path[i]);
+}
+// sort 用の比較関数。どの2つを比べても答えが矛盾しない(=並び順が一意に決まる)ようにする
+export function compareRoutes(a, b) {
+    const aParts = a.segments;
+    const bParts = b.segments;
+    // まずセグメント数で分ける。数が違うルート同士はそもそも同じパスにマッチしないので、
+    // ここで順番を決めてしまっても優先順位には影響しない
+    // (以前はここで 0 = 「同じ」と答えていたため、sort の結果が登録順に左右されていた)
+    if (aParts.length !== bParts.length) {
+        return aParts.length - bParts.length;
+    }
+    for (let i = 0; i < aParts.length; i++) {
+        const aIsParam = aParts[i].startsWith(":");
+        const bIsParam = bParts[i].startsWith(":");
+        // aがパラメータでbがパラメータでない場合、bを優先する
+        if (aIsParam && !bIsParam)
+            return 1;
+        // aがパラメータでなくbがパラメータの場合、aを優先する
+        if (!aIsParam && bIsParam)
+            return -1;
+    }
+    return 0;
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,4 @@
+export declare function isWorkers(): boolean;
+export declare function cwd(): string | null;
+export declare function env(name: string): string | undefined;
+export declare function canRead(path: string): boolean;

package/dist/src/runtime.js

@@ -0,0 +1,49 @@
+// ランタイムごとに違う処理(カレントディレクトリ、環境変数、ファイルの読み込み権限)。開発用ページと serve() で使う
+//
+// Deno は、許可されていない環境変数やファイルを読もうとすると、ターミナルで「許可しますか?」と聞いてきて
+// その間リクエストが止まってしまう。なので先に permissions.querySync() で「許可済みか」だけを確かめ、
+// 許可されていなければ読まずにあきらめる(聞き返しはしない)
+const g = globalThis;
+// Cloudflare Workers(workerd)で動いているか。Workers の navigator.userAgent は決まった値になる
+export function isWorkers() {
+    return g.navigator?.userAgent === "Cloudflare-Workers";
+}
+function denoAllows(desc) {
+    try {
+        return g.Deno.permissions.querySync(desc).state === "granted";
+    }
+    catch {
+        return false;
+    }
+}
+// スラッシュ区切りのカレントディレクトリ。分からなければ null
+export function cwd() {
+    try {
+        // Deno 2 には process もあるが、権限の確認をしたいので Deno を先に見る
+        // 全体({ name: "read" })で聞くと、--allow-read=. のように範囲を絞ったときに "prompt" になってしまう。
+        // カレントディレクトリが読めればよいので、"." で聞く
+        if (g.Deno)
+            return denoAllows({ name: "read", path: "." }) ? g.Deno.cwd().replaceAll("\\", "/") : null;
+        if (g.process)
+            return g.process.cwd().replaceAll("\\", "/");
+    }
+    catch {
+        // 読めなければあきらめる
+    }
+    return null;
+}
+export function env(name) {
+    try {
+        if (g.Deno)
+            return denoAllows({ name: "env", variable: name }) ? g.Deno.env.get(name) : undefined;
+        return g.process?.env[name];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function canRead(path) {
+    if (g.Deno)
+        return denoAllows({ name: "read", path });
+    return true;
+}

package/dist/src/validate.d.ts

@@ -0,0 +1,47 @@
+import { type Handler } from "./context.ts";
+import { HttpError } from "./errors.ts";
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly types?: {
+            readonly input: Input;
+            readonly output: Output;
+        } | undefined;
+    };
+}
+type StandardResult<Output> = {
+    readonly value: Output;
+    readonly issues?: undefined;
+} | {
+    readonly issues: readonly StandardIssue[];
+};
+export type StandardIssue = {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | {
+        readonly key: PropertyKey;
+    })[] | undefined;
+};
+export type InferOutput<S> = S extends StandardSchemaV1<any, infer Output> ? Output : never;
+export type RouteSchemas = {
+    params?: StandardSchemaV1;
+    query?: StandardSchemaV1;
+    body?: StandardSchemaV1;
+};
+export type Validated<S extends RouteSchemas> = {
+    [K in keyof S & ("query" | "body")]: InferOutput<S[K]>;
+};
+export type ValidatedParams<S extends RouteSchemas, Fallback> = S extends {
+    params: StandardSchemaV1;
+} ? InferOutput<S["params"]> : Fallback;
+export type ValidationTarget = "params" | "query" | "body";
+export declare class ValidationError extends HttpError {
+    readonly target: ValidationTarget;
+    readonly issues: readonly StandardIssue[];
+    constructor(target: ValidationTarget, issues: readonly StandardIssue[]);
+    describe(): string;
+}
+export declare function checkSchemas(path: string, schemas: RouteSchemas): void;
+export declare function withValidation(schemas: RouteSchemas, handler: Handler): Handler;
+export {};

package/dist/src/validate.js

@@ -0,0 +1,87 @@
+// Standard Schema(https://standardschema.dev)によるバリデーション
+// Zod・Valibot・ArkType など、Standard Schema に対応したライブラリのスキーマをそのまま使える(Senri はどれにも依存しない)
+//
+// app.post("/users/:id", { params, query, body }, handler) のように、ルートにスキーマを渡す
+// - params: パスパラメーター。通ればハンドラーの第1引数(と c.params)が変換後の値になる
+// - query: c.query() の結果。通れば c.valid("query") で読める
+// - body: c.body() の結果(Content-Type に合わせて読んだもの)。通れば c.valid("body") で読める
+// どれかが通らなければ、ハンドラーは呼ばずに 400 にする(ValidationError)
+import { setValidated } from "./context.js";
+import { HttpError } from "./errors.js";
+// バリデーションに通らなかった。issues はスキーマのライブラリが返したもの
+// app.onError で受けて、自分の形(JSON など)で返すこともできる
+export class ValidationError extends HttpError {
+    target;
+    issues;
+    constructor(target, issues) {
+        // 本番の本文(message)には中身を出さない(スキーマの作りをそのまま外に見せないため)
+        super(400, "400 Bad Request");
+        this.name = "ValidationError";
+        this.target = target;
+        this.issues = issues;
+    }
+    // 開発モードで返す、どこが違うかの一覧
+    describe() {
+        const lines = this.issues.map((issue) => {
+            const path = issuePath(issue);
+            return `- ${path ? `${path}: ` : ""}${issue.message}`;
+        });
+        return [`400 Bad Request: ${LABEL[this.target]}が、スキーマに合いません`, ...lines].join("\n");
+    }
+}
+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;
+}
+// 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 new TypeError(`${path}: 2つ目の引数には { params, query, body } のスキーマかハンドラーを渡してください`);
+    }
+    for (const [key, schema] of Object.entries(schemas)) {
+        if (key !== "params" && key !== "query" && key !== "body") {
+            throw new TypeError(`${path}: スキーマに渡せるのは params / query / body だけです("${key}" は使えません)`);
+        }
+        if (schema !== undefined && !isSchema(schema)) {
+            throw new TypeError(`${path}: ${key} が Standard Schema のスキーマではありません(Zod・Valibot・ArkType などのスキーマを渡してください)`);
+        }
+    }
+}
+async function run(schema, target, value) {
+    const result = await schema["~standard"].validate(value);
+    if (result.issues)
+        throw new ValidationError(target, result.issues);
+    return result.value;
+}
+// スキーマで確かめてからハンドラーを呼ぶハンドラーにする。params → query → body の順に確かめる
+export function withValidation(schemas, handler) {
+    return async (params, c) => {
+        let validParams = params;
+        if (schemas.params) {
+            validParams = (await run(schemas.params, "params", params));
+            c.params = validParams;
+        }
+        if (schemas.query)
+            setValidated(c, "query", await run(schemas.query, "query", c.query()));
+        if (schemas.body)
+            setValidated(c, "body", await run(schemas.body, "body", await c.body()));
+        return handler(validParams, c);
+    };
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@senrijs/senri",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Web 標準の Request / Response で書かれた、小さな Web フレームワーク。Bun・Deno・Node.js・Cloudflare Workers で動く",
+  "license": "MIT",
+  "author": "ibuki-hum4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Senrijs/Senri.git"
+  },
+  "homepage": "https://github.com/Senrijs/Senri#readme",
+  "bugs": {
+    "url": "https://github.com/Senrijs/Senri/issues"
+  },
+  "keywords": [
+    "web",
+    "framework",
+    "router",
+    "http",
+    "fetch",
+    "bun",
+    "deno",
+    "node",
+    "cloudflare-workers",
+    "standard-schema"
+  ],
+  "type": "module",
+  "private": false,
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./node": {
+      "types": "./dist/adapters/node/index.d.ts",
+      "import": "./dist/adapters/node/index.js"
+    },
+    "./serve": {
+      "types": "./dist/adapters/serve/index.d.ts",
+      "import": "./dist/adapters/serve/index.js"
+    },
+    "./static": {
+      "types": "./dist/adapters/static/index.d.ts",
+      "import": "./dist/adapters/static/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "build:pages": "vite build -c ui/vite.config.ts && node scripts/build-pages.ts",
+    "typecheck": "bun run build && bun check && bun check -p test && bun check -p test/node && bun check -p adapters/node && bun check -p examples/bun && bun check -p examples/node && bun check -p scripts && deno check examples/deno/index.ts && bun check -p adapters/serve && bun check -p adapters/static && bun check -p ui",
+    "dev": "bun --watch examples/bun/index.ts",
+    "test": "bun test",
+    "test:node": "bun run build && node --test --test-timeout=5000 \"test/node/**/*.test.ts\"",
+    "smoke": "node scripts/smoke.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^26.6.5",
+    "@vitejs/plugin-vue": "6.0.10",
+    "arktype": "2.2.8",
+    "typescript": "^7",
+    "valibot": "1.5.0",
+    "vite": "8.3.5",
+    "vite-plugin-singlefile": "2.3.4",
+    "vue": "3.5.44",
+    "workerd": "1.20261010.1",
+    "zod": "4.6.6"
+  }
+}