@fragno-dev/core 0.1.4 → 0.1.6

package/src/api/fragment-instantiation.ts

@@ -3,7 +3,7 @@ import { type FragnoRouteConfig, type HTTPMethod } from "./api";
 import { FragnoApiError } from "./error";
 import { getMountRoute } from "./internal/route";
 import { addRoute, createRouter, findRoute } from "rou3";
-import { RequestInputContext } from "./request-input-context";
+import { RequestInputContext, type RequestBodyType } from "./request-input-context";
 import type { ExtractPathParams } from "./internal/path";
 import { RequestOutputContext } from "./request-output-context";
 import {
@@ -19,14 +19,23 @@ import {
 } from "./request-middleware";
 import type { FragmentDefinition } from "./fragment-builder";
 import { MutableRequestState } from "./mutable-request-state";
+import type { RouteHandlerInputOptions } from "./route-handler-input-options";
+import type { ExtractRouteByPath, ExtractRoutePath } from "../client/client";
+import { type FragnoResponse, parseFragnoResponse } from "./fragno-response";
+import type { InferOrUnknown } from "../util/types-util";
 
 export interface FragnoPublicConfig {
   mountRoute?: string;
 }
 
+export type FetcherConfig =
+  | { type: "options"; options: RequestInit }
+  | { type: "function"; fetcher: typeof fetch };
+
 export interface FragnoPublicClientConfig {
   mountRoute?: string;
   baseUrl?: string;
+  fetcherConfig?: FetcherConfig;
 }
 
 type AstroHandlers = {
@@ -48,6 +57,8 @@ type SolidStartHandlers = {
   OPTIONS: (args: { request: Request }) => Promise<Response>;
 };
 
+type TanStackStartHandlers = SolidStartHandlers;
+
 type StandardHandlers = {
   GET: (req: Request) => Promise<Response>;
   POST: (req: Request) => Promise<Response>;
@@ -64,6 +75,7 @@ type HandlersByFramework = {
   "next-js": StandardHandlers;
   "svelte-kit": StandardHandlers;
   "solid-start": SolidStartHandlers;
+  "tanstack-start": TanStackStartHandlers;
 };
 
 // Not actually a symbol, since we might be dealing with multiple instances of this code.
@@ -86,6 +98,26 @@ export interface FragnoInstantiatedFragment<
   handlersFor: <T extends FullstackFrameworks>(framework: T) => HandlersByFramework[T];
   handler: (req: Request) => Promise<Response>;
   mountRoute: string;
+  callRoute: <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
+    method: TMethod,
+    path: TPath,
+    inputOptions?: RouteHandlerInputOptions<
+      TPath,
+      ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
+    >,
+  ) => Promise<
+    FragnoResponse<
+      InferOrUnknown<NonNullable<ExtractRouteByPath<TRoutes, TPath, TMethod>["outputSchema"]>>
+    >
+  >;
+  callRouteRaw: <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
+    method: TMethod,
+    path: TPath,
+    inputOptions?: RouteHandlerInputOptions<
+      TPath,
+      ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
+    >,
+  ) => Promise<Response>;
   withMiddleware: (
     handler: FragnoMiddlewareCallback<TRoutes, TDeps, TServices>,
   ) => FragnoInstantiatedFragment<TRoutes, TDeps, TServices, TAdditionalContext>;
@@ -130,6 +162,8 @@ export function createFragment<
   TServices,
   TAdditionalContext
 > {
+  type TRoutes = FlattenRouteFactories<TRoutesOrFactories>;
+
   const definition = fragmentBuilder.definition;
 
   const dependencies = definition.dependencies?.(config, options) ?? ({} as TDeps);
@@ -190,6 +224,96 @@ export function createFragment<
 
       return fragment;
     },
+    callRoute: async <TMethod extends HTTPMethod, TPath extends ExtractRoutePath<TRoutes, TMethod>>(
+      method: TMethod,
+      path: TPath,
+      inputOptions?: RouteHandlerInputOptions<
+        TPath,
+        ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
+      >,
+    ): Promise<
+      FragnoResponse<
+        InferOrUnknown<NonNullable<ExtractRouteByPath<TRoutes, TPath, TMethod>["outputSchema"]>>
+      >
+    > => {
+      const response = await fragment.callRouteRaw(method, path, inputOptions);
+      return parseFragnoResponse(response);
+    },
+    callRouteRaw: async <
+      TMethod extends HTTPMethod,
+      TPath extends ExtractRoutePath<TRoutes, TMethod>,
+    >(
+      method: TMethod,
+      path: TPath,
+      inputOptions?: RouteHandlerInputOptions<
+        TPath,
+        ExtractRouteByPath<TRoutes, TPath, TMethod>["inputSchema"]
+      >,
+    ): Promise<Response> => {
+      // Find the route configuration
+      const route = routes.find((r) => r.method === method && r.path === path);
+
+      if (!route) {
+        return Response.json(
+          {
+            error: `Route ${method} ${path} not found`,
+            code: "ROUTE_NOT_FOUND",
+          },
+          { status: 404 },
+        );
+      }
+
+      const {
+        pathParams = {} as ExtractPathParams<TPath>,
+        body,
+        query,
+        headers,
+      } = inputOptions || {};
+
+      // Convert query to URLSearchParams if needed
+      const searchParams =
+        query instanceof URLSearchParams
+          ? query
+          : query
+            ? new URLSearchParams(query)
+            : new URLSearchParams();
+
+      // Convert headers to Headers if needed
+      const requestHeaders =
+        headers instanceof Headers ? headers : headers ? new Headers(headers) : new Headers();
+
+      // Construct RequestInputContext
+      const inputContext = new RequestInputContext({
+        path: route.path,
+        method: route.method,
+        pathParams,
+        searchParams,
+        headers: requestHeaders,
+        parsedBody: body,
+        inputSchema: route.inputSchema,
+        shouldValidateInput: true, // Enable validation for production use
+      });
+
+      // Construct RequestOutputContext
+      const outputContext = new RequestOutputContext(route.outputSchema);
+
+      // Call the route handler
+      try {
+        const response = await route.handler(inputContext, outputContext);
+        return response;
+      } catch (error) {
+        console.error("Error in callRoute handler", error);
+
+        if (error instanceof FragnoApiError) {
+          return error.toResponse();
+        }
+
+        return Response.json(
+          { error: "Internal server error", code: "INTERNAL_SERVER_ERROR" },
+          { status: 500 },
+        );
+      }
+    },
     handlersFor: <T extends FullstackFrameworks>(framework: T): HandlersByFramework[T] => {
       const handler = fragment.handler;
 
@@ -233,6 +357,15 @@ export function createFragment<
           HEAD: ({ request }: { request: Request }) => handler(request),
           OPTIONS: ({ request }: { request: Request }) => handler(request),
         },
+        "tanstack-start": {
+          GET: ({ request }: { request: Request }) => handler(request),
+          POST: ({ request }: { request: Request }) => handler(request),
+          PUT: ({ request }: { request: Request }) => handler(request),
+          DELETE: ({ request }: { request: Request }) => handler(request),
+          PATCH: ({ request }: { request: Request }) => handler(request),
+          HEAD: ({ request }: { request: Request }) => handler(request),
+          OPTIONS: ({ request }: { request: Request }) => handler(request),
+        },
       } satisfies HandlersByFramework;
 
       return allHandlers[framework];
@@ -269,10 +402,28 @@ export function createFragment<
       const outputContext = new RequestOutputContext(outputSchema);
 
       // Create mutable request state that can be modified by middleware
-      // Clone the request to avoid consuming the body stream
-      const clonedReq = req.clone();
-      const requestBody =
-        clonedReq.body instanceof ReadableStream ? await clonedReq.json() : undefined;
+      // Clone the request to read body as both text and JSON without consuming original stream
+      let requestBody: RequestBodyType = undefined;
+      let rawBody: string | undefined = undefined;
+
+      if (req.body instanceof ReadableStream) {
+        // Clone request to make sure we don't consume body stream
+        const clonedReq = req.clone();
+
+        // Get raw text
+        rawBody = await clonedReq.text();
+
+        // Parse JSON if body is not empty
+        if (rawBody) {
+          try {
+            requestBody = JSON.parse(rawBody);
+          } catch {
+            // If JSON parsing fails, keep body as undefined
+            // This handles cases where body is not JSON
+            requestBody = undefined;
+          }
+        }
+      }
 
       const requestState = new MutableRequestState({
         pathParams: route.params ?? {},
@@ -323,6 +474,7 @@ export function createFragment<
         pathParams: (route.params ?? {}) as ExtractPathParams<typeof path>,
         inputSchema,
         state: requestState,
+        rawBody,
       });
 
       try {

package/src/api/fragno-response.ts

@@ -0,0 +1,132 @@
+/**
+ * Discriminated union representing all possible Fragno response types
+ */
+export type FragnoResponse<T> =
+  | {
+      type: "empty";
+      status: number;
+      headers: Headers;
+    }
+  | {
+      type: "error";
+      status: number;
+      headers: Headers;
+      error: { message: string; code: string };
+    }
+  | {
+      type: "json";
+      status: number;
+      headers: Headers;
+      data: T;
+    }
+  | {
+      type: "jsonStream";
+      status: number;
+      headers: Headers;
+      stream: AsyncGenerator<T extends unknown[] ? T[number] : T>;
+    };
+
+/**
+ * Parse a Response object into a FragnoResponse discriminated union
+ */
+export async function parseFragnoResponse<T>(response: Response): Promise<FragnoResponse<T>> {
+  const status = response.status;
+  const headers = response.headers;
+  const contentType = headers.get("content-type") || "";
+
+  // Check for streaming response
+  if (contentType.includes("application/x-ndjson")) {
+    return {
+      type: "jsonStream",
+      status,
+      headers,
+      stream: parseNDJSONStream<T>(response),
+    };
+  }
+
+  // Parse JSON body
+  const text = await response.text();
+
+  // Empty response
+  if (!text || text === "null") {
+    return {
+      type: "empty",
+      status,
+      headers,
+    };
+  }
+
+  const data = JSON.parse(text);
+
+  // Error response (has message and code, or error and code)
+  if (data && typeof data === "object" && "code" in data) {
+    if ("message" in data) {
+      return {
+        type: "error",
+        status,
+        headers,
+        error: { message: data.message, code: data.code },
+      };
+    }
+    if ("error" in data) {
+      return {
+        type: "error",
+        status,
+        headers,
+        error: { message: data.error, code: data.code },
+      };
+    }
+  }
+
+  // JSON response
+  return {
+    type: "json",
+    status,
+    headers,
+    data: data as T,
+  };
+}
+
+/**
+ * Parse an NDJSON stream into an async generator
+ */
+async function* parseNDJSONStream<T>(
+  response: Response,
+): AsyncGenerator<T extends unknown[] ? T[number] : T> {
+  if (!response.body) {
+    return;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+
+      // Keep the last incomplete line in the buffer
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        if (line.trim()) {
+          yield JSON.parse(line) as T extends unknown[] ? T[number] : T;
+        }
+      }
+    }
+
+    // Process any remaining data in the buffer
+    if (buffer.trim()) {
+      yield JSON.parse(buffer) as T extends unknown[] ? T[number] : T;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

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");