saeeol 1.2.5 → 1.2.7

package/test/server/workspace-proxy.test.ts

@@ -1,165 +0,0 @@
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import Http from "node:http"
-import { describe, expect } from "bun:test"
-import { Context, Effect, Layer, Queue } from "effect"
-import { FetchHttpClient, HttpClient, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { HttpApiProxy } from "../../src/server/routes/instance/httpapi/middleware/proxy"
-import { testEffect } from "../lib/effect"
-
-function serverUrl() {
-  return HttpServer.HttpServer.use((server) => Effect.succeed(HttpServer.formatAddress(server.address)))
-}
-
-const testServerLayer = Layer.mergeAll(
-  NodeHttpServer.layer(Http.createServer, { host: "127.0.0.1", port: 0 }),
-  NodeServices.layer,
-  FetchHttpClient.layer,
-  Socket.layerWebSocketConstructorGlobal,
-)
-const it = testEffect(testServerLayer)
-
-type TestHandler<E, R> = (
-  request: HttpServerRequest.HttpServerRequest,
-) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
-
-function listenServer<E, R>(handler: TestHandler<E, R>) {
-  return Effect.gen(function* () {
-    yield* HttpServer.serveEffect()(HttpServerRequest.HttpServerRequest.use(handler))
-    return yield* serverUrl()
-  })
-}
-
-function listenTestServer<E, R>(handler: TestHandler<E, R>) {
-  return Effect.gen(function* () {
-    // Build into the current test scope so the listener stays alive until the
-    // test finishes. Using Effect.provide here would release it immediately.
-    const context = yield* Layer.build(NodeHttpServer.layer(Http.createServer, { host: "127.0.0.1", port: 0 }))
-    const server = Context.get(context, HttpServer.HttpServer)
-    yield* server.serve(HttpServerRequest.HttpServerRequest.use(handler))
-    return HttpServer.formatAddress(server.address)
-  })
-}
-
-function echoWebSocket(request: HttpServerRequest.HttpServerRequest) {
-  return Effect.gen(function* () {
-    const socket = yield* Effect.orDie(request.upgrade)
-    const write = yield* socket.writer
-    // The upstream announces the negotiated protocol, then echoes every
-    // received frame. The assertions use those messages to prove proxy flow.
-    yield* socket
-      .runRaw((message) => write(`echo:${String(message)}`), {
-        onOpen: write(`protocol:${request.headers["sec-websocket-protocol"] ?? "none"}`).pipe(
-          Effect.catch(() => Effect.void),
-        ),
-      })
-      .pipe(Effect.catch(() => Effect.void))
-    return HttpServerResponse.empty()
-  })
-}
-
-describe("HttpApi workspace proxy", () => {
-  it.live("proxies HTTP request and returns streamed response with status and headers", () =>
-    Effect.gen(function* () {
-      const url = yield* listenServer(
-        Effect.fnUntraced(function* (req: HttpServerRequest.HttpServerRequest) {
-          const body = yield* req.text
-          return yield* HttpServerResponse.json(
-            { path: req.url, method: req.method, body },
-            {
-              status: 201,
-              headers: {
-                "content-encoding": "identity",
-                "content-length": "999",
-                "x-remote": "yes",
-              },
-            },
-          )
-        }),
-      )
-
-      const request = HttpServerRequest.fromWeb(
-        new Request("http://localhost/session/abc", { method: "POST", body: "request-body" }),
-      )
-      const httpClient = yield* HttpClient.HttpClient
-      const response = yield* HttpApiProxy.http(
-        httpClient,
-        `${url}/session/abc?keep=yes`,
-        { "x-extra": "injected" },
-        request,
-      )
-
-      expect(response.status).toBe(201)
-      const client = HttpServerResponse.toClientResponse(response)
-      expect(yield* client.json).toEqual({
-        path: "/session/abc?keep=yes",
-        method: "POST",
-        body: "request-body",
-      })
-      expect(response.headers["x-remote"]).toBe("yes")
-      expect(response.headers["content-encoding"]).toBeUndefined()
-      expect(response.headers["content-length"]).toBeUndefined()
-    }),
-  )
-
-  it.live("returns 500 when remote is unreachable", () =>
-    Effect.gen(function* () {
-      const request = HttpServerRequest.fromWeb(new Request("http://localhost/anything"))
-      const httpClient = yield* HttpClient.HttpClient
-      const response = yield* HttpApiProxy.http(httpClient, "http://127.0.0.1:1/unreachable", undefined, request)
-
-      expect(response.status).toBe(500)
-    }),
-  )
-
-  it.live("strips saeeol-internal headers and merges extra headers", () =>
-    Effect.gen(function* () {
-      let forwarded: Record<string, string> = {}
-      const url = yield* listenServer((req) =>
-        Effect.sync(() => {
-          forwarded = req.headers
-          return HttpServerResponse.empty()
-        }),
-      )
-
-      const request = HttpServerRequest.fromWeb(
-        new Request("http://localhost/test", {
-          headers: {
-            "x-saeeol-directory": "/secret/path",
-            "x-saeeol-workspace": "ws_123",
-            "x-custom": "preserved",
-          },
-        }),
-      )
-      const httpClient = yield* HttpClient.HttpClient
-      yield* HttpApiProxy.http(httpClient, `${url}/test`, { "x-injected": "extra" }, request)
-
-      expect(forwarded["x-saeeol-directory"]).toBeUndefined()
-      expect(forwarded["x-saeeol-workspace"]).toBeUndefined()
-      expect(forwarded["x-custom"]).toBe("preserved")
-      expect(forwarded["x-injected"]).toBe("extra")
-    }),
-  )
-
-  it.live("proxies websocket messages and protocols", () =>
-    Effect.gen(function* () {
-      const upstreamUrl = yield* listenTestServer(echoWebSocket)
-
-      // Client -> proxy listener -> HttpApiProxy.websocket -> upstream listener.
-      // The client never connects to upstream directly.
-      const proxyUrl = yield* listenServer((request) => HttpApiProxy.websocket(request, `${upstreamUrl}/echo`))
-
-      const socket = yield* Socket.makeWebSocket(`${proxyUrl.replace(/^http/, "ws")}/proxy`, {
-        closeCodeIsError: () => false,
-        protocols: "chat",
-      })
-      const messages = yield* Queue.unbounded<string>()
-      yield* socket.runRaw((message) => Queue.offer(messages, String(message))).pipe(Effect.forkScoped)
-      const write = yield* socket.writer
-
-      expect(yield* Queue.take(messages)).toBe("protocol:chat")
-      yield* write("hello")
-      expect(yield* Queue.take(messages)).toBe("echo:hello")
-    }),
-  )
-})

package/test/server/workspace-routing.test.ts

@@ -1,85 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { isLocalWorkspaceRoute, getWorkspaceRouteSessionID, workspaceProxyURL } from "../../src/server/workspace"
-import { SessionID } from "../../src/session/schema"
-
-describe("isLocalWorkspaceRoute", () => {
-  test("GET /session is local", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session")).toBe(true)
-  })
-
-  test("GET /session/ses_abc is local (prefix match)", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session/ses_abc")).toBe(true)
-  })
-
-  test("POST /session is not local (method mismatch)", () => {
-    expect(isLocalWorkspaceRoute("POST", "/session")).toBe(false)
-  })
-
-  test("/session/status is forwarded regardless of method", () => {
-    expect(isLocalWorkspaceRoute("GET", "/session/status")).toBe(false)
-    expect(isLocalWorkspaceRoute("POST", "/session/status")).toBe(false)
-  })
-
-  test("unrecognized paths are not local", () => {
-    expect(isLocalWorkspaceRoute("GET", "/config")).toBe(false)
-    expect(isLocalWorkspaceRoute("POST", "/session/ses_abc/message")).toBe(false)
-  })
-})
-
-describe("getWorkspaceRouteSessionID", () => {
-  test("extracts session ID from path", () => {
-    const url = new URL("http://localhost/session/ses_abc123/message")
-    expect(getWorkspaceRouteSessionID(url)).toBe(SessionID.make("ses_abc123"))
-  })
-
-  test("extracts session ID without trailing path", () => {
-    const url = new URL("http://localhost/session/ses_xyz")
-    expect(getWorkspaceRouteSessionID(url)).toBe(SessionID.make("ses_xyz"))
-  })
-
-  test("returns null for /session/status", () => {
-    const url = new URL("http://localhost/session/status")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-
-  test("returns null for non-session paths", () => {
-    const url = new URL("http://localhost/config")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-
-  test("returns null for bare /session path", () => {
-    const url = new URL("http://localhost/session")
-    expect(getWorkspaceRouteSessionID(url)).toBeNull()
-  })
-})
-
-describe("workspaceProxyURL", () => {
-  test("appends request path to target", () => {
-    const result = workspaceProxyURL("http://remote:8080/base", new URL("http://localhost/config"))
-    expect(result.toString()).toBe("http://remote:8080/base/config")
-  })
-
-  test("strips trailing slash on target before appending", () => {
-    const result = workspaceProxyURL("http://remote:8080/base/", new URL("http://localhost/session/abc"))
-    expect(result.pathname).toBe("/base/session/abc")
-  })
-
-  test("preserves query params from request but removes workspace", () => {
-    const url = new URL("http://localhost/config?workspace=ws_123&keep=yes")
-    const result = workspaceProxyURL("http://remote:8080/base", url)
-    expect(result.searchParams.get("workspace")).toBeNull()
-    expect(result.searchParams.get("keep")).toBe("yes")
-  })
-
-  test("preserves hash from request", () => {
-    const url = new URL("http://localhost/page#section")
-    const result = workspaceProxyURL("http://remote:8080", url)
-    expect(result.hash).toBe("#section")
-  })
-
-  test("works with URL object as target", () => {
-    const target = new URL("http://remote:3000/api")
-    const result = workspaceProxyURL(target, new URL("http://localhost/users"))
-    expect(result.toString()).toBe("http://remote:3000/api/users")
-  })
-})