effect-start 0.28.0 → 0.30.0

package/src/bun/BunRoute.ts

@@ -1,12 +1,13 @@
-import type * as Bun from "bun"
-import * as Array from "effect/Array"
+import * as Bun from "bun"
+import * as NPath from "node:path"
 import * as Data from "effect/Data"
+import * as Either from "effect/Either"
 import * as Effect from "effect/Effect"
+import * as FiberRef from "effect/FiberRef"
 import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
-import * as FilePathPattern from "../FilePathPattern.ts"
-import * as Hyper from "../hyper/Hyper.ts"
-import * as HyperHtml from "../hyper/HyperHtml.ts"
+import * as Html from "../Html.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as Route from "../Route.ts"
 import * as Unique from "../Unique.ts"
 import * as BunServer from "./BunServer.ts"
@@ -36,6 +37,8 @@ export function descriptors(
 
 type HTMLBundleModule = Bun.HTMLBundle | { default: Bun.HTMLBundle }
 
+const bundleDepthRef = FiberRef.unsafeMake(0)
+
 export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModule>) {
   const bunPrefix = `/.BunRoute-${Unique.token(10)}`
   const bunLoad = () =>
@@ -66,6 +69,7 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
     > = (context, next) =>
       Effect.gen(function* () {
         const originalRequest = context.request
+        const bundleDepth = yield* FiberRef.get(bundleDepthRef)
 
         if (originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true") {
           const url = new URL(originalRequest.url)
@@ -79,60 +83,83 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
           )
         }
 
-        const bunServer = yield* BunServer.BunServer
-        const url = new URL(originalRequest.url)
+        let html = ""
+        let status = 200
+        let contentType = "text/html;charset=utf-8"
 
-        const internalPath = `${bunPrefix}${url.pathname}`
-        const internalUrl = new URL(internalPath, bunServer.server.url)
+        if (bundleDepth === 0) {
+          const bunServer = yield* BunServer.BunServer
+          const url = new URL(originalRequest.url)
 
-        const headers = new Headers(originalRequest.headers)
-        headers.set(INTERNAL_FETCH_HEADER, "true")
+          const internalPath = `${bunPrefix}${url.pathname}`
+          const internalUrl = new URL(internalPath, bunServer.server.url)
 
-        const proxyRequest = new Request(internalUrl, {
-          method: originalRequest.method,
-          headers,
-        })
+          const headers = new Headers(originalRequest.headers)
+          headers.set(INTERNAL_FETCH_HEADER, "true")
 
-        const response = yield* Effect.tryPromise({
-          try: () => fetch(proxyRequest),
-          catch: (error) =>
-            new BunRouteError({
-              reason: "ProxyError",
-              pattern: internalPath,
-              message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-            }),
-        })
+          const proxyRequest = new Request(internalUrl, {
+            method: originalRequest.method,
+            headers,
+          })
 
-        let html = yield* Effect.tryPromise({
-          try: () => response.text(),
-          catch: (error) =>
-            new BunRouteError({
-              reason: "ProxyError",
-              pattern: internalPath,
-              message: String(error),
-            }),
-        })
+          const response = yield* Effect.tryPromise({
+            try: () => fetch(proxyRequest),
+            catch: (error) =>
+              new BunRouteError({
+                reason: "ProxyError",
+                pattern: internalPath,
+                message: `Failed to fetch internal HTML bundle: ${String(error)}`,
+              }),
+          })
+
+          html = yield* Effect.tryPromise({
+            try: () => response.text(),
+            catch: (error) =>
+              new BunRouteError({
+                reason: "ProxyError",
+                pattern: internalPath,
+                message: String(error),
+              }),
+          })
+          status = response.status
+          contentType = response.headers.get("content-type") ?? contentType
+        } else {
+          html = yield* readBundleHtml(bunLoad).pipe(
+            Effect.mapError(
+              (error) =>
+                new BunRouteError({
+                  reason: "ProxyError",
+                  pattern: bunPrefix,
+                  message: `Failed to load nested HTML bundle: ${String(error)}`,
+                }),
+            ),
+          )
+        }
 
-        const childEntity = yield* next(context)
+        const childEntity = yield* next(context).pipe(
+          Effect.locally(bundleDepthRef, bundleDepth + 1),
+        )
         const children = childEntity?.body ?? childEntity
 
         let childrenHtml = ""
         if (children != null) {
           if ((children as unknown) instanceof Response) {
             childrenHtml = yield* Effect.promise(() => (children as unknown as Response).text())
-          } else if (Hyper.isGenericJsxObject(children)) {
-            childrenHtml = HyperHtml.renderToString(children)
+          } else if (Html.isGenericJsxObject(children)) {
+            childrenHtml = Html.renderToString(children)
           } else {
             childrenHtml = String(children)
           }
         }
 
-        html = html.replace(/%children%/g, childrenHtml)
+        childrenHtml = yield* stripInjectedBunScripts(childrenHtml)
+
+        html = html.replaceAll("%children%", childrenHtml)
 
         return Entity.make(html, {
-          status: response.status,
+          status,
           headers: {
-            "content-type": response.headers.get("content-type"),
+            "content-type": contentType,
           },
         })
       })
@@ -149,6 +176,67 @@ export function htmlBundle(load: () => HTMLBundleModule | Promise<HTMLBundleModu
   }
 }
 
+function stripInjectedBunScripts(html: string) {
+  let removeNextInlineScript = false
+  const rewriter = new HTMLRewriter().on("script", {
+    element(element) {
+      const src = element.getAttribute("src")
+      const hasDevAttribute = element.getAttribute("data-bun-dev-server-script") !== null
+
+      if (hasDevAttribute || (src !== null && src.startsWith("/_bun/client/"))) {
+        element.remove()
+        removeNextInlineScript = true
+        return
+      }
+
+      if (removeNextInlineScript && src === null) {
+        element.remove()
+        removeNextInlineScript = false
+        return
+      }
+
+      removeNextInlineScript = false
+    },
+  })
+
+  return Effect.tryPromise({
+    try: () => rewriter.transform(new Response(html)).text(),
+    catch: (error) =>
+      new BunRouteError({
+        reason: "ProxyError",
+        pattern: "stripInjectedBunScripts",
+        message: String(error),
+      }),
+  })
+}
+
+function readBundleHtml(bunLoad: () => Promise<Bun.HTMLBundle>) {
+  return Effect.tryPromise({
+    try: () => bunLoad(),
+    catch: (error) =>
+      new BunRouteError({
+        reason: "ProxyError",
+        pattern: "readBundleHtml",
+        message: String(error),
+      }),
+  }).pipe(
+    Effect.andThen((bundle) => {
+      const indexPath = NPath.isAbsolute(bundle.index)
+        ? bundle.index
+        : NPath.resolve(NPath.dirname(Bun.main), bundle.index)
+      return Effect.tryPromise({
+        try: () => Bun.file(indexPath).text(),
+        catch: (error) =>
+          new BunRouteError({
+            reason: "ProxyError",
+            pattern: indexPath,
+            message: String(error),
+          }),
+      })
+    }),
+  )
+}
+
 type BunServerFetchHandler = (
   request: Request,
   server: Bun.Server<unknown>,
@@ -180,16 +268,13 @@ export type BunRoutes = Record<string, BunServerRouteHandler>
  */
 
 export function validateBunPattern(pattern: string): Option.Option<BunRouteError> {
-  const segs = FilePathPattern.segments(pattern)
-
-  const invalid = Array.findFirst(segs, (seg) => seg._tag === "InvalidSegment")
-
-  if (Option.isSome(invalid)) {
+  const parsed = PathPattern.fromFilePath(pattern)
+  if (Either.isLeft(parsed)) {
     return Option.some(
       new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
-        message: `Pattern "${pattern}" contains invalid segment.`,
+        message: parsed.left.message,
       }),
     )
   }

package/src/bun/BunServer.ts

@@ -11,14 +11,15 @@ import * as Runtime from "effect/Runtime"
 import type * as Scope from "effect/Scope"
 import * as NOs from "node:os"
 import * as NPath from "node:path"
-import * as PathPattern from "../PathPattern.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as PlatformRuntime from "../PlatformRuntime.ts"
 import * as Route from "../Route.ts"
 import * as RouteHttp from "../RouteHttp.ts"
-import * as StartApp from "../StartApp.ts"
+import * as StartApp from "../_StartApp.ts"
 import type * as RouteMount from "../RouteMount.ts"
 import * as RouteTree from "../RouteTree.ts"
 import * as BunRoute from "./BunRoute.ts"
+
 export interface WebSocketContext {
   readonly deferred: Deferred.Deferred<Bun.ServerWebSocket<WebSocketContext>>
   readonly closeDeferred: Deferred.Deferred<void, Socket.SocketError>
@@ -112,7 +113,7 @@ export const make = (
           ws.data.closeDeferred,
           Socket.defaultCloseCodeIsError(code)
             ? Exit.fail(
-                new Socket.SocketCloseError({
+                new Socket.SocketError({
                   reason: "Close",
                   code,
                   closeReason,

package/src/bundler/BundleRoute.ts

@@ -3,10 +3,10 @@ import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Entity from "../Entity.ts"
-import * as PathPattern from "../PathPattern.ts"
+import * as PathPattern from "../_PathPattern.ts"
 import * as Route from "../Route.ts"
 import * as RouteTree from "../RouteTree.ts"
-import * as Values from "../Values.ts"
+import * as Values from "../_Values.ts"
 import * as Bundle from "./Bundle.ts"
 
 /**

package/src/cli/Argument.ts

@@ -0,0 +1,45 @@
+import type * as Redacted from "effect/Redacted"
+import * as Param from "./Param.ts"
+import * as Primitive from "./Primitive.ts"
+
+export interface Argument<A> extends Param.Param<"argument", A> {}
+
+const argMake = Param.makeConstructor("argument")
+
+export const string = (name: string): Argument<string> => argMake(name, Primitive.string)
+export const integer = (name: string): Argument<number> => argMake(name, Primitive.integer)
+export const float = (name: string): Argument<number> => argMake(name, Primitive.float)
+export const date = (name: string): Argument<Date> => argMake(name, Primitive.date)
+export const redacted = (name: string): Argument<Redacted.Redacted<string>> =>
+  argMake(name, Primitive.redacted)
+export const choice = <const C extends ReadonlyArray<string>>(
+  name: string,
+  choices: C,
+): Argument<C[number]> =>
+  Param.makeSingleParam({
+    kind: "argument",
+    name,
+    primitiveType: Primitive.choice(choices.map((v) => [v, v] as const)),
+  })
+export const choiceWithValue = <const C extends ReadonlyArray<readonly [string, any]>>(
+  name: string,
+  choices: C,
+): Argument<C[number][1]> =>
+  Param.makeSingleParam({ kind: "argument", name, primitiveType: Primitive.choice(choices) })
+export const none: Argument<never> = Param.makeSingleParam({
+  kind: "argument",
+  name: "__none__",
+  primitiveType: Primitive.none,
+}) as Argument<never>
+
+const combinators = Param.makeParamCombinators("argument")
+export const optional = combinators.optional
+export const withDefault = combinators.withDefault
+export const withDescription = combinators.withDescription
+export const withMetavar = combinators.withMetavar
+export const map = combinators.map
+export const mapEffect = combinators.mapEffect
+export const variadic = combinators.variadic
+export const filter = combinators.filter
+export const withSchema = combinators.withSchema
+export const orElse = combinators.orElse

package/src/cli/CliError.ts

@@ -0,0 +1,68 @@
+import * as Predicate from "effect/Predicate"
+
+const CliErrorTypeId = "~effect-start/Cli/CliError"
+
+export const isCliError = (u: unknown): u is CliError => Predicate.hasProperty(u, CliErrorTypeId)
+
+export type CliErrorReason =
+  | "UnrecognizedOption"
+  | "DuplicateOption"
+  | "MissingOption"
+  | "MissingArgument"
+  | "InvalidValue"
+  | "UnknownSubcommand"
+  | "ShowHelp"
+  | "UserError"
+
+const suggestText = (suggestions: ReadonlyArray<string>) =>
+  suggestions.length > 0 ? `\n\n  Did you mean this?\n    ${suggestions.join("\n    ")}` : ""
+
+const formatMessage = (reason: CliErrorReason, props: Record<string, any>): string => {
+  switch (reason) {
+    case "UnrecognizedOption": {
+      const base = props.command
+        ? `Unrecognized flag: ${props.option} in command ${props.command.join(" ")}`
+        : `Unrecognized flag: ${props.option}`
+      return base + suggestText(props.suggestions ?? [])
+    }
+    case "DuplicateOption":
+      return `Duplicate flag "${props.option}" in parent "${props.parentCommand}" and subcommand "${props.childCommand}".`
+    case "MissingOption":
+      return `Missing required flag: --${props.option}`
+    case "MissingArgument":
+      return `Missing required argument: ${props.argument}`
+    case "InvalidValue":
+      return props.kind === "argument"
+        ? `Invalid value for argument <${props.option}>: "${props.value}". Expected: ${props.expected}`
+        : `Invalid value for flag --${props.option}: "${props.value}". Expected: ${props.expected}`
+    case "UnknownSubcommand": {
+      const base = props.parent
+        ? `Unknown subcommand "${props.subcommand}" for "${props.parent.join(" ")}"`
+        : `Unknown subcommand "${props.subcommand}"`
+      return base + suggestText(props.suggestions ?? [])
+    }
+    case "ShowHelp":
+      return "Help requested"
+    case "UserError":
+      return String(props.cause)
+  }
+}
+
+export class CliError {
+  readonly _tag = "CliError"
+  readonly [CliErrorTypeId] = CliErrorTypeId
+  readonly reason: CliErrorReason
+  constructor(props: { reason: CliErrorReason } & Record<string, any>) {
+    this.reason = props.reason
+    Object.assign(this, props)
+  }
+  get message(): string {
+    return formatMessage(this.reason, this as any)
+  }
+}
+
+export const formatErrors = (errors: ReadonlyArray<CliError>): string => {
+  if (errors.length === 0) return ""
+  if (errors.length === 1) return `\nERROR\n  ${errors[0].message}`
+  return `\nERRORS\n` + errors.map((e) => `  ${e.message}`).join("\n")
+}