@zapier/zapier-sdk 0.33.0 → 0.33.2

package/dist/utils/telemetry-context.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isTelemetryNested, runWithTelemetryContext, setMethodMetadata, getMethodMetadata, } from "./telemetry-context";
-describe("telemetry-context", () => {
-    describe("isTelemetryNested", () => {
-        it("returns false outside any context", () => {
-            expect(isTelemetryNested()).toBe(false);
-        });
-        it("returns false inside top-level runWithTelemetryContext (depth 0)", () => {
-            runWithTelemetryContext(() => {
-                expect(isTelemetryNested()).toBe(false);
-            });
-        });
-        it("returns true inside nested runWithTelemetryContext (depth 1)", () => {
-            runWithTelemetryContext(() => {
-                runWithTelemetryContext(() => {
-                    expect(isTelemetryNested()).toBe(true);
-                });
-            });
-        });
-        it("returns true at deeper nesting levels", () => {
-            runWithTelemetryContext(() => {
-                runWithTelemetryContext(() => {
-                    runWithTelemetryContext(() => {
-                        expect(isTelemetryNested()).toBe(true);
-                    });
-                });
-            });
-        });
-        it("restores context after exiting nested scope", () => {
-            runWithTelemetryContext(() => {
-                expect(isTelemetryNested()).toBe(false);
-                runWithTelemetryContext(() => {
-                    expect(isTelemetryNested()).toBe(true);
-                });
-                expect(isTelemetryNested()).toBe(false);
-            });
-            expect(isTelemetryNested()).toBe(false);
-        });
-    });
-    describe("async boundaries", () => {
-        it("works correctly across async/await boundaries", async () => {
-            await runWithTelemetryContext(async () => {
-                expect(isTelemetryNested()).toBe(false);
-                await new Promise((resolve) => setTimeout(resolve, 1));
-                expect(isTelemetryNested()).toBe(false);
-                await runWithTelemetryContext(async () => {
-                    expect(isTelemetryNested()).toBe(true);
-                    await new Promise((resolve) => setTimeout(resolve, 1));
-                    expect(isTelemetryNested()).toBe(true);
-                });
-            });
-        });
-        it("isolates parallel async calls from each other", async () => {
-            const results = [];
-            await runWithTelemetryContext(async () => {
-                const task1 = runWithTelemetryContext(async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 5));
-                    results.push({ id: "task1-inner", nested: isTelemetryNested() });
-                });
-                const task2 = (async () => {
-                    await new Promise((resolve) => setTimeout(resolve, 1));
-                    results.push({ id: "task2-top", nested: isTelemetryNested() });
-                })();
-                await Promise.all([task1, task2]);
-            });
-            const task1Result = results.find((r) => r.id === "task1-inner");
-            const task2Result = results.find((r) => r.id === "task2-top");
-            expect(task1Result?.nested).toBe(true);
-            expect(task2Result?.nested).toBe(false);
-        });
-    });
-    describe("setMethodMetadata / getMethodMetadata", () => {
-        it("round-trips metadata within ALS context", () => {
-            runWithTelemetryContext(() => {
-                setMethodMetadata({
-                    selectedApi: "SlackCLIAPI@1.0.0",
-                    operationType: "write",
-                    operationKey: "send_message",
-                });
-                const metadata = getMethodMetadata();
-                expect(metadata).toEqual({
-                    selectedApi: "SlackCLIAPI@1.0.0",
-                    operationType: "write",
-                    operationKey: "send_message",
-                });
-            });
-        });
-        it("returns undefined outside any ALS context", () => {
-            expect(getMethodMetadata()).toBeUndefined();
-        });
-        it("is isolated between different runWithTelemetryContext scopes", () => {
-            runWithTelemetryContext(() => {
-                setMethodMetadata({ selectedApi: "parent" });
-                runWithTelemetryContext(() => {
-                    setMethodMetadata({ selectedApi: "child" });
-                    expect(getMethodMetadata()?.selectedApi).toBe("child");
-                });
-                expect(getMethodMetadata()?.selectedApi).toBe("parent");
-            });
-        });
-        it("merges partial metadata updates", () => {
-            runWithTelemetryContext(() => {
-                setMethodMetadata({ selectedApi: "SlackCLIAPI@1.0.0" });
-                setMethodMetadata({ operationType: "write" });
-                const metadata = getMethodMetadata();
-                expect(metadata).toEqual({
-                    selectedApi: "SlackCLIAPI@1.0.0",
-                    operationType: "write",
-                });
-            });
-        });
-        it("is readable in .then() handler within same ALS scope (paginated pattern)", async () => {
-            await runWithTelemetryContext(async () => {
-                setMethodMetadata({
-                    selectedApi: "SlackCLIAPI@1.0.0",
-                    operationType: "write",
-                    operationKey: "send_message",
-                });
-                const result = await Promise.resolve("done").then(() => {
-                    return getMethodMetadata();
-                });
-                expect(result).toEqual({
-                    selectedApi: "SlackCLIAPI@1.0.0",
-                    operationType: "write",
-                    operationKey: "send_message",
-                });
-            });
-        });
-        it("is a no-op outside ALS context", () => {
-            setMethodMetadata({ selectedApi: "test" });
-            expect(getMethodMetadata()).toBeUndefined();
-        });
-    });
-    describe("runWithTelemetryContext", () => {
-        it("returns the value from the wrapped function", () => {
-            const result = runWithTelemetryContext(() => 42);
-            expect(result).toBe(42);
-        });
-        it("returns async values from the wrapped function", async () => {
-            const result = await runWithTelemetryContext(async () => "hello");
-            expect(result).toBe("hello");
-        });
-        it("propagates errors from the wrapped function", () => {
-            expect(() => runWithTelemetryContext(() => {
-                throw new Error("test error");
-            })).toThrow("test error");
-        });
-        it("propagates async errors from the wrapped function", async () => {
-            await expect(runWithTelemetryContext(async () => {
-                throw new Error("async test error");
-            })).rejects.toThrow("async test error");
-        });
-    });
-});

package/dist/utils/telemetry-utils.test.d.ts

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

package/dist/utils/telemetry-utils.test.d.ts.map

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

package/dist/utils/telemetry-utils.test.js

@@ -1,155 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { createTelemetryCallback } from "./telemetry-utils";
-import { runWithTelemetryContext, setMethodMetadata, } from "./telemetry-context";
-describe("createTelemetryCallback", () => {
-    it("should create callback that emits telemetry with explicit method name", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "testMethod");
-        callback.onMethodCalled({
-            methodName: "ignoredName",
-            durationMs: 123,
-            success: true,
-            argumentCount: 2,
-            isPaginated: false,
-        });
-        expect(mockEmit).toHaveBeenCalledWith({
-            method_name: "testMethod",
-            execution_duration_ms: 123,
-            success_flag: true,
-            error_message: null,
-            error_type: null,
-            argument_count: 2,
-            is_paginated: false,
-            selected_api: null,
-            operation_type: null,
-            operation_key: null,
-        });
-    });
-    it("should include error details when method fails", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "failingMethod");
-        const testError = new Error("Test failure");
-        callback.onMethodCalled({
-            methodName: "ignoredName",
-            durationMs: 50,
-            success: false,
-            error: testError,
-            argumentCount: 1,
-            isPaginated: false,
-        });
-        expect(mockEmit).toHaveBeenCalledWith({
-            method_name: "failingMethod",
-            execution_duration_ms: 50,
-            success_flag: false,
-            error_message: "Test failure",
-            error_type: "Error",
-            argument_count: 1,
-            is_paginated: false,
-            selected_api: null,
-            operation_type: null,
-            operation_key: null,
-        });
-    });
-    it("should handle paginated method calls", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "listItems");
-        callback.onMethodCalled({
-            methodName: "ignoredName",
-            durationMs: 200,
-            success: true,
-            argumentCount: 1,
-            isPaginated: true,
-        });
-        expect(mockEmit).toHaveBeenCalledWith({
-            method_name: "listItems",
-            execution_duration_ms: 200,
-            success_flag: true,
-            error_message: null,
-            error_type: null,
-            argument_count: 1,
-            is_paginated: true,
-            selected_api: null,
-            operation_type: null,
-            operation_key: null,
-        });
-    });
-    it("should handle custom error types", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "customFailMethod");
-        class CustomError extends Error {
-            constructor(message) {
-                super(message);
-                this.name = "CustomError";
-            }
-        }
-        const customError = new CustomError("Custom failure");
-        callback.onMethodCalled({
-            methodName: "ignoredName",
-            durationMs: 75,
-            success: false,
-            error: customError,
-            argumentCount: 3,
-            isPaginated: false,
-        });
-        expect(mockEmit).toHaveBeenCalledWith({
-            method_name: "customFailMethod",
-            execution_duration_ms: 75,
-            success_flag: false,
-            error_message: "Custom failure",
-            error_type: "CustomError",
-            argument_count: 3,
-            is_paginated: false,
-            selected_api: null,
-            operation_type: null,
-            operation_key: null,
-        });
-    });
-    it("should include ALS metadata when set", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "runAction");
-        runWithTelemetryContext(() => {
-            setMethodMetadata({
-                selectedApi: "SlackCLIAPI@1.0.0",
-                operationType: "write",
-                operationKey: "send_message",
-            });
-            callback.onMethodCalled({
-                methodName: "ignoredName",
-                durationMs: 100,
-                success: true,
-                argumentCount: 1,
-                isPaginated: false,
-            });
-        });
-        expect(mockEmit).toHaveBeenCalledWith({
-            method_name: "runAction",
-            execution_duration_ms: 100,
-            success_flag: true,
-            error_message: null,
-            error_type: null,
-            argument_count: 1,
-            is_paginated: false,
-            selected_api: "SlackCLIAPI@1.0.0",
-            operation_type: "write",
-            operation_key: "send_message",
-        });
-    });
-    it("should default metadata fields to null when no ALS metadata is set", () => {
-        const mockEmit = vi.fn();
-        const callback = createTelemetryCallback(mockEmit, "listApps");
-        runWithTelemetryContext(() => {
-            callback.onMethodCalled({
-                methodName: "ignoredName",
-                durationMs: 50,
-                success: true,
-                argumentCount: 0,
-                isPaginated: false,
-            });
-        });
-        expect(mockEmit).toHaveBeenCalledWith(expect.objectContaining({
-            selected_api: null,
-            operation_type: null,
-            operation_key: null,
-        }));
-    });
-});

package/dist/utils/url-utils.test.d.ts

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

package/dist/utils/url-utils.test.d.ts.map

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

package/dist/utils/url-utils.test.js

@@ -1,103 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { getZapierBaseUrl, getTrackingBaseUrl } from "./url-utils";
-describe("getZapierBaseUrl", () => {
-    describe("with valid Zapier domains", () => {
-        it("should return root domain for zapier.* patterns", () => {
-            expect(getZapierBaseUrl("https://zapier.com")).toBe("https://zapier.com");
-            expect(getZapierBaseUrl("https://api.zapier.com")).toBe("https://zapier.com");
-            expect(getZapierBaseUrl("https://staging.zapier.com")).toBe("https://zapier.com");
-            expect(getZapierBaseUrl("https://custom.zapier.dev:8080")).toBe("https://zapier.dev");
-        });
-        it("should return root domain for zapier-*.* patterns", () => {
-            expect(getZapierBaseUrl("https://zapier-staging.dev")).toBe("https://zapier-staging.dev");
-            expect(getZapierBaseUrl("https://zapier-production.example.com")).toBe("https://example.com");
-            expect(getZapierBaseUrl("http://zapier-custom.local")).toBe("http://zapier-custom.local");
-        });
-    });
-    describe("with non-Zapier domains", () => {
-        it("should return undefined for non-Zapier domains", () => {
-            expect(getZapierBaseUrl("https://example.com")).toBe(undefined);
-            expect(getZapierBaseUrl("https://api.example.com")).toBe(undefined);
-            expect(getZapierBaseUrl("http://localhost")).toBe(undefined);
-            expect(getZapierBaseUrl("http://127.0.0.1")).toBe(undefined);
-            expect(getZapierBaseUrl("https://my-zapier.com")).toBe(undefined);
-        });
-    });
-    describe("with invalid inputs", () => {
-        it("should return undefined for invalid or missing URLs", () => {
-            expect(getZapierBaseUrl()).toBe(undefined);
-            expect(getZapierBaseUrl(undefined)).toBe(undefined);
-            expect(getZapierBaseUrl("")).toBe(undefined);
-            expect(getZapierBaseUrl("invalid-url")).toBe(undefined);
-        });
-    });
-});
-describe("getTrackingBaseUrl", () => {
-    let originalEnv;
-    beforeEach(() => {
-        originalEnv = {
-            ZAPIER_TRACKING_BASE_URL: process.env.ZAPIER_TRACKING_BASE_URL,
-            ZAPIER_BASE_URL: process.env.ZAPIER_BASE_URL,
-        };
-    });
-    afterEach(() => {
-        if (originalEnv.ZAPIER_TRACKING_BASE_URL !== undefined) {
-            process.env.ZAPIER_TRACKING_BASE_URL =
-                originalEnv.ZAPIER_TRACKING_BASE_URL;
-        }
-        else {
-            delete process.env.ZAPIER_TRACKING_BASE_URL;
-        }
-        if (originalEnv.ZAPIER_BASE_URL !== undefined) {
-            process.env.ZAPIER_BASE_URL = originalEnv.ZAPIER_BASE_URL;
-        }
-        else {
-            delete process.env.ZAPIER_BASE_URL;
-        }
-    });
-    describe("precedence rules", () => {
-        it("should prioritize trackingBaseUrl parameter", () => {
-            process.env.ZAPIER_TRACKING_BASE_URL = "https://env-tracking.zapier.com";
-            expect(getTrackingBaseUrl({
-                trackingBaseUrl: "https://param-tracking.zapier.com",
-                baseUrl: "https://api.example.com",
-            })).toBe("https://param-tracking.zapier.com");
-        });
-        it("should use ZAPIER_TRACKING_BASE_URL environment variable", () => {
-            process.env.ZAPIER_TRACKING_BASE_URL = "https://env-tracking.zapier.com";
-            expect(getTrackingBaseUrl({
-                baseUrl: "https://api.example.com",
-            })).toBe("https://env-tracking.zapier.com");
-        });
-        it("should derive from baseUrl if it's a Zapier domain", () => {
-            delete process.env.ZAPIER_TRACKING_BASE_URL;
-            expect(getTrackingBaseUrl({
-                baseUrl: "https://api.zapier.com",
-            })).toBe("https://zapier.com");
-            expect(getTrackingBaseUrl({
-                baseUrl: "https://custom.zapier.dev:8080",
-            })).toBe("https://zapier.dev");
-        });
-        it("should use baseUrl directly for non-Zapier domains", () => {
-            delete process.env.ZAPIER_TRACKING_BASE_URL;
-            expect(getTrackingBaseUrl({
-                baseUrl: "https://api.example.com",
-            })).toBe("https://api.example.com");
-            expect(getTrackingBaseUrl({
-                baseUrl: "http://localhost:3000",
-            })).toBe("http://localhost:3000");
-        });
-        it("should fallback to ZAPIER_BASE_URL constant", async () => {
-            delete process.env.ZAPIER_TRACKING_BASE_URL;
-            process.env.ZAPIER_BASE_URL = "https://custom.zapier.com";
-            // Clear module cache and re-import to get fresh constants
-            vi.resetModules();
-            const { getTrackingBaseUrl: freshGetTrackingBaseUrl } = await import("./url-utils");
-            expect(freshGetTrackingBaseUrl({})).toBe("https://custom.zapier.com");
-            delete process.env.ZAPIER_BASE_URL;
-            vi.resetModules();
-            const { getTrackingBaseUrl: defaultGetTrackingBaseUrl } = await import("./url-utils");
-            expect(defaultGetTrackingBaseUrl({})).toBe("https://zapier.com");
-        });
-    });
-});

package/dist/utils/validation.test.d.ts

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

package/dist/utils/validation.test.d.ts.map

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

package/dist/utils/validation.test.js

@@ -1,44 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { z } from "zod";
-import { createValidator } from "./validation";
-import { ZapierValidationError } from "../types/errors";
-describe("validation utilities", () => {
-    describe("createValidator", () => {
-        it("should validate valid input", () => {
-            const schema = z.object({
-                name: z.string(),
-                age: z.number(),
-            });
-            const validator = createValidator(schema);
-            const result = validator({ name: "John", age: 30 });
-            expect(result).toEqual({ name: "John", age: 30 });
-        });
-        it("should throw ZapierValidationError for invalid input", () => {
-            const schema = z.object({
-                name: z.string(),
-                age: z.number(),
-            });
-            const validator = createValidator(schema);
-            expect(() => {
-                validator({ name: "John", age: "not-a-number" });
-            }).toThrow(ZapierValidationError);
-        });
-        it("should include helpful error messages", () => {
-            const schema = z.object({
-                name: z.string(),
-                age: z.number().min(0),
-            });
-            const validator = createValidator(schema);
-            try {
-                validator({ name: 123, age: -5 });
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(ZapierValidationError);
-                expect(error.message).toContain("name:");
-                expect(error.message).toContain("age:");
-                expect(error.details
-                    ?.zodErrors).toBeDefined();
-            }
-        });
-    });
-});