effect-start 0.29.0 → 0.30.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.29.0",
+  "version": "0.30.1",
   "license": "MIT",
   "files": [
     "src/",
@@ -11,75 +11,75 @@
   "type": "module",
   "exports": {
     ".": {
-      "source": "./src/index.ts",
+      "bun": "./src/index.ts",
       "default": "./dist/index.js"
     },
+    "./*": {
+      "bun": "./src/*.ts",
+      "default": "./dist/*.js"
+    },
+    "./_*": null,
     "./client/assets.d.ts": "./src/assets.d.ts",
     "./jsx-runtime": {
-      "source": "./src/hyper/jsx-runtime.ts",
-      "default": "./dist/hyper/jsx-runtime.js"
+      "bun": "./src/jsx-runtime.ts",
+      "default": "./dist/jsx-runtime.js"
     },
     "./jsx-dev-runtime": {
-      "source": "./src/hyper/jsx-runtime.ts",
-      "default": "./dist/hyper/jsx-runtime.js"
+      "bun": "./src/jsx-runtime.ts",
+      "default": "./dist/jsx-runtime.js"
     },
     "./lint/plugin": {
-      "source": "./src/lint/plugin.js",
+      "bun": "./src/lint/plugin.js",
       "default": "./dist/lint/plugin.js"
     },
-    "./x/*": {
-      "source": "./src/x/*/index.ts",
-      "default": "./dist/x/*/index.js"
-    },
-    "./x/tailwind/plugin": {
-      "source": "./src/x/tailwind/plugin.ts",
-      "default": "./dist/x/tailwind/plugin.js"
-    },
     "./bun": {
-      "source": "./src/bun/index.ts",
+      "bun": "./src/bun/index.ts",
       "default": "./dist/bun/index.js"
     },
     "./cli": {
-      "source": "./src/cli/index.ts",
+      "bun": "./src/cli/index.ts",
       "default": "./dist/cli/index.js"
     },
     "./client": {
-      "source": "./src/client/index.ts",
+      "bun": "./src/client/index.ts",
       "default": "./dist/client/index.js"
     },
+    "./cloudflare": {
+      "bun": "./src/cloudflare/index.ts",
+      "default": "./dist/cloudflare/index.js"
+    },
     "./datastar": {
-      "source": "./src/datastar/index.ts",
+      "bun": "./src/datastar/index.ts",
       "default": "./dist/datastar/index.js"
     },
     "./experimental": {
-      "source": "./src/experimental/index.ts",
+      "bun": "./src/experimental/index.ts",
       "default": "./dist/experimental/index.js"
     },
-    "./hyper": {
-      "source": "./src/hyper/index.ts",
-      "default": "./dist/hyper/index.js"
+"./sql": {
+      "bun": "./src/sql/index.ts",
+      "default": "./dist/sql/index.js"
     },
     "./sql/*": {
-      "source": "./src/sql/*/index.ts",
+      "bun": "./src/sql/*/index.ts",
       "default": "./dist/sql/*/index.js"
     },
-    "./sql": {
-      "source": "./src/sql/index.ts",
-      "default": "./dist/sql/index.js"
-    },
-    "./testing": {
-      "source": "./src/testing/index.ts",
-      "default": "./dist/testing/index.js"
-    },
     "./studio": {
-      "source": "./src/studio/index.ts",
+      "bun": "./src/studio/index.ts",
       "default": "./dist/studio/index.js"
     },
-    "./*": {
-      "source": "./src/*.ts",
-      "default": "./dist/*.js"
+    "./tailscale": {
+      "bun": "./src/tailscale/index.ts",
+      "default": "./dist/tailscale/index.js"
+    },
+    "./tailwind": {
+      "bun": "./src/tailwind/index.ts",
+      "default": "./dist/tailwind/index.js"
+    },
+    "./testing": {
+      "bun": "./src/testing/index.ts",
+      "default": "./dist/testing/index.js"
     },
-    "./_*": null,
     "./package.json": "./package.json"
   },
   "scripts": {

package/src/{_Development.ts → Development.ts}

@@ -100,6 +100,11 @@ export const layer = (opts?: {
   filter?: (event: FileSystem.WatchEvent) => boolean
 }) => Layer.scoped(Development, watch(opts))
 
+export const layerTest = Layer.effect(
+  Development,
+  Effect.map(PubSub.unbounded<DevelopmentEvent>(), (events) => ({ events })),
+)
+
 export const option = Effect.serviceOption(Development)
 
 export const events: Stream.Stream<DevelopmentEvent> = Stream.unwrap(

package/src/Fetch.ts

@@ -3,7 +3,6 @@ import * as Effect from "effect/Effect"
 import * as Schedule from "effect/Schedule"
 import * as Stream from "effect/Stream"
 import * as Entity from "./Entity.ts"
-import * as Values from "./_Values.ts"
 
 const TypeId = "~effect-start/FetchClient" as const
 
@@ -175,42 +174,16 @@ const ClientProto: any = {
 
 type WebHandler = (request: Request) => Response | Promise<Response>
 
-type FromHandlerInit = Omit<RequestInit, "body"> &
-  ({ url: string } | { path: `/${string}` }) & {
-    body?: RequestInit["body"] | Record<string, unknown>
-  }
-
-export function fromHandler(handler: WebHandler): FetchClient
-export function fromHandler(handler: WebHandler, init: FromHandlerInit): Promise<Response>
-export function fromHandler(
-  handler: WebHandler,
-  init?: FromHandlerInit,
-): FetchClient | Promise<Response> {
-  if (init === undefined) {
-    const transport: Middleware = (request) =>
-      Effect.map(
-        Effect.tryPromise({
-          try: () => Promise.resolve(handler(request)),
-          catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
-        }),
-        (response) => Entity.fromResponse<FetchError>(response, request),
-      )
-    return use(transport)
-  }
-
-  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 as BodyInit,
-  })
-  return Promise.resolve(handler(request))
+export function fromHandler(handler: WebHandler): FetchClient {
+  const transport: Middleware = (request) =>
+    Effect.map(
+      Effect.tryPromise({
+        try: () => Promise.resolve(handler(request)),
+        catch: (e) => new FetchError({ reason: "Network", cause: e, request }),
+      }),
+      (response) => Entity.fromResponse<FetchError>(response, request),
+    )
+  return use(transport)
 }
 
 export function filterStatus(

package/src/FileRouter.ts

@@ -7,7 +7,7 @@ import * as Layer from "effect/Layer"
 import * as Stream from "effect/Stream"
 import * as NPath from "node:path"
 import * as NUrl from "node:url"
-import * as Development from "./_Development.ts"
+import * as Development from "./Development.ts"
 import * as FileRouterCodegen from "./FileRouterCodegen.ts"
 import * as NodeUtils from "./node/NodeUtils.ts"
 import * as PathPattern from "./_PathPattern.ts"
@@ -190,6 +190,7 @@ export function getFileRoutes(
 ): Effect.Effect<OrderedFileRoutes, FileRouterError> {
   return Effect.gen(function* () {
     const routes = paths
+      .map((f) => f.replaceAll("\\", "/"))
       .map((f) => f.match(ROUTE_PATH_REGEX))
       .filter(Boolean)
       .map((v) => {

package/src/GlobalLayer.ts

@@ -67,7 +67,9 @@ export const globalLayer =
               )
               yield* Deferred.succeed(deferred, ctx)
               yield* Effect.never
-            }),
+            }).pipe(
+              Effect.catchAllCause((cause) => Deferred.failCause(deferred, cause)),
+            ),
           ),
         ) as Fiber.RuntimeFiber<void>
 

package/src/{hyper/HyperHtml.ts → Html.ts}

@@ -1,27 +1,46 @@
-/**
- * Renders Hyper JSX nodes to HTML.
- *
- * Effect Start comes with {@link Hyper} and {@link JsxRuntime} to enable
- * JSX support. The advantage of using JSX over HTML strings or templates
- * is type safety and better editor support.
- *
- * JSX nodes are compatible with React's and Solid's.
-
- * You can enable JSX support by updating `tsconfig.json`:
- *
- * {
- *   compilerOptions: {
- *     jsx: "react-jsx",
- *     jsxImportSource: "effect-start" | "react" | "praect" // etc.
- *   }
- * }
- */
-
-import type * as Hyper from "./Hyper.ts"
-import type * as HyperNode from "./HyperNode.ts"
-import type * as JsxRuntime from "./jsx-runtime.ts"
 import type { JSX } from "./jsx.d.ts"
 
+export const TypeId = "~effect-start/HyperNode" as const
+
+const NoChildren: ReadonlyArray<never> = Object.freeze([])
+
+type Primitive = string | number | boolean | null | undefined
+
+export type ElementType = string | Component
+
+export type ElemenetProps = {
+  [key: string]:
+    | Primitive
+    | Element
+    | Iterable<Primitive | Element>
+    | Record<string, unknown>
+    | ((window: Window) => void)
+}
+
+export type Component = (props: ElemenetProps) => Element | Primitive
+
+export interface Element {
+  type: ElementType
+  props: ElemenetProps
+}
+
+export function make(type: ElementType, props: ElemenetProps): Element {
+  return {
+    type,
+    props: {
+      ...props,
+      children: props.children ?? NoChildren,
+    },
+  }
+}
+
+export function isGenericJsxObject(value: unknown): value is {
+  type: any
+  props: any
+} {
+  return typeof value === "object" && value !== null && "type" in value && "props" in value
+}
+
 const EMPTY_TAGS = [
   "area",
   "base",
@@ -53,12 +72,11 @@ let map = {
 
 const RAW_TEXT_TAGS = ["script", "style"]
 
-// Prevents closing html tags in embedded css/js source
 const escapeRawText = (text: string) => text.replaceAll("</", "<\\/")
 
 export function renderToString(
   node: JSX.Children,
-  hooks?: { onNode?: (node: HyperNode.HyperNode) => void },
+  hooks?: { onNode?: (node: Element) => void },
 ): string {
   const stack: Array<any> = [node]
   let result = ""
@@ -68,7 +86,6 @@ export function renderToString(
 
     if (typeof current === "string") {
       if (current.startsWith("<") && current.endsWith(">")) {
-        // This is a closing tag, don't escape it
         result += current
       } else {
         result += esc(current)
@@ -82,17 +99,14 @@ export function renderToString(
     }
 
     if (typeof current === "boolean") {
-      // React-like behavior: booleans render nothing
       continue
     }
 
     if (current === null || current === undefined) {
-      // React-like behavior: null/undefined render nothing
       continue
     }
 
     if (Array.isArray(current)) {
-      // Handle arrays by pushing all items to stack in reverse order
       for (let i = current.length - 1; i >= 0; i--) {
         stack.push(current[i])
       }
@@ -165,10 +179,56 @@ export function renderToString(
         }
       }
     } else if (current && typeof current === "object") {
-      // Handle objects without type property - convert to string or ignore
-      // This prevents [object Object] from appearing
       continue
     }
   }
   return result
 }
+
+const HtmlStringSymbol = Symbol.for("HtmlString")
+
+export interface HtmlString {
+  readonly [HtmlStringSymbol]: true
+  readonly value: string
+}
+
+const makeHtmlString = (value: string): HtmlString => ({
+  [HtmlStringSymbol]: true,
+  value,
+})
+
+const isHtmlString = (value: unknown): value is HtmlString =>
+  typeof value === "object" && value !== null && HtmlStringSymbol in value
+
+type HtmlValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | undefined
+  | HtmlString
+  | Function
+  | Record<string, unknown>
+  | ReadonlyArray<HtmlValue>
+
+const resolveValue = (value: HtmlValue): string => {
+  if (value === null || value === undefined || value === false || value === true) return ""
+  if (isHtmlString(value)) return value.value
+  if (Array.isArray(value)) return (value as Array<HtmlValue>).map(resolveValue).join("")
+  if (typeof value === "function") return value.toString()
+  if (typeof value === "object") return JSON.stringify(value)
+  if (typeof value === "string") return value
+  return String(value)
+}
+
+export const html = (strings: TemplateStringsArray, ...values: Array<HtmlValue>): HtmlString => {
+  let result = strings[0]
+  for (let i = 0; i < values.length; i++) {
+    result += resolveValue(values[i])
+    result += strings[i + 1]
+  }
+  return makeHtmlString(result)
+}
+
+html.raw = (value: string): HtmlString => makeHtmlString(value)

package/src/Route.ts

@@ -1,12 +1,18 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 import * as Pipeable from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
+import * as Development from "./Development.ts"
 import * as Entity from "./Entity.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
 import type * as Values from "./_Values.ts"
+import * as Html from "./Html.ts"
+import type { JSX } from "./jsx.d.ts"
+
+export const render = RouteBody.render
 
 export const RouteItems: unique symbol = Symbol()
 export const RouteDescriptor: unique symbol = Symbol()
@@ -162,6 +168,7 @@ export function items<T extends RouteSet.Data<any, any, any>>(self: T): RouteSet
 export function descriptor<T extends RouteSet.Data<any, any, any>>(
   self: T,
 ): T[typeof RouteDescriptor]
+export function descriptor<E extends RouteDescriptor.Any>(self: RouteSet.Data<any, any, any>): E
 export function descriptor<T extends RouteSet.Data<any, any, any>>(
   self: Iterable<T>,
 ): Array<T[typeof RouteDescriptor]>
@@ -203,8 +210,10 @@ export const text = RouteBody.build<string, "text">({
   format: "text",
 })
 
-export const html = RouteBody.build<string, "html">({
+export const html = RouteBody.build<string | JSX.Children, string, "html">({
   format: "html",
+  handle: (body) =>
+    typeof body === "string" ? body : Html.renderToString(body as JSX.Children),
 })
 
 export const json = RouteBody.build<Values.Json, "json">({
@@ -215,20 +224,31 @@ export const bytes = RouteBody.build<Uint8Array, "bytes">({
   format: "bytes",
 })
 
-export { render } from "./RouteBody.ts"
-
 export { sse } from "./RouteSse.ts"
 
-export function redirect(
+export function redirect<D extends RouteDescriptor.Any, B, I extends Route.Tuple>(
   url: string | URL,
   options?: { status?: 301 | 302 | 303 | 307 | 308 },
-): Entity.Entity<""> {
-  return Entity.make("", {
-    status: options?.status ?? 302,
-    headers: {
-      location: url instanceof URL ? url.href : url,
-    },
-  })
+): (
+  self: RouteSet.RouteSet<D, B, I>,
+) => RouteSet.RouteSet<D, B, [...I, Route.Route<{}, {}, "", never, never>]> {
+  const route = make<{}, {}, "">(
+    () =>
+      Effect.succeed(
+        Entity.make("", {
+          status: options?.status ?? 302,
+          headers: {
+            location: url instanceof URL ? url.href : url,
+          },
+        }),
+      ),
+  )
+
+  return (self) =>
+    set<D, B, [...I, Route.Route<{}, {}, "", never, never>]>(
+      [...items(self), route],
+      descriptor(self),
+    )
 }
 
 export class Routes extends Context.Tag("effect-start/Routes")<Routes, RouteTree.RouteTree>() {}
@@ -237,6 +257,42 @@ export function layer(routes: RouteTree.RouteMap | RouteTree.RouteTree) {
   return Layer.sync(Routes, () => (RouteTree.isRouteTree(routes) ? routes : RouteTree.make(routes)))
 }
 
+/**
+ * Creates a route that short-curcits in development.
+ *
+ * Note that when we convert the routes to web handles in {@link import("./RouteHttp.ts")},
+ * we exclude them altogeteher in development.
+ */
+export function devOnly<D extends RouteDescriptor.Any, B, I extends Route.Tuple>(
+  self: RouteSet.RouteSet<D, B, I>,
+): RouteSet.RouteSet<D, B, [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>]> {
+  const route: Route.Route<{ dev: true }, { dev: true }, unknown, any, any> = make<
+    { dev: true },
+    { dev: true },
+    unknown,
+    any,
+    any
+  >(
+    (context, next) =>
+      Effect.flatMap(Development.option, (developmentOption) =>
+        Option.isSome(developmentOption)
+          ? Effect.succeed(next({ ...context, dev: true }))
+          : Effect.succeed(Entity.make("", { status: 404 })),
+      ),
+    { dev: true },
+  )
+
+  const nextItems: [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>] = [
+    ...items(self),
+    route,
+  ]
+
+  return set<D, B, [...I, Route.Route<{ dev: true }, { dev: true }, unknown, any, any>]>(
+    nextItems,
+    descriptor(self),
+  )
+}
+
 export { make as tree } from "./RouteTree.ts"
 
 export function lazy<T extends RouteSet.Any>(