effect-start 0.23.1 → 0.26.0

package/dist/RouteSchema.js

@@ -1,188 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Schema from "effect/Schema";
-import * as Entity from "./Entity.js";
-import * as Http from "./Http.js";
-import * as PathPattern from "./PathPattern.js";
-import * as Route from "./Route.js";
-import * as RouteHook from "./RouteHook.js";
-export const RequestBodyError = (reason, cause) => ({ _tag: "RequestBodyError", reason, cause });
-export const File = Schema.TaggedStruct("File", {
-    key: Schema.String,
-    name: Schema.String,
-    contentType: Schema.String,
-    content: Schema.Uint8ArrayFromSelf,
-});
-export function schemaHeaders(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.map(decode(Http.mapHeaders(ctx.request.headers)), (parsed) => ({
-        context: {
-            headers: {
-                ...ctx.headers,
-                ...parsed,
-            },
-        },
-    })));
-}
-export function schemaCookies(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.map(decode(Http.parseCookies(ctx.request.headers.get("cookie"))), (parsed) => ({
-        context: {
-            cookies: {
-                ...ctx.cookies,
-                ...parsed,
-            },
-        },
-    })));
-}
-export function schemaSearchParams(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => {
-        const url = new URL(ctx.request.url);
-        return Effect.map(decode(Http.mapUrlSearchParams(url.searchParams)), (parsed) => ({
-            context: {
-                searchParams: {
-                    ...ctx.searchParams,
-                    ...parsed,
-                },
-            },
-        }));
-    });
-}
-export function schemaPathParams(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => {
-        const url = new URL(ctx.request.url);
-        const pattern = ctx.path ?? "/";
-        const params = PathPattern.match(pattern, url.pathname) ?? {};
-        return Effect.map(decode(params), (parsed) => ({
-            context: {
-                pathParams: {
-                    ...ctx.pathParams,
-                    ...parsed,
-                },
-            },
-        }));
-    });
-}
-export function schemaBodyJson(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.gen(function* () {
-        const json = yield* Effect.tryPromise({
-            try: () => ctx.request.json(),
-            catch: (error) => RequestBodyError("JsonError", error),
-        });
-        const parsed = yield* decode(json);
-        return {
-            context: {
-                body: {
-                    ...ctx.body,
-                    ...parsed,
-                },
-            },
-        };
-    }));
-}
-export function schemaBodyUrlParams(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.gen(function* () {
-        const text = yield* Effect.tryPromise({
-            try: () => ctx.request.text(),
-            catch: (error) => RequestBodyError("UrlParamsError", error),
-        });
-        const params = new URLSearchParams(text);
-        const parsed = yield* decode(Http.mapUrlSearchParams(params));
-        return {
-            context: {
-                body: {
-                    ...ctx.body,
-                    ...parsed,
-                },
-            },
-        };
-    }));
-}
-export function schemaBodyMultipart(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.gen(function* () {
-        const record = yield* Effect.tryPromise({
-            try: () => Http.parseFormData(ctx.request),
-            catch: (error) => RequestBodyError("MultipartError", error),
-        });
-        const parsed = yield* decode(record);
-        return {
-            context: {
-                body: {
-                    ...ctx.body,
-                    ...parsed,
-                },
-            },
-        };
-    }));
-}
-export function schemaBodyForm(fields) {
-    const decode = Schema.decodeUnknown(fields);
-    return RouteHook.filter((ctx) => Effect.gen(function* () {
-        const contentType = ctx.request.headers.get("content-type") ?? "";
-        if (contentType.includes("application/x-www-form-urlencoded")) {
-            const text = yield* Effect.tryPromise({
-                try: () => ctx.request.text(),
-                catch: (error) => RequestBodyError("UrlParamsError", error),
-            });
-            const params = new URLSearchParams(text);
-            const record = Http.mapUrlSearchParams(params);
-            const parsed = yield* decode(record);
-            return {
-                context: {
-                    body: {
-                        ...ctx.body,
-                        ...parsed,
-                    },
-                },
-            };
-        }
-        const record = yield* Effect.tryPromise({
-            try: () => Http.parseFormData(ctx.request),
-            catch: (error) => RequestBodyError("FormDataError", error),
-        });
-        const parsed = yield* decode(record);
-        return {
-            context: {
-                body: {
-                    ...ctx.body,
-                    ...parsed,
-                },
-            },
-        };
-    }));
-}
-export function schemaError(schema, options) {
-    const status = options?.status ?? schema.status;
-    if (typeof status !== "number") {
-        throw new Error("schemaError: status is required either via options or as a static property on the schema");
-    }
-    const encode = Schema.encode(schema);
-    const is = Schema.is(schema);
-    return function (self) {
-        const route = Route.make((_context, next) => Entity.resolve(next()).pipe(Effect.catchIf(is, (error) => Effect.map(Effect.orDie(encode(error)), (encoded) => Entity.make(encoded, { status })))));
-        const items = [
-            ...Route.items(self),
-            route,
-        ];
-        return Route.set(items, Route.descriptor(self));
-    };
-}
-export function schemaSuccess(schema) {
-    const encode = Schema.encodeUnknown(schema);
-    return function (self) {
-        const route = Route.make((_context, next) => Effect.flatMap(Entity.resolve(next()), (entity) => Effect.map(encode(entity.body), (encoded) => Entity.make(encoded, {
-            status: entity.status,
-            headers: entity.headers,
-            url: entity.url,
-        }))));
-        const items = [
-            ...Route.items(self),
-            route,
-        ];
-        return Route.set(items, Route.descriptor(self));
-    };
-}

package/dist/RouteSse.d.ts

@@ -1,21 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-import type * as Utils from "effect/Utils";
-import * as Entity from "./Entity.ts";
-import * as Route from "./Route.ts";
-import type * as Values from "./Values.ts";
-export interface SseEvent {
-    data?: string | undefined;
-    event?: string;
-    retry?: number;
-}
-export type SseTaggedEvent = {
-    readonly _tag: string;
-};
-export type SseEventInput = SseEvent | SseTaggedEvent;
-export type SseHandlerInput<B, E, R> = Stream.Stream<SseEventInput, E, R> | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> | ((context: Values.Simplify<B>, next: (context?: Partial<B> & Record<string, unknown>) => Entity.Entity<string>) => Stream.Stream<SseEventInput, E, R> | Effect.Effect<Stream.Stream<SseEventInput, E, R>, E, R> | Generator<Utils.YieldWrap<Effect.Effect<unknown, E, R>>, Stream.Stream<SseEventInput, E, R>, unknown>);
-export declare function sse<D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple, E = never, R = never>(handler: SseHandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & {
-    format: "text";
-}>, E, R>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{
-    format: "text";
-}, {}, Stream.Stream<string, E, R>, E, R>]>;

package/dist/RouteSse.js

@@ -1,79 +0,0 @@
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Schedule from "effect/Schedule";
-import * as Stream from "effect/Stream";
-import * as Entity from "./Entity.js";
-import * as Route from "./Route.js";
-import * as StreamExtra from "./StreamExtra.js";
-const HEARTBEAT_INTERVAL = Duration.seconds(5);
-const HEARTBEAT = ": <3\n\n";
-function isTaggedEvent(event) {
-    return Object.hasOwn(event, "_tag") && typeof event["_tag"] === "string";
-}
-function formatSseEvent(event) {
-    if (isTaggedEvent(event)) {
-        const json = JSON.stringify(event);
-        return `event: ${event._tag}\ndata: ${json}\n\n`;
-    }
-    const e = event;
-    let result = "";
-    if (e.event) {
-        result += `event: ${e.event}\n`;
-    }
-    if (typeof e.data === "string") {
-        for (const line of e.data.split("\n")) {
-            result += `data: ${line}\n`;
-        }
-    }
-    if (e.retry !== undefined) {
-        result += `retry: ${e.retry}\n`;
-    }
-    if (result === "") {
-        return "";
-    }
-    return result + "\n";
-}
-export function sse(handler) {
-    return function (self) {
-        const sseHandler = (ctx, _next) => {
-            const getStream = () => {
-                if (typeof handler === "function") {
-                    const result = handler(ctx, _next);
-                    if (StreamExtra.isStream(result)) {
-                        return Effect.succeed(result);
-                    }
-                    if (Effect.isEffect(result)) {
-                        return result;
-                    }
-                    return Effect.gen(function* () {
-                        return yield* result;
-                    });
-                }
-                if (StreamExtra.isStream(handler)) {
-                    return Effect.succeed(handler);
-                }
-                if (Effect.isEffect(handler)) {
-                    return handler;
-                }
-                return Effect.succeed(Stream.empty);
-            };
-            return Effect.map(getStream(), (eventStream) => {
-                const formattedStream = Stream.map(eventStream, formatSseEvent);
-                const heartbeat = Stream.repeat(Stream.succeed(HEARTBEAT), Schedule.spaced(HEARTBEAT_INTERVAL)).pipe(Stream.drop(1));
-                const merged = Stream.merge(formattedStream, heartbeat, {
-                    haltStrategy: "left",
-                });
-                return Entity.make(merged, {
-                    headers: {
-                        "content-type": "text/event-stream",
-                        "cache-control": "no-cache",
-                        connection: "keep-alive",
-                    },
-                });
-            });
-        };
-        const route = Route.make(sseHandler, { format: "text" });
-        const items = [...Route.items(self), route];
-        return Route.set(items, Route.descriptor(self));
-    };
-}

package/dist/RouteTree.d.ts

@@ -1,57 +0,0 @@
-import * as PathPattern from "./PathPattern.ts";
-import * as Route from "./Route.ts";
-import type * as RouteMount from "./RouteMount.ts";
-declare const TypeId: unique symbol;
-declare const RouteTreeRoutes: unique symbol;
-type MethodRoute = Route.Route.With<{
-    method: string;
-}>;
-export type RouteTuple = Iterable<MethodRoute>;
-export type LayerRoute = Iterable<Route.Route.With<{
-    method: "*";
-}>>;
-type LayerKey = "*";
-declare const LayerKey: LayerKey;
-export type InputRouteMap = {
-    [LayerKey]?: LayerRoute;
-} & {
-    [path: PathPattern.PathPattern]: RouteTuple | RouteTree;
-};
-export type RouteMap = {
-    [path: PathPattern.PathPattern]: Route.Route.Tuple;
-};
-export type Routes<T extends RouteTree> = T[typeof RouteTreeRoutes];
-export interface RouteTree<Routes extends RouteMap = RouteMap> {
-    [TypeId]: typeof TypeId;
-    [RouteTreeRoutes]: Routes;
-}
-type PrefixKeys<T, Prefix extends string> = {
-    [K in keyof T as K extends string ? `${Prefix}${K}` : never]: T[K];
-};
-type InferItems<T> = T extends Route.RouteSet.Data<any, any, infer M> ? M : [];
-type LayerItems<T extends InputRouteMap> = "*" extends keyof T ? InferItems<T["*"]> : [];
-type FlattenRouteMap<T extends InputRouteMap> = {
-    [K in Exclude<keyof T, "*"> as T[K] extends RouteTree ? never : K]: [
-        ...LayerItems<T>,
-        ...InferItems<T[K]>
-    ];
-} & UnionToIntersection<FlattenNested<T, Exclude<keyof T, "*">, LayerItems<T>>>;
-type FlattenNested<T, K, L extends Route.Route.Tuple> = K extends keyof T ? T[K] extends RouteTree<infer R> ? PrefixKeys<PrependLayers<R, L>, K & string> : {} : {};
-type PrependLayers<T extends RouteMap, L extends Route.Route.Tuple> = {
-    [K in keyof T]: T[K] extends Route.Route.Tuple ? [...L, ...T[K]] : never;
-};
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-export declare function make<const Routes extends InputRouteMap>(input: Routes): RouteTree<FlattenRouteMap<Routes>>;
-export type WalkDescriptor = {
-    path: PathPattern.PathPattern;
-    method: string;
-} & Route.RouteDescriptor.Any;
-export declare function walk(tree: RouteTree): Generator<RouteMount.MountedRoute>;
-export declare function merge(a: RouteTree, b: RouteTree): RouteTree;
-export declare function isRouteTree(input: unknown): input is RouteTree;
-export interface LookupResult {
-    route: RouteMount.MountedRoute;
-    params: Record<string, string>;
-}
-export declare function lookup(tree: RouteTree, method: string, path: string): LookupResult | null;
-export {};

package/dist/RouteTree.js

@@ -1,93 +0,0 @@
-import * as Predicate from "effect/Predicate";
-import * as PathPattern from "./PathPattern.js";
-import * as Route from "./Route.js";
-const TypeId = Symbol.for("effect-start/RouteTree");
-const RouteTreeRoutes = Symbol();
-const LayerKey = "*";
-function routes(tree) {
-    return tree[RouteTreeRoutes];
-}
-// segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
-function sortScore(path) {
-    const segments = path.split("/");
-    const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"));
-    const maxPriority = Math.max(...segments.map((s) => !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1), 0);
-    return greedyIdx === -1
-        ? // non-greedy: sort by depth, then by max segment priority
-            (segments.length << 16) + (maxPriority << 8)
-        : // greedy: sort after non-greedy, by greedy position (later = first), then priority
-            (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8);
-}
-function sortRoutes(input) {
-    const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b));
-    const sorted = {};
-    for (const key of keys) {
-        sorted[key] = input[key];
-    }
-    return sorted;
-}
-export function make(input) {
-    const layerRoutes = [...(input[LayerKey] ?? [])];
-    const merged = {};
-    function flatten(map, prefix, layers) {
-        for (const key of Object.keys(map)) {
-            if (key === LayerKey)
-                continue;
-            const path = key;
-            const entry = map[path];
-            const fullPath = `${prefix}${path}`;
-            if (isRouteTree(entry)) {
-                flatten(routes(entry), fullPath, layers);
-            }
-            else {
-                merged[fullPath] = [...layers, ...entry];
-            }
-        }
-    }
-    flatten(input, "", layerRoutes);
-    return {
-        [TypeId]: TypeId,
-        [RouteTreeRoutes]: sortRoutes(merged),
-    };
-}
-function* flattenRoutes(path, routes) {
-    for (const route of routes) {
-        const descriptor = {
-            ...route[Route.RouteDescriptor],
-            path,
-        };
-        yield Route.make(route.handler, descriptor);
-    }
-}
-export function* walk(tree) {
-    const _routes = routes(tree);
-    for (const path of Object.keys(_routes)) {
-        yield* flattenRoutes(path, _routes[path]);
-    }
-}
-export function merge(a, b) {
-    const combined = { ...routes(a) };
-    for (const [path, items] of Object.entries(routes(b))) {
-        const key = path;
-        combined[key] = combined[key] ? [...combined[key], ...items] : items;
-    }
-    return {
-        [TypeId]: TypeId,
-        [RouteTreeRoutes]: sortRoutes(combined),
-    };
-}
-export function isRouteTree(input) {
-    return Predicate.hasProperty(input, TypeId);
-}
-export function lookup(tree, method, path) {
-    for (const route of walk(tree)) {
-        const descriptor = Route.descriptor(route);
-        if (descriptor.method !== "*" && descriptor.method !== method)
-            continue;
-        const params = PathPattern.match(descriptor.path, path);
-        if (params !== null) {
-            return { route, params };
-        }
-    }
-    return null;
-}

package/dist/RouteTrie.d.ts

@@ -1,20 +0,0 @@
-import * as Route from "./Route.ts";
-export interface Node {
-    children: Record<string, Node>;
-    paramChild: Node | null;
-    paramName: string | null;
-    requiredWildcardChild: Node | null;
-    requiredWildcardName: string | null;
-    optionalWildcardChild: Node | null;
-    optionalWildcardName: string | null;
-    routes: Array<Route.Route.Route>;
-}
-export interface RouteTrie {
-    readonly methods: Record<string, Node>;
-}
-export interface LookupResult {
-    route: Route.Route.Route;
-    params: Record<string, string>;
-}
-export declare function make(set: Route.RouteSet.Any): RouteTrie;
-export declare function lookup(trie: RouteTrie, method: string, path: string): Array<LookupResult>;

package/dist/RouteTrie.js

@@ -1,152 +0,0 @@
-import * as PathPattern from "./PathPattern.js";
-import * as Route from "./Route.js";
-function createNode() {
-    return {
-        children: {},
-        paramChild: null,
-        paramName: null,
-        requiredWildcardChild: null,
-        requiredWildcardName: null,
-        optionalWildcardChild: null,
-        optionalWildcardName: null,
-        routes: [],
-    };
-}
-function insertRoute(node, segments, route) {
-    if (segments.length === 0) {
-        node.routes.push(route);
-        return;
-    }
-    const segment = segments[0];
-    const rest = segments.slice(1);
-    if (segment.startsWith(":")) {
-        const name = segment.slice(1);
-        if (name.endsWith("+")) {
-            if (!node.requiredWildcardChild) {
-                node.requiredWildcardChild = createNode();
-            }
-            node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1);
-            node.requiredWildcardChild.routes.push(route);
-        }
-        else if (name.endsWith("*")) {
-            if (!node.optionalWildcardChild) {
-                node.optionalWildcardChild = createNode();
-            }
-            node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1);
-            node.optionalWildcardChild.routes.push(route);
-        }
-        else if (name.endsWith("?")) {
-            if (!node.paramChild) {
-                node.paramChild = createNode();
-            }
-            node.paramChild.paramName = name.slice(0, -1);
-            insertRoute(node.paramChild, rest, route);
-            insertRoute(node, rest, route);
-        }
-        else {
-            if (!node.paramChild) {
-                node.paramChild = createNode();
-            }
-            node.paramChild.paramName = name;
-            insertRoute(node.paramChild, rest, route);
-        }
-    }
-    else {
-        if (!node.children[segment]) {
-            node.children[segment] = createNode();
-        }
-        insertRoute(node.children[segment], rest, route);
-    }
-}
-function collectRoutes(items, parentPath, parentMethod) {
-    const results = [];
-    for (const item of items) {
-        const desc = Route.descriptor(item);
-        const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath;
-        const currentMethod = desc?.method ?? parentMethod;
-        if (Route.isRoute(item)) {
-            if (currentPath !== "") {
-                results.push({
-                    route: item,
-                    method: currentMethod,
-                    path: currentPath,
-                });
-            }
-        }
-        else {
-            const nestedItems = Route.items(item);
-            results.push(...collectRoutes(nestedItems, currentPath, currentMethod));
-        }
-    }
-    return results;
-}
-export function make(set) {
-    const methods = {};
-    const collected = collectRoutes(Route.items(set), "", "*");
-    for (const { route, method, path } of collected) {
-        if (!methods[method]) {
-            methods[method] = createNode();
-        }
-        const result = PathPattern.validate(path);
-        if (!result.ok) {
-            throw new Error(result.error);
-        }
-        insertRoute(methods[method], result.segments, route);
-    }
-    return { methods };
-}
-function lookupNode(node, segments, params) {
-    const results = [];
-    if (segments.length === 0) {
-        for (const route of node.routes) {
-            results.push({ route, params });
-        }
-        if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-            for (const route of node.optionalWildcardChild.routes) {
-                results.push({ route, params });
-            }
-        }
-        return results;
-    }
-    const segment = segments[0];
-    const rest = segments.slice(1);
-    if (node.children[segment]) {
-        results.push(...lookupNode(node.children[segment], rest, params));
-    }
-    if (node.paramChild && node.paramChild.paramName) {
-        const newParams = { ...params, [node.paramChild.paramName]: segment };
-        results.push(...lookupNode(node.paramChild, rest, newParams));
-    }
-    if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
-        const wildcardValue = segments.join("/");
-        const newParams = {
-            ...params,
-            [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
-        };
-        for (const route of node.requiredWildcardChild.routes) {
-            results.push({ route, params: newParams });
-        }
-    }
-    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-        const wildcardValue = segments.join("/");
-        const newParams = {
-            ...params,
-            [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
-        };
-        for (const route of node.optionalWildcardChild.routes) {
-            results.push({ route, params: newParams });
-        }
-    }
-    return results;
-}
-export function lookup(trie, method, path) {
-    const segments = path.split("/").filter(Boolean);
-    const results = [];
-    if (trie.methods[method]) {
-        results.push(...lookupNode(trie.methods[method], segments, {}));
-    }
-    if (method !== "*" && trie.methods["*"]) {
-        results.push(...lookupNode(trie.methods["*"], segments, {}));
-    }
-    return results;
-}