effect-start 0.33.0 → 0.35.0

package/src/RouteMount.ts

@@ -7,10 +7,7 @@ import type * as RouteBody from "./RouteBody.ts"
 
 const RouteSetTypeId = "~effect-start/RouteSet" as const
 
-// oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
-type Module = typeof import("./RouteMount.ts")
-
-export type Self = RouteMount.Builder | Module
+export type Self = RouteMount.Builder<any, any> | typeof import("./RouteMount.ts")
 
 export const use = makeMethodDescriber("*")
 export const get = makeMethodDescriber("GET")
@@ -65,7 +62,7 @@ function makeMethodDescriber<M extends RouteMount.Method>(method: M): RouteMount
       const itemDescriptor = Route.descriptor(item)
       const newDescriptor = { method, ...itemDescriptor }
       return Route.make(
-        (item as Route.Route.Route).handler as Route.Route.Handler<any, any, any, any>,
+        (item as Route.Route).handler as Route.Route.Handler<any, any, any, any>,
         newDescriptor,
       )
     })
@@ -75,7 +72,7 @@ function makeMethodDescriber<M extends RouteMount.Method>(method: M): RouteMount
   return describeMethod as RouteMount.Describer<M>
 }
 
-export type MountedRoute = Route.Route.Route<
+export type MountedRoute = Route.Route<
   {
     method: RouteMount.Method
     path: PathPattern.PathPattern
@@ -90,22 +87,43 @@ export type MountedRoute = Route.Route.Route<
 export namespace RouteMount {
   export type Method = "*" | Http.Method
 
-  export type MountSet = Route.RouteSet.RouteSet<{ method: Method }, {}, Route.Route.Tuple>
+  export type MountSet = Route.RouteSet<{ method: Method }, {}, Route.Route.Tuple>
+
+  export type Builder<D extends {} = {}, I extends Route.Route.Tuple = []> = Route.RouteSet<
+    D,
+    {},
+    I
+  > &
+    (HasMethod<I> extends true ? {} : { use: Describer<"*"> }) & {
+      get: Describer<"GET">
+      post: Describer<"POST">
+      put: Describer<"PUT">
+      del: Describer<"DELETE">
+      patch: Describer<"PATCH">
+      head: Describer<"HEAD">
+      options: Describer<"OPTIONS">
+    }
 
-  export interface Builder<D extends {} = {}, I extends Route.Route.Tuple = []>
-    extends Route.RouteSet.RouteSet<D, {}, I>, Module {}
+  type HasMethod<I extends Route.Route.Tuple> = I extends [
+    infer Head,
+    ...infer Tail extends Route.Route.Tuple,
+  ]
+    ? Head extends Route.Route<{ method: infer M }, any, any, any, any>
+      ? M extends Http.Method
+        ? true
+        : HasMethod<Tail>
+      : HasMethod<Tail>
+    : false
 
-  export type EmptySet<M extends Method, B = {}> = Route.RouteSet.RouteSet<{ method: M }, B, []>
+  export type EmptySet<M extends Method, B = {}> = Route.RouteSet<{ method: M }, B, []>
 
   export type Items<S> = S extends Builder<any, infer I> ? I : []
 
   export type BuilderBindings<S> =
-    S extends Builder<any, infer I>
-      ? Types.Simplify<WildcardBindings<I>> & { request: Request }
-      : { request: Request }
+    S extends Builder<any, infer I> ? Types.Simplify<WildcardBindings<I>> : {}
 
   type WildcardBindingsItem<T> =
-    T extends Route.Route.Route<{ method: "*" }, infer B, any, any, any> ? B : {}
+    T extends Route.Route<{ method: "*" }, infer B, any, any, any> ? B : {}
 
   type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
     k: infer I,
@@ -119,35 +137,24 @@ export namespace RouteMount {
     }[number]
   >
 
-  // Flatten items: merge method into descriptor and accumulate bindings through the chain
-  // `request` is omitted from bindings since it's implicit (always available)
-  export type FlattenItems<M extends Method, B, I extends Route.Route.Tuple> = I extends [
-    Route.Route.Route<infer D, infer RB, infer A, infer E, infer R>,
+  export type FlattenItems<M extends Method, I extends Route.Route.Tuple> = I extends [
+    Route.Route<infer D, infer RB, infer A, infer E, infer R>,
     ...infer Tail extends Route.Route.Tuple,
   ]
-    ? [
-        Route.Route.Route<
-          Types.Simplify<{ method: M } & D> & {},
-          Types.Simplify<Omit<B & RB, "request">>,
-          A,
-          E,
-          R
-        >,
-        ...FlattenItems<M, Types.Simplify<B & RB>, Tail>,
-      ]
+    ? [Route.Route<Types.Simplify<{ method: M } & D> & {}, RB, A, E, R>, ...FlattenItems<M, Tail>]
     : []
 
   export interface Describer<M extends Method> {
     <S extends Self, A extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<A>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<A>>]>
 
     <S extends Self, A extends Route.RouteSet.Any, B extends Route.RouteSet.Any>(
       this: S,
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<B>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<B>>]>
 
     <
       S extends Self,
@@ -159,7 +166,7 @@ export namespace RouteMount {
       ab: (a: EmptySet<M, BuilderBindings<S>>) => A,
       bc: (b: A) => B,
       cd: (c: B) => C,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<C>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<C>>]>
 
     <
       S extends Self,
@@ -173,7 +180,7 @@ export namespace RouteMount {
       bc: (b: A) => B,
       cd: (c: B) => C,
       de: (d: C) => D,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<D>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<D>>]>
 
     <
       S extends Self,
@@ -189,7 +196,7 @@ export namespace RouteMount {
       cd: (c: B) => C,
       de: (d: C) => D,
       ef: (e: D) => E,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<E>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<E>>]>
 
     <
       S extends Self,
@@ -207,7 +214,7 @@ export namespace RouteMount {
       de: (d: C) => D,
       ef: (e: D) => E,
       fg: (f: E) => F,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<F>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<F>>]>
 
     <
       S extends Self,
@@ -227,7 +234,7 @@ export namespace RouteMount {
       ef: (e: D) => E,
       fg: (f: E) => F,
       gh: (g: F) => G,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<G>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<G>>]>
 
     <
       S extends Self,
@@ -249,7 +256,7 @@ export namespace RouteMount {
       fg: (f: E) => F,
       gh: (g: F) => G,
       hi: (h: G) => H,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<H>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<H>>]>
 
     <
       S extends Self,
@@ -273,6 +280,6 @@ export namespace RouteMount {
       gh: (g: F) => G,
       hi: (h: G) => H,
       ij: (i: H) => I,
-    ): Builder<{}, [...Items<S>, ...FlattenItems<M, BuilderBindings<S>, Route.RouteSet.Items<I>>]>
+    ): Builder<{}, [...Items<S>, ...FlattenItems<M, Route.RouteSet.Items<I>>]>
   }
 }