@fragno-dev/core 0.1.11 → 0.2.2

package/src/client/client.test.ts

@@ -1,14 +1,16 @@
 import { afterEach, assert, beforeEach, describe, expect, test, vi } from "vitest";
+
+import { atom, computed, effect } from "nanostores";
 import { z } from "zod";
+
+import { defineFragment } from "../api/fragment-definition-builder";
+import { RequestOutputContext } from "../api/request-output-context";
 import { defineRoute } from "../api/route";
-import { buildUrl, createClientBuilder, getCacheKey, isGetHook, isMutatorHook } from "./client";
-import { useFragno } from "./vanilla";
 import { createAsyncIteratorFromCallback, waitForAsyncIterator } from "../util/async";
+import { buildUrl, createClientBuilder, getCacheKey, isGetHook, isMutatorHook } from "./client";
 import type { FragnoPublicClientConfig } from "./client";
-import { atom, computed, effect } from "nanostores";
-import { defineFragment } from "../api/fragment-definition-builder";
-import { RequestOutputContext } from "../api/request-output-context";
 import { FragnoClientUnknownApiError } from "./client-error";
+import { useFragno } from "./vanilla";
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -111,6 +113,59 @@ describe("getCacheKey", () => {
   });
 });
 
+describe("FormData utilities", () => {
+  // These tests verify the internal FormData handling behavior
+
+  test("prepareRequestBody should JSON-stringify regular objects", () => {
+    // We can't test internal functions directly, but we can test through the mutator behavior
+    // This is a placeholder to document expected behavior
+    const body = { name: "test", value: 123 };
+    expect(JSON.stringify(body)).toBe('{"name":"test","value":123}');
+  });
+
+  test("FormData should be detected correctly", () => {
+    const formData = new FormData();
+    formData.append("file", new Blob(["test"]), "test.txt");
+
+    expect(formData instanceof FormData).toBe(true);
+    expect({} instanceof FormData).toBe(false);
+    // Note: null instanceof X is a TS error, so we test with a nullable variable
+    const nullValue: unknown = null;
+    expect(nullValue instanceof FormData).toBe(false);
+  });
+
+  test("File and Blob should be detected correctly", () => {
+    const file = new File(["content"], "test.txt", { type: "text/plain" });
+    const blob = new Blob(["content"], { type: "text/plain" });
+
+    expect(file instanceof File).toBe(true);
+    expect(file instanceof Blob).toBe(true);
+    expect(blob instanceof Blob).toBe(true);
+    expect(blob instanceof File).toBe(false);
+  });
+
+  test("toFormData should convert object with files to FormData", () => {
+    const file = new File(["content"], "test.txt", { type: "text/plain" });
+    const formData = new FormData();
+    formData.append("file", file, file.name);
+    formData.append("description", "A test file");
+
+    expect(formData.get("file")).toBeInstanceOf(File);
+    expect(formData.get("description")).toBe("A test file");
+  });
+
+  test("FormData can contain multiple files", () => {
+    const file1 = new File(["content1"], "test1.txt", { type: "text/plain" });
+    const file2 = new File(["content2"], "test2.txt", { type: "text/plain" });
+    const formData = new FormData();
+    formData.append("files", file1, file1.name);
+    formData.append("files", file2, file2.name);
+
+    const files = formData.getAll("files");
+    expect(files).toHaveLength(2);
+  });
+});
+
 describe("invalidation", () => {
   const testFragment = defineFragment("test-fragment").build();
   const testRoutes = [
@@ -1271,6 +1326,125 @@ describe("createMutator", () => {
 
     expect(result).toBeUndefined();
   });
+
+  test("body is optional when inputSchema allows undefined", async () => {
+    const testFragment = defineFragment("test-fragment").build();
+    const testRoutes = [
+      defineRoute({
+        method: "POST",
+        path: "/sign-out",
+        inputSchema: z.object({ sessionId: z.string().optional() }).optional(),
+        outputSchema: z.object({ success: z.boolean() }),
+        handler: async (_ctx, { empty }) => empty(),
+      }),
+    ] as const;
+
+    vi.mocked(global.fetch).mockImplementation(async () => {
+      return new Response(null, { status: 204 });
+    });
+
+    const cb = createClientBuilder(testFragment, clientConfig, testRoutes);
+    const signOut = cb.createMutator("POST", "/sign-out");
+
+    const result = await signOut.mutateQuery({});
+    expect(result).toBeUndefined();
+
+    const storeResult = await signOut.mutatorStore.mutate({});
+    expect(storeResult).toBeUndefined();
+  });
+
+  test("should send octet-stream body without wrapping", async () => {
+    const testFragment = defineFragment("test-fragment").build();
+    const testRoutes = [
+      defineRoute({
+        method: "PUT",
+        path: "/upload",
+        contentType: "application/octet-stream",
+        inputSchema: z.unknown(),
+        handler: async (_ctx, { empty }) => empty(),
+      }),
+    ] as const;
+
+    vi.mocked(global.fetch).mockImplementation(async () => {
+      return new Response(null, { status: 204 });
+    });
+
+    const cb = createClientBuilder(testFragment, clientConfig, testRoutes);
+    const upload = cb.createMutator("PUT", "/upload");
+    const body = new Uint8Array([1, 2, 3, 4]);
+
+    await upload.mutateQuery({ body });
+
+    const [_url, options] = vi.mocked(global.fetch).mock.calls[0];
+    const headers = options?.headers as Record<string, string> | undefined;
+
+    expect(headers?.["Content-Type"]).toBe("application/octet-stream");
+    expect(options?.body).toBe(body);
+  });
+
+  test("should send ReadableStream body with duplex for octet-stream", async () => {
+    const testFragment = defineFragment("test-fragment").build();
+    const testRoutes = [
+      defineRoute({
+        method: "PUT",
+        path: "/upload",
+        contentType: "application/octet-stream",
+        inputSchema: z.unknown(),
+        handler: async (_ctx, { empty }) => empty(),
+      }),
+    ] as const;
+
+    let capturedOptions: (RequestInit & { duplex?: "half" }) | undefined;
+    let capturedBodyText = "";
+
+    vi.mocked(global.fetch).mockImplementation(async (_url, options) => {
+      capturedOptions = options as RequestInit & { duplex?: "half" };
+      const body = capturedOptions?.body;
+
+      if (!(body instanceof ReadableStream)) {
+        throw new Error("Expected ReadableStream body");
+      }
+
+      const reader = body.getReader();
+      const chunks: Uint8Array[] = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        if (value) {
+          chunks.push(value);
+        }
+      }
+
+      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+      }
+      capturedBodyText = new TextDecoder().decode(combined);
+
+      return new Response(null, { status: 204 });
+    });
+
+    const cb = createClientBuilder(testFragment, clientConfig, testRoutes);
+    const upload = cb.createMutator("PUT", "/upload");
+    const body = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode("streamed body"));
+        controller.close();
+      },
+    });
+
+    await upload.mutateQuery({ body });
+
+    const headers = capturedOptions?.headers as Record<string, string> | undefined;
+    expect(headers?.["Content-Type"]).toBe("application/octet-stream");
+    expect(capturedOptions?.duplex).toBe("half");
+    expect(capturedBodyText).toBe("streamed body");
+  });
 });
 
 describe("createMutator - streaming", () => {
@@ -1997,6 +2171,55 @@ describe("Custom Fetcher Configuration", () => {
     expect(url4).toBe("http://localhost:3000/api/test-fragment/users/456?include=posts");
   });
 
+  test("public mountRoute is used for hooks", async () => {
+    let capturedUrl: string | undefined;
+
+    (global.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (url) => {
+      capturedUrl = String(url);
+      return {
+        headers: new Headers(),
+        ok: true,
+        json: async () => [{ id: 1, name: "John" }],
+      } as Response;
+    });
+
+    const client = createClientBuilder(
+      testFragment,
+      { ...clientConfig, mountRoute: "/api/uploads-direct" },
+      testRoutes,
+    );
+
+    const useUsers = client.createHook("/users");
+    await useUsers.query();
+
+    expect(capturedUrl).toBe("http://localhost:3000/api/uploads-direct/users");
+  });
+
+  test("public mountRoute is used for mutators", async () => {
+    let capturedUrl: string | undefined;
+
+    (global.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (url) => {
+      capturedUrl = String(url);
+      return {
+        headers: new Headers(),
+        ok: true,
+        status: 200,
+        json: async () => ({ id: 2, name: "Jane" }),
+      } as Response;
+    });
+
+    const client = createClientBuilder(
+      testFragment,
+      { ...clientConfig, mountRoute: "/api/uploads-proxy" },
+      testRoutes,
+    );
+
+    const mutator = client.createMutator("POST", "/users");
+    await mutator.mutateQuery({ body: { name: "Jane" } });
+
+    expect(capturedUrl).toBe("http://localhost:3000/api/uploads-proxy/users");
+  });
+
   test("getFetcher returns correct fetcher and options", () => {
     const customFetch = vi.fn() as unknown as typeof fetch;
     const client = createClientBuilder(
@@ -2013,7 +2236,7 @@ describe("Custom Fetcher Configuration", () => {
     expect(defaultOptions).toBeUndefined();
   });
 
-  test("getFetcher returns default fetch and options", () => {
+  test("getFetcher returns a bound default fetch and options", async () => {
     const client = createClientBuilder(
       testFragment,
       {
@@ -2023,9 +2246,20 @@ describe("Custom Fetcher Configuration", () => {
       testRoutes,
     );
 
-    const { fetcher, defaultOptions } = client.getFetcher();
-    expect(fetcher).toBe(fetch);
-    expect(defaultOptions).toBeDefined();
-    expect(defaultOptions?.credentials).toBe("include");
+    const originalFetch = globalThis.fetch;
+    const fetchSpy = vi.fn<typeof fetch>().mockResolvedValue(new Response(null, { status: 204 }));
+    globalThis.fetch = fetchSpy;
+
+    try {
+      const { fetcher, defaultOptions } = client.getFetcher();
+      expect(fetcher).not.toBe(globalThis.fetch);
+      expect(defaultOptions).toBeDefined();
+      expect(defaultOptions?.credentials).toBe("include");
+
+      await fetcher("https://example.com");
+      expect(fetchSpy).toHaveBeenCalledWith("https://example.com");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
   });
 });