@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/api/client.test.js

@@ -1,611 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createZapierApi } from "./client";
-import * as auth from "../auth";
-import { ZapierRateLimitError } from "../types/errors";
-vi.mock("../auth");
-describe("ApiClient", () => {
-    const mockResolveAuthToken = vi.mocked(auth.resolveAuthToken);
-    const mockInvalidateCredentialsToken = vi.mocked(auth.invalidateCredentialsToken);
-    let mockFetch;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Prevent any actual HTTP calls
-        mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            text: () => Promise.resolve(JSON.stringify({ data: "test" })),
-        });
-        global.fetch = mockFetch;
-    });
-    describe("authentication token resolution", () => {
-        it("should pass credentials to resolveAuthToken when provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const credentials = {
-                type: "client_credentials",
-                clientId: "my-client",
-                clientSecret: "my-secret",
-            };
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                credentials,
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                credentials,
-                token: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                requiredScopes: undefined,
-                debug: false,
-            });
-        });
-        it("should pass undefined credentials when not provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                credentials: undefined,
-                token: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                requiredScopes: undefined,
-                debug: false,
-            });
-        });
-        it("should pass deprecated token option to resolveAuthToken", async () => {
-            mockResolveAuthToken.mockResolvedValue("direct-token");
-            const client = createZapierApi({
-                token: "direct-token",
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would use the direct token
-            await client.get("/test", { authRequired: true });
-            // resolveAuthToken is still called, but it returns the direct token immediately
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                credentials: undefined,
-                token: "direct-token",
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                requiredScopes: undefined,
-                debug: false,
-            });
-        });
-        it("should pass string credentials to resolveAuthToken", async () => {
-            mockResolveAuthToken.mockResolvedValue("string-token");
-            const client = createZapierApi({
-                credentials: "string-token",
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                credentials: "string-token",
-                token: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                requiredScopes: undefined,
-                debug: false,
-            });
-        });
-        it("should pass credentials function to resolveAuthToken", async () => {
-            mockResolveAuthToken.mockResolvedValue("function-token");
-            const credentialsFn = () => Promise.resolve("dynamic-token");
-            const client = createZapierApi({
-                credentials: credentialsFn,
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                credentials: credentialsFn,
-                token: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                requiredScopes: undefined,
-                debug: false,
-            });
-        });
-    });
-    describe("401 cache invalidation", () => {
-        it("should invalidate credentials token on 401 response", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            mockInvalidateCredentialsToken.mockResolvedValue(undefined);
-            const clientCredentials = {
-                type: "client_credentials",
-                clientId: "my-client-id",
-                clientSecret: "my-secret",
-            };
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 401,
-                statusText: "Unauthorized",
-                text: () => Promise.resolve(JSON.stringify({ message: "Invalid token" })),
-            });
-            const client = createZapierApi({
-                credentials: clientCredentials,
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            await expect(client.get("/test")).rejects.toThrow();
-            expect(mockInvalidateCredentialsToken).toHaveBeenCalledWith({
-                credentials: clientCredentials,
-                token: undefined,
-            });
-        });
-        it("should not invalidate cache on 403 response", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 403,
-                statusText: "Forbidden",
-                text: () => Promise.resolve(JSON.stringify({ message: "Access denied" })),
-            });
-            const client = createZapierApi({
-                credentials: "test-token",
-                baseUrl: "https://api.custom.zapier.dev",
-                debug: false,
-            });
-            await expect(client.get("/test")).rejects.toThrow();
-            expect(mockInvalidateCredentialsToken).not.toHaveBeenCalled();
-        });
-    });
-    describe("URL path configuration", () => {
-        beforeEach(() => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-        });
-        it("should apply pathPrefix for /relay path with Zapier base URL", async () => {
-            const client = createZapierApi({
-                baseUrl: "https://zapier.com",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/relay/some/path");
-            expect(mockFetch).toHaveBeenCalledWith("https://sdkapi.zapier.com/api/v0/sdk/relay/some/path", expect.any(Object));
-        });
-        it("should apply pathPrefix for /zapier path with Zapier base URL", async () => {
-            const client = createZapierApi({
-                baseUrl: "https://zapier.com",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/zapier/apps");
-            expect(mockFetch).toHaveBeenCalledWith("https://sdkapi.zapier.com/api/v0/sdk/zapier/apps", expect.any(Object));
-        });
-        it("should apply pathPrefix for /relay path with localhost base URL", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/relay/some/path");
-            expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/api/v0/sdk/relay/some/path", expect.any(Object));
-        });
-        it("should apply pathPrefix for /zapier path with localhost base URL", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/zapier/apps");
-            expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/api/v0/sdk/zapier/apps", expect.any(Object));
-        });
-        it("should not apply pathPrefix for non-configured paths", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/other/path");
-            expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/other/path", expect.any(Object));
-        });
-        it("should handle exact path match for pathPrefix", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/relay");
-            expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/api/v0/sdk/relay/", expect.any(Object));
-        });
-        it("should use sdkapi subdomain when Zapier base URL has trailing slash", async () => {
-            const client = createZapierApi({
-                baseUrl: "https://zapier-staging.com/",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/zapier/api/v4/profile/");
-            expect(mockFetch).toHaveBeenCalledWith("https://sdkapi.zapier-staging.com/api/v0/sdk/zapier/api/v4/profile/", expect.any(Object));
-        });
-        it("should preserve base URL path for localhost with path component", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000/a/b/c",
-                credentials: "test-token",
-                debug: false,
-            });
-            await client.get("/relay/some/path");
-            expect(mockFetch).toHaveBeenCalledWith("http://localhost:3000/a/b/c/api/v0/sdk/relay/some/path", expect.any(Object));
-        });
-    });
-    describe("fetch body serialization", () => {
-        beforeEach(() => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-        });
-        it("should JSON.stringify plain object bodies", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const body = { channel: "C123", text: "hello" };
-            await client.fetch("/relay/api.example.com/data", {
-                method: "POST",
-                body: body,
-            });
-            const [, options] = mockFetch.mock.calls[0];
-            expect(options.body).toBe(JSON.stringify(body));
-        });
-        it("should JSON.stringify array bodies", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const body = [{ id: 1 }, { id: 2 }];
-            await client.fetch("/relay/api.example.com/data", {
-                method: "POST",
-                body: body,
-            });
-            const [, options] = mockFetch.mock.calls[0];
-            expect(options.body).toBe(JSON.stringify(body));
-        });
-        it("should not stringify FormData bodies", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const body = new FormData();
-            body.append("file", "contents");
-            await client.fetch("/relay/api.example.com/upload", {
-                method: "POST",
-                body,
-            });
-            const [, options] = mockFetch.mock.calls[0];
-            expect(options.body).toBe(body);
-        });
-        it("should not stringify Blob bodies", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const body = new Blob(["binary data"], {
-                type: "application/octet-stream",
-            });
-            await client.fetch("/relay/api.example.com/upload", {
-                method: "POST",
-                body,
-            });
-            const [, options] = mockFetch.mock.calls[0];
-            expect(options.body).toBe(body);
-        });
-        it("should pass string bodies through unchanged", async () => {
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const body = '{"already": "stringified"}';
-            await client.fetch("/relay/api.example.com/data", {
-                method: "POST",
-                body,
-            });
-            const [, options] = mockFetch.mock.calls[0];
-            expect(options.body).toBe(body);
-        });
-    });
-    describe("rate limiting (429) retry behavior", () => {
-        beforeEach(() => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            vi.useFakeTimers();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-        it("should retry on 429 and succeed on subsequent attempt", async () => {
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers({ "retry-after": "1" }),
-                        text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify({ data: "success" })),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const resultPromise = client.get("/test");
-            // Fast-forward through the retry delay
-            await vi.advanceTimersByTimeAsync(1000);
-            const result = await resultPromise;
-            expect(result).toEqual({ data: "success" });
-            expect(callCount).toBe(2);
-        });
-        it("should throw ZapierRateLimitError after max retries exhausted", async () => {
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 429,
-                statusText: "Too Many Requests",
-                headers: new Headers({
-                    "retry-after": "1",
-                    "x-ratelimit-limit": "100",
-                    "x-ratelimit-remaining": "0",
-                }),
-                text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-                maxNetworkRetries: 2,
-            });
-            const resultPromise = client.get("/test");
-            // Attach error handler immediately to prevent unhandled rejection
-            let caughtError;
-            resultPromise.catch((err) => {
-                caughtError = err;
-            });
-            // Advance through all retry delays
-            await vi.advanceTimersByTimeAsync(1000); // 1st retry
-            await vi.advanceTimersByTimeAsync(1000); // 2nd retry
-            // Wait for promise to settle
-            await vi.advanceTimersByTimeAsync(0);
-            expect(caughtError).toBeInstanceOf(ZapierRateLimitError);
-            expect(caughtError).toMatchObject({
-                rateLimit: {
-                    retryAfterMs: 1000,
-                    limit: 100,
-                    remaining: 0,
-                },
-            });
-            // Should have made 3 calls (initial + 2 retries)
-            expect(global.fetch).toHaveBeenCalledTimes(3);
-        });
-        it("should use exponential backoff when no Retry-After header", async () => {
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount <= 2) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers(),
-                        text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify({ data: "success" })),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const resultPromise = client.get("/test");
-            // First retry: ~1000ms base delay
-            await vi.advanceTimersByTimeAsync(1500);
-            // Second retry: ~2000ms base delay
-            await vi.advanceTimersByTimeAsync(3000);
-            const result = await resultPromise;
-            expect(result).toEqual({ data: "success" });
-            expect(callCount).toBe(3);
-        });
-        it("should respect X-RateLimit-Reset when no Retry-After header", async () => {
-            const resetTime = Math.floor(Date.now() / 1000) + 2; // 2 seconds from now
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers({
-                            "x-ratelimit-reset": String(resetTime),
-                        }),
-                        text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify({ data: "success" })),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const resultPromise = client.get("/test");
-            // Advance past the reset time
-            await vi.advanceTimersByTimeAsync(2500);
-            const result = await resultPromise;
-            expect(result).toEqual({ data: "success" });
-            expect(callCount).toBe(2);
-        });
-        it("should emit retry events via onEvent", async () => {
-            const events = [];
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers({ "retry-after": "1" }),
-                        text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    text: () => Promise.resolve(JSON.stringify({ data: "success" })),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-                onEvent: (event) => events.push(event),
-            });
-            const resultPromise = client.get("/test");
-            await vi.advanceTimersByTimeAsync(1000);
-            await resultPromise;
-            expect(events).toContainEqual(expect.objectContaining({
-                type: "api:rate_limit_retry",
-                payload: expect.objectContaining({
-                    retry: 1,
-                    maxNetworkRetries: 3,
-                    delayMs: 1000,
-                }),
-            }));
-        });
-        it("should disable retries when maxNetworkRetries is 0", async () => {
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 429,
-                statusText: "Too Many Requests",
-                headers: new Headers({ "retry-after": "1" }),
-                text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-                maxNetworkRetries: 0,
-            });
-            await expect(client.get("/test")).rejects.toThrow(ZapierRateLimitError);
-            // Should only make 1 call (no retries)
-            expect(global.fetch).toHaveBeenCalledTimes(1);
-        });
-        it("should also retry on raw fetch calls", async () => {
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers({ "retry-after": "1" }),
-                        text: () => Promise.resolve("Rate limited"),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    headers: new Headers(),
-                    text: () => Promise.resolve("success"),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-            });
-            const resultPromise = client.fetch("/test");
-            await vi.advanceTimersByTimeAsync(1000);
-            const response = await resultPromise;
-            expect(response.status).toBe(200);
-            expect(callCount).toBe(2);
-        });
-        it("should fail immediately when retry delay exceeds maxNetworkRetryDelayMs", async () => {
-            global.fetch = vi.fn().mockResolvedValue({
-                ok: false,
-                status: 429,
-                statusText: "Too Many Requests",
-                headers: new Headers({ "retry-after": "60" }), // Server wants 60 seconds
-                text: () => Promise.resolve(JSON.stringify({ message: "Rate limited" })),
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-                maxNetworkRetryDelayMs: 5000, // But we only want to wait up to 5 seconds
-            });
-            try {
-                await client.get("/test");
-                expect.fail("Should have thrown ZapierRateLimitError");
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(ZapierRateLimitError);
-                // Verify retries is 0 (no retries happened), not maxNetworkRetries
-                expect(error.retries).toBe(0);
-            }
-            // Should only make 1 call (no retries because delay exceeds max)
-            expect(global.fetch).toHaveBeenCalledTimes(1);
-        });
-        it("should retry when delay is within maxNetworkRetryDelayMs", async () => {
-            let callCount = 0;
-            global.fetch = vi.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    return Promise.resolve({
-                        ok: false,
-                        status: 429,
-                        statusText: "Too Many Requests",
-                        headers: new Headers({ "retry-after": "1" }), // Server wants 1 second
-                        text: () => Promise.resolve("Rate limited"),
-                    });
-                }
-                return Promise.resolve({
-                    ok: true,
-                    status: 200,
-                    headers: new Headers(),
-                    text: () => Promise.resolve(JSON.stringify({ data: "success" })),
-                });
-            });
-            const client = createZapierApi({
-                baseUrl: "http://localhost:3000",
-                credentials: "test-token",
-                debug: false,
-                maxNetworkRetryDelayMs: 5000, // 5 seconds is enough for 1 second delay
-            });
-            const resultPromise = client.get("/test");
-            await vi.advanceTimersByTimeAsync(1000);
-            const result = await resultPromise;
-            expect(result).toEqual({ data: "success" });
-            expect(callCount).toBe(2);
-        });
-    });
-});

package/dist/api/debug.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=debug.test.d.ts.map

package/dist/api/debug.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.test.d.ts","sourceRoot":"","sources":["../../src/api/debug.test.ts"],"names":[],"mappings":""}

package/dist/api/debug.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { censorHeaders } from "./debug";
-describe("censorHeaders", () => {
-    it("should return undefined for undefined headers", () => {
-        expect(censorHeaders(undefined)).toBeUndefined();
-    });
-    it("should return headers unchanged for non-auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            "User-Agent": "test",
-        };
-        const result = censorHeaders(headers);
-        // Headers API normalizes header names to lowercase
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test");
-    });
-    it("should censor authorization header with Bearer prefix - long token", () => {
-        const headers = { authorization: "Bearer abcdef1234567890xyz" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer abcd...0xyz");
-    });
-    it("should censor authorization header with Bearer prefix - short token", () => {
-        const headers = { authorization: "Bearer short123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer s...");
-    });
-    it("should censor x-api-key header - long token", () => {
-        const headers = { "x-api-key": "sk-1234567890abcdefghij" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("sk-1...ghij");
-    });
-    it("should censor x-api-key header - short token", () => {
-        const headers = { "x-api-key": "short" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("s...");
-    });
-    it("should handle Headers object input", () => {
-        const headers = new Headers();
-        headers.set("authorization", "Bearer verylongtoken123456789");
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer very...6789");
-    });
-    it("should handle mixed case authorization headers", () => {
-        const headers = { Authorization: "Bearer mixedcasetoken123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer mixe...n123");
-    });
-    it("should preserve non-auth headers while censoring auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            authorization: "Bearer shouldbecensored123456789",
-            "User-Agent": "test-agent",
-        };
-        const result = censorHeaders(headers);
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test-agent");
-        expect(result.authorization).toBe("Bearer shou...6789");
-    });
-});

package/dist/api/polling.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=polling.test.d.ts.map

package/dist/api/polling.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polling.test.d.ts","sourceRoot":"","sources":["../../src/api/polling.test.ts"],"names":[],"mappings":""}