npm - effect-start - Versions diffs - 0.15.0 → 0.17.0 - Mend

effect-start 0.15.0 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/package.json +2 -1
package/src/ContentNegotiation.test.ts +103 -0
package/src/ContentNegotiation.ts +10 -3
package/src/Development.test.ts +119 -0
package/src/Development.ts +137 -0
package/src/Entity.test.ts +592 -0
package/src/Entity.ts +359 -0
package/src/FileRouter.ts +2 -2
package/src/Http.test.ts +315 -20
package/src/Http.ts +153 -11
package/src/PathPattern.ts +3 -1
package/src/Route.ts +26 -10
package/src/RouteBody.test.ts +98 -66
package/src/RouteBody.ts +125 -35
package/src/RouteHook.ts +15 -14
package/src/RouteHttp.test.ts +2549 -83
package/src/RouteHttp.ts +337 -113
package/src/RouteHttpTracer.ts +92 -0
package/src/RouteMount.test.ts +23 -10
package/src/RouteMount.ts +161 -4
package/src/RouteSchema.test.ts +346 -0
package/src/RouteSchema.ts +386 -7
package/src/RouteSse.test.ts +249 -0
package/src/RouteSse.ts +195 -0
package/src/RouteTree.test.ts +233 -85
package/src/RouteTree.ts +98 -44
package/src/StreamExtra.ts +21 -1
package/src/Values.test.ts +263 -0
package/src/Values.ts +68 -6
package/src/bun/BunBundle.ts +0 -73
package/src/bun/BunHttpServer.ts +23 -7
package/src/bun/BunRoute.test.ts +162 -0
package/src/bun/BunRoute.ts +144 -105
package/src/hyper/HyperHtml.test.ts +119 -0
package/src/hyper/HyperHtml.ts +10 -2
package/src/hyper/HyperNode.ts +2 -0
package/src/hyper/HyperRoute.test.tsx +197 -0
package/src/hyper/HyperRoute.ts +61 -0
package/src/hyper/index.ts +4 -0
package/src/hyper/jsx.d.ts +15 -0
package/src/index.ts +2 -0
package/src/node/FileSystem.ts +8 -0
package/src/testing/TestLogger.test.ts +0 -3
package/src/testing/TestLogger.ts +15 -9
package/src/FileSystemExtra.test.ts +0 -242
package/src/FileSystemExtra.ts +0 -66

package/src/bun/BunRoute.test.ts ADDED Viewed

@@ -0,0 +1,162 @@
+import * as test from "bun:test"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Route from "../Route.ts"
+import * as BunHttpServer from "./BunHttpServer.ts"
+import * as BunRoute from "./BunRoute.ts"
+const layerServer = Layer.scoped(
+  BunHttpServer.BunHttpServer,
+  BunHttpServer.make({ port: 0 }),
+)
+const testLayer = (routes: ReturnType<typeof Route.tree>) =>
+  Layer.provideMerge(
+    BunHttpServer.layerRoutes(routes),
+    layerServer,
+  )
+test.describe(BunRoute.htmlBundle, () => {
+  test.test("wraps child content with layout", async () => {
+    const routes = Route.tree({
+      "/": Route.get(
+        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
+        Route.html("<p>Hello World</p>"),
+      ),
+    })
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+    test.expect(response.status).toBe(200)
+    const html = await response.text()
+    test.expect(html).toContain("<p>Hello World</p>")
+    test.expect(html).toContain("<body>")
+    test.expect(html).toContain("</body>")
+  })
+  test.test("replaces %yield% with child content", async () => {
+    const routes = Route.tree({
+      "/page": Route.get(
+        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
+        Route.html("<div>Page Content</div>"),
+      ),
+    })
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/page`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+    const html = await response.text()
+    test.expect(html).toContain("<div>Page Content</div>")
+    test.expect(html).not.toContain("%children%")
+  })
+  test.test("works with use() for wildcard routes", async () => {
+    const routes = Route.tree({
+      "*": Route.use(
+        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
+      ),
+      "/:path*": Route.get(Route.html("<section>Catch All</section>")),
+    })
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/any/path`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+    test.expect(response.status).toBe(200)
+    const html = await response.text()
+    test.expect(html).toContain("<section>Catch All</section>")
+  })
+  test.test("has format: html descriptor", async () => {
+    const routes = Route.tree({
+      "/": Route.get(
+        BunRoute.htmlBundle(() => import("../../static/LayoutSlots.html")),
+        Route.html("<p>content</p>"),
+      ),
+    })
+    const response = await Effect.runPromise(
+      Effect.scoped(
+        Effect
+          .gen(function*() {
+            const bunServer = yield* BunHttpServer.BunHttpServer
+            return yield* Effect.promise(() =>
+              fetch(`http://localhost:${bunServer.server.port}/`)
+            )
+          })
+          .pipe(Effect.provide(testLayer(routes))),
+      ),
+    )
+    test.expect(response.status).toBe(200)
+    const contentType = response.headers.get("content-type")
+    test.expect(contentType).toContain("text/html")
+  })
+})
+test.describe(BunRoute.validateBunPattern, () => {
+  test.test("returns none for valid patterns", () => {
+    test
+      .expect(Option.isNone(BunRoute.validateBunPattern("/users")))
+      .toBe(true)
+    test
+      .expect(Option.isNone(BunRoute.validateBunPattern("/users/[id]")))
+      .toBe(true)
+    test
+      .expect(Option.isNone(BunRoute.validateBunPattern("/[...rest]")))
+      .toBe(true)
+  })
+  test.test("returns error for prefixed params", () => {
+    const result = BunRoute.validateBunPattern("/pk_[id]")
+    test.expect(Option.isSome(result)).toBe(true)
+  })
+  test.test("returns error for suffixed params", () => {
+    const result = BunRoute.validateBunPattern("/[id]_suffix")
+    test.expect(Option.isSome(result)).toBe(true)
+  })
+})
+test.describe(BunRoute.isHtmlBundle, () => {
+  test.test("returns false for non-objects", () => {
+    test.expect(BunRoute.isHtmlBundle(null)).toBe(false)
+    test.expect(BunRoute.isHtmlBundle(undefined)).toBe(false)
+    test.expect(BunRoute.isHtmlBundle("string")).toBe(false)
+  })
+  test.test("returns true for object with index property", () => {
+    test.expect(BunRoute.isHtmlBundle({ index: "index.html" })).toBe(true)
+  })
+})

package/src/bun/BunRoute.ts CHANGED Viewed

@@ -1,11 +1,9 @@
-// @ts-nocheck
-import * as HttpServerRequest from "@effect/platform/HttpServerRequest"
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse"
 import type * as Bun from "bun"
 import * as Array from "effect/Array"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
-import * as Predicate from "effect/Predicate"
+import * as Entity from "../Entity.ts"
 import * as Hyper from "../hyper/Hyper.ts"
 import * as HyperHtml from "../hyper/HyperHtml.ts"
 import * as Random from "../Random.ts"
@@ -13,106 +11,155 @@ import * as Route from "../Route.ts"
 import * as RouterPattern from "../RouterPattern.ts"
 import * as BunHttpServer from "./BunHttpServer.ts"
-const BunHandlerTypeId: unique symbol = Symbol.for("effect-start/BunHandler")
 const INTERNAL_FETCH_HEADER = "x-effect-start-internal-fetch"
-export type BunHandler =
-  & Route.RouteHandler<string, Router.RouterError, BunHttpServer.BunHttpServer>
-  & {
-    [BunHandlerTypeId]: typeof BunHandlerTypeId
-    internalPathPrefix: string
-    load: () => Promise<Bun.HTMLBundle>
-  }
+export class BunRouteError extends Data.TaggedError("BunRouteError")<{
+  reason: "ProxyError" | "UnsupportedPattern"
+  pattern: string
+  message: string
+}> {}
+export type BunDescriptors = {
+  bunPrefix: string
+  bunLoad: () => Promise<Bun.HTMLBundle>
+}
-export function isBunHandler(input: unknown): input is BunHandler {
-  return typeof input === "function"
-    && Predicate.hasProperty(input, BunHandlerTypeId)
+export function descriptors(
+  route: Route.Route.Route,
+): BunDescriptors | undefined {
+  const descriptor = Route.descriptor(route) as Partial<BunDescriptors>
+  if (
+    typeof descriptor.bunPrefix === "string"
+    && typeof descriptor.bunLoad === "function"
+  ) {
+    return descriptor as BunDescriptors
+  }
+  return undefined
 }
-export function bundle(
+export function htmlBundle(
   load: () => Promise<Bun.HTMLBundle | { default: Bun.HTMLBundle }>,
-): BunHandler {
-  const internalPathPrefix = `/.BunRoute-${Random.token(6)}`
-  const handler = (context: Route.RouteContext, next: Route.RouteNext) =>
-    Effect.gen(function*() {
-      const request = yield* HttpServerRequest.HttpServerRequest
-      const originalRequest = request.source as Request
-      if (
-        originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
-      ) {
-        return yield* Effect.fail(
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: context.url.pathname,
-            message:
-              "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
-          }),
-        )
-      }
-      const bunServer = yield* BunHttpServer.BunHttpServer
-      const internalPath = `${internalPathPrefix}${context.url.pathname}`
-      const internalUrl = new URL(internalPath, bunServer.server.url)
-      const headers = new Headers(originalRequest.headers)
-      headers.set(INTERNAL_FETCH_HEADER, "true")
-      const proxyRequest = new Request(internalUrl, {
-        method: originalRequest.method,
-        headers,
-      })
+) {
+  const bunPrefix = `/.BunRoute-${Random.token(6)}`
+  const bunLoad = () => load().then(mod => "default" in mod ? mod.default : mod)
+  const descriptors = { bunPrefix, bunLoad, format: "html" as const }
+  return function<
+    D extends Route.RouteDescriptor.Any,
+    B extends {},
+    I extends Route.Route.Tuple,
+  >(
+    self: Route.RouteSet.RouteSet<D, B, I>,
+  ): Route.RouteSet.RouteSet<
+    D,
+    B,
+    [
+      ...I,
+      Route.Route.Route<
+        BunDescriptors & { format: "html" },
+        { request: Request },
+        string,
+        BunRouteError,
+        BunHttpServer.BunHttpServer
+      >,
+    ]
+  > {
+    const handler: Route.Route.Handler<
+      BunDescriptors & { format: "html" } & { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    > = (context, next) =>
+      Effect.gen(function*() {
+        const originalRequest = context.request
+        if (
+          originalRequest.headers.get(INTERNAL_FETCH_HEADER) === "true"
+        ) {
+          const url = new URL(originalRequest.url)
+          return yield* Effect.fail(
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: url.pathname,
+              message:
+                "Request to internal Bun server was caught by BunRoute handler. This should not happen. Please report a bug.",
+            }),
+          )
+        }
-      const response = yield* Effect.tryPromise({
-        try: () => fetch(proxyRequest),
-        catch: (error) =>
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: internalPath,
-            message: `Failed to fetch internal HTML bundle: ${String(error)}`,
-          }),
-      })
+        const bunServer = yield* BunHttpServer.BunHttpServer
+        const url = new URL(originalRequest.url)
+        const internalPath = `${bunPrefix}${url.pathname}`
+        const internalUrl = new URL(internalPath, bunServer.server.url)
+        const headers = new Headers(originalRequest.headers)
+        headers.set(INTERNAL_FETCH_HEADER, "true")
+        const proxyRequest = new Request(internalUrl, {
+          method: originalRequest.method,
+          headers,
+        })
+        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)}`,
+            }),
+        })
+        let html = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (error) =>
+            new BunRouteError({
+              reason: "ProxyError",
+              pattern: internalPath,
+              message: String(error),
+            }),
+        })
+        const childEntity = yield* Entity.resolve(next(context))
+        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 {
+            childrenHtml = String(children)
+          }
+        }
+        html = html.replace(/%children%/g, childrenHtml)
-      let html = yield* Effect.tryPromise({
-        try: () => response.text(),
-        catch: (error) =>
-          new Router.RouterError({
-            reason: "ProxyError",
-            pattern: internalPath,
-            message: String(error),
-          }),
+        return Entity.make(html, {
+          status: response.status,
+          headers: {
+            "content-type": response.headers.get("content-type"),
+          },
+        })
       })
-      const children = yield* next()
-      let childrenHtml = ""
-      if (children != null) {
-        if (HttpServerResponse.isServerResponse(children)) {
-          const webResponse = HttpServerResponse.toWeb(children)
-          childrenHtml = yield* Effect.promise(() => webResponse.text())
-        } else if (Hyper.isGenericJsxObject(children)) {
-          childrenHtml = HyperHtml.renderToString(children)
-        } else {
-          childrenHtml = String(children)
-        }
-      }
-      html = html.replace(/%yield%/g, childrenHtml)
-      html = html.replace(
-        /%slots\.(\w+)%/g,
-        (_, name) => context.slots[name] ?? "",
-      )
-      return html
-    })
-  return Object.assign(handler, {
-    [BunHandlerTypeId]: BunHandlerTypeId,
-    internalPathPrefix,
-    load: () => load().then(mod => "default" in mod ? mod.default : mod),
-  }) as BunHandler
+    const route = Route.make<
+      BunDescriptors & { format: "html" },
+      { request: Request },
+      string,
+      BunRouteError,
+      BunHttpServer.BunHttpServer
+    >(handler, descriptors)
+    return Route.set(
+      [...Route.items(self), route] as any,
+      Route.descriptor(self),
+    )
+  }
 }
 type BunServerFetchHandler = (
@@ -127,14 +174,6 @@ type BunServerRouteHandler =
 export type BunRoutes = Record<string, BunServerRouteHandler>
-type MethodHandlers = Partial<
-  Record<Bun.Serve.HTTPMethod, BunServerFetchHandler>
->
-function isMethodHandlers(value: unknown): value is MethodHandlers {
-  return typeof value === "object" && value !== null && !("index" in value)
-}
 /**
  * Validates that a route pattern can be implemented with Bun.serve routes.
  *
@@ -156,7 +195,7 @@ function isMethodHandlers(value: unknown): value is MethodHandlers {
 export function validateBunPattern(
   pattern: string,
-): Option.Option<Router.RouterError> {
+): Option.Option<BunRouteError> {
   const segments = RouterPattern.parse(pattern)
   const unsupported = Array.findFirst(segments, (seg) => {
@@ -169,7 +208,7 @@ export function validateBunPattern(
   if (Option.isSome(unsupported)) {
     return Option.some(
-      new Router.RouterError({
+      new BunRouteError({
         reason: "UnsupportedPattern",
         pattern,
         message:
@@ -182,7 +221,7 @@ export function validateBunPattern(
   return Option.none()
 }
-export const isHTMLBundle = (handle: any) => {
+export const isHtmlBundle = (handle: any) => {
   return (
     typeof handle === "object"
     && handle !== null

package/src/hyper/HyperHtml.test.ts CHANGED Viewed

@@ -88,3 +88,122 @@ test.it("mixed boolean and string attributes", () => {
     .expect(html)
     .toBe("<input type=\"checkbox\" checked name=\"test\" value=\"on\">")
 })
+test.it("data-* attributes with object values are JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-signals": {
+      draft: "",
+      pendingDraft: "",
+      username: "User123",
+    },
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe(
+      "<div data-signals=\"{&quot;draft&quot;:&quot;&quot;,&quot;pendingDraft&quot;:&quot;&quot;,&quot;username&quot;:&quot;User123&quot;}\"></div>",
+    )
+})
+test.it("data-* attributes with array values are JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-items": [1, 2, 3],
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe("<div data-items=\"[1,2,3]\"></div>")
+})
+test.it("data-* attributes with nested object values", () => {
+  const node = HyperNode.make("div", {
+    "data-config": {
+      user: { name: "John", active: true },
+      settings: { theme: "dark" },
+    },
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe(
+      "<div data-config=\"{&quot;user&quot;:{&quot;name&quot;:&quot;John&quot;,&quot;active&quot;:true},&quot;settings&quot;:{&quot;theme&quot;:&quot;dark&quot;}}\"></div>",
+    )
+})
+test.it("data-* string values are not JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    "data-value": "hello world",
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe("<div data-value=\"hello world\"></div>")
+})
+test.it("non-data attributes with object values are not JSON stringified", () => {
+  const node = HyperNode.make("div", {
+    style: "color: red",
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe("<div style=\"color: red\"></div>")
+})
+test.it("script with function child renders as IIFE", () => {
+  const handler = (window: Window) => {
+    console.log("Hello from", window.document.title)
+  }
+  const node = HyperNode.make("script", {
+    children: handler,
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe(`<script>(${handler.toString()})(window)</script>`)
+})
+test.it("script with arrow function child renders as IIFE", () => {
+  const node = HyperNode.make("script", {
+    children: (window: Window) => {
+      window.alert("test")
+    },
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toContain("<script>(")
+  test
+    .expect(html)
+    .toContain(")(window)</script>")
+  test
+    .expect(html)
+    .toContain("window.alert")
+})
+test.it("script with string child renders normally", () => {
+  const node = HyperNode.make("script", {
+    children: "console.log('hello')",
+  })
+  const html = HyperHtml.renderToString(node)
+  test
+    .expect(html)
+    .toBe("<script>console.log(&apos;hello&apos;)</script>")
+})

package/src/hyper/HyperHtml.ts CHANGED Viewed

@@ -120,8 +120,13 @@ export function renderToString(
             result += ` ${esc(key)}`
           } else {
             const resolvedKey = key === "className" ? "class" : key
+            const value = props[key]
-            result += ` ${esc(resolvedKey)}="${esc(props[key])}"`
+            if (key.startsWith("data-") && typeof value === "object") {
+              result += ` ${esc(resolvedKey)}="${esc(JSON.stringify(value))}"`
+            } else {
+              result += ` ${esc(resolvedKey)}="${esc(value)}"`
+            }
           }
         }
       }
@@ -139,7 +144,10 @@ export function renderToString(
           result += html
         } else {
           const children = props.children
-          if (Array.isArray(children)) {
+          if (type === "script" && typeof children === "function") {
+            result += `(${children.toString()})(window)`
+          } else if (Array.isArray(children)) {
             for (let i = children.length - 1; i >= 0; i--) {
               stack.push(children[i])
             }

package/src/hyper/HyperNode.ts CHANGED Viewed

@@ -12,6 +12,8 @@ export type Props = {
     | Primitive
     | HyperNode
     | Iterable<Primitive | HyperNode>
+    | Record<string, unknown>
+    | ((window: Window) => void)
 }
 export type HyperComponent = (