@fragno-dev/core 0.1.11 → 0.2.2

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

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, expectTypeOf } from "vitest";
+
+import { z } from "zod";
+
+import type { RequestThisContext } from "./api";
 import { defineFragment } from "./fragment-definition-builder";
 import {
   instantiate,
@@ -7,8 +11,6 @@ import {
 } from "./fragment-instantiator";
 import { defineRoute, defineRoutes, type AnyFragmentDefinition } from "./route";
 import type { FragnoPublicConfig } from "./shared-types";
-import type { RequestThisContext } from "./api";
-import { z } from "zod";
 
 describe("fragment-instantiator", () => {
   describe("basic instantiation", () => {
@@ -416,6 +418,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 +502,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", () => {
@@ -803,6 +1019,48 @@ describe("fragment-instantiator", () => {
 
       expect(contextCreationSpy).toHaveBeenCalledTimes(2);
     });
+
+    it("should store lifecycle waitUntil in request storage", async () => {
+      const requestWaitUntilSymbol = Symbol.for("fragno-request-wait-until");
+      const waitUntil = vi.fn();
+
+      const definition = defineFragment("test-fragment")
+        .withRequestStorage(() => ({}))
+        .withThisContext(({ storage }) => {
+          const ctx = {
+            get waitUntil() {
+              return (storage.getStore() as Record<symbol, unknown>)[requestWaitUntilSymbol];
+            },
+          };
+          return { serviceContext: ctx, handlerContext: ctx };
+        })
+        .build();
+
+      const routes = defineRoutes(definition).create(({ defineRoute }) => [
+        defineRoute({
+          method: "GET",
+          path: "/test",
+          handler: async function (_input, { json }) {
+            return json({
+              hasWaitUntil: typeof this.waitUntil === "function",
+              sameWaitUntil: this.waitUntil === waitUntil,
+            });
+          },
+        }),
+      ]);
+
+      const fragment = instantiate(definition)
+        .withRoutes([routes])
+        .withOptions({ mountRoute: "/api" })
+        .build();
+
+      const response = await fragment.handler(new Request("http://localhost/api/test"), {
+        waitUntil,
+      });
+      const data = await response.json();
+
+      expect(data).toEqual({ hasWaitUntil: true, sameWaitUntil: true });
+    });
   });
 
   describe("defineService with custom this context", () => {
@@ -1251,188 +1509,75 @@ describe("fragment-instantiator", () => {
     });
   });
 
-  describe("linked fragments", () => {
-    it("should instantiate linked fragments with the parent fragment", () => {
-      interface Config {
-        apiKey: string;
-      }
-
-      // Create a linked fragment definition
-      const linkedFragmentDef = defineFragment<Config>("linked-fragment")
-        .providesService("linkedService", () => ({
-          getValue: () => "from-linked",
-        }))
-        .build();
-
-      // Create main fragment with linked fragment
-      const definition = defineFragment<Config>("main-fragment")
-        .withLinkedFragment("internal", ({ config, options }) => {
-          return instantiate(linkedFragmentDef).withConfig(config).withOptions(options).build();
-        })
-        .build();
-
-      const fragment = instantiate(definition)
-        .withConfig({ apiKey: "test-key" })
-        .withOptions({ mountRoute: "/api" })
-        .build();
-
-      // Verify linked fragment exists
-      expect(Object.keys(fragment.$internal.linkedFragments).length).toBe(1);
-      expect("internal" in fragment.$internal.linkedFragments).toBe(true);
-
-      const linkedFragment = fragment.$internal.linkedFragments.internal;
-      expect(linkedFragment).toBeDefined();
-      expect(linkedFragment?.name).toBe("linked-fragment");
-    });
-
-    it("should pass config and options to linked fragments", () => {
-      interface Config {
-        value: string;
-      }
-
-      interface Options extends FragnoPublicConfig {
-        customOption: string;
-      }
-
-      const linkedFragmentDef = defineFragment<Config, Options>("linked-fragment")
-        .withDependencies(({ config, options }) => ({
-          combined: `${config.value}-${options.customOption}`,
-        }))
-        .build();
-
-      const definition = defineFragment<Config, Options>("main-fragment")
-        .withLinkedFragment("internal", ({ config, options }) => {
-          return instantiate(linkedFragmentDef).withConfig(config).withOptions(options).build();
-        })
-        .build();
-
-      const fragment = instantiate(definition)
-        .withConfig({ value: "config" })
-        .withOptions({ customOption: "option", mountRoute: "/api" } as Options)
-        .build();
-
-      const linkedFragment = fragment.$internal.linkedFragments.internal;
-      expect(linkedFragment?.$internal.deps).toEqual({
-        combined: "config-option",
-      });
-    });
-
-    it("should allow linked fragments to provide services", () => {
-      const linkedFragmentDef = defineFragment("linked-fragment")
-        .providesService("settingsService", () => ({
-          get: (key: string) => `value-for-${key}`,
-          set: (key: string, value: string) => {
-            console.log(`Setting ${key} = ${value}`);
-          },
-        }))
-        .build();
-
+  describe("internal routes", () => {
+    it("should mount internal routes under /_internal", async () => {
       const definition = defineFragment("main-fragment")
-        .withLinkedFragment("internal", ({ config, options }) => {
-          return instantiate(linkedFragmentDef).withConfig(config).withOptions(options).build();
-        })
+        .withInternalRoutes([
+          defineRoute({
+            method: "GET",
+            path: "/status",
+            handler: async (_input, { json }) => {
+              return json({ ok: true });
+            },
+          }),
+        ])
         .build();
 
       const fragment = instantiate(definition).withOptions({}).build();
 
-      const linkedFragment = fragment.$internal.linkedFragments.internal;
-      expect(linkedFragment?.services.settingsService).toBeDefined();
-      expect(linkedFragment?.services.settingsService.get("test")).toBe("value-for-test");
+      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 support multiple linked fragments", () => {
-      const linkedFragmentDef1 = defineFragment("linked-fragment-1")
-        .providesService("service1", () => ({ method: () => "service1" }))
-        .build();
-
-      const linkedFragmentDef2 = defineFragment("linked-fragment-2")
-        .providesService("service2", () => ({ method: () => "service2" }))
-        .build();
-
+    it("should mount internal routes under the fragment mount route", async () => {
       const definition = defineFragment("main-fragment")
-        .withLinkedFragment("internal1", ({ config, options }) => {
-          return instantiate(linkedFragmentDef1).withConfig(config).withOptions(options).build();
-        })
-        .withLinkedFragment("internal2", ({ config, options }) => {
-          return instantiate(linkedFragmentDef2).withConfig(config).withOptions(options).build();
-        })
+        .withInternalRoutes([
+          defineRoute({
+            method: "GET",
+            path: "/status",
+            handler: async (_input, { json }) => {
+              return json({ ok: true });
+            },
+          }),
+        ])
         .build();
 
-      const fragment = instantiate(definition).withOptions({}).build();
-
-      expect(Object.keys(fragment.$internal.linkedFragments).length).toBe(2);
-      expect("internal1" in fragment.$internal.linkedFragments).toBe(true);
-      expect("internal2" in fragment.$internal.linkedFragments).toBe(true);
-
-      const linked1 = fragment.$internal.linkedFragments.internal1;
-      const linked2 = fragment.$internal.linkedFragments.internal2;
+      const fragment = instantiate(definition).withOptions({ mountRoute: "/api" }).build();
 
-      expect(linked1?.services.service1.method()).toBe("service1");
-      expect(linked2?.services.service2.method()).toBe("service2");
+      const request = new Request("http://localhost/api/_internal/status");
+      const response = await fragment.handler(request);
+      expect(response.status).toBe(200);
+      await expect(response.json()).resolves.toEqual({ ok: true });
     });
 
-    it("should pass service dependencies to linked fragments", () => {
-      interface ExternalService {
-        getValue: () => string;
-      }
-
-      const externalService: ExternalService = {
-        getValue: () => "external-value",
-      };
-
-      const linkedFragmentDef = defineFragment("linked-fragment")
-        .usesService<"externalService", ExternalService>("externalService")
-        .providesService("linkedService", ({ serviceDeps }) => ({
-          getFromExternal: () => serviceDeps.externalService.getValue(),
-        }))
-        .build();
-
-      const definition = defineFragment("main-fragment")
-        .usesService<"externalService", ExternalService>("externalService")
-        .withLinkedFragment("internal", ({ config, options, serviceDependencies }) => {
-          return instantiate(linkedFragmentDef)
-            .withConfig(config)
-            .withOptions(options)
-            .withServices(serviceDependencies!)
-            .build();
-        })
-        .build();
-
-      const fragment = instantiate(definition)
-        .withOptions({})
-        .withServices({ externalService })
-        .build();
-
-      const linkedFragment = fragment.$internal.linkedFragments.internal;
-      expect(linkedFragment?.services.linkedService.getFromExternal()).toBe("external-value");
-    });
+    it("should resolve internal route factories with services", async () => {
+      const definitionBuilder = defineFragment("main-fragment").providesService(
+        "statusService",
+        () => ({
+          getStatus: () => ({ ok: true }),
+        }),
+      );
 
-    it("should expose linked fragment services as private services", () => {
-      const linkedFragmentDef = defineFragment("linked-fragment")
-        .providesService("linkedService", () => ({
-          getValue: () => "from-linked",
-        }))
-        .build();
+      const internalRoutes = defineRoutes(definitionBuilder.build()).create(
+        ({ services, defineRoute }) => [
+          defineRoute({
+            method: "GET",
+            path: "/status",
+            handler: async (_input, { json }) => {
+              return json(services.statusService.getStatus());
+            },
+          }),
+        ],
+      );
 
-      const definition = defineFragment("main-fragment")
-        .withLinkedFragment("internal", ({ config, options }) => {
-          return instantiate(linkedFragmentDef).withConfig(config).withOptions(options).build();
-        })
-        .providesService("mainService", ({ privateServices }) => ({
-          getLinkedValue: () => {
-            return privateServices.linkedService.getValue();
-          },
-        }))
-        .build();
+      const definition = definitionBuilder.withInternalRoutes([internalRoutes]).build();
 
       const fragment = instantiate(definition).withOptions({}).build();
 
-      // The main service can access linked fragment services via privateServices
-      expect(fragment.services.mainService.getLinkedValue()).toBe("from-linked");
-
-      // Linked fragment services are NOT directly exposed on the main fragment
-      // @ts-expect-error - Linked fragment service should not be accessible
-      expect(fragment.services.linkedService).toBeUndefined();
+      const response = await fragment.callRouteRaw("GET", "/_internal/status" as never);
+      expect(response.status).toBe(200);
+      await expect(response.json()).resolves.toEqual({ ok: true });
     });
   });