@npy/fetch 0.1.1 → 0.1.3

package/tests/multipart.test.ts

@@ -0,0 +1,348 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { createFetch } from "../src/fetch";
+import { createTestServer } from "./test-utils";
+
+interface MultipartEchoResponse {
+    method: string;
+    contentType: string;
+    contentLength: number | null;
+    fields: Record<
+        string,
+        | string
+        | string[]
+        | {
+              type: "file";
+              filename: string;
+              mimeType: string;
+              size: number;
+              content: string;
+          }
+    >;
+}
+
+describe("multipart/form-data — integration", () => {
+    const testServer = createTestServer();
+
+    afterAll(async () => {
+        await testServer.stop();
+    });
+
+    test("Content-Type is multipart/form-data and contains a boundary", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("x", "1");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            expect(response.status).toBe(200);
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.contentType).toContain("multipart/form-data");
+            expect(echo.contentType).toMatch(/boundary=[^\s;]+/);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("Content-Length is sent and matches the body received by the server", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("field", "some value");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            expect(response.status).toBe(200);
+
+            const echo: MultipartEchoResponse = await response.json();
+
+            expect(echo.contentLength).not.toBeNull();
+            expect(echo.contentLength).toBeGreaterThan(0);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("single text field is received correctly", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("greeting", "hello world");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields["greeting"]).toBe("hello world");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("multiple text fields are all received", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("first", "Alice");
+            form.append("last", "Smith");
+            form.append("age", "30");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields["first"]).toBe("Alice");
+            expect(echo.fields["last"]).toBe("Smith");
+            expect(echo.fields["age"]).toBe("30");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("multiple values for the same field name are received as an array", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("tag", "typescript");
+            form.append("tag", "http");
+            form.append("tag", "fetch");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields["tag"]).toEqual(["typescript", "http", "fetch"]);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("multibyte UTF-8 field values are received correctly", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("greeting", "こんにちは");
+            form.append("emoji", "🚀");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields["greeting"]).toBe("こんにちは");
+            expect(echo.fields["emoji"]).toBe("🚀");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("Blob field content is received intact", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const content = "hello from blob";
+            const form = new FormData();
+            form.append(
+                "upload",
+                new Blob([content], { type: "text/plain" }),
+                "hello.txt",
+            );
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            const file = echo.fields["upload"] as {
+                type: string;
+                filename: string;
+                mimeType: string;
+                content: string;
+            };
+
+            expect(file.filename).toBe("hello.txt");
+            expect(file.mimeType).toContain("text/plain");
+            expect(file.content).toBe(content);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("binary Blob field is received with correct byte count", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const bytes = new Uint8Array(256).map((_, i) => i);
+            const form = new FormData();
+            form.append(
+                "bin",
+                new Blob([bytes], { type: "application/octet-stream" }),
+                "data.bin",
+            );
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            const file = echo.fields["bin"] as {
+                size: number;
+                mimeType: string;
+            };
+
+            expect(file.size).toBe(256);
+            expect(file.mimeType).toBe("application/octet-stream");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("Blob without explicit MIME type is received with correct content", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("f", new Blob(["data"]), "file.dat");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+            const file = echo.fields["f"] as { size: number; content: string };
+            expect(file.size).toBe(4);
+            expect(file.content).toBe("data");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("mixed text and Blob fields are all received correctly", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("title", "My Upload");
+            form.append(
+                "file",
+                new Blob(["<html><body>hi</body></html>"], {
+                    type: "text/html",
+                }),
+                "index.html",
+            );
+            form.append("note", "optional note");
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const echo: MultipartEchoResponse = await response.json();
+
+            expect(echo.fields["title"]).toBe("My Upload");
+            expect(echo.fields["note"]).toBe("optional note");
+
+            const file = echo.fields["file"] as {
+                filename: string;
+                content: string;
+            };
+            expect(file.filename).toBe("index.html");
+            expect(file.content).toBe("<html><body>hi</body></html>");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("empty FormData sends a structurally valid body", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: new FormData() },
+            );
+
+            expect(response.status).toBe(200);
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields).toEqual({});
+            expect(echo.contentLength).toBeGreaterThan(0);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("Content-Length is accurate for a large Blob field", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const large = new Uint8Array(64 * 1024).fill(0x41);
+            const form = new FormData();
+            form.append(
+                "payload",
+                new Blob([large], { type: "application/octet-stream" }),
+                "large.bin",
+            );
+
+            const response = await fetchLike(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            expect(response.status).toBe(200);
+
+            const echo: MultipartEchoResponse = await response.json();
+            const file = echo.fields["payload"] as { size: number };
+
+            expect(file.size).toBe(64 * 1024);
+            expect(echo.contentLength).toBeGreaterThan(64 * 1024);
+        } finally {
+            await fetchLike.close();
+        }
+    });
+
+    test("Request object with FormData body is forwarded correctly", async () => {
+        const fetchLike = createFetch();
+
+        try {
+            const form = new FormData();
+            form.append("from", "request-object");
+
+            const request = new Request(
+                `${testServer.baseUrl}/multipart-echo`,
+                { method: "POST", body: form },
+            );
+
+            const response = await fetchLike(request);
+            expect(response.status).toBe(200);
+
+            const echo: MultipartEchoResponse = await response.json();
+            expect(echo.fields["from"]).toBe("request-object");
+        } finally {
+            await fetchLike.close();
+        }
+    });
+});

package/tests/test-utils.ts

@@ -0,0 +1,335 @@
+import { gzipSync } from "node:zlib";
+
+export interface TestServer {
+    server: ReturnType<typeof Bun.serve>;
+    baseUrl: string;
+    stop(): Promise<void>;
+}
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+export function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function headersToObject(headers: Headers): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [key, value] of headers.entries()) {
+        out[key] = value;
+    }
+    return out;
+}
+
+function json(value: unknown, init?: ResponseInit): Response {
+    return Response.json(value, init);
+}
+
+function textResponse(
+    body: string,
+    init?: ResponseInit & { headers?: Record<string, string> },
+): Response {
+    return new Response(body, {
+        ...init,
+        headers: {
+            "content-type": "text/plain; charset=utf-8",
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+
+function headAwareText(
+    request: Request,
+    body: string,
+    init?: ResponseInit & { headers?: Record<string, string> },
+): Response {
+    if (request.method === "HEAD") {
+        return new Response(null, {
+            ...init,
+            headers: {
+                "content-type": "text/plain; charset=utf-8",
+                ...(init?.headers ?? {}),
+            },
+        });
+    }
+
+    return textResponse(body, init);
+}
+
+function headAwareJson(
+    request: Request,
+    body: unknown,
+    init?: ResponseInit & { headers?: Record<string, string> },
+): Response {
+    if (request.method === "HEAD") {
+        return new Response(null, {
+            ...init,
+            headers: {
+                "content-type": "application/json",
+                ...(init?.headers ?? {}),
+            },
+        });
+    }
+
+    return json(body, {
+        ...init,
+        headers: {
+            "content-type": "application/json",
+            ...(init?.headers ?? {}),
+        },
+    });
+}
+
+export function createTestServer(): TestServer {
+    const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        async fetch(request: Request): Promise<Response> {
+            const url = new URL(request.url);
+            const headers = headersToObject(request.headers);
+
+            switch (url.pathname) {
+                case "/text": {
+                    return headAwareText(request, "Hello, World!");
+                }
+
+                case "/json": {
+                    return headAwareJson(request, { message: "Hello, JSON!" });
+                }
+
+                case "/echo": {
+                    if (request.method === "HEAD") {
+                        return new Response(null, {
+                            status: 200,
+                            headers: {
+                                "content-type": "application/json",
+                            },
+                        });
+                    }
+
+                    const bodyBytes = new Uint8Array(
+                        await request.arrayBuffer(),
+                    );
+                    const bodyText = decoder.decode(bodyBytes);
+
+                    return json(
+                        {
+                            method: request.method,
+                            url: `${url.pathname}${url.search}`,
+                            headers,
+                            bodyText,
+                            bodyLength: bodyBytes.byteLength,
+                        },
+                        {
+                            status: 200,
+                            headers: {
+                                "content-type": "application/json",
+                            },
+                        },
+                    );
+                }
+
+                case "/slow": {
+                    await sleep(200);
+                    return textResponse("Finally!");
+                }
+
+                case "/slow-body": {
+                    let sent = 0;
+
+                    const stream = new ReadableStream<Uint8Array>({
+                        async pull(controller) {
+                            if (sent === 0) {
+                                controller.enqueue(encoder.encode("part-1 "));
+                                sent = 1;
+                                return;
+                            }
+
+                            if (sent === 1) {
+                                await sleep(200);
+                                controller.enqueue(encoder.encode("part-2"));
+                                controller.close();
+                                sent = 2;
+                            }
+                        },
+                    });
+
+                    return new Response(stream, {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                        },
+                    });
+                }
+
+                case "/chunked": {
+                    let index = 0;
+                    const chunks = ["chunk1", "chunk2", "chunk3"];
+
+                    const stream = new ReadableStream<Uint8Array>({
+                        pull(controller) {
+                            if (index >= chunks.length) {
+                                controller.close();
+                                return;
+                            }
+
+                            controller.enqueue(encoder.encode(chunks[index]));
+                            index += 1;
+                        },
+                    });
+
+                    return new Response(stream, {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                        },
+                    });
+                }
+
+                case "/gzip": {
+                    const payload = gzipSync("This is compressed content!");
+
+                    return new Response(payload, {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                            "content-encoding": "gzip",
+                            "content-length": String(payload.byteLength),
+                        },
+                    });
+                }
+
+                case "/bad-gzip": {
+                    const payload = encoder.encode("not actually gzip");
+
+                    return new Response(payload, {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                            "content-encoding": "gzip",
+                            "content-length": String(payload.byteLength),
+                        },
+                    });
+                }
+
+                case "/large": {
+                    const body = "x".repeat(1024);
+
+                    return textResponse(body, {
+                        headers: {
+                            "content-length": String(
+                                encoder.encode(body).byteLength,
+                            ),
+                        },
+                    });
+                }
+
+                case "/large-stream": {
+                    let remaining = 32;
+
+                    const stream = new ReadableStream<Uint8Array>({
+                        pull(controller) {
+                            if (remaining === 0) {
+                                controller.close();
+                                return;
+                            }
+
+                            controller.enqueue(encoder.encode("x".repeat(64)));
+                            remaining -= 1;
+                        },
+                    });
+
+                    return new Response(stream, {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                        },
+                    });
+                }
+
+                case "/huge-header": {
+                    return new Response("ok", {
+                        status: 200,
+                        headers: {
+                            "content-type": "text/plain; charset=utf-8",
+                            "x-huge": "a".repeat(4096),
+                        },
+                    });
+                }
+
+                case "/redirect": {
+                    return textResponse("Redirecting to /redirected-target", {
+                        status: 302,
+                        headers: {
+                            location: "/redirected-target",
+                        },
+                    });
+                }
+
+                case "/redirected-target": {
+                    return textResponse("You followed the redirect");
+                }
+
+                case "/multipart-echo": {
+                    let fields: Record<string, unknown>;
+
+                    try {
+                        const formData = await request.formData();
+                        fields = {};
+
+                        for (const [key, value] of formData.entries()) {
+                            const v = value as unknown;
+
+                            if (v instanceof Blob) {
+                                fields[key] = {
+                                    type: "file",
+                                    filename:
+                                        "name" in v
+                                            ? String((v as any).name)
+                                            : "blob",
+                                    mimeType: (v as Blob).type,
+                                    size: (v as Blob).size,
+                                    content: await (v as Blob).text(),
+                                };
+                            } else {
+                                const existing = fields[key];
+                                fields[key] =
+                                    existing !== undefined
+                                        ? [
+                                              ...(Array.isArray(existing)
+                                                  ? existing
+                                                  : [existing]),
+                                              value,
+                                          ]
+                                        : value;
+                            }
+                        }
+                    } catch (err) {
+                        return json({ error: String(err) }, { status: 400 });
+                    }
+
+                    return json({
+                        method: request.method,
+                        contentType: request.headers.get("content-type"),
+                        contentLength: request.headers.get("content-length")
+                            ? Number(request.headers.get("content-length"))
+                            : null,
+                        fields,
+                    });
+                }
+
+                default: {
+                    return textResponse("Not Found", { status: 404 });
+                }
+            }
+        },
+    });
+
+    return {
+        server,
+        baseUrl: `http://${server.hostname}:${server.port}`,
+        async stop() {
+            await server.stop(true);
+        },
+    };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "isolatedDeclarations": false
+    },
+    "include": ["src/**/*.ts"],
+    "exclude": [
+        "tests",
+        "examples",
+        "benchmarks",
+        "**/*.test.ts",
+        "**/*.test-utils.ts",
+        "**/__fixtures__/**"
+    ]
+}