@multiplatform.one/frappe 6.0.4 → 6.3.0

package/dist/cjs/core/http.spec.cjs

@@ -1,1259 +0,0 @@
-var import_vitest = require("vitest");
-var import_http = require("./http.cjs");
-var import_types = require("./types.cjs");
-(0, import_vitest.describe)("HttpClient", () => {
-  let client;
-  const baseURL = "https://api.example.com";
-  const getMockFetch = () => import_vitest.vi.mocked(fetch);
-  (0, import_vitest.beforeEach)(() => {
-    client = new import_http.HttpClient(baseURL);
-    global.fetch = import_vitest.vi.fn();
-  });
-  (0, import_vitest.afterEach)(() => {
-    import_vitest.vi.restoreAllMocks();
-  });
-  (0, import_vitest.describe)("constructor", () => {
-    (0, import_vitest.it)("should initialize with base URL", () => {
-      const httpClient = new import_http.HttpClient(baseURL);
-      (0, import_vitest.expect)(httpClient).toBeDefined();
-    });
-    (0, import_vitest.it)("should accept auth config", () => {
-      const httpClient = new import_http.HttpClient(baseURL, {
-        useToken: true,
-        token: "test-token",
-        type: import_types.AuthType.Bearer
-      });
-      (0, import_vitest.expect)(httpClient).toBeDefined();
-    });
-    (0, import_vitest.it)("should accept retry config", () => {
-      const httpClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 5,
-        baseDelayMs: 500,
-        exponentialBackoff: false
-      });
-      (0, import_vitest.expect)(httpClient).toBeDefined();
-    });
-  });
-  (0, import_vitest.describe)("request", () => {
-    (0, import_vitest.it)("should make basic GET request", async () => {
-      const mockPayload = {
-        data: "test"
-      };
-      const mockHeaders = new Headers({
-        "Content-Type": "application/json"
-      });
-      const mockRes = {
-        ok: true,
-        headers: mockHeaders,
-        status: 200,
-        json: async () => mockPayload
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-        method: "GET",
-        credentials: "include"
-      }));
-      (0, import_vitest.expect)(result.payload).toEqual(mockPayload);
-      (0, import_vitest.expect)(result.headers).toBe(mockHeaders);
-      (0, import_vitest.expect)(result.status).toBe(200);
-      (0, import_vitest.expect)(result._res).toBe(mockRes);
-    });
-    (0, import_vitest.it)("should make POST request with JSON body", async () => {
-      const requestBody = {
-        foo: "bar",
-        nested: {
-          value: 123
-        }
-      };
-      const mockPayload = {
-        success: true
-      };
-      const mockHeaders = new Headers({
-        "Content-Type": "application/json"
-      });
-      const mockRes = {
-        ok: true,
-        headers: mockHeaders,
-        status: 200,
-        json: async () => mockPayload
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Post, "/test", {
-        body: requestBody
-      });
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-        method: "POST",
-        body: JSON.stringify(requestBody),
-        headers: import_vitest.expect.any(Headers),
-        credentials: "include"
-      }));
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("Content-Type")).toBe("application/json");
-      (0, import_vitest.expect)(result.payload).toEqual(mockPayload);
-      (0, import_vitest.expect)(result.status).toBe(200);
-    });
-    (0, import_vitest.it)("should handle FormData body", async () => {
-      const formData = new FormData();
-      formData.append("field", "value");
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Post, "/upload", {
-        body: formData
-      });
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/upload`, import_vitest.expect.objectContaining({
-        method: "POST",
-        body: formData,
-        headers: import_vitest.expect.any(Headers),
-        credentials: "include"
-      }));
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should handle URLSearchParams body", async () => {
-      const params = new URLSearchParams();
-      params.append("key", "value");
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "text/plain"
-        }),
-        status: 200,
-        text: async () => "success"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Post, "/form", {
-        body: params
-      });
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/form`, import_vitest.expect.objectContaining({
-        method: "POST",
-        body: params,
-        credentials: "include"
-      }));
-      (0, import_vitest.expect)(result.payload).toBe("success");
-    });
-    (0, import_vitest.it)("should convert object to FormData when Content-Type is multipart/form-data", async () => {
-      const requestBody = {
-        field1: "value1",
-        field2: "value2"
-      };
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {
-        body: requestBody,
-        headers: {
-          "Content-Type": "multipart/form-data"
-        }
-      });
-      const calledBody = getMockFetch().mock.calls[0]?.[1]?.body;
-      (0, import_vitest.expect)(calledBody).toBeInstanceOf(FormData);
-    });
-    (0, import_vitest.it)("should convert object to URLSearchParams when Content-Type is application/x-www-form-urlencoded", async () => {
-      const requestBody = {
-        field1: "value1",
-        field2: "value2"
-      };
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "text/plain"
-        }),
-        status: 200,
-        text: async () => "success"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {
-        body: requestBody,
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        }
-      });
-      const calledBody = getMockFetch().mock.calls[0]?.[1]?.body;
-      (0, import_vitest.expect)(calledBody).toBe("field1=value1&field2=value2");
-    });
-    (0, import_vitest.it)("should handle text response", async () => {
-      const textResponse = "Plain text response";
-      const mockHeaders = new Headers({
-        "Content-Type": "text/plain"
-      });
-      const mockRes = {
-        ok: true,
-        headers: mockHeaders,
-        status: 200,
-        text: async () => textResponse
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Get, "/text", {});
-      (0, import_vitest.expect)(result.payload).toBe(textResponse);
-      (0, import_vitest.expect)(result.headers).toBe(mockHeaders);
-      (0, import_vitest.expect)(result.status).toBe(200);
-    });
-    (0, import_vitest.it)("should throw FrappeError on non-ok response", async () => {
-      const errorPayload = {
-        message: "Bad Request",
-        details: "Invalid input"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue({
-        ok: false,
-        status: 400,
-        statusText: "Bad Request",
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        json: async () => errorPayload
-      });
-      await (0, import_vitest.expect)(client.request(import_types.HttpMethod.Post, "/test", {})).rejects.toThrow(import_types.FrappeError);
-      try {
-        await client.request(import_types.HttpMethod.Post, "/test", {});
-      } catch (error) {
-        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
-        (0, import_vitest.expect)(error.status).toBe(400);
-        (0, import_vitest.expect)(error.message).toBe("Bad Request");
-        (0, import_vitest.expect)(error.data).toEqual(errorPayload);
-      }
-    });
-    (0, import_vitest.it)("should handle network errors", async () => {
-      const networkError = new Error("Network error");
-      global.fetch = import_vitest.vi.fn().mockRejectedValue(networkError);
-      await (0, import_vitest.expect)(client.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow("Network error");
-    });
-  });
-  (0, import_vitest.describe)("authentication", () => {
-    (0, import_vitest.it)("should add Bearer token to headers", async () => {
-      const token = "test-bearer-token";
-      const authClient = new import_http.HttpClient(baseURL, {
-        useToken: true,
-        token,
-        type: import_types.AuthType.Bearer
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await authClient.request(import_types.HttpMethod.Get, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("Authorization")).toBe(`Bearer ${token}`);
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.credentials).toBe("omit");
-    });
-    (0, import_vitest.it)("should add token auth to headers", async () => {
-      const token = "test-token";
-      const authClient = new import_http.HttpClient(baseURL, {
-        useToken: true,
-        token,
-        type: import_types.AuthType.Token
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await authClient.request(import_types.HttpMethod.Get, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("Authorization")).toBe(`token ${token}`);
-    });
-    (0, import_vitest.it)("should support token as function", async () => {
-      const token = "dynamic-token";
-      const authClient = new import_http.HttpClient(baseURL, {
-        useToken: true,
-        token: async () => token,
-        type: import_types.AuthType.Bearer
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await authClient.request(import_types.HttpMethod.Get, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("Authorization")).toBe(`Bearer ${token}`);
-    });
-    (0, import_vitest.it)("should add CSRF token for non-GET requests without token auth", async () => {
-      const csrfToken = "csrf-test-token";
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: `frappe-csrf-token=${csrfToken}; path=/`
-        },
-        writable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBe(csrfToken);
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-    });
-    (0, import_vitest.it)("should use credentials include when not using token auth", async () => {
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.credentials).toBe("include");
-    });
-    (0, import_vitest.it)("should set token dynamically via function", async () => {
-      const tokenFn = import_vitest.vi.fn().mockResolvedValue("new-token");
-      const authClient = new import_http.HttpClient(baseURL, {
-        useToken: true,
-        token: tokenFn
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await authClient.request(import_types.HttpMethod.Get, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("Authorization")).toBe("Bearer new-token");
-      (0, import_vitest.expect)(tokenFn).toHaveBeenCalledTimes(1);
-    });
-  });
-  (0, import_vitest.describe)("retry logic", () => {
-    (0, import_vitest.it)("should retry on retry-able status codes", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 2,
-        baseDelayMs: 10,
-        retryStatusCodes: [503]
-      });
-      let attempt = 0;
-      global.fetch = import_vitest.vi.fn().mockImplementation(async () => {
-        attempt++;
-        if (attempt < 3) {
-          return {
-            ok: false,
-            status: 503,
-            statusText: "Service Unavailable",
-            headers: new Headers({
-              "Content-Type": "text/plain"
-            }),
-            text: async () => "Service temporarily unavailable"
-          };
-        }
-        return {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json"
-          }),
-          status: 200,
-          json: async () => ({
-            success: true
-          })
-        };
-      });
-      const result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should retry on network errors when configured", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 1,
-        baseDelayMs: 10,
-        retryOnNetworkError: true
-      });
-      let attempt = 0;
-      global.fetch = import_vitest.vi.fn().mockImplementation(async () => {
-        attempt++;
-        if (attempt === 1) {
-          throw new Error("Network error");
-        }
-        return {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json"
-          }),
-          status: 200,
-          json: async () => ({
-            success: true
-          })
-        };
-      });
-      const result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(2);
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should not retry on non-retry-able status codes", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 2,
-        baseDelayMs: 10,
-        retryStatusCodes: [503]
-      });
-      global.fetch = import_vitest.vi.fn().mockResolvedValue({
-        ok: false,
-        status: 400,
-        statusText: "Bad Request",
-        headers: new Headers({
-          "Content-Type": "text/plain"
-        }),
-        text: async () => "Bad request"
-      });
-      await (0, import_vitest.expect)(retryClient.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow(import_types.FrappeError);
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(1);
-    });
-    (0, import_vitest.it)("should use exponential backoff when configured", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 3,
-        baseDelayMs: 100,
-        exponentialBackoff: true,
-        maxDelayMs: 500,
-        retryStatusCodes: [503]
-      });
-      const delays = [];
-      import_vitest.vi.spyOn(global, "setTimeout").mockImplementation((fn, delay) => {
-        delays.push(delay || 0);
-        if (typeof fn === "function") fn();
-        return 0;
-      });
-      let attempt = 0;
-      global.fetch = import_vitest.vi.fn().mockImplementation(async () => {
-        attempt++;
-        if (attempt <= 3) {
-          return {
-            ok: false,
-            status: 503,
-            statusText: "Service Unavailable",
-            headers: new Headers({
-              "Content-Type": "text/plain"
-            }),
-            text: async () => "Service unavailable"
-          };
-        }
-        return {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json"
-          }),
-          status: 200,
-          json: async () => ({
-            success: true
-          })
-        };
-      });
-      const result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(delays[0]).toBe(100);
-      (0, import_vitest.expect)(delays[1]).toBe(200);
-      (0, import_vitest.expect)(delays[2]).toBe(400);
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should respect maxDelayMs", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 3,
-        baseDelayMs: 100,
-        exponentialBackoff: true,
-        maxDelayMs: 150,
-        retryStatusCodes: [503]
-      });
-      const delays = [];
-      import_vitest.vi.spyOn(global, "setTimeout").mockImplementation((fn, delay) => {
-        delays.push(delay || 0);
-        if (typeof fn === "function") fn();
-        return 0;
-      });
-      let attempt = 0;
-      global.fetch = import_vitest.vi.fn().mockImplementation(async () => {
-        attempt++;
-        if (attempt <= 3) {
-          return {
-            ok: false,
-            status: 503,
-            statusText: "Service Unavailable",
-            headers: new Headers({
-              "Content-Type": "text/plain"
-            }),
-            text: async () => "Service unavailable"
-          };
-        }
-        return {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json"
-          }),
-          status: 200,
-          json: async () => ({
-            success: true
-          })
-        };
-      });
-      const result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(delays[0]).toBe(100);
-      (0, import_vitest.expect)(delays[1]).toBe(150);
-      (0, import_vitest.expect)(delays[2]).toBe(150);
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should use custom shouldRetry function", async () => {
-      const shouldRetry = import_vitest.vi.fn((_err, attempt2) => attempt2 < 2);
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 3,
-        baseDelayMs: 10,
-        shouldRetry
-      });
-      let attempt = 0;
-      global.fetch = import_vitest.vi.fn().mockImplementation(async () => {
-        attempt++;
-        if (attempt < 3) {
-          return {
-            ok: false,
-            status: 500,
-            statusText: "Internal Server Error",
-            headers: new Headers({
-              "Content-Type": "text/plain"
-            }),
-            text: async () => "Server error"
-          };
-        }
-        return {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json"
-          }),
-          status: 200,
-          json: async () => ({
-            success: true
-          })
-        };
-      });
-      const result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
-      (0, import_vitest.expect)(shouldRetry).toHaveBeenCalledTimes(2);
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
-      (0, import_vitest.expect)(result.payload).toEqual({
-        success: true
-      });
-    });
-    (0, import_vitest.it)("should throw last error after max retries", async () => {
-      const retryClient = new import_http.HttpClient(baseURL, void 0, {
-        maxRetries: 2,
-        baseDelayMs: 10,
-        retryStatusCodes: [503]
-      });
-      global.fetch = import_vitest.vi.fn().mockResolvedValue({
-        ok: false,
-        status: 503,
-        statusText: "Service Unavailable",
-        headers: new Headers({
-          "Content-Type": "text/plain"
-        }),
-        text: async () => "Service unavailable"
-      });
-      await (0, import_vitest.expect)(retryClient.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow(import_types.FrappeError);
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
-    });
-  });
-  (0, import_vitest.describe)("convenience methods", () => {
-    (0, import_vitest.beforeEach)(() => {
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-    });
-    (0, import_vitest.describe)("get", () => {
-      (0, import_vitest.it)("should make GET request without params", async () => {
-        const result = await client.get("/test");
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "GET"
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should make GET request with params", async () => {
-        await client.get("/test", {
-          foo: "bar",
-          num: 123,
-          bool: true,
-          nullValue: null,
-          undefinedValue: void 0
-        });
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?foo=bar&num=123&bool=true`, import_vitest.expect.objectContaining({
-          method: "GET"
-        }));
-      });
-      (0, import_vitest.it)("should handle complex params", async () => {
-        await client.get("/test", {
-          array: [1, 2, 3],
-          object: {
-            nested: "value"
-          }
-        });
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?array=%5B1%2C2%2C3%5D&object=%7B%22nested%22%3A%22value%22%7D`, import_vitest.expect.objectContaining({
-          method: "GET"
-        }));
-      });
-      (0, import_vitest.it)("should pass custom headers", async () => {
-        await client.get("/test", {}, {
-          "X-Custom": "header"
-        });
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("X-Custom")).toBe("header");
-      });
-    });
-    (0, import_vitest.describe)("post", () => {
-      (0, import_vitest.it)("should make POST request without body", async () => {
-        const result = await client.post("/test");
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "POST"
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should make POST request with body", async () => {
-        const body = {
-          data: "test"
-        };
-        const result = await client.post("/test", body);
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "POST",
-          body: JSON.stringify(body)
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should pass custom headers", async () => {
-        await client.post("/test", {}, {
-          "X-Custom": "header"
-        });
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("X-Custom")).toBe("header");
-      });
-    });
-    (0, import_vitest.describe)("put", () => {
-      (0, import_vitest.it)("should make PUT request", async () => {
-        const body = {
-          data: "test"
-        };
-        const result = await client.put("/test", body);
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "PUT",
-          body: JSON.stringify(body)
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should pass custom headers", async () => {
-        await client.put("/test", {}, {
-          "X-Custom": "header"
-        });
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("X-Custom")).toBe("header");
-      });
-    });
-    (0, import_vitest.describe)("delete", () => {
-      (0, import_vitest.it)("should make DELETE request", async () => {
-        const result = await client.delete("/test");
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "DELETE"
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should make DELETE request with body", async () => {
-        const body = {
-          id: "123"
-        };
-        const result = await client.delete("/test", body);
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "DELETE",
-          body: JSON.stringify(body)
-        }));
-        (0, import_vitest.expect)(result.payload).toEqual({
-          success: true
-        });
-      });
-      (0, import_vitest.it)("should pass custom headers", async () => {
-        await client.delete("/test", void 0, {
-          "X-Custom": "header"
-        });
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("X-Custom")).toBe("header");
-      });
-    });
-    (0, import_vitest.describe)("head", () => {
-      (0, import_vitest.it)("should make HEAD request and return response", async () => {
-        const mockRes = {
-          ok: true,
-          headers: new Headers({
-            "Content-Type": "application/json",
-            "Content-Length": "1234"
-          }),
-          status: 200,
-          text: async () => "",
-          json: async () => ({})
-        };
-        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-        const response = await client.head("/test");
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
-          method: "HEAD"
-        }));
-        (0, import_vitest.expect)(response.headers.get("Content-Type")).toBe("application/json");
-        (0, import_vitest.expect)(response.headers.get("Content-Length")).toBe("1234");
-        (0, import_vitest.expect)(response.status).toBe(200);
-      });
-      (0, import_vitest.it)("should make HEAD request with params", async () => {
-        const mockRes = {
-          ok: true,
-          headers: new Headers(),
-          status: 200,
-          text: async () => "",
-          json: async () => ({})
-        };
-        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-        const response = await client.head("/test", {
-          check: "true"
-        });
-        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?check=true`, import_vitest.expect.objectContaining({
-          method: "HEAD"
-        }));
-        (0, import_vitest.expect)(response.status).toBe(200);
-      });
-      (0, import_vitest.it)("should pass custom headers", async () => {
-        const mockRes = {
-          ok: true,
-          headers: new Headers(),
-          status: 200,
-          text: async () => "",
-          json: async () => ({})
-        };
-        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-        await client.head("/test", {}, {
-          "X-Custom": "header"
-        });
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("X-Custom")).toBe("header");
-      });
-      (0, import_vitest.it)("should throw FrappeError on non-ok response", async () => {
-        global.fetch = import_vitest.vi.fn().mockResolvedValue({
-          ok: false,
-          status: 404,
-          statusText: "Not Found",
-          headers: new Headers(),
-          text: async () => "Not found"
-        });
-        await (0, import_vitest.expect)(client.head("/test")).rejects.toThrow(import_types.FrappeError);
-        try {
-          await client.head("/test");
-        } catch (error) {
-          (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
-          (0, import_vitest.expect)(error.status).toBe(404);
-          (0, import_vitest.expect)(error.message).toBe("Not Found");
-        }
-      });
-      (0, import_vitest.it)("should use credentials include when not using token auth", async () => {
-        const mockRes = {
-          ok: true,
-          headers: new Headers(),
-          status: 200,
-          text: async () => "",
-          json: async () => ({})
-        };
-        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-        await client.head("/test");
-        (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.credentials).toBe("include");
-      });
-      (0, import_vitest.it)("should use credentials omit and add auth header when using token auth", async () => {
-        const authClient = new import_http.HttpClient(baseURL, {
-          useToken: true,
-          token: "test-token",
-          type: import_types.AuthType.Bearer
-        });
-        const mockRes = {
-          ok: true,
-          headers: new Headers(),
-          status: 200,
-          text: async () => "",
-          json: async () => ({})
-        };
-        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-        await authClient.head("/test");
-        (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.credentials).toBe("omit");
-        const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-        (0, import_vitest.expect)(calledHeaders?.get("Authorization")).toBe("Bearer test-token");
-      });
-    });
-  });
-  (0, import_vitest.describe)("edge cases", () => {
-    (0, import_vitest.it)("should handle empty response", async () => {
-      const mockRes = {
-        ok: true,
-        headers: new Headers(),
-        status: 200,
-        text: async () => "",
-        json: async () => {
-          throw new Error("Invalid JSON");
-        }
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      const result = await client.request(import_types.HttpMethod.Get, "/empty", {});
-      (0, import_vitest.expect)(result.payload).toBe("");
-      (0, import_vitest.expect)(result.status).toBe(200);
-    });
-    (0, import_vitest.it)("should handle ArrayBuffer body", async () => {
-      const buffer = new ArrayBuffer(8);
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/binary", {
-        body: buffer
-      });
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.body).toBe(buffer);
-    });
-    (0, import_vitest.it)("should handle Blob body", async () => {
-      const blob = new Blob(["test"], {
-        type: "text/plain"
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/blob", {
-        body: blob
-      });
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.body).toBe(blob);
-    });
-    (0, import_vitest.it)("should handle ArrayBufferView body", async () => {
-      const uint8Array = new Uint8Array([1, 2, 3, 4]);
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/typed-array", {
-        body: uint8Array
-      });
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.body).toBe(uint8Array);
-    });
-    (0, import_vitest.it)("should handle relative paths", async () => {
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Get, "relative/path", {});
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/relative/path`, import_vitest.expect.any(Object));
-    });
-    (0, import_vitest.it)("should handle absolute paths", async () => {
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Get, "/absolute/path", {});
-      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/absolute/path`, import_vitest.expect.any(Object));
-    });
-    (0, import_vitest.it)("should handle error response with _server_messages", async () => {
-      const errorPayload = {
-        _server_messages: "Server error messages",
-        exc: "Exception details",
-        message: "Error message"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue({
-        ok: false,
-        status: 500,
-        statusText: "Internal Server Error",
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        json: async () => errorPayload
-      });
-      try {
-        await client.request(import_types.HttpMethod.Post, "/test", {});
-      } catch (error) {
-        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
-        (0, import_vitest.expect)(error.message).toBe("Error message");
-      }
-    });
-    (0, import_vitest.it)("should handle error response with exc", async () => {
-      const errorPayload = {
-        exc: "Exception details"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue({
-        ok: false,
-        status: 500,
-        statusText: "Internal Server Error",
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        json: async () => errorPayload
-      });
-      try {
-        await client.request(import_types.HttpMethod.Post, "/test", {});
-      } catch (error) {
-        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
-        (0, import_vitest.expect)(error.message).toBe("Exception details");
-      }
-    });
-    (0, import_vitest.it)("should handle FormData with Blob values", async () => {
-      const blob = new Blob(["file content"], {
-        type: "text/plain"
-      });
-      const requestBody = {
-        field: "value",
-        file: blob
-      };
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/upload", {
-        body: requestBody,
-        headers: {
-          "Content-Type": "multipart/form-data"
-        }
-      });
-      const calledBody = getMockFetch().mock.calls[0]?.[1]?.body;
-      (0, import_vitest.expect)(calledBody).toBeInstanceOf(FormData);
-    });
-    (0, import_vitest.it)("should skip non-string values in URLSearchParams conversion", async () => {
-      const requestBody = {
-        field1: "value1",
-        field2: 123,
-        field3: null,
-        field4: void 0
-      };
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "text/plain"
-        }),
-        status: 200,
-        text: async () => "success"
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {
-        body: requestBody,
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        }
-      });
-      const calledBody = getMockFetch().mock.calls[0]?.[1]?.body;
-      (0, import_vitest.expect)(calledBody).toBe("field1=value1");
-    });
-    (0, import_vitest.it)("should handle ReadableStream body", async () => {
-      const stream = new ReadableStream();
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/stream", {
-        body: stream
-      });
-      (0, import_vitest.expect)(getMockFetch().mock.calls[0]?.[1]?.body).toBe(stream);
-    });
-    (0, import_vitest.it)("should handle global frappe csrf token", async () => {
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: ""
-        },
-        writable: true,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true,
-        configurable: true
-      });
-      Object.defineProperty(global, "frappe", {
-        value: {
-          csrf_token: "global-csrf-token"
-        },
-        writable: true,
-        configurable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBe("global-csrf-token");
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "frappe", {
-        value: void 0,
-        configurable: true
-      });
-    });
-    (0, import_vitest.it)("should prefer frappe-csrf-token cookie over csrf_token", async () => {
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: "frappe-csrf-token=preferred; csrf_token=fallback"
-        },
-        writable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBe("preferred");
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-    });
-    (0, import_vitest.it)("should use csrf_token cookie as fallback", async () => {
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: "csrf_token=fallback"
-        },
-        writable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBe("fallback");
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-    });
-    (0, import_vitest.it)("should not add CSRF token for GET requests", async () => {
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: "frappe-csrf-token=test-token"
-        },
-        writable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Get, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBeNull();
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-    });
-    (0, import_vitest.it)("should handle cookie with special characters", async () => {
-      Object.defineProperty(global, "document", {
-        value: {
-          cookie: "frappe-csrf-token=%2Ftest%2Ftoken%3D"
-        },
-        writable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: {},
-        writable: true
-      });
-      const mockRes = {
-        ok: true,
-        headers: new Headers({
-          "Content-Type": "application/json"
-        }),
-        status: 200,
-        json: async () => ({
-          success: true
-        })
-      };
-      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
-      await client.request(import_types.HttpMethod.Post, "/test", {});
-      const calledHeaders = getMockFetch().mock.calls[0]?.[1]?.headers;
-      (0, import_vitest.expect)(calledHeaders?.get("X-Frappe-CSRF-Token")).toBe("/test/token=");
-      Object.defineProperty(global, "document", {
-        value: void 0,
-        configurable: true
-      });
-      Object.defineProperty(global, "window", {
-        value: void 0,
-        configurable: true
-      });
-    });
-  });
-});