@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/auth.test.js

@@ -1,480 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import * as auth from "./auth";
-import { resetDeprecationWarnings } from "./utils/logging";
-// Mock both CLI login import paths (SDK tries @zapier/zapier-sdk-cli/login
-// first, then falls back to @zapier/zapier-sdk-cli-login)
-const mockGetToken = vi.fn();
-vi.mock("@zapier/zapier-sdk-cli/login", () => ({
-    getToken: mockGetToken,
-}));
-vi.mock("@zapier/zapier-sdk-cli-login", () => ({
-    getToken: mockGetToken,
-}));
-// Mock fetch for client credentials tests
-const mockFetch = vi.fn();
-describe("auth", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        auth.clearTokenCache();
-        resetDeprecationWarnings();
-        // Clear all ZAPIER_* env vars
-        delete process.env.ZAPIER_CREDENTIALS;
-        delete process.env.ZAPIER_CREDENTIALS_CLIENT_ID;
-        delete process.env.ZAPIER_CREDENTIALS_CLIENT_SECRET;
-        delete process.env.ZAPIER_CREDENTIALS_BASE_URL;
-        delete process.env.ZAPIER_TOKEN;
-        delete process.env.ZAPIER_AUTH_CLIENT_ID;
-        delete process.env.ZAPIER_AUTH_BASE_URL;
-    });
-    afterEach(() => {
-        auth.clearTokenCache();
-    });
-    describe("getTokenFromCliLogin", () => {
-        it("should pass options to CLI login package getToken", async () => {
-            mockGetToken.mockResolvedValue("cli-token");
-            const options = {
-                baseUrl: "https://api.custom.zapier.com",
-                onEvent: vi.fn(),
-                fetch: vi.fn(),
-            };
-            const result = await auth.getTokenFromCliLogin(options);
-            expect(result).toBe("cli-token");
-            expect(mockGetToken).toHaveBeenCalled();
-        });
-        it("should propagate errors from CLI login package getToken", async () => {
-            mockGetToken.mockRejectedValue(new Error("Token refresh failed"));
-            await expect(auth.getTokenFromCliLogin({})).rejects.toThrow("Token refresh failed");
-        });
-        it("should set isCliLoginAvailable to true when import succeeds", async () => {
-            mockGetToken.mockResolvedValue("cli-token");
-            await auth.getTokenFromCliLogin({});
-            expect(auth.isCliLoginAvailable()).toBe(true);
-        });
-    });
-    describe("resolveAuthToken", () => {
-        it("should return string credentials directly", async () => {
-            const result = await auth.resolveAuthToken({
-                credentials: "my-token",
-            });
-            expect(result).toBe("my-token");
-        });
-        it("should use deprecated token option with warning", async () => {
-            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-            const result = await auth.resolveAuthToken({
-                token: "deprecated-token",
-            });
-            expect(result).toBe("deprecated-token");
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("deprecated"));
-            warnSpy.mockRestore();
-        });
-        it("should resolve credentials from env var (string token)", async () => {
-            // Set env var and re-import to pick up the new value
-            process.env.ZAPIER_CREDENTIALS = "env-token";
-            vi.resetModules();
-            const freshAuth = await import("./auth");
-            const result = await freshAuth.resolveAuthToken({});
-            expect(result).toBe("env-token");
-        });
-        it("should resolve credentials from ZAPIER_TOKEN with deprecation warning", async () => {
-            // Set env var and re-import to pick up the new value
-            process.env.ZAPIER_TOKEN = "legacy-token";
-            vi.resetModules();
-            const freshAuth = await import("./auth");
-            const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
-            const result = await freshAuth.resolveAuthToken({});
-            expect(result).toBe("legacy-token");
-            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("ZAPIER_TOKEN is deprecated"));
-            warnSpy.mockRestore();
-        });
-        it("should fall back to CLI login when no credentials provided", async () => {
-            mockGetToken.mockResolvedValue("cli-stored-token");
-            const result = await auth.resolveAuthToken({});
-            expect(result).toBe("cli-stored-token");
-            expect(mockGetToken).toHaveBeenCalled();
-        });
-        it("should return undefined when no credentials found", async () => {
-            mockGetToken.mockResolvedValue(undefined);
-            const result = await auth.resolveAuthToken({});
-            expect(result).toBeUndefined();
-        });
-        it("should call credentials function and use result", async () => {
-            const credentialsFn = vi.fn().mockResolvedValue("dynamic-token");
-            const result = await auth.resolveAuthToken({
-                credentials: credentialsFn,
-            });
-            expect(result).toBe("dynamic-token");
-            expect(credentialsFn).toHaveBeenCalled();
-        });
-        it("should throw if credentials function returns another function", async () => {
-            const credentialsFn = vi.fn().mockResolvedValue(() => "nested");
-            await expect(auth.resolveAuthToken({
-                credentials: credentialsFn,
-            })).rejects.toThrow("Credentials function returned another function");
-        });
-    });
-    describe("client credentials flow", () => {
-        it("should exchange client credentials for token with scope and audience", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "exchanged-token",
-                    expires_in: 3600,
-                }),
-            });
-            const result = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "test-client-id",
-                    clientSecret: "test-client-secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(result).toBe("exchanged-token");
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/oauth/token/"), expect.objectContaining({
-                method: "POST",
-                body: expect.any(URLSearchParams),
-            }));
-            // Verify the body includes required parameters
-            const callArgs = mockFetch.mock.calls[0];
-            const body = callArgs[1].body;
-            expect(body.get("grant_type")).toBe("client_credentials");
-            expect(body.get("client_id")).toBe("test-client-id");
-            expect(body.get("client_secret")).toBe("test-client-secret");
-            expect(body.get("scope")).toBe("external");
-            expect(body.get("audience")).toBe("zapier.com");
-        });
-        it("should cache token from client credentials exchange", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "cached-token",
-                    expires_in: 3600,
-                }),
-            });
-            // First call - should exchange
-            const result1 = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "cache-test-client",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            // Second call - should use cache
-            const result2 = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "cache-test-client",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(result1).toBe("cached-token");
-            expect(result2).toBe("cached-token");
-            expect(mockFetch).toHaveBeenCalledTimes(1); // Only called once due to cache
-        });
-        it("should deduplicate concurrent client credentials exchanges", async () => {
-            let resolveExchange;
-            const exchangePromise = new Promise((resolve) => {
-                resolveExchange = resolve;
-            });
-            mockFetch.mockReturnValue(exchangePromise);
-            // Start two concurrent requests - they will both start executing
-            const promise1 = auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "concurrent-test-client",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            const promise2 = auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "concurrent-test-client",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            // Let microtasks run so both promises start
-            await new Promise((r) => setTimeout(r, 0));
-            // Now resolve the exchange
-            resolveExchange({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "concurrent-token",
-                    expires_in: 3600,
-                }),
-            });
-            const [result1, result2] = await Promise.all([promise1, promise2]);
-            expect(result1).toBe("concurrent-token");
-            expect(result2).toBe("concurrent-token");
-            expect(mockFetch).toHaveBeenCalledTimes(1); // Only one exchange despite two concurrent calls
-        });
-        it("should throw on client credentials exchange failure", async () => {
-            mockFetch.mockResolvedValue({
-                ok: false,
-                status: 401,
-                statusText: "Unauthorized",
-                text: () => Promise.resolve("Invalid credentials"),
-            });
-            await expect(auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "bad-client",
-                    clientSecret: "bad-secret",
-                },
-                fetch: mockFetch,
-            })).rejects.toThrow("Client credentials exchange failed");
-        });
-        it("should merge requiredScopes with credentials scope", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "merged-scope-token",
-                    expires_in: 3600,
-                }),
-            });
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "scope-test-client",
-                    clientSecret: "secret",
-                    scope: "external",
-                },
-                requiredScopes: ["credentials"],
-                fetch: mockFetch,
-            });
-            const callArgs = mockFetch.mock.calls[0];
-            const body = callArgs[1].body;
-            // Scopes should be merged and sorted alphabetically
-            expect(body.get("scope")).toBe("credentials external");
-        });
-        it("should always include external scope with requiredScopes", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "required-scope-token",
-                    expires_in: 3600,
-                }),
-            });
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "required-scope-client",
-                    clientSecret: "secret",
-                },
-                requiredScopes: ["credentials"],
-                fetch: mockFetch,
-            });
-            const callArgs = mockFetch.mock.calls[0];
-            const body = callArgs[1].body;
-            // Should include both external (always present) and credentials (required)
-            expect(body.get("scope")).toBe("credentials external");
-        });
-        it("should cache tokens separately for different scope combinations", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "first-scope-token",
-                    expires_in: 3600,
-                }),
-            });
-            // First call with no requiredScopes
-            const result1 = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "scope-cache-client",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(result1).toBe("first-scope-token");
-            expect(mockFetch).toHaveBeenCalledTimes(1);
-            // Second call with different requiredScopes - should NOT use cache
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "second-scope-token",
-                    expires_in: 3600,
-                }),
-            });
-            const result2 = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "scope-cache-client",
-                    clientSecret: "secret",
-                },
-                requiredScopes: ["credentials"],
-                fetch: mockFetch,
-            });
-            expect(result2).toBe("second-scope-token");
-            expect(mockFetch).toHaveBeenCalledTimes(2); // Should have made a new request
-            // Third call with same requiredScopes as second - should use cache
-            const result3 = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "scope-cache-client",
-                    clientSecret: "secret",
-                },
-                requiredScopes: ["credentials"],
-                fetch: mockFetch,
-            });
-            expect(result3).toBe("second-scope-token");
-            expect(mockFetch).toHaveBeenCalledTimes(2); // No new request
-        });
-    });
-    describe("PKCE credentials", () => {
-        it("should delegate PKCE credentials to CLI login", async () => {
-            mockGetToken.mockResolvedValue("pkce-stored-token");
-            const result = await auth.resolveAuthToken({
-                credentials: {
-                    type: "pkce",
-                    clientId: "pkce-client",
-                },
-            });
-            expect(result).toBe("pkce-stored-token");
-            expect(mockGetToken).toHaveBeenCalled();
-        });
-        it("should throw when PKCE credentials have no stored token", async () => {
-            mockGetToken.mockResolvedValue(undefined);
-            await expect(auth.resolveAuthToken({
-                credentials: {
-                    type: "pkce",
-                    clientId: "pkce-client",
-                },
-            })).rejects.toThrow("PKCE credentials require interactive login");
-        });
-    });
-    describe("token cache management", () => {
-        it("should invalidate cached token", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "will-be-invalidated",
-                    expires_in: 3600,
-                }),
-            });
-            // First call - cache the token
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(mockFetch).toHaveBeenCalledTimes(1);
-            // Invalidate the cache (default scope is "external")
-            auth.invalidateCachedToken("invalidate-test", ["external"]);
-            // Next call should fetch again
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "new-token-after-invalidation",
-                    expires_in: 3600,
-                }),
-            });
-            const result = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(result).toBe("new-token-after-invalidation");
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-        it("should clear all cached tokens", async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "token",
-                    expires_in: 3600,
-                }),
-            });
-            // Cache a token
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "clear-test",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            // Clear all caches
-            auth.clearTokenCache();
-            // Should fetch again
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "clear-test",
-                    clientSecret: "secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe("invalidateCredentialsToken", () => {
-        it("should invalidate cached token for client credentials", async () => {
-            const mockFetch = vi.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    access_token: "cached-token",
-                    expires_in: 3600,
-                }),
-            });
-            // First, get a token to populate the cache
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test-client",
-                    clientSecret: "test-secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(mockFetch).toHaveBeenCalledTimes(1);
-            // Verify token is cached (no new fetch)
-            const cachedToken = await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test-client",
-                    clientSecret: "test-secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(cachedToken).toBe("cached-token");
-            expect(mockFetch).toHaveBeenCalledTimes(1);
-            // Invalidate the token
-            await auth.invalidateCredentialsToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test-client",
-                    clientSecret: "test-secret",
-                },
-            });
-            // Next request should fetch a new token
-            await auth.resolveAuthToken({
-                credentials: {
-                    type: "client_credentials",
-                    clientId: "invalidate-test-client",
-                    clientSecret: "test-secret",
-                },
-                fetch: mockFetch,
-            });
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-        it("should do nothing for string credentials", async () => {
-            // Should not throw
-            await auth.invalidateCredentialsToken({
-                credentials: "string-token",
-            });
-        });
-        it("should do nothing when no credentials provided", async () => {
-            // Should not throw
-            await auth.invalidateCredentialsToken({});
-        });
-    });
-});

package/dist/plugins/eventEmission/builders.test.d.ts

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

package/dist/plugins/eventEmission/builders.test.d.ts.map

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

package/dist/plugins/eventEmission/builders.test.js

@@ -1,138 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildMethodCalledEvent, buildErrorEvent, buildApplicationLifecycleEvent, buildErrorEventWithContext, } from "./builders";
-describe("buildMethodCalledEvent", () => {
-    it("should use data.selected_api when provided", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "runAction",
-            execution_duration_ms: 100,
-            success_flag: true,
-            argument_count: 1,
-            selected_api: "SlackCLIAPI@1.0.0",
-        });
-        expect(event.selected_api).toBe("SlackCLIAPI@1.0.0");
-    });
-    it("should use data.operation_type and data.operation_key when provided", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "runAction",
-            execution_duration_ms: 100,
-            success_flag: true,
-            argument_count: 1,
-            operation_type: "write",
-            operation_key: "send_message",
-        });
-        expect(event.operation_type).toBe("write");
-        expect(event.operation_key).toBe("send_message");
-    });
-    it("should fall back to null when data fields are not provided", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        expect(event.selected_api).toBeNull();
-        expect(event.operation_type).toBeNull();
-        expect(event.operation_key).toBeNull();
-    });
-    it("should prefer data.selected_api over context.selected_api", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "runAction",
-            execution_duration_ms: 100,
-            success_flag: true,
-            argument_count: 1,
-            selected_api: "SlackCLIAPI@2.0.0",
-        }, { selected_api: "SlackCLIAPI@1.0.0" });
-        expect(event.selected_api).toBe("SlackCLIAPI@2.0.0");
-    });
-    it("should fall back to context.selected_api when data.selected_api is not provided", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "runAction",
-            execution_duration_ms: 100,
-            success_flag: true,
-            argument_count: 1,
-        }, { selected_api: "SlackCLIAPI@1.0.0" });
-        expect(event.selected_api).toBe("SlackCLIAPI@1.0.0");
-    });
-    it("should default call_context to null (plugin layer overrides this)", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        expect(event.call_context).toBeNull();
-    });
-    it("should populate sdk_version", () => {
-        const event = buildMethodCalledEvent({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        expect(event.sdk_version).toBe("unknown");
-    });
-});
-describe("buildErrorEvent", () => {
-    it("should build an error event with correct fields", () => {
-        const event = buildErrorEvent({
-            error_message: "Something went wrong",
-            error_type: "RuntimeError",
-            is_user_facing: false,
-        }, { selected_api: "SlackCLIAPI@1.0.0" });
-        expect(event.error_message).toBe("Something went wrong");
-        expect(event.error_type).toBe("RuntimeError");
-        expect(event.selected_api).toBe("SlackCLIAPI@1.0.0");
-        expect(event.sdk_version).toBe("unknown");
-    });
-    it("should not allow sdk_version to be overwritten via data spread", () => {
-        const event = buildErrorEvent({
-            error_message: "test",
-            error_type: "Error",
-            is_user_facing: false,
-            sdk_version: "evil-version",
-        }, {});
-        expect(event.sdk_version).not.toBe("evil-version");
-    });
-});
-describe("buildApplicationLifecycleEvent", () => {
-    it("should build a lifecycle event with correct fields", () => {
-        const event = buildApplicationLifecycleEvent({
-            lifecycle_event_type: "startup",
-        }, { app_id: 123 });
-        expect(event.lifecycle_event_type).toBe("startup");
-        expect(event.app_id).toBe(123);
-        expect(event.sdk_version).toBe("unknown");
-    });
-    it("should not allow sdk_version to be overwritten via data spread", () => {
-        const event = buildApplicationLifecycleEvent({
-            lifecycle_event_type: "startup",
-            sdk_version: "evil-version",
-        }, {});
-        expect(event.sdk_version).not.toBe("evil-version");
-    });
-});
-describe("buildErrorEventWithContext", () => {
-    it("should build an error event with execution time", () => {
-        const startTime = Date.now() - 500;
-        const event = buildErrorEventWithContext({
-            error_message: "Timeout",
-            error_type: "TimeoutError",
-            is_user_facing: false,
-            execution_start_time: startTime,
-        }, { selected_api: "SlackCLIAPI@1.0.0" });
-        expect(event.error_message).toBe("Timeout");
-        expect(event.error_type).toBe("TimeoutError");
-        expect(event.selected_api).toBe("SlackCLIAPI@1.0.0");
-        expect(event.sdk_version).toBe("unknown");
-        expect(event.execution_time_before_error_ms).toBeGreaterThanOrEqual(400);
-    });
-    it("should not allow sdk_version to be overwritten via data spread", () => {
-        const event = buildErrorEventWithContext({
-            error_message: "test",
-            error_type: "Error",
-            is_user_facing: false,
-            sdk_version: "evil-version",
-        }, {});
-        expect(event.sdk_version).not.toBe("evil-version");
-    });
-});

package/dist/plugins/eventEmission/index.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for Event Emission Plugin
- */
-export {};
-//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/eventEmission/index.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/index.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}