effect-start 0.17.0 → 0.17.2

package/dist/RouteMount.js

@@ -0,0 +1,77 @@
+import * as Function from "effect/Function";
+import * as Route from "./Route.js";
+const RouteSetTypeId = Symbol.for("effect-start/RouteSet");
+export const use = makeMethodDescriber("*");
+export const get = makeMethodDescriber("GET");
+export const post = makeMethodDescriber("POST");
+export const put = makeMethodDescriber("PUT");
+export const del = makeMethodDescriber("DELETE");
+export const patch = makeMethodDescriber("PATCH");
+export const head = makeMethodDescriber("HEAD");
+export const options = makeMethodDescriber("OPTIONS");
+export const add = function (path, routes) {
+    const baseItems = Route.isRouteSet(this)
+        ? Route.items(this)
+        : [];
+    const routeSet = typeof routes === "function"
+        ? routes(make([]))
+        : routes;
+    const routeItems = Route.items(routeSet);
+    const newItems = routeItems.map((item) => {
+        const itemDescriptor = Route.descriptor(item);
+        const concatenatedPath = typeof itemDescriptor?.path === "string"
+            ? path + itemDescriptor.path
+            : path;
+        const newDescriptor = { ...itemDescriptor, path: concatenatedPath };
+        return Route.isRoute(item)
+            ? Route.make(item.handler, newDescriptor)
+            : Route.set(Route.items(item), newDescriptor);
+    });
+    return make([
+        ...baseItems,
+        ...newItems,
+    ]);
+};
+const Proto = Object.assign(Object.create(null), {
+    [RouteSetTypeId]: RouteSetTypeId,
+    *[Symbol.iterator]() {
+        yield* Route.items(this);
+    },
+    use,
+    get,
+    post,
+    put,
+    del,
+    patch,
+    head,
+    options,
+    add,
+});
+function make(items) {
+    return Object.assign(Object.create(Proto), {
+        [Route.RouteItems]: items,
+        [Route.RouteDescriptor]: {},
+    });
+}
+function makeMethodDescriber(method) {
+    function describeMethod(...fs) {
+        const baseItems = Route.isRouteSet(this)
+            ? Route.items(this)
+            : [];
+        const methodSet = Route.set([], { method });
+        const f = Function.flow(...fs);
+        const result = f(methodSet);
+        const resultItems = Route.items(result);
+        // Items are already flat (only Routes), just merge method into each descriptor
+        const flattenedItems = resultItems.map((item) => {
+            const itemDescriptor = Route.descriptor(item);
+            const newDescriptor = { method, ...itemDescriptor };
+            return Route.make(item.handler, newDescriptor);
+        });
+        return make([
+            ...baseItems,
+            ...flattenedItems,
+        ]);
+    }
+    return describeMethod;
+}

package/dist/RouteSchema.d.ts

@@ -0,0 +1,65 @@
+import * as ParseResult from "effect/ParseResult";
+import * as Schema from "effect/Schema";
+import type * as Scope from "effect/Scope";
+import * as Http from "./Http.ts";
+import * as Route from "./Route.ts";
+export interface RequestBodyError {
+    readonly _tag: "RequestBodyError";
+    readonly reason: "JsonError" | "UrlParamsError" | "MultipartError" | "FormDataError";
+    readonly cause: unknown;
+}
+export declare const RequestBodyError: (reason: RequestBodyError["reason"], cause: unknown) => RequestBodyError;
+export declare const File: Schema.TaggedStruct<"File", {
+    key: typeof Schema.String;
+    name: typeof Schema.String;
+    contentType: typeof Schema.String;
+    content: typeof Schema.Uint8ArrayFromSelf;
+}>;
+export declare function schemaHeaders<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        headers: A;
+    }, unknown, ParseResult.ParseError, R>
+]>;
+export declare function schemaCookies<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        cookies: A;
+    }, unknown, ParseResult.ParseError, R>
+]>;
+export declare function schemaSearchParams<A, I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        searchParams: A;
+    }, unknown, ParseResult.ParseError, R>
+]>;
+export declare function schemaPathParams<A, I extends Readonly<Record<string, string | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        pathParams: A;
+    }, unknown, ParseResult.ParseError, R>
+]>;
+export declare function schemaBodyJson<A, I, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        body: A;
+    }, unknown, RequestBodyError | ParseResult.ParseError, R>
+]>;
+export declare function schemaBodyUrlParams<A, I extends Readonly<Record<string, string | ReadonlyArray<string> | undefined>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        body: A;
+    }, unknown, RequestBodyError | ParseResult.ParseError, R>
+]>;
+export declare function schemaBodyMultipart<A, I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        body: A;
+    }, unknown, RequestBodyError | ParseResult.ParseError, R | Scope.Scope>
+]>;
+export declare function schemaBodyForm<A, I extends Partial<Record<string, ReadonlyArray<Http.FilePart> | ReadonlyArray<string> | string>>, R>(fields: Schema.Schema<A, I, R>): <D extends Route.RouteDescriptor.Any, SB extends {}, P extends Route.Route.Tuple>(self: Route.RouteSet.RouteSet<D, SB, P>) => Route.RouteSet.RouteSet<D, SB, [
+    ...P,
+    Route.Route.Route<{}, {
+        body: A;
+    }, unknown, RequestBodyError | ParseResult.ParseError, R | Scope.Scope>
+]>;

package/dist/RouteSchema.js

@@ -0,0 +1,155 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Http from "./Http.js";
+import * as PathPattern from "./PathPattern.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,
+                },
+            },
+        };
+    }));
+}

package/dist/RouteSse.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,56 @@
+import * as PathPattern from "./PathPattern.ts";
+import * as Route from "./Route.ts";
+import * 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 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

@@ -0,0 +1,91 @@
+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 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

@@ -0,0 +1,20 @@
+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: 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): LookupResult[];