@congminh1254/shopee-sdk 1.6.2 → 1.8.0

package/README.md

@@ -8,6 +8,8 @@
 
 🎉 **The most complete, production-ready TypeScript SDK for Shopee Open API** 🎉
 
+<a href="https://www.buymeacoffee.com/congminh1254" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee" style="height: 40px !important;width: 150px !important;" ></a>
+
 Build powerful Shopee integrations with confidence using our fully-featured SDK that covers **100% of Shopee's API endpoints**. Trusted by developers, built by the community.
 
 ## 📚 Documentation
@@ -32,6 +34,7 @@ Build powerful Shopee integrations with confidence using our fully-featured SDK
 - [PushManager](./docs/managers/push.md) - Webhooks and notifications
 - [PublicManager](./docs/managers/public.md) - Public API endpoints
 - [AdsManager](./docs/managers/ads.md) - Advertising campaigns
+- [AmsManager](./docs/managers/ams.md) - Affiliate Marketing Solutions (AMS)
 - [AccountHealthManager](./docs/managers/account-health.md) - Performance metrics
 - [ShopManager](./docs/managers/shop.md) - Shop information and settings
 - [MediaManager](./docs/managers/media.md) - Image and video upload
@@ -50,6 +53,7 @@ Build powerful Shopee integrations with confidence using our fully-featured SDK
 - [SbsManager](./docs/managers/sbs.md) - Shopee Business Services (SBS) warehouse inventory
 - [FbsManager](./docs/managers/fbs.md) - Fulfillment by Shopee operations
 - [LivestreamManager](./docs/managers/livestream.md) - Live streaming features
+- [VideoManager](./docs/managers/video.md) - Shopee Video features and analytics
 
 ## Installation
 
@@ -60,7 +64,7 @@ npm install @congminh1254/shopee-sdk
 **Requirements:** Node.js >= 20.0.0
 
 ### What You Get
-✅ Complete TypeScript definitions for all 27 API managers  
+✅ Complete TypeScript definitions for all 29 API managers  
 ✅ Automatic token refresh and management  
 ✅ Built-in error handling and retry logic  
 ✅ Zero dependencies (except node-fetch)  
@@ -124,12 +128,12 @@ See the [Setup Guide](./docs/guides/setup.md) and [Authentication Guide](./docs/
 ## Why Choose This SDK?
 
 ### 🚀 Production-Ready & Battle-Tested
-- **75%+ test coverage** with 86 comprehensive tests - ensuring reliability in production
+- **95%+ test coverage** with 671 comprehensive tests - ensuring reliability in production
 - **Zero compromises** - Every Shopee API endpoint is implemented and documented
 - **Type-safe** - Full TypeScript definitions prevent errors before they happen
 - **Actively maintained** - Regular updates to stay in sync with Shopee API changes
 
-### 💪 Complete API Coverage - All 27 Managers Implemented
+### 💪 Complete API Coverage - All 29 Managers Implemented
 Unlike other SDKs with partial coverage, we provide **complete access** to every Shopee API:
 
 **Core Commerce:**
@@ -146,6 +150,7 @@ Unlike other SDKs with partial coverage, we provide **complete access** to every
 - ⚡ **ShopFlashSaleManager** - Flash sale campaigns
 - 🎯 **FollowPrizeManager** - Follow prize activities
 - ⭐ **TopPicksManager** - Top picks product collections
+- 📣 **AmsManager** - Affiliate marketing solutions (AMS)
 
 **Store Management:**
 - 🏪 **ShopManager** - Shop information and profile management
@@ -165,6 +170,7 @@ Unlike other SDKs with partial coverage, we provide **complete access** to every
 - 🏭 **SbsManager** - Shopee Business Services warehouse inventory
 - 📦 **FbsManager** - Fulfillment by Shopee operations
 - 📹 **LivestreamManager** - Live streaming features
+- 🎬 **VideoManager** - Shopee Video features and analytics
 
 ### ✨ Developer Experience First
 - **Intuitive API design** - Clean, consistent interfaces across all managers

package/lib/__tests__/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/errors.test.js

@@ -0,0 +1,49 @@
+import { ShopeeSdkError, ShopeeApiError } from "../errors.js";
+describe("ShopeeSdkError", () => {
+    it("should create an error with the correct name and message", () => {
+        const errorMessage = "Test error message";
+        const error = new ShopeeSdkError(errorMessage);
+        expect(error).toBeInstanceOf(Error);
+        expect(error).toBeInstanceOf(ShopeeSdkError);
+        expect(error.name).toBe("ShopeeSdkError");
+        expect(error.message).toBe(errorMessage);
+    });
+    it("should have a proper error stack", () => {
+        const error = new ShopeeSdkError("Test error");
+        expect(error.stack).toBeDefined();
+        expect(typeof error.stack).toBe("string");
+    });
+});
+describe("ShopeeApiError", () => {
+    it("should create an error with status and data", () => {
+        const status = 400;
+        const data = { error: "Invalid request", message: "Bad request" };
+        const error = new ShopeeApiError(status, data);
+        expect(error).toBeInstanceOf(Error);
+        expect(error).toBeInstanceOf(ShopeeApiError);
+        expect(error.name).toBe("ShopeeApiError");
+        expect(error.status).toBe(status);
+        expect(error.data).toBe(data);
+        expect(error.message).toContain(status.toString());
+        expect(error.message).toContain(JSON.stringify(data));
+    });
+    it("should handle different types of data", () => {
+        const testCases = [
+            { status: 404, data: { error: "Not found" } },
+            { status: 500, data: "Internal server error" },
+            { status: 401, data: null },
+            { status: 403, data: undefined },
+        ];
+        testCases.forEach(({ status, data }) => {
+            const error = new ShopeeApiError(status, data);
+            expect(error.status).toBe(status);
+            expect(error.data).toBe(data);
+        });
+    });
+    it("should have a proper error stack", () => {
+        const error = new ShopeeApiError(500, { error: "Test error" });
+        expect(error.stack).toBeDefined();
+        expect(typeof error.stack).toBe("string");
+    });
+});
+//# sourceMappingURL=errors.test.js.map

package/lib/__tests__/errors.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.test.js","sourceRoot":"","sources":["../../src/__tests__/errors.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9D,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,MAAM,YAAY,GAAG,oBAAoB,CAAC;QAC1C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,YAAY,CAAC,CAAC;QAE/C,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACpC,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAC7C,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC1C,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC1C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,YAAY,CAAC,CAAC;QAC/C,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAClC,MAAM,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,gBAAgB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,MAAM,GAAG,GAAG,CAAC;QACnB,MAAM,IAAI,GAAG,EAAE,KAAK,EAAE,iBAAiB,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAE/C,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QACpC,MAAM,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;QAC7C,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC1C,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QACnD,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IACxD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,MAAM,SAAS,GAAG;YAChB,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE;YAC7C,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,uBAAuB,EAAE;YAC9C,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE;YAC3B,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE;SACjC,CAAC;QAEF,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;YACrC,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YAC/C,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAClC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC1C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;QAC/D,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;QAClC,MAAM,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/__tests__/fetch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/fetch.test.js

@@ -0,0 +1,494 @@
+import { jest, describe, beforeEach, it, expect } from "@jest/globals";
+import { ShopeeRegion } from "../schemas/region.js";
+import { ShopeeSdkError } from "../errors.js";
+// Mock fetch function
+const mockFetch = jest.fn();
+// Mock the entire fetch module before importing ShopeeFetch
+jest.unstable_mockModule("node-fetch", () => ({
+    default: mockFetch,
+    Blob: globalThis.Blob,
+    FormData: globalThis.FormData,
+    Headers: globalThis.Headers,
+}));
+// Import ShopeeFetch after mocking
+const { ShopeeFetch } = await import("../fetch.js");
+function getRequestContentType(url, options) {
+    return new Request(url, options).headers.get("content-type");
+}
+describe("ShopeeFetch", () => {
+    let mockConfig;
+    let mockSdk;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSdk = {
+            getAuthToken: jest.fn(),
+            refreshToken: jest.fn(),
+        };
+        mockConfig = {
+            partner_id: 12345,
+            partner_key: "test_partner_key",
+            shop_id: 67890,
+            region: ShopeeRegion.GLOBAL,
+            base_url: "https://partner.test-stable.shopeemobile.com/api/v2",
+            sdk: mockSdk,
+        };
+    });
+    describe("fetch method", () => {
+        it("should make successful GET request without auth", async () => {
+            const mockResponse = {
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+                response: { data: "test data" },
+            };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint");
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            expect(result).toEqual(mockResponse);
+        });
+        it("should make successful POST request with body", async () => {
+            const mockResponse = { success: true };
+            const requestBody = { key: "value" };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                method: "POST",
+                body: requestBody,
+            });
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            expect(options.method).toBe("POST");
+            expect(options.body).toBe(JSON.stringify(requestBody));
+            expect(result).toEqual(mockResponse);
+        });
+        it("should serialize multipart bodies when the payload contains binary fields", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValue({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const image = Buffer.from("image-data");
+            await ShopeeFetch.fetch(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                body: {
+                    scene: "normal",
+                    image,
+                },
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            const formData = options.body;
+            expect(formData).toBeInstanceOf(FormData);
+            expect(formData.get("scene")).toBe("normal");
+            expect(formData.get("image")).toBeInstanceOf(Blob);
+            expect(options.headers.get("content-type")).toBeNull();
+            expect(getRequestContentType(`${mockConfig.base_url}/media_space/upload_image`, options)).toMatch(/^multipart\/form-data; boundary=/);
+        });
+        it("should serialize multipart bodies when the payload contains binary arrays", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValue({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const image1 = Buffer.from("image-1");
+            const image2 = Buffer.from("image-2");
+            await ShopeeFetch.fetch(mockConfig, "/media/upload_image", {
+                method: "POST",
+                body: {
+                    business: 2,
+                    scene: 1,
+                    images: [image1, image2],
+                },
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            const formData = options.body;
+            const images = formData.getAll("images");
+            expect(formData).toBeInstanceOf(FormData);
+            expect(formData.get("business")).toBe("2");
+            expect(formData.get("scene")).toBe("1");
+            expect(images).toHaveLength(2);
+            images.forEach((image) => expect(image).toBeInstanceOf(Blob));
+            expect(options.headers.get("content-type")).toBeNull();
+            expect(getRequestContentType(`${mockConfig.base_url}/media/upload_image`, options)).toMatch(/^multipart\/form-data; boundary=/);
+        });
+        it("should pass through FormData bodies without forcing JSON content type", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValue({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const formData = new FormData();
+            formData.append("video_upload_id", "upload-id");
+            formData.append("part_content", new Blob([Buffer.from("video-part")]), "part.bin");
+            await ShopeeFetch.fetch(mockConfig, "/media_space/upload_video_part", {
+                method: "POST",
+                body: formData,
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            expect(options.body).toBe(formData);
+            expect(options.headers.get("content-type")).toBeNull();
+            expect(getRequestContentType(`${mockConfig.base_url}/media_space/upload_video_part`, options)).toMatch(/^multipart\/form-data; boundary=/);
+        });
+        it("should serialize multipart bodies with null, undefined, named/unnamed Blobs, and nested objects", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValue({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const fileWithFilename = new Blob([Buffer.from("file-1")]);
+            Object.defineProperty(fileWithFilename, "name", {
+                value: "custom-file.txt",
+                writable: false,
+            });
+            const fileWithoutFilename = new Blob([Buffer.from("file-2")]);
+            await ShopeeFetch.fetch(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                body: {
+                    image: Buffer.from("image-data"),
+                    nullField: null,
+                    undefinedField: undefined,
+                    arrayField: ["string", null, undefined],
+                    namedBlob: fileWithFilename,
+                    unnamedBlob: fileWithoutFilename,
+                    nestedObject: { key: "nested" },
+                },
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            const formData = options.body;
+            expect(formData).toBeInstanceOf(FormData);
+            expect(formData.get("image")).toBeInstanceOf(Blob);
+            expect(formData.get("nullField")).toBeNull();
+            expect(formData.get("undefinedField")).toBeNull();
+            expect(formData.getAll("arrayField")).toEqual(["string"]);
+            expect(formData.get("namedBlob")).toBeInstanceOf(Blob);
+            expect(formData.get("unnamedBlob")).toBeInstanceOf(Blob);
+            expect(formData.get("nestedObject")).toBe(JSON.stringify({ key: "nested" }));
+        });
+        it("should make authenticated request with valid token", async () => {
+            const mockToken = {
+                access_token: "test_access_token",
+                refresh_token: "test_refresh_token",
+                expire_in: 3600,
+                expired_at: Date.now() + 3600000,
+                shop_id: 67890,
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            const mockResponse = { data: "authenticated data" };
+            mockSdk.getAuthToken.mockResolvedValue(mockToken);
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                auth: true,
+            });
+            expect(mockSdk.getAuthToken).toHaveBeenCalledTimes(1);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [url] = mockFetch.mock.calls[0];
+            expect(url).toContain("access_token=test_access_token");
+            expect(url).toContain("shop_id=67890");
+            expect(result).toEqual(mockResponse);
+        });
+        it("should refresh token when expired and retry request", async () => {
+            const expiredToken = {
+                access_token: "expired_token",
+                refresh_token: "test_refresh_token",
+                expire_in: 3600,
+                expired_at: Date.now() - 1000, // Expired
+                shop_id: 67890,
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            const newToken = {
+                access_token: "new_access_token",
+                refresh_token: "new_refresh_token",
+                expire_in: 3600,
+                expired_at: Date.now() + 3600000,
+                shop_id: 67890,
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            const mockResponse = { data: "authenticated data" };
+            mockSdk.getAuthToken.mockResolvedValue(expiredToken);
+            mockSdk.refreshToken.mockResolvedValue(newToken);
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                auth: true,
+            });
+            expect(mockSdk.getAuthToken).toHaveBeenCalledTimes(1);
+            expect(mockSdk.refreshToken).toHaveBeenCalledTimes(1);
+            expect(result).toEqual(mockResponse);
+        });
+        it("should throw error when no access token found", async () => {
+            mockSdk.getAuthToken.mockResolvedValue(null);
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint", { auth: true })).rejects.toThrow(ShopeeSdkError);
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint", { auth: true })).rejects.toThrow("No access token found");
+        });
+        it("should handle invalid access token error and retry after refresh", async () => {
+            const invalidTokenResponse = {
+                error: "invalid_acceess_token",
+                message: "Invalid access token",
+                request_id: "test-request-id",
+            };
+            const successResponse = { data: "success after refresh" };
+            const mockToken = {
+                access_token: "old_token",
+                refresh_token: "refresh_token",
+                expire_in: 3600,
+                expired_at: Date.now() + 3600000,
+                shop_id: 67890,
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockSdk.getAuthToken.mockResolvedValue(mockToken);
+            mockSdk.refreshToken.mockResolvedValue(mockToken);
+            // First call returns invalid token error, second call succeeds
+            mockFetch
+                .mockResolvedValueOnce({
+                status: 401,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(invalidTokenResponse)),
+            })
+                .mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(successResponse)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                auth: true,
+            });
+            expect(mockSdk.refreshToken).toHaveBeenCalledTimes(1);
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(successResponse);
+        });
+        it("should include custom headers in request", async () => {
+            const mockResponse = { data: "test" };
+            const customHeaders = {
+                "X-Custom-Header": "custom-value",
+            };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                headers: customHeaders,
+            });
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            expect(options.headers.get("X-Custom-Header")).toBe("custom-value");
+        });
+        it("should include User-Agent header with SDK version", async () => {
+            const mockResponse = { data: "test" };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/test/endpoint");
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            const userAgent = options.headers.get("user-agent");
+            expect(userAgent).toMatch(/^congminh1254\/shopee-sdk\/v\d+\.\d+\.\d+$/);
+        });
+        it("should include query parameters in URL", async () => {
+            const mockResponse = { data: "test" };
+            const params = {
+                param1: "value1",
+                param2: 123,
+                param3: ["array1", "array2"],
+            };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                params,
+            });
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [url] = mockFetch.mock.calls[0];
+            expect(url).toContain("param1=value1");
+            expect(url).toContain("param2=123");
+            expect(url).toContain("param3=array1");
+            expect(url).toContain("param3=array2");
+        });
+        it("should remove undefined query parameters from URL", async () => {
+            const mockResponse = { data: "test" };
+            const params = {
+                param1: "value1",
+                param2: undefined,
+            };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                params,
+            });
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            const [url] = mockFetch.mock.calls[0];
+            expect(url).toContain("param1=value1");
+            expect(url).not.toContain("param2");
+        });
+        it("should handle invalid access token error when refresh fails", async () => {
+            const invalidTokenResponse = {
+                error: "invalid_acceess_token",
+                message: "Invalid access token",
+                request_id: "test-request-id",
+            };
+            const mockToken = {
+                access_token: "old_token",
+                refresh_token: "refresh_token",
+                expire_in: 3600,
+                expired_at: Date.now() + 3600000,
+                shop_id: 67890,
+                request_id: "test-request-id",
+                error: "",
+                message: "",
+            };
+            mockSdk.getAuthToken.mockResolvedValue(mockToken);
+            mockSdk.refreshToken.mockRejectedValue(new Error("Refresh failed"));
+            mockFetch.mockResolvedValueOnce({
+                status: 401,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(invalidTokenResponse)),
+            });
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint", { auth: true })).rejects.toThrow("API Error: 401");
+        });
+        it("should throw ShopeeApiError when API returns error", async () => {
+            const errorResponse = {
+                error: "error_code",
+                message: "Error message",
+                request_id: "test-request-id",
+            };
+            mockFetch.mockResolvedValueOnce({
+                status: 400,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(errorResponse)),
+            });
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint")).rejects.toThrow("API Error: 400");
+        });
+        it("should throw error for unknown response type", async () => {
+            const headers = new Map([["content-type", "text/html"]]);
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: {
+                    get: (name) => headers.get(name.toLowerCase()),
+                },
+                text: jest.fn(() => Promise.resolve("<html>Not JSON</html>")),
+                json: jest.fn(),
+            });
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint")).rejects.toThrow("Unknown response type");
+        });
+        it("should return Buffer for application/pdf response", async () => {
+            const text = "%PDF-1.4 test pdf content";
+            const uint8 = new TextEncoder().encode(text);
+            const headers = new Map([["content-type", "application/pdf"]]);
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: {
+                    get: (name) => headers.get(name.toLowerCase()),
+                },
+                arrayBuffer: jest.fn(() => Promise.resolve(uint8.buffer)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint");
+            expect(result).toBeInstanceOf(Buffer);
+            expect(result.toString()).toBe(text);
+        });
+        it("should return Buffer for application/octet-stream response", async () => {
+            const text = "binary data";
+            const uint8 = new TextEncoder().encode(text);
+            const headers = new Map([["content-type", "application/octet-stream"]]);
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: {
+                    get: (name) => headers.get(name.toLowerCase()),
+                },
+                arrayBuffer: jest.fn(() => Promise.resolve(uint8.buffer)),
+            });
+            const result = await ShopeeFetch.fetch(mockConfig, "/test/endpoint");
+            expect(result).toBeInstanceOf(Buffer);
+            expect(result.toString()).toBe(text);
+        });
+        it("should handle network errors", async () => {
+            const networkError = new Error("Network failed");
+            networkError.name = "FetchError";
+            mockFetch.mockRejectedValueOnce(networkError);
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint")).rejects.toThrow("Network error: Network failed");
+        });
+        it("should handle unexpected errors", async () => {
+            const unexpectedError = new Error("Unexpected error");
+            mockFetch.mockRejectedValueOnce(unexpectedError);
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint")).rejects.toThrow("Unexpected error: Unexpected error");
+        });
+        it("should handle unknown non-Error exceptions", async () => {
+            mockFetch.mockRejectedValueOnce("string error");
+            await expect(ShopeeFetch.fetch(mockConfig, "/test/endpoint")).rejects.toThrow("Unknown error occurred");
+        });
+        it("should handle null body correctly", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/test/endpoint", {
+                method: "POST",
+                body: null,
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            expect(options.body).toBe("null");
+        });
+        it("should serialize multipart bodies with fallback isBlobLike conditions", async () => {
+            const mockResponse = { success: true };
+            mockFetch.mockResolvedValueOnce({
+                status: 200,
+                headers: new Map([["content-type", "application/json"]]),
+                json: jest.fn(() => Promise.resolve(mockResponse)),
+            });
+            await ShopeeFetch.fetch(mockConfig, "/media_space/upload_image", {
+                method: "POST",
+                body: {
+                    image: Buffer.from("image-data"),
+                    nullProto: Object.create(null),
+                },
+            });
+            const [, options] = mockFetch.mock.calls[0];
+            expect(options).toBeDefined();
+            const formData = options.body;
+            expect(formData).toBeInstanceOf(FormData);
+            expect(formData.get("image")).toBeInstanceOf(Blob);
+        });
+    });
+});
+//# sourceMappingURL=fetch.test.js.map