tachyon-dom 0.1.0

package/dist/adapters/node.d.ts

@@ -0,0 +1,25 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type AdapterFetchHandler, type WorkersFetchHandlerOptions, type RouteAdapterHandlerOptions } from "./workers.js";
+export type NodeHandlerOptions = RouteAdapterHandlerOptions & {
+    staticAssets?: StaticAssetOptions;
+    origin?: string | ((request: IncomingMessage) => string);
+    trustedHosts?: readonly string[];
+    trustProxy?: boolean;
+};
+export type NodeFetchHandlerOptions = Omit<WorkersFetchHandlerOptions, "fetch"> & {
+    fetch: AdapterFetchHandler;
+    staticAssets?: StaticAssetOptions;
+    origin?: string | ((request: IncomingMessage) => string);
+    trustedHosts?: readonly string[];
+    trustProxy?: boolean;
+};
+export type StaticAssetOptions = {
+    rootDir: string;
+    basePath?: string;
+    headers?: HeadersInit;
+    fallthroughOnNotFound?: boolean;
+};
+export declare const createStaticAssetHandler: (options: StaticAssetOptions) => ((request: Request) => Promise<Response | undefined>);
+export declare const writeNodeResponse: (webResponse: Response, response: ServerResponse) => Promise<void>;
+export declare const createNodeHandler: (options: NodeHandlerOptions) => (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare const createNodeFetchHandler: (options: NodeFetchHandlerOptions) => ((request: IncomingMessage, response: ServerResponse) => Promise<void>);

package/dist/adapters/node.js

@@ -0,0 +1,360 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { createWorkersFetchHandler, createWorkersHandler, } from "./workers.js";
+const mergeHeaders = (base, extra) => {
+    const headers = new Headers(base);
+    extra?.forEach((value, key) => headers.set(key, value));
+    return headers;
+};
+const contentTypeFor = (file) => {
+    if (file.endsWith(".css")) {
+        return "text/css; charset=utf-8";
+    }
+    if (file.endsWith(".js") || file.endsWith(".mjs")) {
+        return "text/javascript; charset=utf-8";
+    }
+    if (file.endsWith(".json")) {
+        return "application/json; charset=utf-8";
+    }
+    if (file.endsWith(".svg")) {
+        return "image/svg+xml";
+    }
+    if (file.endsWith(".html")) {
+        return "text/html; charset=utf-8";
+    }
+    if (file.endsWith(".wasm")) {
+        return "application/wasm";
+    }
+    return "application/octet-stream";
+};
+const findStaticRoute = (routes, method, url) => routes?.find((route) => {
+    const methods = route.methods ?? ["GET", "HEAD"];
+    const path = route.path.includes("?") ? `${url.pathname}${url.search}` : url.search ? "" : url.pathname;
+    return methods.includes(method) && route.path === path;
+});
+const byteLength = (value) => new TextEncoder().encode(value).byteLength;
+const headersForStaticRoute = (route, extra) => {
+    const headers = mergeHeaders(new Headers(route.headers), extra);
+    if (!headers.has("content-type")) {
+        headers.set("content-type", "text/html; charset=utf-8");
+    }
+    if (!headers.has("content-length")) {
+        headers.set("content-length", String(byteLength(route.body)));
+    }
+    return headers;
+};
+const setNodeHeaders = (response, headers) => {
+    const setCookies = headers.getSetCookie();
+    headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "set-cookie") {
+            response.setHeader(key, value);
+        }
+    });
+    if (setCookies.length === 1) {
+        response.setHeader("set-cookie", setCookies[0] ?? "");
+    }
+    else if (setCookies.length > 1) {
+        response.setHeader("set-cookie", setCookies);
+    }
+};
+const writeNodeStaticRoute = (route, request, response, securityHeaders) => {
+    response.statusCode = route.status ?? 200;
+    setNodeHeaders(response, headersForStaticRoute(route, securityHeaders));
+    response.end(request.method === "HEAD" ? undefined : route.body);
+};
+const withSecurityHeaders = (response, securityHeaders) => {
+    if (!securityHeaders) {
+        return response;
+    }
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: mergeHeaders(response.headers, securityHeaders),
+    });
+};
+const isFileSystemNotFound = (error) => {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+};
+const rawPathnameFromRequestUrl = (requestUrl) => {
+    const raw = requestUrl ?? "/";
+    const queryStart = raw.search(/[?#]/);
+    return queryStart === -1 ? raw : raw.slice(0, queryStart);
+};
+const rawPathStartsWithBase = (rawPathname, basePath) => {
+    if (basePath === "/") {
+        return rawPathname.startsWith("/");
+    }
+    return rawPathname === basePath || rawPathname.startsWith(`${basePath}/`) || rawPathname.startsWith(`${basePath}\\`);
+};
+const staticAssetTraversalResponse = (requestUrl, options) => {
+    const basePath = options.basePath ?? "/";
+    const rawPathname = rawPathnameFromRequestUrl(requestUrl);
+    try {
+        const decodedPathname = decodeURIComponent(rawPathname);
+        if (!rawPathStartsWithBase(rawPathname, basePath) && !rawPathStartsWithBase(decodedPathname, basePath)) {
+            return undefined;
+        }
+        const relativePath = decodedPathname.slice(basePath.length).replace(/^\/+/, "");
+        return relativePath.split(/[\\/]/).includes("..") ? new Response("Forbidden", { status: 403 }) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const createStaticAssetHandler = (options) => async (request) => {
+    const basePath = options.basePath ?? "/";
+    const url = new URL(request.url);
+    if (basePath !== "/" && url.pathname !== basePath && !url.pathname.startsWith(`${basePath}/`)) {
+        return undefined;
+    }
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        if (options.fallthroughOnNotFound) {
+            return undefined;
+        }
+        return new Response("Method Not Allowed", { status: 405, headers: { allow: "GET, HEAD" } });
+    }
+    let relativePath;
+    try {
+        relativePath = decodeURIComponent(url.pathname.slice(basePath.length)).replace(/^\/+/, "");
+    }
+    catch {
+        return new Response("Not Found", { status: 404 });
+    }
+    if (!relativePath) {
+        return options.fallthroughOnNotFound ? undefined : new Response("Forbidden", { status: 403 });
+    }
+    if (relativePath.split(/[\\/]/).some((segment) => segment === ".." || segment.startsWith("."))) {
+        return new Response("Forbidden", { status: 403 });
+    }
+    const root = path.resolve(options.rootDir);
+    const file = path.resolve(root, relativePath);
+    if (!file.startsWith(`${root}${path.sep}`)) {
+        return new Response("Forbidden", { status: 403 });
+    }
+    try {
+        const canonicalRoot = await realpath(root);
+        const canonicalFile = await realpath(file);
+        if (!canonicalFile.startsWith(`${canonicalRoot}${path.sep}`)) {
+            return new Response("Forbidden", { status: 403 });
+        }
+        const canonicalRelativePath = path.relative(canonicalRoot, canonicalFile);
+        if (canonicalRelativePath.split(path.sep).some((segment) => segment.startsWith("."))) {
+            return new Response("Forbidden", { status: 403 });
+        }
+        const info = await stat(canonicalFile);
+        if (!info.isFile()) {
+            return options.fallthroughOnNotFound ? undefined : new Response("Not Found", { status: 404 });
+        }
+        const headers = new Headers(options.headers);
+        if (!headers.has("content-type")) {
+            headers.set("content-type", contentTypeFor(canonicalFile));
+        }
+        headers.set("content-length", String(info.size));
+        return new Response(request.method === "HEAD" ? null : await readFile(canonicalFile), { status: 200, headers });
+    }
+    catch (error) {
+        if (options.fallthroughOnNotFound && isFileSystemNotFound(error)) {
+            return undefined;
+        }
+        return new Response("Not Found", { status: 404 });
+    }
+};
+export const writeNodeResponse = async (webResponse, response) => {
+    response.statusCode = webResponse.status;
+    setNodeHeaders(response, webResponse.headers);
+    const writable = response;
+    if (!webResponse.body || typeof writable.write !== "function") {
+        response.end(await webResponse.text());
+        return;
+    }
+    if (typeof response.flushHeaders === "function") {
+        response.flushHeaders();
+    }
+    const reader = webResponse.body.getReader();
+    let responseClosed = false;
+    let finished = false;
+    let cancelPromise;
+    const onCloseOrError = () => {
+        if (finished || response.writableEnded) {
+            return;
+        }
+        responseClosed = true;
+        cancelPromise = reader.cancel().catch(() => undefined);
+    };
+    if (typeof response.once === "function") {
+        response.once("close", onCloseOrError);
+        response.once("error", onCloseOrError);
+    }
+    try {
+        while (!responseClosed) {
+            const result = await reader.read();
+            if (responseClosed) {
+                return;
+            }
+            if (result.done) {
+                finished = true;
+                response.end();
+                return;
+            }
+            if (writable.write(Buffer.from(result.value)) === false && typeof response.once === "function") {
+                await new Promise((resolve) => {
+                    const resume = () => {
+                        response.off?.("drain", resume);
+                        response.off?.("close", resume);
+                        response.off?.("error", resume);
+                        resolve();
+                    };
+                    response.once("drain", resume);
+                    response.once("close", resume);
+                    response.once("error", resume);
+                });
+            }
+        }
+    }
+    finally {
+        if (typeof response.off === "function") {
+            response.off("close", onCloseOrError);
+            response.off("error", onCloseOrError);
+        }
+        await cancelPromise;
+    }
+};
+const requestBody = (request) => {
+    if (request.method === "GET" || request.method === "HEAD") {
+        return undefined;
+    }
+    return Readable.toWeb(request);
+};
+const firstHeaderValue = (value) => Array.isArray(value) ? value[0] : value;
+const normalizeOrigin = (origin) => {
+    const candidate = origin.includes("://") ? origin : `https://${origin}`;
+    return new URL(candidate).origin;
+};
+const hostName = (host) => host.toLowerCase().replace(/:\d+$/, "");
+const isTrustedHost = (host, trustedHosts) => {
+    if (!trustedHosts || trustedHosts.length === 0) {
+        return false;
+    }
+    const normalized = host.toLowerCase();
+    const normalizedName = hostName(normalized);
+    return trustedHosts.some((trusted) => {
+        const candidate = trusted.toLowerCase();
+        return normalized === candidate || normalizedName === candidate;
+    });
+};
+const badRequestResponse = (message) => new Response(message, { status: 400 });
+const requestUrl = (request, options = {}) => {
+    const host = firstHeaderValue(request.headers.host) ?? "localhost";
+    const hasTrustedHosts = options.trustedHosts !== undefined && options.trustedHosts.length > 0;
+    const trustedHost = isTrustedHost(host, options.trustedHosts) ? host : "localhost";
+    if (hasTrustedHosts && trustedHost === "localhost") {
+        return badRequestResponse("Untrusted Host header");
+    }
+    const protocol = options.trustProxy
+        ? (firstHeaderValue(request.headers["x-forwarded-proto"]) ?? "http").split(",")[0]?.trim() || "http"
+        : "http";
+    const origin = options.origin
+        ? normalizeOrigin(typeof options.origin === "function" ? options.origin(request) : options.origin)
+        : `${protocol}://${trustedHost}`;
+    return `${origin}${request.url ?? "/"}`;
+};
+const requestAbortSignal = (request, response) => {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort();
+        }
+    };
+    request.once("aborted", abort);
+    request.once("close", () => {
+        if (request.aborted) {
+            abort();
+        }
+    });
+    if (typeof response?.once === "function") {
+        response.once("close", () => {
+            if (!response.writableEnded) {
+                abort();
+            }
+        });
+    }
+    return controller.signal;
+};
+const webRequestFor = (request, options = {}, response) => {
+    const url = requestUrl(request, options);
+    if (url instanceof Response) {
+        return url;
+    }
+    const body = requestBody(request);
+    const init = {
+        method: request.method ?? "GET",
+        headers: request.headers,
+        signal: requestAbortSignal(request, response),
+        ...(body ? { body, duplex: "half" } : {}),
+    };
+    return new Request(url, init);
+};
+const nodeObservability = (observability) => observability ? { ...observability, adapter: observability.adapter ?? "node" } : undefined;
+export const createNodeHandler = (options) => async (request, response) => {
+    const url = requestUrl(request, options);
+    if (url instanceof Response) {
+        await writeNodeResponse(url, response);
+        return;
+    }
+    const staticRoute = findStaticRoute(options.staticRoutes, request.method ?? "GET", new URL(url));
+    if (staticRoute) {
+        writeNodeStaticRoute(staticRoute, request, response, options.securityHeaders);
+        return;
+    }
+    const webRequest = webRequestFor(request, options, response);
+    if (webRequest instanceof Response) {
+        await writeNodeResponse(webRequest, response);
+        return;
+    }
+    if (options.staticAssets) {
+        const traversal = staticAssetTraversalResponse(request.url, options.staticAssets);
+        if (traversal) {
+            await writeNodeResponse(withSecurityHeaders(traversal, options.securityHeaders), response);
+            return;
+        }
+        const asset = await createStaticAssetHandler(options.staticAssets)(webRequest);
+        if (asset) {
+            await writeNodeResponse(withSecurityHeaders(asset, options.securityHeaders), response);
+            return;
+        }
+    }
+    const webResponse = await createWorkersHandler({
+        ...options,
+        observability: nodeObservability(options.observability),
+    }).fetch(webRequest);
+    await writeNodeResponse(webResponse, response);
+};
+export const createNodeFetchHandler = (options) => {
+    const staticAssetHandler = options.staticAssets ? createStaticAssetHandler(options.staticAssets) : undefined;
+    const fetchHandler = createWorkersFetchHandler({
+        ...options,
+        observability: nodeObservability(options.observability),
+        fetch: async (request) => {
+            const asset = await staticAssetHandler?.(request);
+            return asset ?? options.fetch(request);
+        },
+    });
+    return async (request, response) => {
+        const webRequest = webRequestFor(request, options, response);
+        if (webRequest instanceof Response) {
+            await writeNodeResponse(webRequest, response);
+            return;
+        }
+        if (options.staticAssets) {
+            const traversal = staticAssetTraversalResponse(request.url, options.staticAssets);
+            if (traversal) {
+                await writeNodeResponse(withSecurityHeaders(traversal, options.securityHeaders), response);
+                return;
+            }
+        }
+        const webResponse = await fetchHandler.fetch(webRequest);
+        await writeNodeResponse(webResponse, response);
+    };
+};

package/dist/adapters/workers.d.ts

@@ -0,0 +1,149 @@
+import { type MatchedRoute, type RouteDefinition, type RouteContext, type RouteCachePolicy, type RouteEnvironment, type RouteHeadDescriptor, type RouteResource, type RouteRenderOptions } from "../router.js";
+export type WorkersAssetsBinding = {
+    fetch: (request: Request) => Response | Promise<Response>;
+};
+export type AdapterFetchHandler = (request: Request) => Response | Promise<Response>;
+export type AdapterObservabilityMetadata = Record<string, string | number | boolean | undefined>;
+export type AdapterRequestStartEvent = {
+    type: "request_start";
+    request: Request;
+    method: string;
+    path: string;
+    adapter: string;
+    runtime?: string;
+    metadata?: AdapterObservabilityMetadata;
+    startedAt: number;
+};
+export type AdapterRouteMatchedEvent = {
+    type: "route_matched";
+    request: Request;
+    method: string;
+    path: string;
+    adapter: string;
+    runtime?: string;
+    metadata?: AdapterObservabilityMetadata;
+    routeId: string;
+    routePattern: string;
+    matchedRoute: MatchedRoute;
+    startedAt: number;
+};
+export type AdapterResponseEvent = {
+    type: "response";
+    request: Request;
+    method: string;
+    path: string;
+    adapter: string;
+    runtime?: string;
+    metadata?: AdapterObservabilityMetadata;
+    status: number;
+    routeId?: string;
+    routePattern?: string;
+    failedBeforeRouteDispatch: boolean;
+    durationMs: number;
+    startedAt: number;
+};
+export type AdapterErrorEvent = {
+    type: "error";
+    request: Request;
+    method: string;
+    path: string;
+    adapter: string;
+    runtime?: string;
+    metadata?: AdapterObservabilityMetadata;
+    error: unknown;
+    routeId?: string;
+    routePattern?: string;
+    failedBeforeRouteDispatch: boolean;
+    durationMs: number;
+    startedAt: number;
+};
+export type AdapterObservabilityHooks = {
+    adapter?: string;
+    runtime?: string;
+    metadata?: AdapterObservabilityMetadata;
+    onRequestStart?: (event: AdapterRequestStartEvent) => void | Promise<void>;
+    onRouteMatched?: (event: AdapterRouteMatchedEvent) => void | Promise<void>;
+    onResponse?: (event: AdapterResponseEvent) => void | Promise<void>;
+    onError?: (event: AdapterErrorEvent) => void | Promise<void>;
+};
+export type WorkersAssetOptions<Env> = {
+    binding?: WorkersAssetsBinding;
+    bindingName?: keyof Env & string;
+    basePath?: string;
+    headers?: HeadersInit;
+    fallthroughStatuses?: readonly number[];
+};
+export type WorkersRouteContext<Env, Data = unknown, ActionResult = unknown> = Omit<RouteContext<Data, ActionResult>, "route"> & {
+    bindings: Env;
+    route: WorkersRouteDefinition<Env, Data, ActionResult>;
+};
+export type WorkersRouteDefinition<Env, Data = unknown, ActionResult = unknown> = Omit<RouteDefinition<Data, ActionResult>, "action" | "cache" | "children" | "head" | "headers" | "loader" | "render" | "resources" | "stream"> & {
+    loader?: (context: Omit<WorkersRouteContext<Env, Data, ActionResult>, "data" | "outlet">) => Data | Promise<Data>;
+    action?: (context: Omit<WorkersRouteContext<Env, Data, ActionResult>, "data" | "outlet">) => ActionResult | Promise<ActionResult>;
+    head?: (context: WorkersRouteContext<Env, Data, ActionResult>) => RouteHeadDescriptor | Promise<RouteHeadDescriptor>;
+    resources?: readonly RouteResource[] | ((context: WorkersRouteContext<Env, Data, ActionResult>) => readonly RouteResource[]);
+    headers?: HeadersInit | ((context: WorkersRouteContext<Env, Data, ActionResult>) => HeadersInit | Promise<HeadersInit>);
+    cache?: RouteCachePolicy | ((context: WorkersRouteContext<Env, Data, ActionResult>) => RouteCachePolicy | Promise<RouteCachePolicy>);
+    render: (context: WorkersRouteContext<Env, Data, ActionResult>) => string | Promise<string>;
+    stream?: (context: WorkersRouteContext<Env, Data, ActionResult>) => AsyncIterable<string>;
+    children?: WorkersRouteDefinition<Env>[];
+};
+export type WorkersRouteMiddleware<Env> = (context: {
+    request: Request;
+    url: URL;
+    env: RouteEnvironment;
+    bindings: Env;
+}) => ReturnType<NonNullable<RouteRenderOptions["middleware"]>[number]>;
+export type WorkersCsrfOptions<Env> = {
+    verify: (context: {
+        request: Request;
+        url: URL;
+        env: RouteEnvironment;
+        bindings: Env;
+    }) => boolean | Promise<boolean>;
+};
+export type WorkersHandlerOptions<Env = Record<string, unknown>> = Omit<RouteRenderOptions, "csrf" | "middleware"> & {
+    routes: readonly WorkersRouteDefinition<Env, any, any>[];
+    middleware?: readonly WorkersRouteMiddleware<Env>[];
+    csrf?: WorkersCsrfOptions<Env>;
+    securityHeaders?: Headers;
+    streaming?: boolean;
+    staticRoutes?: readonly StaticRouteDefinition[];
+    assets?: WorkersAssetOptions<Env>;
+    observability?: AdapterObservabilityHooks | undefined;
+};
+export type RouteAdapterHandlerOptions = RouteRenderOptions & {
+    routes: readonly RouteDefinition[];
+    securityHeaders?: Headers;
+    streaming?: boolean;
+    staticRoutes?: readonly StaticRouteDefinition[];
+    assets?: WorkersAssetOptions<Record<string, unknown>>;
+    observability?: AdapterObservabilityHooks | undefined;
+};
+export type WorkersFetchHandlerOptions<Env = Record<string, unknown>> = {
+    fetch: AdapterFetchHandler;
+    securityHeaders?: Headers;
+    staticRoutes?: readonly StaticRouteDefinition[];
+    assets?: WorkersAssetOptions<Env>;
+    observability?: AdapterObservabilityHooks | undefined;
+};
+export type StaticRouteDefinition = {
+    path: string;
+    body: string;
+    status?: number;
+    headers?: HeadersInit;
+    methods?: readonly string[];
+};
+export declare const defineStaticRoute: (route: StaticRouteDefinition) => StaticRouteDefinition;
+export declare const workersStreamFromChunks: (chunks: AsyncIterable<string>) => ReadableStream<Uint8Array>;
+type WorkersHandler<Env> = {
+    fetch: (request: Request, ...args: [Env] extends [never] ? [env?: undefined] : [env: Env]) => Promise<Response>;
+};
+export declare function createWorkersHandler<Env = never>(options: WorkersHandlerOptions<Env>): WorkersHandler<Env>;
+export declare function createWorkersHandler(options: RouteAdapterHandlerOptions): {
+    fetch: (request: Request, env?: unknown) => Promise<Response>;
+};
+export declare const createWorkersFetchHandler: <Env = Record<string, unknown>>(options: WorkersFetchHandlerOptions<Env>) => {
+    fetch: (request: Request, env?: Env) => Promise<Response>;
+};
+export {};