effect-start 0.17.0 → 0.17.2

package/dist/FileRouterPattern.js

@@ -0,0 +1,35 @@
+import * as RouterPattern from "./RouterPattern.js";
+export function parse(pattern) {
+    const trimmedPath = pattern.replace(/(^\/)|(\/$)/g, "");
+    if (trimmedPath === "") {
+        return [];
+    }
+    const segmentStrings = trimmedPath
+        .split("/")
+        .filter(s => s !== "");
+    if (segmentStrings.length === 0) {
+        return [];
+    }
+    const segments = segmentStrings.map((s) => {
+        // (group) - Groups (FileRouter-specific)
+        const groupMatch = s.match(/^\((\w+)\)$/);
+        if (groupMatch) {
+            return { _tag: "GroupSegment", name: groupMatch[1] };
+        }
+        // Delegate to RouterPattern for all other segment types
+        return RouterPattern.parseSegment(s);
+    });
+    if (segments.some((seg) => seg === null)) {
+        throw new Error(`Invalid path segment in "${pattern}": contains invalid characters or format`);
+    }
+    return segments;
+}
+export function formatSegment(seg) {
+    if (seg._tag === "GroupSegment")
+        return `(${seg.name})`;
+    return RouterPattern.formatSegment(seg);
+}
+export function format(segments) {
+    const joined = segments.map(formatSegment).join("/");
+    return (joined ? `/${joined}` : "/");
+}

package/dist/Http.d.ts

@@ -0,0 +1,37 @@
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+type Respondable = Response | Promise<Response>;
+export type WebHandler = (request: Request) => Respondable;
+export type WebMiddleware = (request: Request, next: WebHandler) => Respondable;
+export declare function fetch(handler: WebHandler, init: Omit<RequestInit, "body"> & ({
+    url: string;
+} | {
+    path: `/${string}`;
+}) & {
+    body?: RequestInit["body"] | Record<string, unknown>;
+}): Promise<Response>;
+export declare function createAbortableRequest(init: Omit<RequestInit, "signal"> & ({
+    url: string;
+} | {
+    path: `/${string}`;
+})): {
+    request: Request;
+    abort: () => void;
+};
+export declare function mapHeaders(headers: Headers): Record<string, string | undefined>;
+export declare function parseCookies(cookieHeader: string | null): Record<string, string | undefined>;
+export declare function mapUrlSearchParams(params: URLSearchParams): Record<string, string | ReadonlyArray<string> | undefined>;
+export interface FilePart {
+    readonly _tag: "File";
+    readonly key: string;
+    readonly name: string;
+    readonly contentType: string;
+    readonly content: Uint8Array;
+}
+export interface FieldPart {
+    readonly _tag: "Field";
+    readonly key: string;
+    readonly value: string;
+}
+export type MultipartPart = FilePart | FieldPart;
+export declare function parseFormData(request: Request): Promise<Record<string, ReadonlyArray<FilePart> | ReadonlyArray<string> | string>>;
+export {};

package/dist/Http.js

@@ -0,0 +1,92 @@
+import * as Values from "./Values.js";
+export function fetch(handler, init) {
+    const url = "path" in init
+        ? `http://localhost${init.path}`
+        : init.url;
+    const isPlain = Values.isPlainObject(init.body);
+    const headers = new Headers(init.headers);
+    if (isPlain && !headers.has("Content-Type")) {
+        headers.set("Content-Type", "application/json");
+    }
+    const body = isPlain ? JSON.stringify(init.body) : init.body;
+    const request = new Request(url, {
+        ...init,
+        headers,
+        body: body,
+    });
+    return Promise.resolve(handler(request));
+}
+export function createAbortableRequest(init) {
+    const url = "path" in init
+        ? `http://localhost${init.path}`
+        : init.url;
+    const controller = new AbortController();
+    const request = new Request(url, { ...init, signal: controller.signal });
+    return { request, abort: () => controller.abort() };
+}
+export function mapHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key.toLowerCase()] = value;
+    });
+    return result;
+}
+export function parseCookies(cookieHeader) {
+    if (!cookieHeader)
+        return {};
+    const result = {};
+    for (const part of cookieHeader.split(";")) {
+        const idx = part.indexOf("=");
+        if (idx === -1) {
+            // Cookie without value (e.g., "name" or just whitespace)
+            const key = part.trim();
+            if (key) {
+                result[key] = undefined;
+            }
+        }
+        else {
+            const key = part.slice(0, idx).trim();
+            const value = part.slice(idx + 1).trim();
+            if (key) {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+export function mapUrlSearchParams(params) {
+    const result = {};
+    for (const key of new Set(params.keys())) {
+        const values = params.getAll(key);
+        result[key] = values.length === 1 ? values[0] : values;
+    }
+    return result;
+}
+export async function parseFormData(request) {
+    const formData = await request.formData();
+    const result = {};
+    for (const key of new Set(formData.keys())) {
+        const values = formData.getAll(key);
+        const first = values[0];
+        if (typeof first === "string") {
+            result[key] = values.length === 1 ? first : values;
+        }
+        else {
+            const files = [];
+            for (const value of values) {
+                if (typeof value !== "string") {
+                    const content = new Uint8Array(await value.arrayBuffer());
+                    files.push({
+                        _tag: "File",
+                        key,
+                        name: value.name,
+                        contentType: value.type || "application/octet-stream",
+                        content,
+                    });
+                }
+            }
+            result[key] = files;
+        }
+    }
+    return result;
+}

package/dist/HttpAppExtra.d.ts

@@ -0,0 +1,7 @@
+import { HttpServerRequest, HttpServerResponse } from "@effect/platform";
+import * as HttpApp from "@effect/platform/HttpApp";
+import { RouteNotFound } from "@effect/platform/HttpServerError";
+import { Effect } from "effect";
+export declare const renderError: (error: unknown, accept?: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest>;
+export declare function handleErrors<E, R>(app: HttpApp.Default<E, R>): HttpApp.Default<Exclude<E, RouteNotFound>, R | HttpServerRequest.HttpServerRequest>;
+export declare const withErrorHandled: <E, R>(app: HttpApp.Default<E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest | R>;

package/dist/HttpAppExtra.js

@@ -0,0 +1,320 @@
+import { HttpServerRequest, HttpServerResponse, } from "@effect/platform";
+import * as HttpMiddleware from "@effect/platform/HttpMiddleware";
+import { Cause, Effect, Option, ParseResult, Record, } from "effect";
+/**
+ * Groups: function, path
+ */
+const StackLinePattern = /^at (.*?) \((.*?)\)/;
+const ERROR_PAGE_CSS = `
+  :root {
+    --error-red: #c00;
+    --error-red-dark: #a00;
+    --bg-error: #fee;
+    --bg-light: #f5f5f5;
+    --bg-white: #fff;
+    --border-color: #ddd;
+    --text-dark: #333;
+    --text-gray: #666;
+    --text-mono: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+  }
+
+  * { box-sizing: border-box; }
+
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+    color: var(--text-dark);
+    line-height: 1.6;
+    min-height: 100dvh;
+  }
+
+  .error-page { width: 100%; margin: 0; }
+
+  .error-header {
+    background: var(--error-red);
+    color: white;
+    padding: 2rem 2.5rem;
+    margin: 0;
+    font-family: var(--text-mono);
+  }
+
+  .error-header h1 {
+    margin: 0 0 0.5rem 0;
+    font-size: 2rem;
+    font-weight: 600;
+    font-family: var(--text-mono);
+  }
+
+  .error-message {
+    margin: 0;
+    font-size: 1.1rem;
+    opacity: 0.95;
+    font-family: var(--text-mono);
+  }
+
+  .error-content {
+    background: var(--bg-white);
+    padding: 2rem 2.5rem;
+  }
+
+  .stack-trace {
+    margin: 1.5rem 0;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    overflow: hidden;
+  }
+
+  .stack-trace-header {
+    font-weight: 600;
+    padding: 0.75rem 1rem;
+    background: var(--bg-light);
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .stack-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    max-height: 400px;
+    overflow-y: auto;
+  }
+
+  .stack-list li {
+    padding: 0.5rem 1rem;
+    font-family: var(--text-mono);
+    font-size: 0.875rem;
+    border-bottom: 1px solid var(--border-color);
+    background: var(--bg-white);
+  }
+
+  .stack-list li:last-child { border-bottom: none; }
+
+  .stack-list li:hover { background: #fafafa; }
+
+  .stack-list code {
+    background: transparent;
+    padding: 0;
+    font-weight: 600;
+    color: var(--error-red-dark);
+  }
+
+  .stack-list .path { color: var(--text-gray); margin-left: 0.5rem; }
+
+  .request-info {
+    margin: 1.5rem 0;
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    overflow: hidden;
+  }
+
+  .request-info-header {
+    font-weight: 700;
+    padding: 0.75rem 1rem;
+    background: var(--bg-light);
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .request-info-content {
+    padding: 1rem;
+    font-family: var(--text-mono);
+    font-size: 0.875rem;
+    white-space: pre-wrap;
+    word-break: break-all;
+  }
+
+  @media (max-width: 768px) {
+    .error-header, .error-content { padding: 1.5rem 1rem; }
+    .error-header h1 { font-size: 1.5rem; }
+  }
+`;
+function errorHtml(data) {
+    let detailsHtml = "";
+    if (data.details) {
+        const detailsObj = data.details;
+        if ("stack" in detailsObj && Array.isArray(detailsObj.stack)) {
+            const stackFrames = detailsObj.stack;
+            detailsHtml = renderStackTrace(stackFrames);
+        }
+    }
+    const requestHtml = data.requestContext
+        ? renderRequestContext(data.requestContext)
+        : "";
+    const messageHtml = data.message
+        ? `<p class="error-message">${escapeHtml(data.message)}</p>`
+        : "";
+    const headerTitle = data.errorName ?? "UnexpectedError";
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${headerTitle} - Error ${data.status}</title>
+  <style>${ERROR_PAGE_CSS}</style>
+</head>
+<body>
+  <div class="error-header">
+    <h1>${escapeHtml(headerTitle)}</h1>
+    ${messageHtml}
+  </div>
+  <div class="error-content">
+    ${detailsHtml}
+    ${requestHtml}
+  </div>
+</body>
+</html>`;
+    return HttpServerResponse.text(html, {
+        status: data.status,
+        contentType: "text/html",
+    });
+}
+function errorText(status, tag, details) {
+    const text = details ? `${tag}\n${JSON.stringify(details, null, 2)}` : tag;
+    return HttpServerResponse.text(text, { status });
+}
+function respondWithError(accept, status, tag, message, details, requestContext, errorName) {
+    if (accept.includes("text/html")) {
+        return errorHtml({
+            status,
+            tag,
+            message,
+            details,
+            requestContext,
+            errorName,
+        });
+    }
+    if (accept.includes("text/plain")) {
+        return errorText(status, tag, details);
+    }
+    return HttpServerResponse.unsafeJson({ error: { _tag: tag, ...details } }, { status });
+}
+export const renderError = (error, accept = "") => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const requestContext = {
+        url: request.url,
+        method: request.method,
+        headers: filterSensitiveHeaders(request.headers),
+    };
+    let unwrappedError;
+    if (Cause.isCause(error)) {
+        const failure = Cause.failureOption(error).pipe(Option.getOrUndefined);
+        if (failure?.["_tag"]) {
+            unwrappedError = failure;
+        }
+        yield* Effect.logError(error);
+    }
+    switch (unwrappedError?._tag) {
+        case "RouteNotFound":
+            return respondWithError(accept, 404, "RouteNotFound", "The page you were looking for doesn't exist", undefined, requestContext);
+        case "RequestError": {
+            const message = unwrappedError.reason === "Decode"
+                ? "Request body is invalid"
+                : "Request could not be processed";
+            return respondWithError(accept, 400, "RequestError", message, {
+                reason: unwrappedError.reason,
+            }, requestContext);
+        }
+        case "ParseError": {
+            const issues = yield* ParseResult.ArrayFormatter.formatIssue(unwrappedError.issue);
+            const cleanIssues = issues.map((v) => Record.remove(v, "_tag"));
+            return respondWithError(accept, 400, "ParseError", "Validation failed", {
+                issues: cleanIssues,
+            }, requestContext);
+        }
+    }
+    if (Cause.isCause(error)) {
+        const defects = [...Cause.defects(error)];
+        const defect = defects[0];
+        if (defect instanceof Error) {
+            const stackFrames = extractPrettyStack(defect.stack ?? "");
+            return respondWithError(accept, 500, "UnexpectedError", defect.message, {
+                name: defect.name,
+                stack: stackFrames,
+            }, requestContext, defect.name);
+        }
+    }
+    return respondWithError(accept, 500, "UnexpectedError", "An unexpected error occurred", undefined, requestContext, "UnexpectedError");
+});
+function parseStackFrame(line) {
+    const match = line.trim().match(StackLinePattern);
+    if (!match)
+        return null;
+    const [_, fn, fullPath] = match;
+    const relativePath = fullPath.replace(process.cwd(), ".");
+    let type;
+    if (relativePath.includes("node_modules")) {
+        type = "node_modules";
+    }
+    else if (relativePath.startsWith("./src")
+        || relativePath.startsWith("./examples")) {
+        type = "application";
+    }
+    else {
+        type = "framework";
+    }
+    return {
+        function: fn,
+        file: relativePath,
+        type,
+    };
+}
+function extractPrettyStack(stack) {
+    return stack
+        .split("\n")
+        .slice(1)
+        .map(parseStackFrame)
+        .filter((frame) => frame !== null);
+}
+function renderStackFrames(frames) {
+    if (frames.length === 0) {
+        return "<li>No stack frames</li>";
+    }
+    return frames
+        .map((f) => `<li><code>${f.function}</code> at <span class="path">${f.file}</span></li>`)
+        .join("");
+}
+function renderStackTrace(frames) {
+    return `
+    <div class="stack-trace">
+      <div class="stack-trace-header">Stack Trace (${frames.length})</div>
+      <ul class="stack-list">${renderStackFrames(frames)}</ul>
+    </div>
+  `;
+}
+function escapeHtml(unsafe) {
+    return unsafe
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+function filterSensitiveHeaders(headers) {
+    const sensitive = ["authorization", "cookie", "x-api-key"];
+    return Object.fromEntries(Object.entries(headers).filter(([key]) => !sensitive.includes(key.toLowerCase())));
+}
+function renderRequestContext(context) {
+    const headersText = Object
+        .entries(context.headers)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join("\n");
+    const requestText = `${context.method} ${context.url}\n${headersText}`;
+    return `
+    <div class="request-info">
+      <div class="request-info-header">Request</div>
+      <div class="request-info-content">${escapeHtml(requestText)}</div>
+    </div>
+  `;
+}
+export function handleErrors(app) {
+    return Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const accept = request.headers.accept ?? "";
+        return yield* app.pipe(Effect.catchAllCause((cause) => renderError(cause, accept)));
+    });
+}
+export const withErrorHandled = HttpMiddleware.make(app => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const accept = request.headers.accept ?? "";
+    return yield* app.pipe(Effect.catchAllCause((cause) => renderError(cause, accept)));
+}));

package/dist/HttpUtils.d.ts

@@ -0,0 +1,3 @@
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+export type FetchHandler = (request: Request) => Promise<Response>;
+export declare function makeUrlFromRequest(request: HttpServerRequest.HttpServerRequest): URL;

package/dist/HttpUtils.js

@@ -0,0 +1,11 @@
+export function makeUrlFromRequest(request) {
+    const origin = request.headers.origin
+        ?? request.headers.host
+        ?? "http://localhost";
+    const protocol = request.headers["x-forwarded-proto"] ?? "http";
+    const host = request.headers.host ?? "localhost";
+    const base = origin.startsWith("http")
+        ? origin
+        : `${protocol}://${host}`;
+    return new URL(request.url, base);
+}

package/dist/PathPattern.d.ts

@@ -0,0 +1,134 @@
+export type PathPattern = `/${string}`;
+export type Segments<Path extends string> = Path extends `/${infer Rest}` ? Segments<Rest> : Path extends `${infer Head}/${infer Tail}` ? [Head, ...Segments<Tail>] : Path extends "" ? [] : [Path];
+export type Params<T extends string> = string extends T ? Record<string, string> : T extends `${infer _Start}:${infer Param}?/${infer Rest}` ? {
+    [K in Param]?: string;
+} & Params<`/${Rest}`> : T extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param]: string;
+} & Params<`/${Rest}`> : T extends `${infer _Start}:${infer Param}+` ? {
+    [K in Param]: string;
+} : T extends `${infer _Start}:${infer Param}*` ? {
+    [K in Param]?: string;
+} : T extends `${infer _Start}:${infer Param}?` ? {
+    [K in Param]?: string;
+} : T extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : {};
+export type ValidateResult = {
+    ok: true;
+    segments: string[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function validate(path: string): ValidateResult;
+export declare function match(pattern: string, path: string): Record<string, string> | null;
+export declare function toRegex(path: string): RegExp;
+/**
+ * Converts to Express path pattern.
+ *
+ * @see https://expressjs.com/en/guide/routing.html
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `{/:param}`
+ * - `:param+` → `/*param`
+ * - `:param*` → `/`, `/*param`
+ */
+export declare function toExpress(path: string): string[];
+/**
+ * Converts to URLPattern path pattern.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/URL_Pattern_API
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `:param+`
+ * - `:param*` → `:param*`
+ */
+export declare function toURLPattern(path: string): string[];
+/**
+ * Converts to React Router path pattern.
+ *
+ * @see https://reactrouter.com/start/framework/routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (splat, required)
+ * - `:param*` → `/`, `/*` (splat, optional - two routes)
+ */
+export declare function toReactRouter(path: string): string[];
+/**
+ * Alias for toReactRouter.
+ *
+ * @see https://reactrouter.com/start/framework/routing
+ */
+export declare const toRemix: typeof toReactRouter;
+/**
+ * Converts to Remix file-based route naming convention.
+ *
+ * Returns a file path segment (without extension) for Remix's
+ * flat file routing convention.
+ *
+ * @see https://remix.run/docs/file-conventions/routes
+ *
+ * - `:param` → `$param`
+ * - `:param?` → `($param)`
+ * - `:param+` → `$` (splat)
+ * - `:param*` → `($)` (optional splat) - Note: not officially supported
+ */
+export declare function toRemixFile(path: string): string;
+/**
+ * Converts to TanStack Router path/file pattern.
+ *
+ * TanStack uses the same `$param` syntax for both route paths and file names.
+ * Returns a dot-separated file name (without extension).
+ *
+ * @see https://tanstack.com/router/v1/docs/framework/react/guide/path-params
+ * @see https://tanstack.com/router/v1/docs/framework/react/routing/file-naming-conventions
+ *
+ * - `:param` → `$param`
+ * - `:param?` → `{-$param}` (optional segment)
+ * - `:param+` → `$` (splat)
+ * - `:param*` → `$` (splat, optional not supported - treated as required)
+ */
+export declare function toTanStack(path: string): string;
+/**
+ * Converts to Hono path pattern.
+ *
+ * Hono uses unnamed wildcards - they are NOT accessible via c.req.param().
+ * Use c.req.path to access the matched path for wildcard routes.
+ *
+ * @see https://hono.dev/docs/api/routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (unnamed, required)
+ * - `:param*` → `/`, `/*` (unnamed, optional - two routes)
+ */
+export declare function toHono(path: string): string[];
+/**
+ * Converts to Effect HttpRouter / find-my-way path pattern.
+ *
+ * Effect uses colon-style params with unnamed wildcards.
+ *
+ * @see https://effect.website/docs/platform/http-router
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `:param?`
+ * - `:param+` → `*` (unnamed)
+ * - `:param*` → `/`, `/*` (two routes)
+ */
+export declare function toEffect(path: string): string[];
+/**
+ * Converts to Bun.serve path pattern.
+ *
+ * Since Bun doesn't support optional params (`:param?`), optional segments
+ * are expanded into multiple routes.
+ *
+ * @see https://bun.sh/docs/api/http#routing
+ *
+ * - `:param` → `:param`
+ * - `:param?` → `/`, `/:param` (two routes)
+ * - `:param+` → `/*`
+ * - `:param*` → `/`, `/*` (two routes)
+ */
+export declare function toBun(path: string): PathPattern[];