effect-start 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-start",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "license": "MIT",
   "exports": {
@@ -15,11 +15,13 @@
     "./jsx-runtime": "./src/jsx-runtime.ts",
     "./jsx-dev-runtime": "./src/jsx-runtime.ts",
     "./hyper": "./src/hyper/index.ts",
-    "./x/*": "./src/x/*/index.ts"
+    "./x/*": "./src/x/*/index.ts",
+    "./middlewares/BasicAuthMiddleware": "./src/middlewares/BasicAuthMiddleware.ts",
+    "./assets.d.ts": "./src/assets.d.ts"
   },
   "scripts": {
     "format": "bunx dprint fmt",
-    "test": "bun test src/",
+    "test": "bun test ./src/",
     "deploy": "bunx npm publish --access public"
   },
   "dependencies": {

package/src/FileHttpRouter.test.ts

@@ -61,7 +61,7 @@ t.it("HTTP methods", () =>
           .post(Route.html(Effect.succeed("POST")))
           .put(Route.html(Effect.succeed("PUT")))
           .patch(Route.html(Effect.succeed("PATCH")))
-          .del(Route.html(Effect.succeed("DELETE")))
+          .delete(Route.html(Effect.succeed("DELETE")))
           .options(Route.html(Effect.succeed("OPTIONS")))
           .head(Route.html(Effect.succeed("HEAD"))),
       }),
@@ -148,19 +148,19 @@ t.it(
         {
           path: "/api-v1",
           load: async () => ({
-            default: Route.text(Effect.succeed("API v1")),
+            default: Route.text("API v1"),
           }),
         },
         {
           path: "/files~backup",
           load: async () => ({
-            default: Route.text(Effect.succeed("Backup files")),
+            default: Route.text("Backup files"),
           }),
         },
         {
           path: "/test-route~temp",
           load: async () => ({
-            default: Route.post(Route.text(Effect.succeed("Test route"))),
+            default: Route.post(Route.text("Test route")),
           }),
         },
       ]

package/src/FileHttpRouter.ts

@@ -146,8 +146,6 @@ export function make<
     let router: HttpRouter.HttpRouter<any, any> = HttpRouter.empty
 
     for (const { path, routeSet, layers } of routesWithModules) {
-      const httpRouterPath = RouterPattern.toHttpPath(path)
-
       for (const route of routeSet.set) {
         const matchingLayerRoutes = findMatchingLayerRoutes(route, layers)
 
@@ -182,12 +180,12 @@ export function make<
           finalHandler = middleware(finalHandler)
         }
 
-        router = HttpRouter.route(route.method)(
-          httpRouterPath,
-          finalHandler as any,
-        )(
-          router,
-        )
+        for (const pattern of RouterPattern.toEffect(path)) {
+          router = HttpRouter.route(route.method)(
+            pattern,
+            finalHandler as any,
+          )(router)
+        }
       }
     }
 

package/src/FileRouter.ts

@@ -63,7 +63,7 @@ export function parseRoute(
     )
   }
 
-  // Validate Route constraints: rest segments must be the last segment before the handle
+  // rest segments must be the last segment before the handle
   const pathSegments = segs.slice(0, -1) // All segments except the handle
   const restIndex = pathSegments.findIndex(seg => seg._tag === "RestSegment")
 
@@ -75,7 +75,7 @@ export function parseRoute(
       )
     }
 
-    // Validate that all segments before the rest are literal, param, or group
+    // all segments before the rest must be literal, param, or group
     for (let i = 0; i < restIndex; i++) {
       const seg = pathSegments[i]
       if (
@@ -89,7 +89,7 @@ export function parseRoute(
       }
     }
   } else {
-    // No rest: validate that all path segments are literal, param, or group
+    // No rest: all path segments are literal, param, or group
     for (const seg of pathSegments) {
       if (
         seg._tag !== "LiteralSegment"
@@ -103,8 +103,6 @@ export function parseRoute(
     }
   }
 
-  // Construct routePath from path segments (excluding groups)
-  // Groups like (admin) are stripped from the URL path
   const routePathSegments = pathSegments.filter(
     seg => seg._tag !== "GroupSegment",
   )
@@ -166,7 +164,7 @@ export function layer(options: {
   load: () => Promise<Router.RouterManifest>
   path: string
 }) {
-  return Layer.mergeAll(
+  return Layer.provide(
     Layer.effect(
       Router.Router,
       Effect.promise(() => options.load()),

package/src/FileRouterCodegen.test.ts

@@ -329,7 +329,7 @@ t.it("handles routes with hyphens and underscores in path segments", () => {
 })
 
 t.it("validateRouteModule returns true for valid modules", () => {
-  const validRoute = Route.text(Effect.succeed("Hello"))
+  const validRoute = Route.text("Hello")
 
   t
     .expect(
@@ -348,7 +348,7 @@ t.it("validateRouteModule returns true for valid modules", () => {
   t
     .expect(
       FileRouterCodegen.validateRouteModule({
-        default: Route.json(Effect.succeed({ message: "Hello" })),
+        default: Route.json({ message: "Hello" }),
       }),
     )
     .toBe(true)

package/src/HttpAppExtra.test.ts

@@ -0,0 +1,84 @@
+import { HttpServerRequest } from "@effect/platform"
+import { RouteNotFound } from "@effect/platform/HttpServerError"
+import * as t from "bun:test"
+import {
+  Effect,
+  Layer,
+} from "effect"
+import * as Cause from "effect/Cause"
+import * as HttpAppExtra from "./HttpAppExtra.ts"
+import { effectFn } from "./testing.ts"
+
+const mockRequest = HttpServerRequest.HttpServerRequest.of({
+  url: "http://localhost:3000/test",
+  method: "GET",
+  headers: {
+    "accept": "application/json",
+    "user-agent": "test",
+  },
+} as any)
+
+const mockRequestLayer = Layer.succeed(
+  HttpServerRequest.HttpServerRequest,
+  mockRequest,
+)
+
+const effect = effectFn(mockRequestLayer)
+
+t.describe("renderError", () => {
+  const routeNotFoundCause = Cause.fail(
+    new RouteNotFound({ request: {} as any }),
+  )
+
+  t.it("returns JSON for Accept: application/json", () =>
+    effect(function*() {
+      const response = yield* HttpAppExtra.renderError(
+        routeNotFoundCause,
+        "application/json",
+      )
+
+      t.expect(response.status).toEqual(404)
+      t.expect(response.headers["content-type"]).toContain("application/json")
+    }))
+
+  t.it("returns HTML for Accept: text/html", () =>
+    effect(function*() {
+      const response = yield* HttpAppExtra.renderError(
+        routeNotFoundCause,
+        "text/html",
+      )
+
+      t.expect(response.status).toEqual(404)
+      t.expect(response.headers["content-type"]).toContain("text/html")
+    }))
+
+  t.it("returns plain text for Accept: text/plain", () =>
+    effect(function*() {
+      const response = yield* HttpAppExtra.renderError(
+        routeNotFoundCause,
+        "text/plain",
+      )
+
+      t.expect(response.status).toEqual(404)
+      t.expect(response.headers["content-type"]).toContain("text/plain")
+    }))
+
+  t.it("returns JSON by default (no Accept header)", () =>
+    effect(function*() {
+      const response = yield* HttpAppExtra.renderError(routeNotFoundCause, "")
+
+      t.expect(response.status).toEqual(404)
+      t.expect(response.headers["content-type"]).toContain("application/json")
+    }))
+
+  t.it("returns 500 for unexpected errors", () =>
+    effect(function*() {
+      const unexpectedCause = Cause.fail({ message: "Something went wrong" })
+      const response = yield* HttpAppExtra.renderError(
+        unexpectedCause,
+        "application/json",
+      )
+
+      t.expect(response.status).toEqual(500)
+    }))
+})