@fragno-dev/core 0.1.3 → 0.1.5

package/src/api/request-input-context.test.ts

@@ -42,61 +42,67 @@ describe("RequestContext", () => {
       pathParams: {},
       searchParams: new URLSearchParams(),
       headers: new Headers(),
-      body: undefined,
+      parsedBody: undefined,
     });
 
-    const { path, pathParams, query: searchParams, input, rawBody: body } = ctx;
+    const { path, pathParams, query: searchParams, input, rawBody } = ctx;
 
     expect(path).toBe("/");
     expect(pathParams).toEqual({});
     expect(searchParams).toBeInstanceOf(URLSearchParams);
     expect(input).toBeUndefined();
-    expect(body).toBeUndefined();
+    expect(rawBody).toBeUndefined();
   });
 
   test("Should support body in constructor", () => {
     const jsonBody = { test: "data" };
+    const rawBodyText = JSON.stringify(jsonBody);
     const ctx = new RequestInputContext({
       method: "POST",
       path: "/api/test",
       pathParams: {},
       searchParams: new URLSearchParams(),
       headers: new Headers(),
-      body: jsonBody,
+      parsedBody: jsonBody,
+      rawBody: rawBodyText,
     });
 
-    expect(ctx.rawBody).toEqual(jsonBody);
+    expect(ctx.rawBody).toEqual(rawBodyText);
   });
 
   test("Should support FormData body", () => {
     const formData = new FormData();
     formData.append("key", "value");
+    const rawBodyText = "form-data-as-text";
 
     const ctx = new RequestInputContext({
       path: "/api/form",
       pathParams: {},
       searchParams: new URLSearchParams(),
       headers: new Headers(),
-      body: formData,
+      parsedBody: formData,
+      rawBody: rawBodyText,
       method: "POST",
     });
 
-    expect(ctx.rawBody).toBe(formData);
+    expect(ctx.rawBody).toBe(rawBodyText);
   });
 
   test("Should support Blob body", () => {
     const blob = new Blob(["test content"], { type: "text/plain" });
+    const rawBodyText = "test content";
 
     const ctx = new RequestInputContext({
       path: "/api/upload",
       pathParams: {},
       searchParams: new URLSearchParams(),
       headers: new Headers(),
-      body: blob,
+      parsedBody: blob,
+      rawBody: rawBodyText,
       method: "POST",
     });
 
-    expect(ctx.rawBody).toBe(blob);
+    expect(ctx.rawBody).toBe(rawBodyText);
   });
 
   test("Should create RequestContext with fromRequest static method", async () => {
@@ -105,10 +111,10 @@ describe("RequestContext", () => {
       body: JSON.stringify({ test: "data" }),
     });
 
-    const bodyData = { test: "data" };
     const url = new URL(request.url);
     const clonedReq = request.clone();
     const body = clonedReq.body instanceof ReadableStream ? await clonedReq.json() : undefined;
+    const rawBodyText = JSON.stringify({ test: "data" });
 
     const state = new MutableRequestState({
       pathParams: {},
@@ -123,10 +129,11 @@ describe("RequestContext", () => {
       path: "/api/test",
       pathParams: {},
       state,
+      rawBody: rawBodyText,
     });
 
     expect(ctx.path).toBe("/api/test");
-    expect(ctx.rawBody).toEqual(bodyData);
+    expect(ctx.rawBody).toEqual(rawBodyText);
   });
 
   test("Should create RequestContext with fromSSRContext static method", () => {
@@ -139,7 +146,8 @@ describe("RequestContext", () => {
     });
 
     expect(ctx.path).toBe("/api/ssr");
-    expect(ctx.rawBody).toEqual(bodyData);
+    // rawBody is not set in fromSSRContext
+    expect(ctx.rawBody).toBeUndefined();
   });
 
   describe("Input handling", () => {
@@ -149,7 +157,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: { test: "data" },
+        parsedBody: { test: "data" },
         method: "POST",
       });
 
@@ -162,7 +170,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: { test: "data" },
+        parsedBody: { test: "data" },
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -178,7 +186,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: "test string",
+        parsedBody: "test string",
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -193,7 +201,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: 123, // Invalid for string schema
+        parsedBody: 123, // Invalid for string schema
         inputSchema: invalidSchema,
         method: "POST",
       });
@@ -207,7 +215,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: 123,
+        parsedBody: 123,
         inputSchema: invalidSchema,
         method: "POST",
       });
@@ -236,13 +244,13 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: 123,
+        parsedBody: 123,
         inputSchema: invalidSchema,
         shouldValidateInput: false,
         method: "POST",
       });
 
-      // Should return the raw body without validation when validation is disabled
+      // Should return the parsed body without validation when validation is disabled
       const result = await ctx.input?.valid();
       expect(result).toBe(123);
     });
@@ -256,7 +264,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: formData,
+        parsedBody: formData,
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -274,7 +282,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: blob,
+        parsedBody: blob,
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -290,7 +298,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: null,
+        parsedBody: null,
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -305,7 +313,7 @@ describe("RequestContext", () => {
         pathParams: {},
         searchParams: new URLSearchParams(),
         headers: new Headers(),
-        body: undefined,
+        parsedBody: undefined,
         inputSchema: validStringSchema,
         method: "POST",
       });
@@ -324,7 +332,7 @@ describe("RequestContext", () => {
         headers: new Headers(),
         inputSchema: validStringSchema,
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       // We can't directly access the private field, but we can test the behavior
@@ -340,7 +348,7 @@ describe("RequestContext", () => {
         inputSchema: validStringSchema,
         shouldValidateInput: true,
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       expect(ctx.input).toBeDefined();
@@ -355,7 +363,7 @@ describe("RequestContext", () => {
         inputSchema: validStringSchema,
         shouldValidateInput: false,
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       expect(ctx.input).toBeDefined();
@@ -406,7 +414,7 @@ describe("RequestContext", () => {
         searchParams: new URLSearchParams(),
         headers: new Headers(),
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       expect(ctx.pathParams).toEqual({});
@@ -419,7 +427,7 @@ describe("RequestContext", () => {
         searchParams: new URLSearchParams(),
         headers: new Headers(),
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       expect(ctx.query.toString()).toBe("");
@@ -433,7 +441,7 @@ describe("RequestContext", () => {
         searchParams,
         headers: new Headers(),
         method: "POST",
-        body: undefined,
+        parsedBody: undefined,
       });
 
       expect(ctx.query.get("key")).toBe("value");

package/src/api/request-input-context.ts

@@ -19,7 +19,8 @@ export class RequestInputContext<
   readonly #pathParams: ExtractPathParams<TPath>;
   readonly #searchParams: URLSearchParams;
   readonly #headers: Headers;
-  readonly #body: RequestBodyType;
+  readonly #body: string | undefined;
+  readonly #parsedBody: RequestBodyType;
   readonly #inputSchema: TInputSchema | undefined;
   readonly #shouldValidateInput: boolean;
 
@@ -28,9 +29,9 @@ export class RequestInputContext<
     method: string;
     pathParams: ExtractPathParams<TPath>;
     searchParams: URLSearchParams;
+    parsedBody: RequestBodyType;
+    rawBody?: string;
     headers: Headers;
-    body: RequestBodyType;
-
     request?: Request;
     inputSchema?: TInputSchema;
     shouldValidateInput?: boolean;
@@ -40,7 +41,8 @@ export class RequestInputContext<
     this.#pathParams = config.pathParams;
     this.#searchParams = config.searchParams;
     this.#headers = config.headers;
-    this.#body = config.body;
+    this.#body = config.rawBody;
+    this.#parsedBody = config.parsedBody;
     this.#inputSchema = config.inputSchema;
     this.#shouldValidateInput = config.shouldValidateInput ?? true;
   }
@@ -59,6 +61,7 @@ export class RequestInputContext<
     inputSchema?: TInputSchema;
     shouldValidateInput?: boolean;
     state: MutableRequestState;
+    rawBody?: string;
   }): Promise<RequestInputContext<TPath, TInputSchema>> {
     // Use the mutable state (potentially modified by middleware)
     return new RequestInputContext({
@@ -67,7 +70,8 @@ export class RequestInputContext<
       pathParams: config.state.pathParams as ExtractPathParams<TPath>,
       searchParams: config.state.searchParams,
       headers: config.state.headers,
-      body: config.state.body,
+      parsedBody: config.state.body,
+      rawBody: config.rawBody,
       inputSchema: config.inputSchema,
       shouldValidateInput: config.shouldValidateInput,
     });
@@ -104,7 +108,7 @@ export class RequestInputContext<
       pathParams: config.pathParams,
       searchParams: config.searchParams ?? new URLSearchParams(),
       headers: config.headers ?? new Headers(),
-      body: "body" in config ? config.body : undefined,
+      parsedBody: "body" in config ? config.body : undefined,
       inputSchema: "inputSchema" in config ? config.inputSchema : undefined,
       shouldValidateInput: false, // No input validation in SSR context
     });
@@ -144,13 +148,11 @@ export class RequestInputContext<
   get headers(): Headers {
     return this.#headers;
   }
-  // TODO: Should probably remove this
-  /**
-   * @internal
-   */
-  get rawBody(): RequestBodyType {
+
+  get rawBody(): string | undefined {
     return this.#body;
   }
+
   /**
    * Input validation context (only if inputSchema is defined)
    * @remarks `InputContext`
@@ -175,7 +177,7 @@ export class RequestInputContext<
       valid: async () => {
         if (!this.#shouldValidateInput) {
           // In SSR context, return the body directly without validation
-          return this.#body;
+          return this.#parsedBody;
         }
 
         return this.#validateInput();
@@ -191,11 +193,11 @@ export class RequestInputContext<
       throw new Error("No input schema defined for this route");
     }
 
-    if (this.#body instanceof FormData || this.#body instanceof Blob) {
+    if (this.#parsedBody instanceof FormData || this.#parsedBody instanceof Blob) {
       throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
     }
 
-    const result = await this.#inputSchema["~standard"].validate(this.#body);
+    const result = await this.#inputSchema["~standard"].validate(this.#parsedBody);
 
     if (result.issues) {
       throw new FragnoApiValidationError("Validation failed", result.issues);

package/src/api/request-middleware.test.ts

@@ -628,4 +628,255 @@ describe("Request Middleware", () => {
       custom: "middleware-value",
     });
   });
+
+  test("ifMatchesRoute properly awaits async handlers", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "POST",
+        path: "/users",
+        inputSchema: z.object({ name: z.string() }),
+        outputSchema: z.object({ id: z.number(), name: z.string(), verified: z.boolean() }),
+        handler: async ({ input }, { json }) => {
+          const body = await input.valid();
+          return json({
+            id: 1,
+            name: body.name,
+            verified: false,
+          });
+        },
+      }),
+    ] as const;
+
+    let asyncOperationCompleted = false;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      const result = await ifMatchesRoute("POST", "/users", async ({ input }) => {
+        // Simulate async operation (e.g., database lookup)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const body = await input.valid();
+
+        // Verify the async operation completed
+        asyncOperationCompleted = true;
+
+        // Check if user exists
+        if (body.name === "existing-user") {
+          return new Response(
+            JSON.stringify({
+              message: "User already exists",
+              code: "USER_EXISTS",
+            }),
+            { status: 409, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        return undefined;
+      });
+
+      return result;
+    });
+
+    // Test with existing user
+    const existingUserReq = new Request("http://localhost/api/users", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "existing-user" }),
+    });
+
+    const existingUserRes = await instance.handler(existingUserReq);
+    expect(asyncOperationCompleted).toBe(true);
+    expect(existingUserRes.status).toBe(409);
+    expect(await existingUserRes.json()).toEqual({
+      message: "User already exists",
+      code: "USER_EXISTS",
+    });
+
+    // Reset flag
+    asyncOperationCompleted = false;
+
+    // Test with new user
+    const newUserReq = new Request("http://localhost/api/users", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "new-user" }),
+    });
+
+    const newUserRes = await instance.handler(newUserReq);
+    expect(asyncOperationCompleted).toBe(true);
+    expect(newUserRes.status).toBe(200);
+    expect(await newUserRes.json()).toEqual({
+      id: 1,
+      name: "new-user",
+      verified: false,
+    });
+  });
+
+  test("ifMatchesRoute handles async errors properly", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "GET",
+        path: "/data",
+        outputSchema: z.object({ data: z.string() }),
+        handler: async (_, { json }) => {
+          return json({ data: "test" });
+        },
+      }),
+    ] as const;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      const result = await ifMatchesRoute("GET", "/data", async (_, { error }) => {
+        // Simulate async operation that fails
+        await new Promise((resolve) => setTimeout(resolve, 5));
+
+        // Simulate an error condition (e.g., database unavailable)
+        return error(
+          {
+            message: "Service temporarily unavailable",
+            code: "SERVICE_UNAVAILABLE",
+          },
+          503,
+        );
+      });
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/data", {
+      method: "GET",
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(503);
+    expect(await res.json()).toEqual({
+      message: "Service temporarily unavailable",
+      code: "SERVICE_UNAVAILABLE",
+    });
+  });
+
+  test("ifMatchesRoute with async body modification", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "POST",
+        path: "/posts",
+        inputSchema: z.object({ title: z.string(), content: z.string() }),
+        outputSchema: z.object({
+          title: z.string(),
+          content: z.string(),
+          slug: z.string(),
+          createdAt: z.number(),
+        }),
+        handler: async ({ input }, { json }) => {
+          const body = await input.valid();
+          return json({
+            title: body.title,
+            content: body.content,
+            slug: body.title.toLowerCase().replace(/\s+/g, "-"),
+            createdAt: Date.now(),
+          });
+        },
+      }),
+    ] as const;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute, requestState }) => {
+      const result = await ifMatchesRoute("POST", "/posts", async ({ input }) => {
+        // Simulate async operation to enrich the body (e.g., fetching user data)
+        await new Promise((resolve) => setTimeout(resolve, 5));
+
+        const body = await input.valid();
+
+        // Enrich the body with additional data
+        requestState.setBody({
+          ...body,
+          content: `${body.content}\n\n[Enhanced by middleware]`,
+        });
+
+        return undefined;
+      });
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: "Test Post",
+        content: "Original content",
+      }),
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(200);
+
+    const responseBody = await res.json();
+    expect(responseBody).toMatchObject({
+      title: "Test Post",
+      content: "Original content\n\n[Enhanced by middleware]",
+      slug: "test-post",
+    });
+    expect(responseBody.createdAt).toBeTypeOf("number");
+  });
+
+  test("multiple async operations in ifMatchesRoute complete in order", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "GET",
+        path: "/status",
+        outputSchema: z.object({ message: z.string() }),
+        handler: async (_, { json }) => {
+          return json({ message: "OK" });
+        },
+      }),
+    ] as const;
+
+    const executionOrder: string[] = [];
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      executionOrder.push("start");
+
+      const result = await ifMatchesRoute("GET", "/status", async () => {
+        executionOrder.push("before-first-async");
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        executionOrder.push("after-first-async");
+
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        executionOrder.push("after-second-async");
+
+        return undefined;
+      });
+
+      executionOrder.push("end");
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/status", {
+      method: "GET",
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(200);
+    expect(executionOrder).toEqual([
+      "start",
+      "before-first-async",
+      "after-first-async",
+      "after-second-async",
+      "end",
+    ]);
+  });
 });

package/src/api/request-middleware.ts

@@ -143,6 +143,6 @@ export class RequestMiddlewareInputContext<const TRoutes extends readonly AnyFra
     const outputContext = new RequestOutputContext(this.#route.outputSchema);
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (handler as any)(inputContext, outputContext);
+    return await (handler as any)(inputContext, outputContext);
   };
 }

package/src/test/test.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { createFragmentForTest } from "./test";
 import { defineFragment } from "../api/fragment-builder";
-import { defineRoute } from "../api/route";
+import { defineRoute, defineRoutes } from "../api/route";
 import { z } from "zod";
 
 describe("createFragmentForTest", () => {
@@ -317,6 +317,61 @@ describe("fragment.handler", () => {
     }
   });
 
+  it("should handle route factory created with defineRoutes", async () => {
+    const fragment = defineFragment<{ apiKey: string }>("test").withServices(() => ({
+      getGreeting: (name: string) => `Hello, ${name}!`,
+      getCount: () => 42,
+    }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    type Config = { apiKey: string };
+    type Deps = {};
+    type Services = { getGreeting: (name: string) => string; getCount: () => number };
+
+    const routeFactory = defineRoutes<Config, Deps, Services>().create(({ services }) => [
+      defineRoute({
+        method: "GET",
+        path: "/greeting/:name",
+        outputSchema: z.object({ message: z.string() }),
+        handler: async ({ pathParams }, { json }) => {
+          return json({ message: services.getGreeting(pathParams.name) });
+        },
+      }),
+      defineRoute({
+        method: "GET",
+        path: "/count",
+        outputSchema: z.object({ count: z.number() }),
+        handler: async (_ctx, { json }) => {
+          return json({ count: services.getCount() });
+        },
+      }),
+    ]);
+
+    const routes = [routeFactory] as const;
+    const [greetingRoute, countRoute] = testFragment.initRoutes(routes);
+
+    // Test first route
+    const greetingResponse = await testFragment.handler(greetingRoute, {
+      pathParams: { name: "World" },
+    });
+
+    expect(greetingResponse.type).toBe("json");
+    if (greetingResponse.type === "json") {
+      expect(greetingResponse.data).toEqual({ message: "Hello, World!" });
+    }
+
+    // Test second route
+    const countResponse = await testFragment.handler(countRoute);
+
+    expect(countResponse.type).toBe("json");
+    if (countResponse.type === "json") {
+      expect(countResponse.data).toEqual({ count: 42 });
+    }
+  });
+
   it("should handle path parameters", async () => {
     const fragment = defineFragment<{}>("test");
     const testFragment = createFragmentForTest(fragment, {

package/src/test/test.ts

@@ -357,7 +357,7 @@ export function createFragmentForTest<
         pathParams,
         searchParams,
         headers: requestHeaders,
-        body,
+        parsedBody: body,
         inputSchema: route.inputSchema,
         shouldValidateInput: false, // Skip validation in tests
       });