@fragno-dev/core 0.1.11 → 0.2.0

package/src/api/fragment-instantiator.test.ts

@@ -416,6 +416,56 @@ describe("fragment-instantiator", () => {
       expect(data).toEqual({ userId: "123" });
     });
 
+    it("should URL decode path params", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "GET",
+        path: "/users/:name",
+        handler: async (input, { json }) => {
+          return json({ userName: input.pathParams.name });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      // URL with encoded space: "a%20b" should be decoded to "a b"
+      const request = new Request("http://localhost/api/users/a%20b");
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ userName: "a b" });
+    });
+
+    it("should URL decode path params with special characters", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "GET",
+        path: "/files/:path",
+        handler: async (input, { json }) => {
+          return json({ filePath: input.pathParams.path });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      // URL with encoded slash: "folder%2Fsubfolder" should be decoded to "folder/subfolder"
+      const request = new Request("http://localhost/api/files/folder%2Fsubfolder");
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ filePath: "folder/subfolder" });
+    });
+
     it("should handle POST requests with body", async () => {
       const definition = defineFragment("test-fragment").build();
 
@@ -450,6 +500,170 @@ describe("fragment-instantiator", () => {
       const data = await response.json();
       expect(data).toEqual({ received: { test: "data" } });
     });
+
+    it("should accept FormData for routes with contentType: multipart/form-data", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "POST",
+        path: "/upload",
+        contentType: "multipart/form-data",
+        handler: async (ctx, { json }) => {
+          const formData = ctx.formData();
+          const description = formData.get("description") as string;
+          return json({ description });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const formData = new FormData();
+      formData.append("description", "Test file upload");
+
+      const request = new Request("http://localhost/api/upload", {
+        method: "POST",
+        body: formData,
+      });
+
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ description: "Test file upload" });
+    });
+
+    it("should reject FormData for JSON routes (default contentType)", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "POST",
+        path: "/json-only",
+        inputSchema: z.object({ name: z.string() }),
+        handler: async ({ input }, { json }) => {
+          const body = await input.valid();
+          return json(body);
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const formData = new FormData();
+      formData.append("name", "test");
+
+      const request = new Request("http://localhost/api/json-only", {
+        method: "POST",
+        body: formData,
+      });
+
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(415);
+      const data = await response.json();
+      expect(data.code).toBe("UNSUPPORTED_MEDIA_TYPE");
+    });
+
+    it("should reject JSON for FormData routes", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "POST",
+        path: "/upload",
+        contentType: "multipart/form-data",
+        handler: async (ctx, { json }) => {
+          // Verify formData() works (would throw if not FormData)
+          ctx.formData();
+          return json({ success: true });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const request = new Request("http://localhost/api/upload", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name: "test" }),
+      });
+
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(415);
+      const data = await response.json();
+      expect(data.code).toBe("UNSUPPORTED_MEDIA_TYPE");
+    });
+
+    it("should accept octet-stream for routes with contentType: application/octet-stream", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "PUT",
+        path: "/stream",
+        contentType: "application/octet-stream",
+        handler: async (ctx, { json }) => {
+          const stream = ctx.bodyStream();
+          const text = await new Response(stream).text();
+          return json({ received: text });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const request = new Request("http://localhost/api/stream", {
+        method: "PUT",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: new TextEncoder().encode("hello"),
+      });
+
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data).toEqual({ received: "hello" });
+    });
+
+    it("should reject JSON for octet-stream routes", async () => {
+      const definition = defineFragment("test-fragment").build();
+
+      const route = defineRoute({
+        method: "PUT",
+        path: "/stream",
+        contentType: "application/octet-stream",
+        handler: async (ctx, { json }) => {
+          if (!ctx.isBodyStream()) {
+            throw new Error("Expected stream body");
+          }
+          return json({ ok: true });
+        },
+      });
+
+      const fragment = instantiate(definition)
+        .withRoutes([route])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const request = new Request("http://localhost/api/stream", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ hello: "world" }),
+      });
+
+      const response = await fragment.handler(request);
+
+      expect(response.status).toBe(415);
+      const data = await response.json();
+      expect(data.code).toBe("UNSUPPORTED_MEDIA_TYPE");
+    });
   });
 
   describe("callRoute", () => {
@@ -1285,6 +1499,78 @@ describe("fragment-instantiator", () => {
       expect(linkedFragment?.name).toBe("linked-fragment");
     });
 
+    it("should mount internal linked fragment routes under /_internal", async () => {
+      const linkedFragmentDef = defineFragment("linked-fragment").build();
+      const linkedRoutes = defineRoutes(linkedFragmentDef).create(({ defineRoute }) => [
+        defineRoute({
+          method: "GET",
+          path: "/status",
+          handler: async (_input, { json }) => {
+            return json({ ok: true });
+          },
+        }),
+      ]);
+
+      const definition = defineFragment("main-fragment")
+        .withLinkedFragment("_fragno_internal", ({ config, options }) => {
+          return instantiate(linkedFragmentDef)
+            .withConfig(config)
+            .withOptions(options)
+            .withRoutes([linkedRoutes])
+            .build();
+        })
+        .build();
+
+      const fragment = instantiate(definition).withOptions({}).build();
+
+      const response = await fragment.callRouteRaw("GET", "/_internal/status" as never);
+      expect(response.status).toBe(200);
+      await expect(response.json()).resolves.toEqual({ ok: true });
+    });
+
+    it("should run middleware set on the internal fragment", async () => {
+      const linkedFragmentDef = defineFragment("linked-fragment").build();
+      const linkedRoutes = defineRoutes(linkedFragmentDef).create(({ defineRoute }) => [
+        defineRoute({
+          method: "GET",
+          path: "/status",
+          handler: async (_input, { json }) => {
+            return json({ ok: true });
+          },
+        }),
+      ]);
+
+      const definition = defineFragment("main-fragment")
+        .withLinkedFragment("_fragno_internal", ({ config, options }) => {
+          return instantiate(linkedFragmentDef)
+            .withConfig(config)
+            .withOptions(options)
+            .withRoutes([linkedRoutes])
+            .build();
+        })
+        .build();
+
+      const fragment = instantiate(definition).withOptions({ mountRoute: "/api" }).build();
+
+      const internalFragment = fragment.$internal.linkedFragments._fragno_internal;
+      internalFragment.withMiddleware(async ({ ifMatchesRoute }) => {
+        const result = await ifMatchesRoute("GET", "/status", async (_input, { json }) => {
+          return json({ ok: false, source: "internal-middleware" }, 418);
+        });
+
+        return result;
+      });
+
+      const response = await fragment.handler(
+        new Request("http://localhost/api/_internal/status", {
+          method: "GET",
+        }),
+      );
+
+      expect(response.status).toBe(418);
+      expect(await response.json()).toEqual({ ok: false, source: "internal-middleware" });
+    });
+
     it("should pass config and options to linked fragments", () => {
       interface Config {
         value: string;