@npy/fetch 0.1.3 → 0.1.4

package/tests/multipart.test.ts

@@ -1,348 +0,0 @@
-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

@@ -1,335 +0,0 @@
-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

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